Updated script that can be controled by Nodejs web app

lib/python3.13/site-packages/numpy/testing/_private/extbuild.py

@@ -0,0 +1,252 @@
+"""
+Build a c-extension module on-the-fly in tests.
+See build_and_import_extensions for usage hints
+
+"""
+
+import os
+import pathlib
+import subprocess
+import sys
+import sysconfig
+import textwrap
+
+__all__ = ['build_and_import_extension', 'compile_extension_module']
+
+
+def build_and_import_extension(
+        modname, functions, *, prologue="", build_dir=None,
+        include_dirs=[], more_init=""):
+    """
+    Build and imports a c-extension module `modname` from a list of function
+    fragments `functions`.
+
+
+    Parameters
+    ----------
+    functions : list of fragments
+        Each fragment is a sequence of func_name, calling convention, snippet.
+    prologue : string
+        Code to precede the rest, usually extra ``#include`` or ``#define``
+        macros.
+    build_dir : pathlib.Path
+        Where to build the module, usually a temporary directory
+    include_dirs : list
+        Extra directories to find include files when compiling
+    more_init : string
+        Code to appear in the module PyMODINIT_FUNC
+
+    Returns
+    -------
+    out: module
+        The module will have been loaded and is ready for use
+
+    Examples
+    --------
+    >>> functions = [("test_bytes", "METH_O", \"\"\"
+        if ( !PyBytesCheck(args)) {
+            Py_RETURN_FALSE;
+        }
+        Py_RETURN_TRUE;
+    \"\"\")]
+    >>> mod = build_and_import_extension("testme", functions)
+    >>> assert not mod.test_bytes('abc')
+    >>> assert mod.test_bytes(b'abc')
+    """
+    body = prologue + _make_methods(functions, modname)
+    init = """
+    PyObject *mod = PyModule_Create(&moduledef);
+    #ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED);
+    #endif
+           """
+    if not build_dir:
+        build_dir = pathlib.Path('.')
+    if more_init:
+        init += """#define INITERROR return NULL
+                """
+        init += more_init
+    init += "\nreturn mod;"
+    source_string = _make_source(modname, init, body)
+    try:
+        mod_so = compile_extension_module(
+            modname, build_dir, include_dirs, source_string)
+    except Exception as e:
+        # shorten the exception chain
+        raise RuntimeError(f"could not compile in {build_dir}:") from e
+    import importlib.util
+    spec = importlib.util.spec_from_file_location(modname, mod_so)
+    foo = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(foo)
+    return foo
+
+
+def compile_extension_module(
+        name, builddir, include_dirs,
+        source_string, libraries=[], library_dirs=[]):
+    """
+    Build an extension module and return the filename of the resulting
+    native code file.
+
+    Parameters
+    ----------
+    name : string
+        name of the module, possibly including dots if it is a module inside a
+        package.
+    builddir : pathlib.Path
+        Where to build the module, usually a temporary directory
+    include_dirs : list
+        Extra directories to find include files when compiling
+    libraries : list
+        Libraries to link into the extension module
+    library_dirs: list
+        Where to find the libraries, ``-L`` passed to the linker
+    """
+    modname = name.split('.')[-1]
+    dirname = builddir / name
+    dirname.mkdir(exist_ok=True)
+    cfile = _convert_str_to_file(source_string, dirname)
+    include_dirs = include_dirs + [sysconfig.get_config_var('INCLUDEPY')]
+
+    return _c_compile(
+        cfile, outputfilename=dirname / modname,
+        include_dirs=include_dirs, libraries=[], library_dirs=[],
+        )
+
+
+def _convert_str_to_file(source, dirname):
+    """Helper function to create a file ``source.c`` in `dirname` that contains
+    the string in `source`. Returns the file name
+    """
+    filename = dirname / 'source.c'
+    with filename.open('w') as f:
+        f.write(str(source))
+    return filename
+
+
+def _make_methods(functions, modname):
+    """ Turns the name, signature, code in functions into complete functions
+    and lists them in a methods_table. Then turns the methods_table into a
+    ``PyMethodDef`` structure and returns the resulting code fragment ready
+    for compilation
+    """
+    methods_table = []
+    codes = []
+    for funcname, flags, code in functions:
+        cfuncname = "%s_%s" % (modname, funcname)
+        if 'METH_KEYWORDS' in flags:
+            signature = '(PyObject *self, PyObject *args, PyObject *kwargs)'
+        else:
+            signature = '(PyObject *self, PyObject *args)'
+        methods_table.append(
+            "{\"%s\", (PyCFunction)%s, %s}," % (funcname, cfuncname, flags))
+        func_code = """
+        static PyObject* {cfuncname}{signature}
+        {{
+        {code}
+        }}
+        """.format(cfuncname=cfuncname, signature=signature, code=code)
+        codes.append(func_code)
+
+    body = "\n".join(codes) + """
+    static PyMethodDef methods[] = {
+    %(methods)s
+    { NULL }
+    };
+    static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        "%(modname)s",  /* m_name */
+        NULL,           /* m_doc */
+        -1,             /* m_size */
+        methods,        /* m_methods */
+    };
+    """ % dict(methods='\n'.join(methods_table), modname=modname)
+    return body
+
+
+def _make_source(name, init, body):
+    """ Combines the code fragments into source code ready to be compiled
+    """
+    code = """
+    #include <Python.h>
+
+    %(body)s
+
+    PyMODINIT_FUNC
+    PyInit_%(name)s(void) {
+    %(init)s
+    }
+    """ % dict(
+        name=name, init=init, body=body,
+    )
+    return code
+
+
+def _c_compile(cfile, outputfilename, include_dirs=[], libraries=[],
+               library_dirs=[]):
+    if sys.platform == 'win32':
+        compile_extra = ["/we4013"]
+        link_extra = ["/LIBPATH:" + os.path.join(sys.base_prefix, 'libs')]
+    elif sys.platform.startswith('linux'):
+        compile_extra = [
+            "-O0", "-g", "-Werror=implicit-function-declaration", "-fPIC"]
+        link_extra = []
+    else:
+        compile_extra = link_extra = []
+        pass
+    if sys.platform == 'win32':
+        link_extra = link_extra + ['/DEBUG']  # generate .pdb file
+    if sys.platform == 'darwin':
+        # support Fink & Darwinports
+        for s in ('/sw/', '/opt/local/'):
+            if (s + 'include' not in include_dirs
+                    and os.path.exists(s + 'include')):
+                include_dirs.append(s + 'include')
+            if s + 'lib' not in library_dirs and os.path.exists(s + 'lib'):
+                library_dirs.append(s + 'lib')
+
+    outputfilename = outputfilename.with_suffix(get_so_suffix())
+    build(
+        cfile, outputfilename,
+        compile_extra, link_extra,
+        include_dirs, libraries, library_dirs)
+    return outputfilename
+
+
+def build(cfile, outputfilename, compile_extra, link_extra,
+          include_dirs, libraries, library_dirs):
+    "use meson to build"
+
+    build_dir = cfile.parent / "build"
+    os.makedirs(build_dir, exist_ok=True)
+    so_name = outputfilename.parts[-1]
+    with open(cfile.parent / "meson.build", "wt") as fid:
+        includes = ['-I' + d for d in include_dirs]
+        link_dirs = ['-L' + d for d in library_dirs]
+        fid.write(textwrap.dedent(f"""\
+            project('foo', 'c')
+            shared_module('{so_name}', '{cfile.parts[-1]}',
+                c_args: {includes} + {compile_extra},
+                link_args: {link_dirs} + {link_extra},
+                link_with: {libraries},
+                name_prefix: '',
+                name_suffix: 'dummy',
+            )
+        """))
+    if sys.platform == "win32":
+        subprocess.check_call(["meson", "setup",
+                               "--buildtype=release", 
+                               "--vsenv", ".."],
+                              cwd=build_dir,
+                              )
+    else:
+        subprocess.check_call(["meson", "setup", "--vsenv", ".."],
+                              cwd=build_dir
+                              )
+    subprocess.check_call(["meson", "compile"], cwd=build_dir)
+    os.rename(str(build_dir / so_name) + ".dummy", cfile.parent / so_name)
+        
+def get_so_suffix():
+    ret = sysconfig.get_config_var('EXT_SUFFIX')
+    assert ret
+    return ret

lib/python3.13/site-packages/numpy/testing/_private/utils.pyi

@@ -0,0 +1,413 @@
+import os
+import sys
+import ast
+import types
+import warnings
+import unittest
+import contextlib
+from re import Pattern
+from collections.abc import Callable, Iterable, Sequence
+from typing import (
+    Literal as L,
+    Any,
+    AnyStr,
+    ClassVar,
+    NoReturn,
+    overload,
+    type_check_only,
+    TypeVar,
+    Final,
+    SupportsIndex,
+    ParamSpec
+)
+
+import numpy as np
+from numpy import number, object_, _FloatValue
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    DTypeLike,
+    _ArrayLikeNumber_co,
+    _ArrayLikeObject_co,
+    _ArrayLikeTD64_co,
+    _ArrayLikeDT64_co,
+)
+
+from unittest.case import (
+    SkipTest as SkipTest,
+)
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+_ET = TypeVar("_ET", bound=BaseException)
+_FT = TypeVar("_FT", bound=Callable[..., Any])
+
+# Must return a bool or an ndarray/generic type
+# that is supported by `np.logical_and.reduce`
+_ComparisonFunc = Callable[
+    [NDArray[Any], NDArray[Any]],
+    (
+        bool
+        | np.bool
+        | number[Any]
+        | NDArray[np.bool | number[Any] | object_]
+    )
+]
+
+__all__: list[str]
+
+class KnownFailureException(Exception): ...
+class IgnoreException(Exception): ...
+
+class clear_and_catch_warnings(warnings.catch_warnings):
+    class_modules: ClassVar[tuple[types.ModuleType, ...]]
+    modules: set[types.ModuleType]
+    @overload
+    def __new__(
+        cls,
+        record: L[False] = ...,
+        modules: Iterable[types.ModuleType] = ...,
+    ) -> _clear_and_catch_warnings_without_records: ...
+    @overload
+    def __new__(
+        cls,
+        record: L[True],
+        modules: Iterable[types.ModuleType] = ...,
+    ) -> _clear_and_catch_warnings_with_records: ...
+    @overload
+    def __new__(
+        cls,
+        record: bool,
+        modules: Iterable[types.ModuleType] = ...,
+    ) -> clear_and_catch_warnings: ...
+    def __enter__(self) -> None | list[warnings.WarningMessage]: ...
+    def __exit__(
+        self,
+        __exc_type: None | type[BaseException] = ...,
+        __exc_val: None | BaseException = ...,
+        __exc_tb: None | types.TracebackType = ...,
+    ) -> None: ...
+
+# Type-check only `clear_and_catch_warnings` subclasses for both values of the
+# `record` parameter. Copied from the stdlib `warnings` stubs.
+
+@type_check_only
+class _clear_and_catch_warnings_with_records(clear_and_catch_warnings):
+    def __enter__(self) -> list[warnings.WarningMessage]: ...
+
+@type_check_only
+class _clear_and_catch_warnings_without_records(clear_and_catch_warnings):
+    def __enter__(self) -> None: ...
+
+class suppress_warnings:
+    log: list[warnings.WarningMessage]
+    def __init__(
+        self,
+        forwarding_rule: L["always", "module", "once", "location"] = ...,
+    ) -> None: ...
+    def filter(
+        self,
+        category: type[Warning] = ...,
+        message: str = ...,
+        module: None | types.ModuleType = ...,
+    ) -> None: ...
+    def record(
+        self,
+        category: type[Warning] = ...,
+        message: str = ...,
+        module: None | types.ModuleType = ...,
+    ) -> list[warnings.WarningMessage]: ...
+    def __enter__(self: _T) -> _T: ...
+    def __exit__(
+        self,
+        __exc_type: None | type[BaseException] = ...,
+        __exc_val: None | BaseException = ...,
+        __exc_tb: None | types.TracebackType = ...,
+    ) -> None: ...
+    def __call__(self, func: _FT) -> _FT: ...
+
+verbose: int
+IS_PYPY: Final[bool]
+IS_PYSTON: Final[bool]
+HAS_REFCOUNT: Final[bool]
+HAS_LAPACK64: Final[bool]
+
+def assert_(val: object, msg: str | Callable[[], str] = ...) -> None: ...
+
+# Contrary to runtime we can't do `os.name` checks while type checking,
+# only `sys.platform` checks
+if sys.platform == "win32" or sys.platform == "cygwin":
+    def memusage(processName: str = ..., instance: int = ...) -> int: ...
+elif sys.platform == "linux":
+    def memusage(_proc_pid_stat: str | bytes | os.PathLike[Any] = ...) -> None | int: ...
+else:
+    def memusage() -> NoReturn: ...
+
+if sys.platform == "linux":
+    def jiffies(
+        _proc_pid_stat: str | bytes | os.PathLike[Any] = ...,
+        _load_time: list[float] = ...,
+    ) -> int: ...
+else:
+    def jiffies(_load_time: list[float] = ...) -> int: ...
+
+def build_err_msg(
+    arrays: Iterable[object],
+    err_msg: str,
+    header: str = ...,
+    verbose: bool = ...,
+    names: Sequence[str] = ...,
+    precision: None | SupportsIndex = ...,
+) -> str: ...
+
+def assert_equal(
+    actual: object,
+    desired: object,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def print_assert_equal(
+    test_string: str,
+    actual: object,
+    desired: object,
+) -> None: ...
+
+def assert_almost_equal(
+    actual: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    desired: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    decimal: int = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+) -> None: ...
+
+# Anything that can be coerced into `builtins.float`
+def assert_approx_equal(
+    actual: _FloatValue,
+    desired: _FloatValue,
+    significant: int = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+) -> None: ...
+
+def assert_array_compare(
+    comparison: _ComparisonFunc,
+    x: ArrayLike,
+    y: ArrayLike,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    header: str = ...,
+    precision: SupportsIndex = ...,
+    equal_nan: bool = ...,
+    equal_inf: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def assert_array_equal(
+    x: ArrayLike,
+    y: ArrayLike,
+    /,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def assert_array_almost_equal(
+    x: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    y: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    /,
+    decimal: float = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+) -> None: ...
+
+@overload
+def assert_array_less(
+    x: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    y: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+@overload
+def assert_array_less(
+    x: _ArrayLikeTD64_co,
+    y: _ArrayLikeTD64_co,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+@overload
+def assert_array_less(
+    x: _ArrayLikeDT64_co,
+    y: _ArrayLikeDT64_co,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def runstring(
+    astr: str | bytes | types.CodeType,
+    dict: None | dict[str, Any],
+) -> Any: ...
+
+def assert_string_equal(actual: str, desired: str) -> None: ...
+
+def rundocs(
+    filename: None | str | os.PathLike[str] = ...,
+    raise_on_error: bool = ...,
+) -> None: ...
+
+def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ...
+
+@overload
+def assert_raises(  # type: ignore
+    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+    callable: Callable[_P, Any],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> None: ...
+@overload
+def assert_raises(
+    expected_exception: type[_ET] | tuple[type[_ET], ...],
+    *,
+    msg: None | str = ...,
+) -> unittest.case._AssertRaisesContext[_ET]: ...
+
+@overload
+def assert_raises_regex(
+    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+    expected_regex: str | bytes | Pattern[Any],
+    callable: Callable[_P, Any],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> None: ...
+@overload
+def assert_raises_regex(
+    expected_exception: type[_ET] | tuple[type[_ET], ...],
+    expected_regex: str | bytes | Pattern[Any],
+    *,
+    msg: None | str = ...,
+) -> unittest.case._AssertRaisesContext[_ET]: ...
+
+def decorate_methods(
+    cls: type[Any],
+    decorator: Callable[[Callable[..., Any]], Any],
+    testmatch: None | str | bytes | Pattern[Any] = ...,
+) -> None: ...
+
+def measure(
+    code_str: str | bytes | ast.mod | ast.AST,
+    times: int = ...,
+    label: None | str = ...,
+) -> float: ...
+
+@overload
+def assert_allclose(
+    actual: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    desired: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    rtol: float = ...,
+    atol: float = ...,
+    equal_nan: bool = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+@overload
+def assert_allclose(
+    actual: _ArrayLikeTD64_co,
+    desired: _ArrayLikeTD64_co,
+    rtol: float = ...,
+    atol: float = ...,
+    equal_nan: bool = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def assert_array_almost_equal_nulp(
+    x: _ArrayLikeNumber_co,
+    y: _ArrayLikeNumber_co,
+    nulp: float = ...,
+) -> None: ...
+
+def assert_array_max_ulp(
+    a: _ArrayLikeNumber_co,
+    b: _ArrayLikeNumber_co,
+    maxulp: float = ...,
+    dtype: DTypeLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def assert_warns(
+    warning_class: type[Warning],
+) -> contextlib._GeneratorContextManager[None]: ...
+@overload
+def assert_warns(
+    warning_class: type[Warning],
+    func: Callable[_P, _T],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> _T: ...
+
+@overload
+def assert_no_warnings() -> contextlib._GeneratorContextManager[None]: ...
+@overload
+def assert_no_warnings(
+    func: Callable[_P, _T],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> _T: ...
+
+@overload
+def tempdir(
+    suffix: None = ...,
+    prefix: None = ...,
+    dir: None = ...,
+) -> contextlib._GeneratorContextManager[str]: ...
+@overload
+def tempdir(
+    suffix: None | AnyStr = ...,
+    prefix: None | AnyStr = ...,
+    dir: None | AnyStr | os.PathLike[AnyStr] = ...,
+) -> contextlib._GeneratorContextManager[AnyStr]: ...
+
+@overload
+def temppath(
+    suffix: None = ...,
+    prefix: None = ...,
+    dir: None = ...,
+    text: bool = ...,
+) -> contextlib._GeneratorContextManager[str]: ...
+@overload
+def temppath(
+    suffix: None | AnyStr = ...,
+    prefix: None | AnyStr = ...,
+    dir: None | AnyStr | os.PathLike[AnyStr] = ...,
+    text: bool = ...,
+) -> contextlib._GeneratorContextManager[AnyStr]: ...
+
+@overload
+def assert_no_gc_cycles() -> contextlib._GeneratorContextManager[None]: ...
+@overload
+def assert_no_gc_cycles(
+    func: Callable[_P, Any],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> None: ...
+
+def break_cycles() -> None: ...