Add files using upload-large-folder tool

parrot/lib/python3.10/site-packages/scipy/_lib/tests/test_ccallback.py

@@ -0,0 +1,204 @@
+from numpy.testing import assert_equal, assert_
+from pytest import raises as assert_raises
+
+import time
+import pytest
+import ctypes
+import threading
+from scipy._lib import _ccallback_c as _test_ccallback_cython
+from scipy._lib import _test_ccallback
+from scipy._lib._ccallback import LowLevelCallable
+
+try:
+    import cffi
+    HAVE_CFFI = True
+except ImportError:
+    HAVE_CFFI = False
+
+
+ERROR_VALUE = 2.0
+
+
+def callback_python(a, user_data=None):
+    if a == ERROR_VALUE:
+        raise ValueError("bad value")
+
+    if user_data is None:
+        return a + 1
+    else:
+        return a + user_data
+
+def _get_cffi_func(base, signature):
+    if not HAVE_CFFI:
+        pytest.skip("cffi not installed")
+
+    # Get function address
+    voidp = ctypes.cast(base, ctypes.c_void_p)
+    address = voidp.value
+
+    # Create corresponding cffi handle
+    ffi = cffi.FFI()
+    func = ffi.cast(signature, address)
+    return func
+
+
+def _get_ctypes_data():
+    value = ctypes.c_double(2.0)
+    return ctypes.cast(ctypes.pointer(value), ctypes.c_voidp)
+
+
+def _get_cffi_data():
+    if not HAVE_CFFI:
+        pytest.skip("cffi not installed")
+    ffi = cffi.FFI()
+    return ffi.new('double *', 2.0)
+
+
+CALLERS = {
+    'simple': _test_ccallback.test_call_simple,
+    'nodata': _test_ccallback.test_call_nodata,
+    'nonlocal': _test_ccallback.test_call_nonlocal,
+    'cython': _test_ccallback_cython.test_call_cython,
+}
+
+# These functions have signatures known to the callers
+FUNCS = {
+    'python': lambda: callback_python,
+    'capsule': lambda: _test_ccallback.test_get_plus1_capsule(),
+    'cython': lambda: LowLevelCallable.from_cython(_test_ccallback_cython,
+                                                   "plus1_cython"),
+    'ctypes': lambda: _test_ccallback_cython.plus1_ctypes,
+    'cffi': lambda: _get_cffi_func(_test_ccallback_cython.plus1_ctypes,
+                                   'double (*)(double, int *, void *)'),
+    'capsule_b': lambda: _test_ccallback.test_get_plus1b_capsule(),
+    'cython_b': lambda: LowLevelCallable.from_cython(_test_ccallback_cython,
+                                                     "plus1b_cython"),
+    'ctypes_b': lambda: _test_ccallback_cython.plus1b_ctypes,
+    'cffi_b': lambda: _get_cffi_func(_test_ccallback_cython.plus1b_ctypes,
+                                     'double (*)(double, double, int *, void *)'),
+}
+
+# These functions have signatures the callers don't know
+BAD_FUNCS = {
+    'capsule_bc': lambda: _test_ccallback.test_get_plus1bc_capsule(),
+    'cython_bc': lambda: LowLevelCallable.from_cython(_test_ccallback_cython,
+                                                      "plus1bc_cython"),
+    'ctypes_bc': lambda: _test_ccallback_cython.plus1bc_ctypes,
+    'cffi_bc': lambda: _get_cffi_func(
+        _test_ccallback_cython.plus1bc_ctypes,
+        'double (*)(double, double, double, int *, void *)'
+    ),
+}
+
+USER_DATAS = {
+    'ctypes': _get_ctypes_data,
+    'cffi': _get_cffi_data,
+    'capsule': _test_ccallback.test_get_data_capsule,
+}
+
+
+def test_callbacks():
+    def check(caller, func, user_data):
+        caller = CALLERS[caller]
+        func = FUNCS[func]()
+        user_data = USER_DATAS[user_data]()
+
+        if func is callback_python:
+            def func2(x):
+                return func(x, 2.0)
+        else:
+            func2 = LowLevelCallable(func, user_data)
+            func = LowLevelCallable(func)
+
+        # Test basic call
+        assert_equal(caller(func, 1.0), 2.0)
+
+        # Test 'bad' value resulting to an error
+        assert_raises(ValueError, caller, func, ERROR_VALUE)
+
+        # Test passing in user_data
+        assert_equal(caller(func2, 1.0), 3.0)
+
+    for caller in sorted(CALLERS.keys()):
+        for func in sorted(FUNCS.keys()):
+            for user_data in sorted(USER_DATAS.keys()):
+                check(caller, func, user_data)
+
+
+def test_bad_callbacks():
+    def check(caller, func, user_data):
+        caller = CALLERS[caller]
+        user_data = USER_DATAS[user_data]()
+        func = BAD_FUNCS[func]()
+
+        if func is callback_python:
+            def func2(x):
+                return func(x, 2.0)
+        else:
+            func2 = LowLevelCallable(func, user_data)
+            func = LowLevelCallable(func)
+
+        # Test that basic call fails
+        assert_raises(ValueError, caller, LowLevelCallable(func), 1.0)
+
+        # Test that passing in user_data also fails
+        assert_raises(ValueError, caller, func2, 1.0)
+
+        # Test error message
+        llfunc = LowLevelCallable(func)
+        try:
+            caller(llfunc, 1.0)
+        except ValueError as err:
+            msg = str(err)
+            assert_(llfunc.signature in msg, msg)
+            assert_('double (double, double, int *, void *)' in msg, msg)
+
+    for caller in sorted(CALLERS.keys()):
+        for func in sorted(BAD_FUNCS.keys()):
+            for user_data in sorted(USER_DATAS.keys()):
+                check(caller, func, user_data)
+
+
+def test_signature_override():
+    caller = _test_ccallback.test_call_simple
+    func = _test_ccallback.test_get_plus1_capsule()
+
+    llcallable = LowLevelCallable(func, signature="bad signature")
+    assert_equal(llcallable.signature, "bad signature")
+    assert_raises(ValueError, caller, llcallable, 3)
+
+    llcallable = LowLevelCallable(func, signature="double (double, int *, void *)")
+    assert_equal(llcallable.signature, "double (double, int *, void *)")
+    assert_equal(caller(llcallable, 3), 4)
+
+
+def test_threadsafety():
+    def callback(a, caller):
+        if a <= 0:
+            return 1
+        else:
+            res = caller(lambda x: callback(x, caller), a - 1)
+            return 2*res
+
+    def check(caller):
+        caller = CALLERS[caller]
+
+        results = []
+
+        count = 10
+
+        def run():
+            time.sleep(0.01)
+            r = caller(lambda x: callback(x, caller), count)
+            results.append(r)
+
+        threads = [threading.Thread(target=run) for j in range(20)]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert_equal(results, [2.0**count]*len(threads))
+
+    for caller in CALLERS.keys():
+        check(caller)

parrot/lib/python3.10/site-packages/scipy/_lib/tests/test_public_api.py

@@ -0,0 +1,496 @@
+"""
+This test script is adopted from:
+    https://github.com/numpy/numpy/blob/main/numpy/tests/test_public_api.py
+"""
+
+import pkgutil
+import types
+import importlib
+import warnings
+from importlib import import_module
+
+import pytest
+
+import scipy
+
+from scipy.conftest import xp_available_backends
+
+
+def test_dir_testing():
+    """Assert that output of dir has only one "testing/tester"
+    attribute without duplicate"""
+    assert len(dir(scipy)) == len(set(dir(scipy)))
+
+
+# Historically SciPy has not used leading underscores for private submodules
+# much.  This has resulted in lots of things that look like public modules
+# (i.e. things that can be imported as `import scipy.somesubmodule.somefile`),
+# but were never intended to be public.  The PUBLIC_MODULES list contains
+# modules that are either public because they were meant to be, or because they
+# contain public functions/objects that aren't present in any other namespace
+# for whatever reason and therefore should be treated as public.
+PUBLIC_MODULES = ["scipy." + s for s in [
+    "cluster",
+    "cluster.vq",
+    "cluster.hierarchy",
+    "constants",
+    "datasets",
+    "fft",
+    "fftpack",
+    "integrate",
+    "interpolate",
+    "io",
+    "io.arff",
+    "io.matlab",
+    "io.wavfile",
+    "linalg",
+    "linalg.blas",
+    "linalg.cython_blas",
+    "linalg.lapack",
+    "linalg.cython_lapack",
+    "linalg.interpolative",
+    "misc",
+    "ndimage",
+    "odr",
+    "optimize",
+    "signal",
+    "signal.windows",
+    "sparse",
+    "sparse.linalg",
+    "sparse.csgraph",
+    "spatial",
+    "spatial.distance",
+    "spatial.transform",
+    "special",
+    "stats",
+    "stats.contingency",
+    "stats.distributions",
+    "stats.mstats",
+    "stats.qmc",
+    "stats.sampling"
+]]
+
+# The PRIVATE_BUT_PRESENT_MODULES list contains modules that lacked underscores
+# in their name and hence looked public, but weren't meant to be. All these
+# namespace were deprecated in the 1.8.0 release - see "clear split between
+# public and private API" in the 1.8.0 release notes.
+# These private modules support will be removed in SciPy v2.0.0, as the
+# deprecation messages emitted by each of these modules say.
+PRIVATE_BUT_PRESENT_MODULES = [
+    'scipy.constants.codata',
+    'scipy.constants.constants',
+    'scipy.fftpack.basic',
+    'scipy.fftpack.convolve',
+    'scipy.fftpack.helper',
+    'scipy.fftpack.pseudo_diffs',
+    'scipy.fftpack.realtransforms',
+    'scipy.integrate.dop',
+    'scipy.integrate.lsoda',
+    'scipy.integrate.odepack',
+    'scipy.integrate.quadpack',
+    'scipy.integrate.vode',
+    'scipy.interpolate.dfitpack',
+    'scipy.interpolate.fitpack',
+    'scipy.interpolate.fitpack2',
+    'scipy.interpolate.interpnd',
+    'scipy.interpolate.interpolate',
+    'scipy.interpolate.ndgriddata',
+    'scipy.interpolate.polyint',
+    'scipy.interpolate.rbf',
+    'scipy.io.arff.arffread',
+    'scipy.io.harwell_boeing',
+    'scipy.io.idl',
+    'scipy.io.matlab.byteordercodes',
+    'scipy.io.matlab.mio',
+    'scipy.io.matlab.mio4',
+    'scipy.io.matlab.mio5',
+    'scipy.io.matlab.mio5_params',
+    'scipy.io.matlab.mio5_utils',
+    'scipy.io.matlab.mio_utils',
+    'scipy.io.matlab.miobase',
+    'scipy.io.matlab.streams',
+    'scipy.io.mmio',
+    'scipy.io.netcdf',
+    'scipy.linalg.basic',
+    'scipy.linalg.decomp',
+    'scipy.linalg.decomp_cholesky',
+    'scipy.linalg.decomp_lu',
+    'scipy.linalg.decomp_qr',
+    'scipy.linalg.decomp_schur',
+    'scipy.linalg.decomp_svd',
+    'scipy.linalg.matfuncs',
+    'scipy.linalg.misc',
+    'scipy.linalg.special_matrices',
+    'scipy.misc.common',
+    'scipy.misc.doccer',
+    'scipy.ndimage.filters',
+    'scipy.ndimage.fourier',
+    'scipy.ndimage.interpolation',
+    'scipy.ndimage.measurements',
+    'scipy.ndimage.morphology',
+    'scipy.odr.models',
+    'scipy.odr.odrpack',
+    'scipy.optimize.cobyla',
+    'scipy.optimize.cython_optimize',
+    'scipy.optimize.lbfgsb',
+    'scipy.optimize.linesearch',
+    'scipy.optimize.minpack',
+    'scipy.optimize.minpack2',
+    'scipy.optimize.moduleTNC',
+    'scipy.optimize.nonlin',
+    'scipy.optimize.optimize',
+    'scipy.optimize.slsqp',
+    'scipy.optimize.tnc',
+    'scipy.optimize.zeros',
+    'scipy.signal.bsplines',
+    'scipy.signal.filter_design',
+    'scipy.signal.fir_filter_design',
+    'scipy.signal.lti_conversion',
+    'scipy.signal.ltisys',
+    'scipy.signal.signaltools',
+    'scipy.signal.spectral',
+    'scipy.signal.spline',
+    'scipy.signal.waveforms',
+    'scipy.signal.wavelets',
+    'scipy.signal.windows.windows',
+    'scipy.sparse.base',
+    'scipy.sparse.bsr',
+    'scipy.sparse.compressed',
+    'scipy.sparse.construct',
+    'scipy.sparse.coo',
+    'scipy.sparse.csc',
+    'scipy.sparse.csr',
+    'scipy.sparse.data',
+    'scipy.sparse.dia',
+    'scipy.sparse.dok',
+    'scipy.sparse.extract',
+    'scipy.sparse.lil',
+    'scipy.sparse.linalg.dsolve',
+    'scipy.sparse.linalg.eigen',
+    'scipy.sparse.linalg.interface',
+    'scipy.sparse.linalg.isolve',
+    'scipy.sparse.linalg.matfuncs',
+    'scipy.sparse.sparsetools',
+    'scipy.sparse.spfuncs',
+    'scipy.sparse.sputils',
+    'scipy.spatial.ckdtree',
+    'scipy.spatial.kdtree',
+    'scipy.spatial.qhull',
+    'scipy.spatial.transform.rotation',
+    'scipy.special.add_newdocs',
+    'scipy.special.basic',
+    'scipy.special.cython_special',
+    'scipy.special.orthogonal',
+    'scipy.special.sf_error',
+    'scipy.special.specfun',
+    'scipy.special.spfun_stats',
+    'scipy.stats.biasedurn',
+    'scipy.stats.kde',
+    'scipy.stats.morestats',
+    'scipy.stats.mstats_basic',
+    'scipy.stats.mstats_extras',
+    'scipy.stats.mvn',
+    'scipy.stats.stats',
+]
+
+
+def is_unexpected(name):
+    """Check if this needs to be considered."""
+    if '._' in name or '.tests' in name or '.setup' in name:
+        return False
+
+    if name in PUBLIC_MODULES:
+        return False
+
+    if name in PRIVATE_BUT_PRESENT_MODULES:
+        return False
+
+    return True
+
+
+SKIP_LIST = [
+    'scipy.conftest',
+    'scipy.version',
+    'scipy.special.libsf_error_state'
+]
+
+
+# XXX: this test does more than it says on the tin - in using `pkgutil.walk_packages`,
+# it will raise if it encounters any exceptions which are not handled by `ignore_errors`
+# while attempting to import each discovered package.
+# For now, `ignore_errors` only ignores what is necessary, but this could be expanded -
+# for example, to all errors from private modules or git subpackages - if desired.
+def test_all_modules_are_expected():
+    """
+    Test that we don't add anything that looks like a new public module by
+    accident.  Check is based on filenames.
+    """
+
+    def ignore_errors(name):
+        # if versions of other array libraries are installed which are incompatible
+        # with the installed NumPy version, there can be errors on importing
+        # `array_api_compat`. This should only raise if SciPy is configured with
+        # that library as an available backend.
+        backends = {'cupy': 'cupy',
+                    'pytorch': 'torch',
+                    'dask.array': 'dask.array'}
+        for backend, dir_name in backends.items():
+            path = f'array_api_compat.{dir_name}'
+            if path in name and backend not in xp_available_backends:
+                return
+        raise
+
+    modnames = []
+
+    for _, modname, _ in pkgutil.walk_packages(path=scipy.__path__,
+                                               prefix=scipy.__name__ + '.',
+                                               onerror=ignore_errors):
+        if is_unexpected(modname) and modname not in SKIP_LIST:
+            # We have a name that is new.  If that's on purpose, add it to
+            # PUBLIC_MODULES.  We don't expect to have to add anything to
+            # PRIVATE_BUT_PRESENT_MODULES.  Use an underscore in the name!
+            modnames.append(modname)
+
+    if modnames:
+        raise AssertionError(f'Found unexpected modules: {modnames}')
+
+
+# Stuff that clearly shouldn't be in the API and is detected by the next test
+# below
+SKIP_LIST_2 = [
+    'scipy.char',
+    'scipy.rec',
+    'scipy.emath',
+    'scipy.math',
+    'scipy.random',
+    'scipy.ctypeslib',
+    'scipy.ma'
+]
+
+
+def test_all_modules_are_expected_2():
+    """
+    Method checking all objects. The pkgutil-based method in
+    `test_all_modules_are_expected` does not catch imports into a namespace,
+    only filenames.
+    """
+
+    def find_unexpected_members(mod_name):
+        members = []
+        module = importlib.import_module(mod_name)
+        if hasattr(module, '__all__'):
+            objnames = module.__all__
+        else:
+            objnames = dir(module)
+
+        for objname in objnames:
+            if not objname.startswith('_'):
+                fullobjname = mod_name + '.' + objname
+                if isinstance(getattr(module, objname), types.ModuleType):
+                    if is_unexpected(fullobjname) and fullobjname not in SKIP_LIST_2:
+                        members.append(fullobjname)
+
+        return members
+
+    unexpected_members = find_unexpected_members("scipy")
+    for modname in PUBLIC_MODULES:
+        unexpected_members.extend(find_unexpected_members(modname))
+
+    if unexpected_members:
+        raise AssertionError("Found unexpected object(s) that look like "
+                             f"modules: {unexpected_members}")
+
+
+def test_api_importable():
+    """
+    Check that all submodules listed higher up in this file can be imported
+    Note that if a PRIVATE_BUT_PRESENT_MODULES entry goes missing, it may
+    simply need to be removed from the list (deprecation may or may not be
+    needed - apply common sense).
+    """
+    def check_importable(module_name):
+        try:
+            importlib.import_module(module_name)
+        except (ImportError, AttributeError):
+            return False
+
+        return True
+
+    module_names = []
+    for module_name in PUBLIC_MODULES:
+        if not check_importable(module_name):
+            module_names.append(module_name)
+
+    if module_names:
+        raise AssertionError("Modules in the public API that cannot be "
+                             f"imported: {module_names}")
+
+    with warnings.catch_warnings(record=True):
+        warnings.filterwarnings('always', category=DeprecationWarning)
+        warnings.filterwarnings('always', category=ImportWarning)
+        for module_name in PRIVATE_BUT_PRESENT_MODULES:
+            if not check_importable(module_name):
+                module_names.append(module_name)
+
+    if module_names:
+        raise AssertionError("Modules that are not really public but looked "
+                             "public and can not be imported: "
+                             f"{module_names}")
+
+
+@pytest.mark.parametrize(("module_name", "correct_module"),
+                         [('scipy.constants.codata', None),
+                          ('scipy.constants.constants', None),
+                          ('scipy.fftpack.basic', None),
+                          ('scipy.fftpack.helper', None),
+                          ('scipy.fftpack.pseudo_diffs', None),
+                          ('scipy.fftpack.realtransforms', None),
+                          ('scipy.integrate.dop', None),
+                          ('scipy.integrate.lsoda', None),
+                          ('scipy.integrate.odepack', None),
+                          ('scipy.integrate.quadpack', None),
+                          ('scipy.integrate.vode', None),
+                          ('scipy.interpolate.fitpack', None),
+                          ('scipy.interpolate.fitpack2', None),
+                          ('scipy.interpolate.interpolate', None),
+                          ('scipy.interpolate.ndgriddata', None),
+                          ('scipy.interpolate.polyint', None),
+                          ('scipy.interpolate.rbf', None),
+                          ('scipy.io.harwell_boeing', None),
+                          ('scipy.io.idl', None),
+                          ('scipy.io.mmio', None),
+                          ('scipy.io.netcdf', None),
+                          ('scipy.io.arff.arffread', 'arff'),
+                          ('scipy.io.matlab.byteordercodes', 'matlab'),
+                          ('scipy.io.matlab.mio_utils', 'matlab'),
+                          ('scipy.io.matlab.mio', 'matlab'),
+                          ('scipy.io.matlab.mio4', 'matlab'),
+                          ('scipy.io.matlab.mio5_params', 'matlab'),
+                          ('scipy.io.matlab.mio5_utils', 'matlab'),
+                          ('scipy.io.matlab.mio5', 'matlab'),
+                          ('scipy.io.matlab.miobase', 'matlab'),
+                          ('scipy.io.matlab.streams', 'matlab'),
+                          ('scipy.linalg.basic', None),
+                          ('scipy.linalg.decomp', None),
+                          ('scipy.linalg.decomp_cholesky', None),
+                          ('scipy.linalg.decomp_lu', None),
+                          ('scipy.linalg.decomp_qr', None),
+                          ('scipy.linalg.decomp_schur', None),
+                          ('scipy.linalg.decomp_svd', None),
+                          ('scipy.linalg.matfuncs', None),
+                          ('scipy.linalg.misc', None),
+                          ('scipy.linalg.special_matrices', None),
+                          ('scipy.misc.common', None),
+                          ('scipy.ndimage.filters', None),
+                          ('scipy.ndimage.fourier', None),
+                          ('scipy.ndimage.interpolation', None),
+                          ('scipy.ndimage.measurements', None),
+                          ('scipy.ndimage.morphology', None),
+                          ('scipy.odr.models', None),
+                          ('scipy.odr.odrpack', None),
+                          ('scipy.optimize.cobyla', None),
+                          ('scipy.optimize.lbfgsb', None),
+                          ('scipy.optimize.linesearch', None),
+                          ('scipy.optimize.minpack', None),
+                          ('scipy.optimize.minpack2', None),
+                          ('scipy.optimize.moduleTNC', None),
+                          ('scipy.optimize.nonlin', None),
+                          ('scipy.optimize.optimize', None),
+                          ('scipy.optimize.slsqp', None),
+                          ('scipy.optimize.tnc', None),
+                          ('scipy.optimize.zeros', None),
+                          ('scipy.signal.bsplines', None),
+                          ('scipy.signal.filter_design', None),
+                          ('scipy.signal.fir_filter_design', None),
+                          ('scipy.signal.lti_conversion', None),
+                          ('scipy.signal.ltisys', None),
+                          ('scipy.signal.signaltools', None),
+                          ('scipy.signal.spectral', None),
+                          ('scipy.signal.waveforms', None),
+                          ('scipy.signal.wavelets', None),
+                          ('scipy.signal.windows.windows', 'windows'),
+                          ('scipy.sparse.lil', None),
+                          ('scipy.sparse.linalg.dsolve', 'linalg'),
+                          ('scipy.sparse.linalg.eigen', 'linalg'),
+                          ('scipy.sparse.linalg.interface', 'linalg'),
+                          ('scipy.sparse.linalg.isolve', 'linalg'),
+                          ('scipy.sparse.linalg.matfuncs', 'linalg'),
+                          ('scipy.sparse.sparsetools', None),
+                          ('scipy.sparse.spfuncs', None),
+                          ('scipy.sparse.sputils', None),
+                          ('scipy.spatial.ckdtree', None),
+                          ('scipy.spatial.kdtree', None),
+                          ('scipy.spatial.qhull', None),
+                          ('scipy.spatial.transform.rotation', 'transform'),
+                          ('scipy.special.add_newdocs', None),
+                          ('scipy.special.basic', None),
+                          ('scipy.special.orthogonal', None),
+                          ('scipy.special.sf_error', None),
+                          ('scipy.special.specfun', None),
+                          ('scipy.special.spfun_stats', None),
+                          ('scipy.stats.biasedurn', None),
+                          ('scipy.stats.kde', None),
+                          ('scipy.stats.morestats', None),
+                          ('scipy.stats.mstats_basic', 'mstats'),
+                          ('scipy.stats.mstats_extras', 'mstats'),
+                          ('scipy.stats.mvn', None),
+                          ('scipy.stats.stats', None)])
+def test_private_but_present_deprecation(module_name, correct_module):
+    # gh-18279, gh-17572, gh-17771 noted that deprecation warnings
+    # for imports from private modules
+    # were misleading. Check that this is resolved.
+    module = import_module(module_name)
+    if correct_module is None:
+        import_name = f'scipy.{module_name.split(".")[1]}'
+    else:
+        import_name = f'scipy.{module_name.split(".")[1]}.{correct_module}'
+
+    correct_import = import_module(import_name)
+
+    # Attributes that were formerly in `module_name` can still be imported from
+    # `module_name`, albeit with a deprecation warning.
+    for attr_name in module.__all__:
+        if attr_name == "varmats_from_mat":
+            # defer handling this case, see
+            # https://github.com/scipy/scipy/issues/19223
+            continue
+        # ensure attribute is present where the warning is pointing
+        assert getattr(correct_import, attr_name, None) is not None
+        message = f"Please import `{attr_name}` from the `{import_name}`..."
+        with pytest.deprecated_call(match=message):
+            getattr(module, attr_name)
+
+    # Attributes that were not in `module_name` get an error notifying the user
+    # that the attribute is not in `module_name` and that `module_name` is deprecated.
+    message = f"`{module_name}` is deprecated..."
+    with pytest.raises(AttributeError, match=message):
+        getattr(module, "ekki")
+
+
+def test_misc_doccer_deprecation():
+    # gh-18279, gh-17572, gh-17771 noted that deprecation warnings
+    # for imports from private modules were misleading.
+    # Check that this is resolved.
+    # `test_private_but_present_deprecation` cannot be used since `correct_import`
+    # is a different subpackage (`_lib` instead of `misc`).
+    module = import_module('scipy.misc.doccer')
+    correct_import = import_module('scipy._lib.doccer')
+
+    # Attributes that were formerly in `scipy.misc.doccer` can still be imported from
+    # `scipy.misc.doccer`, albeit with a deprecation warning. The specific message
+    # depends on whether the attribute is in `scipy._lib.doccer` or not.
+    for attr_name in module.__all__:
+        attr = getattr(correct_import, attr_name, None)
+        if attr is None:
+            message = f"`scipy.misc.{attr_name}` is deprecated..."
+        else:
+            message = f"Please import `{attr_name}` from the `scipy._lib.doccer`..."
+        with pytest.deprecated_call(match=message):
+            getattr(module, attr_name)
+
+    # Attributes that were not in `scipy.misc.doccer` get an error
+    # notifying the user that the attribute is not in `scipy.misc.doccer` 
+    # and that `scipy.misc.doccer` is deprecated.
+    message = "`scipy.misc.doccer` is deprecated..."
+    with pytest.raises(AttributeError, match=message):
+        getattr(module, "ekki")

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_amp_update_scale_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> _amp_update_scale(const at::Tensor & self, const at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval);
+TORCH_API at::Tensor & _amp_update_scale_out(at::Tensor & out, const at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval);
+TORCH_API at::Tensor & _amp_update_scale_outf(const at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_coalesce_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _coalesce {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_coalesce")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_coalesce(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+struct TORCH_API _coalesce_out {
+  using schema = at::Tensor & (const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_coalesce")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_coalesce.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_mkldnn_reshape_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _mkldnn_reshape {
+  using schema = at::Tensor (const at::Tensor &, at::IntArrayRef);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_mkldnn_reshape")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_mkldnn_reshape(Tensor self, int[] shape) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, at::IntArrayRef shape);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef shape);
+};
+
+struct TORCH_API _mkldnn_reshape_out {
+  using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_mkldnn_reshape")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_mkldnn_reshape.out(Tensor self, int[] shape, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::IntArrayRef shape, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef shape, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_csr_sum_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _sparse_csr_sum_dim_dtype {
+  using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional<at::ScalarType>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_csr_sum")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim_dtype")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_csr_sum.dim_dtype(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, c10::optional<at::ScalarType> dtype);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, bool keepdim, c10::optional<at::ScalarType> dtype);
+};
+
+struct TORCH_API _sparse_csr_sum_dim_dtype_out {
+  using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional<at::ScalarType>, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_csr_sum")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim_dtype_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_csr_sum.dim_dtype_out(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, c10::optional<at::ScalarType> dtype, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, bool keepdim, c10::optional<at::ScalarType> dtype, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_copy_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _test_autograd_multiple_dispatch_view_copy {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_test_autograd_multiple_dispatch_view_copy")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_test_autograd_multiple_dispatch_view_copy(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+struct TORCH_API _test_autograd_multiple_dispatch_view_copy_out {
+  using schema = at::Tensor & (const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_test_autograd_multiple_dispatch_view_copy")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_test_autograd_multiple_dispatch_view_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_to_dense_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & _to_dense_out(at::Tensor & out, const at::Tensor & self, c10::optional<at::ScalarType> dtype=c10::nullopt, c10::optional<bool> masked_grad=c10::nullopt);
+TORCH_API at::Tensor & _to_dense_outf(const at::Tensor & self, c10::optional<at::ScalarType> dtype, c10::optional<bool> masked_grad, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/abs_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API abs {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::abs")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "abs(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+struct TORCH_API abs_ {
+  using schema = at::Tensor & (at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::abs_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "abs_(Tensor(a!) self) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self);
+};
+
+struct TORCH_API abs_out {
+  using schema = at::Tensor & (const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::abs")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/argmin_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API argmin {
+  using schema = at::Tensor (const at::Tensor &, c10::optional<int64_t>, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::argmin")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "argmin(Tensor self, int? dim=None, bool keepdim=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, c10::optional<int64_t> dim, bool keepdim);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional<int64_t> dim, bool keepdim);
+};
+
+struct TORCH_API argmin_out {
+  using schema = at::Tensor & (const at::Tensor &, c10::optional<int64_t>, bool, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::argmin")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "argmin.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, c10::optional<int64_t> dim, bool keepdim, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional<int64_t> dim, bool keepdim, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_grid_sampler_backward.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/cudnn_grid_sampler_backward_ops.h>
+
+namespace at {
+
+
+// aten::cudnn_grid_sampler_backward(Tensor self, Tensor grid, Tensor grad_output) -> (Tensor grad_self, Tensor grad_grid)
+inline ::std::tuple<at::Tensor,at::Tensor> cudnn_grid_sampler_backward(const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output) {
+    return at::_ops::cudnn_grid_sampler_backward::call(self, grid, grad_output);
+}
+
+// aten::cudnn_grid_sampler_backward.out(Tensor self, Tensor grid, Tensor grad_output, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
+inline ::std::tuple<at::Tensor &,at::Tensor &> cudnn_grid_sampler_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output) {
+    return at::_ops::cudnn_grid_sampler_backward_out::call(self, grid, grad_output, out0, out1);
+}
+// aten::cudnn_grid_sampler_backward.out(Tensor self, Tensor grid, Tensor grad_output, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
+inline ::std::tuple<at::Tensor &,at::Tensor &> cudnn_grid_sampler_backward_outf(const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output, at::Tensor & out0, at::Tensor & out1) {
+    return at::_ops::cudnn_grid_sampler_backward_out::call(self, grid, grad_output, out0, out1);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/frobenius_norm_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API frobenius_norm_dim {
+  using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::frobenius_norm")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "frobenius_norm.dim(Tensor self, int[1] dim, bool keepdim=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, at::IntArrayRef dim, bool keepdim);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, bool keepdim);
+};
+
+struct TORCH_API frobenius_norm_out {
+  using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::frobenius_norm")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "frobenius_norm.out(Tensor self, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hspmm.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/hspmm_ops.h>
+
+namespace at {
+
+
+// aten::hspmm.out(Tensor mat1, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & hspmm_out(at::Tensor & out, const at::Tensor & mat1, const at::Tensor & mat2) {
+    return at::_ops::hspmm_out::call(mat1, mat2, out);
+}
+// aten::hspmm.out(Tensor mat1, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & hspmm_outf(const at::Tensor & mat1, const at::Tensor & mat2, at::Tensor & out) {
+    return at::_ops::hspmm_out::call(mat1, mat2, out);
+}
+
+// aten::hspmm(Tensor mat1, Tensor mat2) -> Tensor
+inline at::Tensor hspmm(const at::Tensor & mat1, const at::Tensor & mat2) {
+    return at::_ops::hspmm::call(mat1, mat2);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/igammac_compositeexplicitautogradnonfunctional_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautogradnonfunctional {
+
+TORCH_API at::Tensor igammac(const at::Tensor & self, const at::Tensor & other);
+TORCH_API at::Tensor & igammac_(at::Tensor & self, const at::Tensor & other);
+
+} // namespace compositeexplicitautogradnonfunctional
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/item.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/item_ops.h>
+
+namespace at {
+
+
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/kthvalue_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> kthvalue(const at::Tensor & self, int64_t k, int64_t dim=-1, bool keepdim=false);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mse_loss_compositeexplicitautogradnonfunctional_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautogradnonfunctional {
+
+TORCH_API at::Tensor mse_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean);
+
+} // namespace compositeexplicitautogradnonfunctional
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/orgqr_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor orgqr(const at::Tensor & self, const at::Tensor & input2);
+TORCH_API at::Tensor & orgqr_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & input2);
+TORCH_API at::Tensor & orgqr_outf(const at::Tensor & self, const at::Tensor & input2, at::Tensor & out);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ormqr.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/ormqr_ops.h>
+
+namespace at {
+
+
+// aten::ormqr.out(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & ormqr_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & input2, const at::Tensor & input3, bool left=true, bool transpose=false) {
+    return at::_ops::ormqr_out::call(self, input2, input3, left, transpose, out);
+}
+// aten::ormqr.out(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & ormqr_outf(const at::Tensor & self, const at::Tensor & input2, const at::Tensor & input3, bool left, bool transpose, at::Tensor & out) {
+    return at::_ops::ormqr_out::call(self, input2, input3, left, transpose, out);
+}
+
+// aten::ormqr(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False) -> Tensor
+inline at::Tensor ormqr(const at::Tensor & self, const at::Tensor & input2, const at::Tensor & input3, bool left=true, bool transpose=false) {
+    return at::_ops::ormqr::call(self, input2, input3, left, transpose);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pad_sequence_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor pad_sequence(at::TensorList sequences, bool batch_first=false, double padding_value=0.0);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/permute_copy_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & permute_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dims);
+TORCH_API at::Tensor & permute_copy_outf(const at::Tensor & self, at::IntArrayRef dims, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rshift_ops.h

@@ -0,0 +1,83 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API __rshift___Scalar {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Scalar(Tensor self, Scalar other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API __rshift___Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Tensor(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API __irshift___Scalar {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__irshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__irshift__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API __irshift___Tensor {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__irshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__irshift__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API __rshift___Scalar_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+};
+
+struct TORCH_API __rshift___Tensor_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_transpose2d.h

@@ -0,0 +1,91 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/slow_conv_transpose2d_ops.h>
+
+namespace at {
+
+
+// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out);
+  }
+}
+
+// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation, at::Tensor & out) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation, at::Tensor & out) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out);
+  }
+}
+
+// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv_transpose2d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out);
+  }
+}
+
+// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv_transpose2d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
+    return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out);
+  }
+}
+
+// aten::slow_conv_transpose2d(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1) -> Tensor
+inline at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) {
+    return at::_ops::slow_conv_transpose2d::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation));
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) {
+    return at::_ops::slow_conv_transpose2d::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation));
+  }
+}
+
+// aten::slow_conv_transpose2d(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1) -> Tensor
+inline at::Tensor slow_conv_transpose2d_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) {
+    return at::_ops::slow_conv_transpose2d::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) {
+    return at::_ops::slow_conv_transpose2d::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
+  }
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API special_bessel_y0 {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::special_bessel_y0")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "special_bessel_y0(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+struct TORCH_API special_bessel_y0_out {
+  using schema = at::Tensor & (const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::special_bessel_y0")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "special_bessel_y0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_chebyshev_polynomial_u.h

@@ -0,0 +1,67 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/special_chebyshev_polynomial_u_ops.h>
+
+namespace at {
+
+
+// aten::special_chebyshev_polynomial_u(Tensor x, Tensor n) -> Tensor
+inline at::Tensor special_chebyshev_polynomial_u(const at::Tensor & x, const at::Tensor & n) {
+    return at::_ops::special_chebyshev_polynomial_u::call(x, n);
+}
+
+// aten::special_chebyshev_polynomial_u.x_scalar(Scalar x, Tensor n) -> Tensor
+inline at::Tensor special_chebyshev_polynomial_u(const at::Scalar & x, const at::Tensor & n) {
+    return at::_ops::special_chebyshev_polynomial_u_x_scalar::call(x, n);
+}
+
+// aten::special_chebyshev_polynomial_u.n_scalar(Tensor x, Scalar n) -> Tensor
+inline at::Tensor special_chebyshev_polynomial_u(const at::Tensor & x, const at::Scalar & n) {
+    return at::_ops::special_chebyshev_polynomial_u_n_scalar::call(x, n);
+}
+
+// aten::special_chebyshev_polynomial_u.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_chebyshev_polynomial_u_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) {
+    return at::_ops::special_chebyshev_polynomial_u_out::call(x, n, out);
+}
+// aten::special_chebyshev_polynomial_u.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_chebyshev_polynomial_u_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) {
+    return at::_ops::special_chebyshev_polynomial_u_out::call(x, n, out);
+}
+
+// aten::special_chebyshev_polynomial_u.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_chebyshev_polynomial_u_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
+    return at::_ops::special_chebyshev_polynomial_u_x_scalar_out::call(x, n, out);
+}
+// aten::special_chebyshev_polynomial_u.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_chebyshev_polynomial_u_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
+    return at::_ops::special_chebyshev_polynomial_u_x_scalar_out::call(x, n, out);
+}
+
+// aten::special_chebyshev_polynomial_u.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_chebyshev_polynomial_u_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
+    return at::_ops::special_chebyshev_polynomial_u_n_scalar_out::call(x, n, out);
+}
+// aten::special_chebyshev_polynomial_u.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_chebyshev_polynomial_u_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
+    return at::_ops::special_chebyshev_polynomial_u_n_scalar_out::call(x, n, out);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_modified_bessel_i0_cuda_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor special_modified_bessel_i0(const at::Tensor & self);
+TORCH_API at::Tensor & special_modified_bessel_i0_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & special_modified_bessel_i0_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace cuda
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/to_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,27 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor to(const at::Tensor & self, at::TensorOptions options={}, bool non_blocking=false, bool copy=false, c10::optional<at::MemoryFormat> memory_format=c10::nullopt);
+TORCH_API at::Tensor to(const at::Tensor & self, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory, bool non_blocking, bool copy, c10::optional<at::MemoryFormat> memory_format);
+TORCH_API at::Tensor to(const at::Tensor & self, at::Device device, at::ScalarType dtype, bool non_blocking=false, bool copy=false, c10::optional<at::MemoryFormat> memory_format=c10::nullopt);
+TORCH_API at::Tensor to(const at::Tensor & self, at::ScalarType dtype, bool non_blocking=false, bool copy=false, c10::optional<at::MemoryFormat> memory_format=c10::nullopt);
+TORCH_API at::Tensor to(const at::Tensor & self, const at::Tensor & other, bool non_blocking=false, bool copy=false, c10::optional<at::MemoryFormat> memory_format=c10::nullopt);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_trilinear3d_meta_dispatch.h

@@ -0,0 +1,28 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor upsample_trilinear3d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
+TORCH_API at::Tensor upsample_trilinear3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
+TORCH_API at::Tensor & upsample_trilinear3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
+TORCH_API at::Tensor & upsample_trilinear3d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w, at::Tensor & out);
+TORCH_API at::Tensor & upsample_trilinear3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional<double> scales_d=c10::nullopt, c10::optional<double> scales_h=c10::nullopt, c10::optional<double> scales_w=c10::nullopt);
+TORCH_API at::Tensor & upsample_trilinear3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w, at::Tensor & out);
+
+} // namespace meta
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/vander_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor vander(const at::Tensor & x, c10::optional<int64_t> N=c10::nullopt, bool increasing=false);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/view_as.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/view_as_ops.h>
+
+namespace at {
+
+
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/view_cuda_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor view(const at::Tensor & self, at::IntArrayRef size);
+TORCH_API at::Tensor view_symint(const at::Tensor & self, c10::SymIntArrayRef size);
+
+} // namespace cuda
+} // namespace at

vllm/lib/python3.10/site-packages/cupyx/scipy/fft/_fft.py

@@ -0,0 +1,683 @@
+from numbers import Number
+import warnings
+
+import numpy as np
+
+import cupy
+
+from cupy.fft._fft import (_fft, _default_fft_func, hfft as _hfft,
+                           ihfft as _ihfft, _swap_direction)
+
+_scipy_150 = False
+_scipy_160 = False
+try:
+    import scipy
+    import scipy.fft as _scipy_fft
+except ImportError:
+    class _DummyModule:
+        def __getattr__(self, name):
+            return None
+
+    _scipy_fft = _DummyModule()
+else:
+    from numpy.lib import NumpyVersion as Version
+    _scipy_150 = Version(scipy.__version__) >= Version('1.5.0')
+    _scipy_160 = Version(scipy.__version__) >= Version('1.6.0')
+    del Version
+    del scipy
+
+# Backend support for scipy.fft
+
+__ua_domain__ = 'numpy.scipy.fft'
+_implemented: dict = {}
+
+
+def __ua_convert__(dispatchables, coerce):
+    if coerce:
+        try:
+            replaced = [
+                cupy.asarray(d.value) if d.coercible and d.type is np.ndarray
+                else d.value for d in dispatchables]
+        except TypeError:
+            return NotImplemented
+    else:
+        replaced = [d.value for d in dispatchables]
+
+    if not all(d.type is not np.ndarray or isinstance(r, cupy.ndarray)
+               for r, d in zip(replaced, dispatchables)):
+        return NotImplemented
+
+    return replaced
+
+
+def __ua_function__(method, args, kwargs):
+    fn = _implemented.get(method, None)
+    if fn is None:
+        return NotImplemented
+    if 'plan' in kwargs and not _scipy_150:
+        warnings.warn('The \'plan\' argument is supported in SciPy v1.5.0+')
+    return fn(*args, **kwargs)
+
+
+def _implements(scipy_func):
+    """Decorator adds function to the dictionary of implemented functions"""
+    def inner(func):
+        _implemented[scipy_func] = func
+        return func
+
+    return inner
+
+
+def _assequence(x):
+    """Convert scalars to a sequence, otherwise pass through ``x`` unchanged"""
+    if isinstance(x, Number):
+        return (x,)
+    return x
+
+
+@_implements(_scipy_fft.fft)
+def fft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the one-dimensional FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis)
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fft.fft`
+    """
+    from cupy.cuda import cufft
+    return _fft(x, (n,), (axis,), norm, cufft.CUFFT_FORWARD,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.ifft)
+def ifft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the one-dimensional inverse FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis)
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fft.ifft`
+    """
+    from cupy.cuda import cufft
+    return _fft(x, (n,), (axis,), norm, cufft.CUFFT_INVERSE,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.fft2)
+def fft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, *, plan=None):
+    """Compute the two-dimensional FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes)
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fft.fft2`
+    """
+    return fftn(x, s, axes, norm, overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.ifft2)
+def ifft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, *,
+          plan=None):
+    """Compute the two-dimensional inverse FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes)
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fft.ifft2`
+    """
+    return ifftn(x, s, axes, norm, overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.fftn)
+def fftn(x, s=None, axes=None, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the N-dimensional FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes)
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fft.fftn`
+    """
+    from cupy.cuda import cufft
+
+    s = _assequence(s)
+    axes = _assequence(axes)
+    func = _default_fft_func(x, s, axes)
+    return func(x, s, axes, norm, cufft.CUFFT_FORWARD, overwrite_x=overwrite_x,
+                plan=plan)
+
+
+@_implements(_scipy_fft.ifftn)
+def ifftn(x, s=None, axes=None, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the N-dimensional inverse FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes)
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fft.ifftn`
+    """
+    from cupy.cuda import cufft
+
+    s = _assequence(s)
+    axes = _assequence(axes)
+    func = _default_fft_func(x, s, axes)
+    return func(x, s, axes, norm, cufft.CUFFT_INVERSE, overwrite_x=overwrite_x,
+                plan=plan)
+
+
+@_implements(_scipy_fft.rfft)
+def rfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the one-dimensional FFT for real input.
+
+    The returned array contains the positive frequency components of the
+    corresponding :func:`fft`, up to and including the Nyquist frequency.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis,
+                                                        value_type='R2C')
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array.
+
+    .. seealso:: :func:`scipy.fft.rfft`
+
+    """
+    from cupy.cuda import cufft
+
+    return _fft(x, (n,), (axis,), norm, cufft.CUFFT_FORWARD, 'R2C',
+                overwrite_x=overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.irfft)
+def irfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the one-dimensional inverse FFT for real input.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis,
+                                                        value_type='C2R')
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array.
+
+    .. seealso:: :func:`scipy.fft.irfft`
+    """
+    from cupy.cuda import cufft
+    return _fft(x, (n,), (axis,), norm, cufft.CUFFT_INVERSE, 'C2R',
+                overwrite_x=overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.rfft2)
+def rfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, *,
+          plan=None):
+    """Compute the two-dimensional FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape to use from the input. If ``s`` is not
+            given, the lengths of the input along the axes specified by
+            ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes,
+                                                        value_type='R2C')
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. The length of the
+            last axis transformed will be ``s[-1]//2+1``.
+
+    .. seealso:: :func:`scipy.fft.rfft2`
+    """
+    return rfftn(x, s, axes, norm, overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.irfft2)
+def irfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, *,
+           plan=None):
+    """Compute the two-dimensional inverse FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the output. If ``s`` is not given,
+            they are determined from the lengths of the input along the axes
+            specified by ``axes``.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes,
+                                                        value_type='C2R')
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. If ``s`` is not
+            given, the length of final transformed axis of output will be
+            `2*(m-1)` where `m` is the length of the final transformed axis of
+            the input.
+
+    .. seealso:: :func:`scipy.fft.irfft2`
+    """
+    return irfftn(x, s, axes, norm, overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.rfftn)
+def rfftn(x, s=None, axes=None, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the N-dimensional FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape to use from the input. If ``s`` is not
+            given, the lengths of the input along the axes specified by
+            ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes,
+                                                        value_type='R2C')
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. The length of the
+            last axis transformed will be ``s[-1]//2+1``.
+
+    .. seealso:: :func:`scipy.fft.rfftn`
+    """
+    from cupy.cuda import cufft
+
+    s = _assequence(s)
+    axes = _assequence(axes)
+    func = _default_fft_func(x, s, axes, value_type='R2C')
+    return func(x, s, axes, norm, cufft.CUFFT_FORWARD, 'R2C',
+                overwrite_x=overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.irfftn)
+def irfftn(x, s=None, axes=None, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the N-dimensional inverse FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the output. If ``s`` is not given,
+            they are determined from the lengths of the input along the axes
+            specified by ``axes``.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes,
+                                                        value_type='C2R')
+
+            Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
+            an auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. If ``s`` is not
+            given, the length of final transformed axis of output will be
+            ``2*(m-1)`` where `m` is the length of the final transformed axis
+            of the input.
+
+    .. seealso:: :func:`scipy.fft.irfftn`
+    """
+    from cupy.cuda import cufft
+
+    s = _assequence(s)
+    axes = _assequence(axes)
+    func = _default_fft_func(x, s, axes, value_type='C2R')
+    return func(x, s, axes, norm, cufft.CUFFT_INVERSE, 'C2R',
+                overwrite_x=overwrite_x, plan=plan)
+
+
+@_implements(_scipy_fft.hfft)
+def hfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the FFT of a signal that has Hermitian symmetry.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Length of the transformed axis of the output. For
+            ``n`` output points, ``n//2+1`` input points are necessary. If
+            ``n`` is not given, it is determined from the length of the input
+            along the axis specified by ``axis``.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (None): This argument is currently not supported.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other. If ``n`` is not
+            given, the length of the transformed axis is ``2*(m-1)`` where `m`
+            is the length of the transformed axis of the input.
+
+    .. seealso:: :func:`scipy.fft.hfft`
+    """
+    # TODO(leofang): support R2C & C2R plans
+    if plan is not None:
+        raise NotImplementedError('hfft plan is currently not yet supported')
+    return _hfft(x, n, axis, norm)
+
+
+@_implements(_scipy_fft.ihfft)
+def ihfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
+    """Compute the FFT of a signal that has Hermitian symmetry.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Number of points along transformation axis in the
+            input to use. If ``n`` is not given, the length of the input along
+            the axis specified by ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (None): This argument is currently not supported.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other. The length of the
+            transformed axis is ``n//2+1``.
+
+    .. seealso:: :func:`scipy.fft.ihfft`
+    """
+    # TODO(leofang): support R2C & C2R plans
+    if plan is not None:
+        raise NotImplementedError('ihfft plan is currently not yet supported')
+    return _ihfft(x, n, axis, norm)
+
+
+@_implements(_scipy_fft.hfft2)
+def hfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, *,
+          plan=None):
+    """Compute the FFT of a two-dimensional signal that has Hermitian symmetry.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the real output.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+            (This argument is currently not supported)
+        plan (None): This argument is currently not supported.
+
+    Returns:
+        cupy.ndarray:
+            The real result of the 2-D Hermitian complex real FFT.
+
+    .. seealso:: :func:`scipy.fft.hfft2`
+    """
+    if plan is not None:
+        raise NotImplementedError('hfft2 plan is currently not yet supported')
+    return irfft2(x.conj(), s, axes, _swap_direction(norm))
+
+
+@_implements(_scipy_fft.ihfft2)
+def ihfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, *,
+           plan=None):
+    """Compute the Inverse FFT of a two-dimensional signal that has Hermitian
+    symmetry.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the real output.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+            (This argument is currently not supported)
+        plan (None): This argument is currently not supported.
+
+    Returns:
+        cupy.ndarray:
+            The real result of the 2-D Hermitian inverse complex real FFT.
+
+    .. seealso:: :func:`scipy.fft.ihfft2`
+    """
+    if plan is not None:
+        raise NotImplementedError('ihfft2 plan is currently not yet supported')
+    return rfft2(x, s, axes, _swap_direction(norm)).conj()
+
+
+@_implements(_scipy_fft.hfftn)
+def hfftn(x, s=None, axes=None, norm=None, overwrite_x=False, *,
+          plan=None):
+    """Compute the FFT of a N-dimensional signal that has Hermitian symmetry.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the real output.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+            (This argument is currently not supported)
+        plan (None): This argument is currently not supported.
+
+    Returns:
+        cupy.ndarray:
+            The real result of the N-D Hermitian complex real FFT.
+
+    .. seealso:: :func:`scipy.fft.hfftn`
+    """
+    if plan is not None:
+        raise NotImplementedError('hfftn plan is currently not yet supported')
+    return irfftn(x.conj(), s, axes, _swap_direction(norm))
+
+
+@_implements(_scipy_fft.ihfftn)
+def ihfftn(x, s=None, axes=None, norm=None, overwrite_x=False, *,
+           plan=None):
+    """Compute the Inverse FFT of a N-dimensional signal that has Hermitian
+    symmetry.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        s (None or tuple of ints): Shape of the real output.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+            (This argument is currently not supported)
+        plan (None): This argument is currently not supported.
+
+    Returns:
+        cupy.ndarray:
+            The real result of the N-D Hermitian inverse complex real FFT.
+
+    .. seealso:: :func:`scipy.fft.ihfftn`
+    """
+    if plan is not None:
+        raise NotImplementedError('ihfftn plan is currently not yet supported')
+    return rfftn(x, s, axes, _swap_direction(norm)).conj()

vllm/lib/python3.10/site-packages/cupyx/scipy/fft/_helper.py

@@ -0,0 +1,51 @@
+from typing import Dict, List, Tuple
+
+import math
+
+
+_next_fast_len_cache: Dict[Tuple[int, List[int]], int] = {}
+
+
+def _next_fast_len_impl(n, primes):
+    if len(primes) == 0:
+        return math.inf
+    result = _next_fast_len_cache.get((n, primes), None)
+    if result is None:
+        if n == 1:
+            result = 1
+        else:
+            p = primes[0]
+            result = min(
+                _next_fast_len_impl((n + p - 1) // p, primes) * p,
+                _next_fast_len_impl(n, primes[1:]))
+        _next_fast_len_cache[(n, primes)] = result
+    return result
+
+
+def next_fast_len(target, real=False):
+    """Find the next fast size to ``fft``.
+
+    Args:
+        target (int): The size of input array.
+        real (bool): ``True`` if the FFT involves real input or output.
+            This parameter is of no use, and only for compatibility to
+            SciPy's interface.
+
+    Returns:
+        int: The smallest fast length greater than or equal to the input value.
+
+    .. seealso:: :func:`scipy.fft.next_fast_len`
+
+    .. note::
+        It may return a different value to :func:`scipy.fft.next_fast_len`
+        as pocketfft's prime factors are different from cuFFT's factors.
+        For details, see the `cuFFT documentation`_.
+
+    .. _cuFFT documentation:
+        https://docs.nvidia.com/cuda/cufft/index.html#accuracy-and-performance
+    """
+    if target == 0:
+        return 0
+
+    primes = (2, 3, 5, 7)
+    return _next_fast_len_impl(target, primes)

vllm/lib/python3.10/site-packages/cupyx/scipy/fft/_realtransforms.py

@@ -0,0 +1,922 @@
+"""Real-to-real transforms
+
+cuFFT does not implement real-to-real FFTs. This module implements forward
+and inverse DCT-II and DCT-III transforms using FFTs.
+
+A length N DCT can be computed using a length N FFT and some additional
+multiplications and reordering of entries.
+
+The approach taken here is based on the work in [1]_, [2]_ and is discussed in
+the freely-available online resources [3]_, [4]_.
+
+The implementation here follows that approach with only minor modification to
+match the normalization conventions in SciPy.
+
+The modifications to turn a type II or III DCT to a DST were implemented as
+described in [5]_.
+
+.. [1] J. Makhoul, "A fast cosine transform in one and two dimensions," in
+    IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. 28,
+    no. 1, pp. 27-34, February 1980.
+
+.. [2] M.J. Narasimha and A.M. Peterson, “On the computation of the discrete
+    cosine  transform,” IEEE Trans. Commun., vol. 26, no. 6, pp. 934–936, 1978.
+
+.. [3] http://fourier.eng.hmc.edu/e161/lectures/dct/node2.html
+
+.. [4] https://dsp.stackexchange.com/questions/2807/fast-cosine-transform-via-fft
+
+.. [5] X. Shao, S. G. Johnson. Type-II/III DCT/DST algorithms with reduced
+    number of arithmetic operations, Signal Processing, Volume 88, Issue 6,
+    pp. 1553-1564, 2008.
+"""
+
+import math
+import numbers
+import operator
+
+import cupy
+from cupy import _core
+from cupy.fft._fft import _cook_shape
+from cupyx.scipy.fft import _fft
+from cupy.exceptions import AxisError
+
+__all__ = ['dct', 'dctn', 'dst', 'dstn', 'idct', 'idctn', 'idst', 'idstn']
+
+
+def _promote_dtype(x):
+    if x.dtype.kind in 'bui':
+        # use float64 instead of promote_types to match SciPy's behavior
+        float_dtype = cupy.float64
+    else:
+        float_dtype = cupy.promote_types(x.dtype, cupy.float32)
+    return x.astype(float_dtype, copy=False)
+
+
+def _get_dct_norm_factor(n, inorm, dct_type=2):
+    """Normalization factors for DCT/DST I-IV.
+
+    Parameters
+    ----------
+    n : int
+        Data size.
+    inorm : {'none', 'sqrt', 'full'}
+        When `inorm` is 'none', the scaling factor is 1.0 (unnormalized). When
+        `inorm` is 1, scaling by ``1/sqrt(d)`` as needed for an orthogonal
+        transform is used. When `inorm` is 2, normalization by ``1/d`` is
+        applied. The value of ``d`` depends on both `n` and the `dct_type`.
+    dct_type : {1, 2, 3, 4}
+        Which type of DCT or DST is being normalized?.
+
+    Returns
+    -------
+    fct : float
+        The normalization factor.
+    """
+    if inorm == 'none':
+        return 1
+    delta = -1 if dct_type == 1 else 0
+    d = 2 * (n + delta)
+    if inorm == 'full':
+        fct = 1 / d
+    elif inorm == 'sqrt':
+        fct = 1 / math.sqrt(d)
+    else:
+        raise ValueError('expected inorm = "none", "sqrt" or "full"')
+    return fct
+
+
+def _reshuffle_dct2(x, n, axis, dst=False):
+    """Reorder entries to allow computation of DCT/DST-II via FFT."""
+    sl_even = [slice(None)] * x.ndim
+    sl_even[axis] = slice(0, None, 2)
+    sl_even = tuple(sl_even)
+    sl_odd = [slice(None)] * x.ndim
+    if n % 2:
+        sl_odd[axis] = slice(-2, None, -2)
+        sl_odd = tuple(sl_odd)
+    else:
+        sl_odd[axis] = slice(None, None, -2)
+        sl_odd = tuple(sl_odd)
+    if dst:
+        x = cupy.concatenate((x[sl_even], -x[sl_odd]), axis=axis)
+    else:
+        x = cupy.concatenate((x[sl_even], x[sl_odd]), axis=axis)
+    return x
+
+
+_mult_factor_dct2 = _core.ElementwiseKernel(
+    in_params='R xr, int32 N, R norm_factor',
+    out_params='C y',
+    operation="""
+    C j(0., -1.);
+    y = (R)2.0 * norm_factor * exp(j * (R)(i * M_PI / (2 * N)));""",
+)
+
+
+def _exp_factor_dct2(x, n, axis, norm_factor, n_truncate=None):
+    """Twiddle & scaling factors for computation of DCT/DST-II via FFT."""
+    if n_truncate is None:
+        n_truncate = n
+    tmp = cupy.empty((n_truncate,), dtype=x.dtype)
+    _mult_factor_dct2(tmp.real, n, norm_factor, tmp)
+
+    if x.ndim == 1:
+        return tmp
+    tmp_shape = [1] * x.ndim
+    tmp_shape[axis] = n_truncate
+    tmp_shape = tuple(tmp_shape)
+    return tmp.reshape(tmp_shape)
+
+
+def _dct_or_dst_type2(
+    x, n=None, axis=-1, forward=True, norm=None, dst=False, overwrite_x=False
+):
+    """Forward DCT/DST-II (or inverse DCT/DST-III) along a single axis
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The data to transform.
+    n : int
+        The size of the transform. If None, ``x.shape[axis]`` is used.
+    axis : int
+        Axis along which the transform is applied.
+    forward : bool
+        Set true to indicate that this is a forward DCT-II as opposed to an
+        inverse DCT-III (The difference between the two is only in the
+        normalization factor).
+    norm : {None, 'ortho', 'forward', 'backward'}
+        The normalization convention to use.
+    dst : bool
+        If True, a discrete sine transform is computed rather than the discrete
+        cosine transform.
+    overwrite_x : bool
+        Indicates that it is okay to overwrite x. In practice, the current
+        implementation never performs the transform in-place.
+
+    Returns
+    -------
+    y: cupy.ndarray
+        The transformed array.
+    """
+    if axis < -x.ndim or axis >= x.ndim:
+        raise AxisError('axis out of range')
+    if axis < 0:
+        axis += x.ndim
+    if n is not None and n < 1:
+        raise ValueError(
+            f'invalid number of data points ({n}) specified'
+        )
+
+    x = _cook_shape(x, (n,), (axis,), 'R2R')
+    n = x.shape[axis]
+
+    x = _reshuffle_dct2(x, x.shape[axis], axis, dst)
+
+    if norm == 'ortho':
+        inorm = 'sqrt'
+    elif norm == 'forward':
+        inorm = 'full' if forward else 'none'
+    else:
+        inorm = 'none' if forward else 'full'
+    norm_factor = _get_dct_norm_factor(n, inorm=inorm, dct_type=2)
+
+    x = _fft.fft(x, n=n, axis=axis, overwrite_x=True)
+    tmp = _exp_factor_dct2(x, n, axis, norm_factor)
+
+    x *= tmp  # broadcasting
+    x = cupy.real(x)
+
+    if norm == 'ortho':
+        sl0 = [slice(None)] * x.ndim
+        sl0[axis] = slice(1)
+        x[tuple(sl0)] *= math.sqrt(2) * 0.5
+
+    if dst:
+        slrev = [slice(None)] * x.ndim
+        slrev[axis] = slice(None, None, -1)
+        x = x[tuple(slrev)]
+    return x
+
+
+def _reshuffle_dct3(y, n, axis, dst):
+    """Reorder entries to allow computation of DCT/DST-II via FFT."""
+    x = cupy.empty_like(y)
+    n_half = (n + 1) // 2
+
+    # Store first half of y in the even entries of the output
+    sl_even = [slice(None)] * y.ndim
+    sl_even[axis] = slice(0, None, 2)
+    sl_even = tuple(sl_even)
+
+    sl_half = [slice(None)] * y.ndim
+    sl_half[axis] = slice(0, n_half)
+    x[sl_even] = y[tuple(sl_half)]
+
+    # Store the second half of y in the odd entries of the output
+    sl_odd = [slice(None)] * y.ndim
+    sl_odd[axis] = slice(1, None, 2)
+    sl_odd = tuple(sl_odd)
+
+    sl_half[axis] = slice(-1, n_half - 1, -1)
+    if dst:
+        x[sl_odd] = -y[tuple(sl_half)]
+    else:
+        x[sl_odd] = y[tuple(sl_half)]
+    return x
+
+
+_mult_factor_dct3 = _core.ElementwiseKernel(
+    in_params='R xr, int32 N, R norm_factor',
+    out_params='C y',
+    operation="""
+    C j(0., 1.);
+    y = (R)(2 * N * norm_factor) * exp(j * (R)(i * M_PI / (2 * N)));""",
+)
+
+
+def _exp_factor_dct3(x, n, axis, dtype, norm_factor):
+    """Twiddle & scaling factors for computation of DCT/DST-III via FFT."""
+    tmp = cupy.empty((n,), dtype=dtype)
+    _mult_factor_dct3(tmp.real, n, norm_factor, tmp)
+    if x.ndim == 1:
+        return tmp
+    # prepare shape for broadcasting along non-transformed axes
+    tmp_shape = [1] * x.ndim
+    tmp_shape[axis] = n
+    tmp_shape = tuple(tmp_shape)
+    return tmp.reshape(tmp_shape)
+
+
+def _dct_or_dst_type3(
+    x, n=None, axis=-1, norm=None, forward=True, dst=False, overwrite_x=False
+):
+    """Forward DCT/DST-III (or inverse DCT/DST-II) along a single axis.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The data to transform.
+    n : int
+        The size of the transform. If None, ``x.shape[axis]`` is used.
+    axis : int
+        Axis along which the transform is applied.
+    forward : bool
+        Set true to indicate that this is a forward DCT-II as opposed to an
+        inverse DCT-III (The difference between the two is only in the
+        normalization factor).
+    norm : {None, 'ortho', 'forward', 'backward'}
+        The normalization convention to use.
+    dst : bool
+        If True, a discrete sine transform is computed rather than the discrete
+        cosine transform.
+    overwrite_x : bool
+        Indicates that it is okay to overwrite x. In practice, the current
+        implementation never performs the transform in-place.
+
+    Returns
+    -------
+    y: cupy.ndarray
+        The transformed array.
+
+    """
+    if axis < -x.ndim or axis >= x.ndim:
+        raise AxisError('axis out of range')
+    if axis < 0:
+        axis += x.ndim
+    if n is not None and n < 1:
+        raise ValueError(
+            f'invalid number of data points ({n}) specified'
+        )
+
+    x = _cook_shape(x, (n,), (axis,), 'R2R')
+    n = x.shape[axis]
+
+    # determine normalization factor
+    if norm == 'ortho':
+        sl0_scale = 0.5 * math.sqrt(2)
+        inorm = 'sqrt'
+    elif norm == 'forward':
+        sl0_scale = 0.5
+        inorm = 'full' if forward else 'none'
+    elif norm == 'backward' or norm is None:
+        sl0_scale = 0.5
+        inorm = 'none' if forward else 'full'
+    else:
+        raise ValueError(f'Invalid norm value "{norm}", should be "backward", '
+                         '"ortho" or "forward"')
+    norm_factor = _get_dct_norm_factor(n, inorm=inorm, dct_type=3)
+    dtype = cupy.promote_types(x, cupy.complex64)
+
+    sl0 = [slice(None)] * x.ndim
+    sl0[axis] = slice(1)
+
+    if dst:
+        slrev = [slice(None)] * x.ndim
+        slrev[axis] = slice(None, None, -1)
+        x = x[tuple(slrev)]
+        if norm == 'ortho':
+            float_dtype = cupy.promote_types(x.dtype, cupy.float32)
+            if x.dtype != float_dtype:
+                x = x.astype(float_dtype)
+            elif not overwrite_x:
+                x = x.copy()
+            x[tuple(sl0)] *= math.sqrt(2)
+            sl0_scale = 0.5
+
+    # scale by exponentials and normalization factor
+    tmp = _exp_factor_dct3(x, n, axis, dtype, norm_factor)
+    x = x * tmp  # broadcasting
+    x[tuple(sl0)] *= sl0_scale
+
+    # inverse fft
+    x = _fft.ifft(x, n=n, axis=axis, overwrite_x=True)
+    x = cupy.real(x)
+
+    # reorder entries
+    return _reshuffle_dct3(x, n, axis, dst)
+
+
+@_fft._implements(_fft._scipy_fft.dct)
+def dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False):
+    """Return the Discrete Cosine Transform of an array, x.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DCT (see Notes). Default type is 2. Currently CuPy only
+        supports types 2 and 3.
+    n : int, optional:
+        Length of the transform.  If ``n < x.shape[axis]``, `x` is
+        truncated. If ``n > x.shape[axis]``, `x` is zero-padded.
+        The default results in ``n = x.shape[axis]``.
+    axis : int, optional
+        Axis along which the dct is computed; the default is over the
+        last axis (i.e., ``axis=-1``).
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    y : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.dct`
+
+    Notes
+    -----
+    For a single dimension array ``x``, ``dct(x, norm='ortho')`` is equal
+    to MATLAB ``dct(x)``.
+
+    For ``norm="ortho"`` both the `dct` and `idct` are scaled by the same
+    overall factor in both directions. By default, the transform is also
+    orthogonalized which for types 1, 2 and 3 means the transform definition is
+    modified to give orthogonality of the DCT matrix (see below).
+
+    For ``norm="backward"``, there is no scaling on `dct` and the `idct` is
+    scaled by ``1/N`` where ``N`` is the "logical" size of the DCT. For
+    ``norm="forward"`` the ``1/N`` normalization is applied to the forward
+    `dct` instead and the `idct` is unnormalized.
+
+    CuPy currently only supports DCT types 2 and 3. 'The' DCT generally
+    refers to DCT type 2, and 'the' Inverse DCT generally refers to DCT
+    type 3 [1]_. See the :func:`scipy.fft.dct` documentation for a full
+    description of each type.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Discrete cosine transform",
+           https://en.wikipedia.org/wiki/Discrete_cosine_transform
+
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = dct(x.real, type, n, axis, norm, overwrite_x)
+        out = out + 1j * dct(x.imag, type, n, axis, norm, overwrite_x)
+        return out
+
+    x = _promote_dtype(x)
+
+    if type == 2:
+        return _dct_or_dst_type2(
+            x, n=n, axis=axis, norm=norm, forward=True, dst=False
+        )
+    elif type == 3:
+        return _dct_or_dst_type3(
+            x, n=n, axis=axis, norm=norm, forward=True, dst=False
+        )
+    elif type in [1, 4]:
+        raise NotImplementedError(
+            'Only DCT-II and DCT-III have been implemented.'
+        )
+    else:
+        raise ValueError('invalid DCT type')
+
+
+@_fft._implements(_fft._scipy_fft.dst)
+def dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False):
+    """Return the Discrete Sine Transform of an array, x.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DST (see Notes). Default type is 2.
+    n : int, optional
+        Length of the transform.  If ``n < x.shape[axis]``, `x` is
+        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
+        default results in ``n = x.shape[axis]``.
+    axis : int, optional
+        Axis along which the dst is computed; the default is over the
+        last axis (i.e., ``axis=-1``).
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    dst : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.dst`
+
+    Notes
+    -----
+
+    For ``norm="ortho"`` both the `dst` and `idst` are scaled by the same
+    overall factor in both directions. By default, the transform is also
+    orthogonalized which for types 2 and 3 means the transform definition is
+    modified to give orthogonality of the DST matrix (see below).
+
+    For ``norm="backward"``, there is no scaling on the `dst` and the `idst` is
+    scaled by ``1/N`` where ``N`` is the "logical" size of the DST.
+
+    See the :func:`scipy.fft.dst` documentation for a full description of each
+    type. CuPy currently only supports DST types 2 and 3.
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = dst(x.real, type, n, axis, norm, overwrite_x)
+        out = out + 1j * dst(x.imag, type, n, axis, norm, overwrite_x)
+        return out
+
+    x = _promote_dtype(x)
+
+    if type == 2:
+        return _dct_or_dst_type2(
+            x, n=n, axis=axis, norm=norm, forward=True, dst=True
+        )
+    elif type == 3:
+        return _dct_or_dst_type3(
+            x, n=n, axis=axis, norm=norm, forward=True, dst=True
+        )
+    elif type in [1, 4]:
+        raise NotImplementedError(
+            'Only DST-II and DST-III have been implemented.'
+        )
+    else:
+        raise ValueError('invalid DST type')
+
+
+@_fft._implements(_fft._scipy_fft.idct)
+def idct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False):
+    """Return the Inverse Discrete Cosine Transform of an array, x.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DCT (see Notes). Default type is 2.
+    n : int, optional
+        Length of the transform.  If ``n < x.shape[axis]``, `x` is
+        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
+        default results in ``n = x.shape[axis]``.
+    axis : int, optional
+        Axis along which the idct is computed; the default is over the
+        last axis (i.e., ``axis=-1``).
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    idct : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.idct`
+
+    Notes
+    -----
+    For a single dimension array `x`, ``idct(x, norm='ortho')`` is equal to
+    MATLAB ``idct(x)``.
+
+    For ``norm="ortho"`` both the `dct` and `idct` are scaled by the same
+    overall factor in both directions. By default, the transform is also
+    orthogonalized which for types 1, 2 and 3 means the transform definition is
+    modified to give orthogonality of the IDCT matrix (see `dct` for the full
+    definitions).
+
+    'The' IDCT is the IDCT-II, which is the same as the normalized DCT-III
+    [1]_. See the :func:`scipy.fft.dct` documentation for a full description of
+    each type. CuPy currently only supports DCT types 2 and 3.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Discrete sine transform",
+           https://en.wikipedia.org/wiki/Discrete_sine_transform
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = idct(x.real, type, n, axis, norm, overwrite_x)
+        out = out + 1j * idct(x.imag, type, n, axis, norm, overwrite_x)
+        return out
+
+    x = _promote_dtype(x)
+
+    if type == 2:
+        # DCT-III is the inverse of DCT-II
+        return _dct_or_dst_type3(x, n=n, axis=axis, norm=norm, forward=False)
+    elif type == 3:
+        # DCT-II is the inverse of DCT-III
+        return _dct_or_dst_type2(x, n=n, axis=axis, norm=norm, forward=False)
+    elif type in [1, 4]:
+        raise NotImplementedError(
+            'Only DCT-II and DCT-III have been implemented.'
+        )
+    else:
+        raise ValueError('invalid DCT type')
+
+
+@_fft._implements(_fft._scipy_fft.idst)
+def idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False):
+    """Return the Inverse Discrete Sine Transform of an array, x.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DST (see Notes). Default type is 2.
+    n : int, optional
+        Length of the transform. If ``n < x.shape[axis]``, `x` is
+        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
+        default results in ``n = x.shape[axis]``.
+    axis : int, optional
+        Axis along which the idst is computed; the default is over the
+        last axis (i.e., ``axis=-1``).
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    idst : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.idst`
+
+    Notes
+    -----
+    For full details of the DST types and normalization modes, as well as
+    references, see :func:`scipy.fft.dst`.
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = idst(x.real, type, n, axis, norm, overwrite_x)
+        out = out + 1j * idst(x.imag, type, n, axis, norm, overwrite_x)
+        return out
+
+    x = _promote_dtype(x)
+
+    if type == 2:
+        # DCT-III is the inverse of DCT-II
+        return _dct_or_dst_type3(
+            x, n=n, axis=axis, norm=norm, forward=False, dst=True
+        )
+    elif type == 3:
+        # DCT-II is the inverse of DCT-III
+        return _dct_or_dst_type2(
+            x, n=n, axis=axis, norm=norm, forward=False, dst=True
+        )
+    elif type in [1, 4]:
+        raise NotImplementedError(
+            'Only DST-II and DST-III have been implemented.'
+        )
+    else:
+        raise ValueError('invalid DST type')
+
+
+def _iterable_of_int(x, name=None):
+    """Convert ``x`` to an iterable sequence of int."""
+    if isinstance(x, numbers.Number):
+        x = (x,)
+
+    try:
+        x = [operator.index(a) for a in x]
+    except TypeError as e:
+        name = name or 'value'
+        raise ValueError(
+            f'{name} must be a scalar or iterable of integers'
+        ) from e
+
+    return x
+
+
+def _init_nd_shape_and_axes(x, shape, axes):
+    """Handles shape and axes arguments for nd transforms."""
+    noshape = shape is None
+    noaxes = axes is None
+
+    if not noaxes:
+        axes = _iterable_of_int(axes, 'axes')
+        axes = [a + x.ndim if a < 0 else a for a in axes]
+
+        if any(a >= x.ndim or a < 0 for a in axes):
+            raise ValueError('axes exceeds dimensionality of input')
+        if len(set(axes)) != len(axes):
+            raise ValueError('all axes must be unique')
+
+    if not noshape:
+        shape = _iterable_of_int(shape, 'shape')
+        nshape = len(shape)
+        if axes and len(axes) != nshape:
+            raise ValueError(
+                'when given, axes and shape arguments'
+                ' have to be of the same length'
+            )
+        if noaxes:
+            if nshape > x.ndim:
+                raise ValueError('shape requires more axes than are present')
+            axes = range(x.ndim - len(shape), x.ndim)
+
+        shape = [x.shape[a] if s == -1 else s for s, a in zip(shape, axes)]
+    elif noaxes:
+        shape = list(x.shape)
+        axes = range(x.ndim)
+    else:
+        shape = [x.shape[a] for a in axes]
+
+    if any(s < 1 for s in shape):
+        raise ValueError(
+            f'invalid number of data points ({shape}) specified'
+        )
+
+    return shape, axes
+
+
+@_fft._implements(_fft._scipy_fft.dctn)
+def dctn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False):
+    """Compute a multidimensional Discrete Cosine Transform.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DCT (see Notes). Default type is 2.
+    s : int or array_like of ints or None, optional
+        The shape of the result. If both `s` and `axes` (see below) are None,
+        `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
+        ``numpy.take(x.shape, axes, axis=0)``.
+        If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
+        If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
+        ``s[i]``.
+        If any element of `s` is -1, the size of the corresponding dimension of
+        `x` is used.
+    axes : int or array_like of ints or None, optional
+        Axes over which the DCT is computed. If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    y : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.dctn`
+
+    Notes
+    -----
+    For full details of the DCT types and normalization modes, as well as
+    references, see `dct`.
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = dctn(x.real, type, s, axes, norm, overwrite_x)
+        out = out + 1j * dctn(x.imag, type, s, axes, norm, overwrite_x)
+        return out
+
+    shape, axes = _init_nd_shape_and_axes(x, s, axes)
+    x = _promote_dtype(x)
+
+    if len(axes) == 0:
+        return x
+
+    for n, axis in zip(shape, axes):
+        x = dct(
+            x, type=type, n=n, axis=axis, norm=norm, overwrite_x=overwrite_x
+        )
+    return x
+
+
+@_fft._implements(_fft._scipy_fft.idctn)
+def idctn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False):
+    """Compute a multidimensional Discrete Cosine Transform.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DCT (see Notes). Default type is 2.
+    s : int or array_like of ints or None, optional
+        The shape of the result. If both `s` and `axes` (see below) are None,
+        `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
+        ``numpy.take(x.shape, axes, axis=0)``.
+        If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
+        If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
+        ``s[i]``.
+        If any element of `s` is -1, the size of the corresponding dimension of
+        `x` is used.
+    axes : int or array_like of ints or None, optional
+        Axes over which the IDCT is computed. If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    y : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.idctn`
+
+    Notes
+    -----
+    For full details of the IDCT types and normalization modes, as well as
+    references, see :func:`scipy.fft.idct`.
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = idctn(x.real, type, s, axes, norm, overwrite_x)
+        out = out + 1j * idctn(x.imag, type, s, axes, norm, overwrite_x)
+        return out
+
+    shape, axes = _init_nd_shape_and_axes(x, s, axes)
+    x = _promote_dtype(x)
+
+    if len(axes) == 0:
+        return x
+
+    for n, axis in zip(shape, axes):
+        x = idct(
+            x, type=type, n=n, axis=axis, norm=norm, overwrite_x=overwrite_x
+        )
+    return x
+
+
+@_fft._implements(_fft._scipy_fft.dstn)
+def dstn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False):
+    """Compute a multidimensional Discrete Sine Transform.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DST (see Notes). Default type is 2.
+    s : int or array_like of ints or None, optional
+        The shape of the result. If both `s` and `axes` (see below) are None,
+        `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
+        ``numpy.take(x.shape, axes, axis=0)``.
+        If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
+        If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
+        ``s[i]``.
+        If any element of `s` is -1, the size of the corresponding dimension of
+        `x` is used.
+    axes : int or array_like of ints or None, optional
+        Axes over which the DST is computed. If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    y : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.dstn`
+
+    Notes
+    -----
+    For full details of the DST types and normalization modes, as well as
+    references, see :func:`scipy.fft.dst`.
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = dstn(x.real, type, s, axes, norm, overwrite_x)
+        out = out + 1j * dstn(x.imag, type, s, axes, norm, overwrite_x)
+        return out
+
+    shape, axes = _init_nd_shape_and_axes(x, s, axes)
+    x = _promote_dtype(x)
+
+    if len(axes) == 0:
+        return x
+
+    for n, axis in zip(shape, axes):
+        x = dst(
+            x, type=type, n=n, axis=axis, norm=norm, overwrite_x=overwrite_x
+        )
+    return x
+
+
+@_fft._implements(_fft._scipy_fft.idstn)
+def idstn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False):
+    """Compute a multidimensional Discrete Sine Transform.
+
+    Parameters
+    ----------
+    x : cupy.ndarray
+        The input array.
+    type : {1, 2, 3, 4}, optional
+        Type of the DST (see Notes). Default type is 2.
+    s : int or array_like of ints or None, optional
+        The shape of the result. If both `s` and `axes` (see below) are None,
+        `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
+        ``numpy.take(x.shape, axes, axis=0)``.
+        If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
+        If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
+        ``s[i]``.
+        If any element of `s` is -1, the size of the corresponding dimension of
+        `x` is used.
+    axes : int or array_like of ints or None, optional
+        Axes over which the IDST is computed. If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+    norm : {"backward", "ortho", "forward"}, optional
+        Normalization mode (see Notes). Default is "backward".
+    overwrite_x : bool, optional
+        If True, the contents of `x` can be destroyed; the default is False.
+
+    Returns
+    -------
+    y : cupy.ndarray of real
+        The transformed input array.
+
+    See Also
+    --------
+    :func:`scipy.fft.idstn`
+
+    Notes
+    -----
+    For full details of the IDST types and normalization modes, as well as
+    references, see :func:`scipy.fft.idst`.
+    """
+    if x.dtype.kind == 'c':
+        # separable application on real and imaginary parts
+        out = idstn(x.real, type, s, axes, norm, overwrite_x)
+        out = out + 1j * idstn(x.imag, type, s, axes, norm, overwrite_x)
+        return out
+
+    shape, axes = _init_nd_shape_and_axes(x, s, axes)
+    x = _promote_dtype(x)
+
+    if len(axes) == 0:
+        return x
+
+    for n, axis in zip(shape, axes):
+        x = idst(
+            x, type=type, n=n, axis=axis, norm=norm, overwrite_x=overwrite_x
+        )
+    return x

vllm/lib/python3.10/site-packages/cupyx/scipy/linalg/__init__.py

@@ -0,0 +1,21 @@
+# flake8: NOQA
+from cupyx.scipy.linalg._special_matrices import (
+    tri, tril, triu, toeplitz, circulant, hankel,
+    hadamard, leslie, kron, block_diag, companion,
+    helmert, hilbert, dft,
+    fiedler, fiedler_companion, convolution_matrix
+)
+from cupyx.scipy.linalg._solve_triangular import solve_triangular  # NOQA
+from cupyx.scipy.linalg._decomp_lu import lu, lu_factor, lu_solve  # NOQA
+
+# uarray backend support (NEP 31)
+# The uarray feature for scipy.linalg is experimental.
+# The interface can change in the future.
+from cupyx.scipy.linalg._uarray import __ua_convert__  # NOQA
+from cupyx.scipy.linalg._uarray import __ua_domain__  # NOQA
+from cupyx.scipy.linalg._uarray import __ua_function__  # NOQA
+
+from cupyx.scipy.linalg._array_utils import bandwidth  # NOQA
+from cupyx.scipy.linalg._matfuncs import khatri_rao  # NOQA
+
+from cupyx.scipy.linalg._matfuncs import expm  # NOQA

vllm/lib/python3.10/site-packages/cupyx/scipy/linalg/_array_utils.py

@@ -0,0 +1,55 @@
+import cupy
+from cupy.linalg import _util
+
+# Find the "bandwise position" of a nonzero cell
+_kernel_cupy_band_pos_c = cupy.ElementwiseKernel(
+    'T A, N r, N c',
+    'N out',
+    'out = A != 0 ? r - c : 0',
+    'cupyx_scipy_linalg_band_pos'
+)
+
+
+def bandwidth(a):
+    """Return the lower and upper bandwidth of a 2D numeric array.
+    Parameters
+    ----------
+    a : ndarray
+        Input array of size (M, N)
+    Returns
+    -------
+    lu : tuple
+        2-tuple of ints indicating the lower and upper bandwidth. A zero
+        denotes no sub- or super-diagonal on that side (triangular), and,
+        say for M rows (M-1) means that side is full. Same example applies
+        to the upper triangular part with (N-1).
+
+    .. seealso:: :func:`scipy.linalg.bandwidth`
+    """
+
+    a = cupy.asarray(a)
+
+    if a.size == 0:
+        return (0, 0)
+    _util._assert_2d(a)
+
+    # Create new matrix A which is C contiguous
+    if a.flags['F_CONTIGUOUS']:
+        A = a.T
+    else:
+        A = a
+
+    # row_num and col_num contain info on the row and column number of A
+    m, n = A.shape
+    row_num, col_num = cupy.mgrid[0:m, 0:n]
+    bandpts = _kernel_cupy_band_pos_c(A, row_num, col_num)
+
+    # If F contiguous, transpose
+    if a.flags['F_CONTIGUOUS']:
+        upper_band = int(cupy.amax(bandpts))
+        lower_band = -int(cupy.amin(bandpts))
+    else:
+        lower_band = int(cupy.amax(bandpts))
+        upper_band = -int(cupy.amin(bandpts))
+
+    return lower_band, upper_band