numpy 2.4.1__cp314-cp314t-win_arm64.whl

numpy/_expired_attrs_2_0.py

@@ -0,0 +1,78 @@
+"""
+Dict of expired attributes that are discontinued since 2.0 release.
+Each item is associated with a migration note.
+"""
+
+__expired_attributes__ = {
+    "geterrobj": "Use the np.errstate context manager instead.",
+    "seterrobj": "Use the np.errstate context manager instead.",
+    "cast": "Use `np.asarray(arr, dtype=dtype)` instead.",
+    "source": "Use `inspect.getsource` instead.",
+    "lookfor":  "Search NumPy's documentation directly.",
+    "who": "Use an IDE variable explorer or `locals()` instead.",
+    "fastCopyAndTranspose": "Use `arr.T.copy()` instead.",
+    "set_numeric_ops":
+        "For the general case, use `PyUFunc_ReplaceLoopBySignature`. "
+        "For ndarray subclasses, define the ``__array_ufunc__`` method "
+        "and override the relevant ufunc.",
+    "NINF": "Use `-np.inf` instead.",
+    "PINF": "Use `np.inf` instead.",
+    "NZERO": "Use `-0.0` instead.",
+    "PZERO": "Use `0.0` instead.",
+    "add_newdoc":
+        "It's still available as `np.lib.add_newdoc`.",
+    "add_docstring":
+        "It's still available as `np.lib.add_docstring`.",
+    "add_newdoc_ufunc":
+        "It's an internal function and doesn't have a replacement.",
+    "safe_eval": "Use `ast.literal_eval` instead.",
+    "float_": "Use `np.float64` instead.",
+    "complex_": "Use `np.complex128` instead.",
+    "longfloat": "Use `np.longdouble` instead.",
+    "singlecomplex": "Use `np.complex64` instead.",
+    "cfloat": "Use `np.complex128` instead.",
+    "longcomplex": "Use `np.clongdouble` instead.",
+    "clongfloat": "Use `np.clongdouble` instead.",
+    "string_": "Use `np.bytes_` instead.",
+    "unicode_": "Use `np.str_` instead.",
+    "Inf": "Use `np.inf` instead.",
+    "Infinity": "Use `np.inf` instead.",
+    "NaN": "Use `np.nan` instead.",
+    "infty": "Use `np.inf` instead.",
+    "issctype": "Use `issubclass(rep, np.generic)` instead.",
+    "maximum_sctype":
+        "Use a specific dtype instead. You should avoid relying "
+        "on any implicit mechanism and select the largest dtype of "
+        "a kind explicitly in the code.",
+    "obj2sctype": "Use `np.dtype(obj).type` instead.",
+    "sctype2char": "Use `np.dtype(obj).char` instead.",
+    "sctypes": "Access dtypes explicitly instead.",
+    "issubsctype": "Use `np.issubdtype` instead.",
+    "set_string_function":
+        "Use `np.set_printoptions` instead with a formatter for "
+        "custom printing of NumPy objects.",
+    "asfarray": "Use `np.asarray` with a proper dtype instead.",
+    "issubclass_": "Use `issubclass` builtin instead.",
+    "tracemalloc_domain": "It's now available from `np.lib`.",
+    "mat": "Use `np.asmatrix` instead.",
+    "recfromcsv": "Use `np.genfromtxt` with comma delimiter instead.",
+    "recfromtxt": "Use `np.genfromtxt` instead.",
+    "deprecate": "Emit `DeprecationWarning` with `warnings.warn` directly, "
+        "or use `typing.deprecated`.",
+    "deprecate_with_doc": "Emit `DeprecationWarning` with `warnings.warn` "
+        "directly, or use `typing.deprecated`.",
+    "find_common_type":
+        "Use `numpy.promote_types` or `numpy.result_type` instead. "
+        "To achieve semantics for the `scalar_types` argument, use "
+        "`numpy.result_type` and pass the Python values `0`, `0.0`, or `0j`.",
+    "round_": "Use `np.round` instead.",
+    "get_array_wrap": "",
+    "DataSource": "It's still available as `np.lib.npyio.DataSource`.",
+    "nbytes": "Use `np.dtype(<dtype>).itemsize` instead.",
+    "byte_bounds": "Now it's available under `np.lib.array_utils.byte_bounds`",
+    "compare_chararrays":
+        "It's still available as `np.char.compare_chararrays`.",
+    "format_parser": "It's still available as `np.rec.format_parser`.",
+    "alltrue": "Use `np.all` instead.",
+    "sometrue": "Use `np.any` instead.",
+}

numpy/_expired_attrs_2_0.pyi

@@ -0,0 +1,61 @@
+from typing import Final, TypedDict, final, type_check_only
+
+@final
+@type_check_only
+class _ExpiredAttributesType(TypedDict):
+    geterrobj: str
+    seterrobj: str
+    cast: str
+    source: str
+    lookfor: str
+    who: str
+    fastCopyAndTranspose: str
+    set_numeric_ops: str
+    NINF: str
+    PINF: str
+    NZERO: str
+    PZERO: str
+    add_newdoc: str
+    add_docstring: str
+    add_newdoc_ufunc: str
+    safe_eval: str
+    float_: str
+    complex_: str
+    longfloat: str
+    singlecomplex: str
+    cfloat: str
+    longcomplex: str
+    clongfloat: str
+    string_: str
+    unicode_: str
+    Inf: str
+    Infinity: str
+    NaN: str
+    infty: str
+    issctype: str
+    maximum_sctype: str
+    obj2sctype: str
+    sctype2char: str
+    sctypes: str
+    issubsctype: str
+    set_string_function: str
+    asfarray: str
+    issubclass_: str
+    tracemalloc_domain: str
+    mat: str
+    recfromcsv: str
+    recfromtxt: str
+    deprecate: str
+    deprecate_with_doc: str
+    find_common_type: str
+    round_: str
+    get_array_wrap: str
+    DataSource: str
+    nbytes: str
+    byte_bounds: str
+    compare_chararrays: str
+    format_parser: str
+    alltrue: str
+    sometrue: str
+
+__expired_attributes__: Final[_ExpiredAttributesType] = ...

numpy/_globals.py

@@ -0,0 +1,121 @@
+"""
+Module defining global singleton classes.
+
+This module raises a RuntimeError if an attempt to reload it is made. In that
+way the identities of the classes defined here are fixed and will remain so
+even if numpy itself is reloaded. In particular, a function like the following
+will still work correctly after numpy is reloaded::
+
+    def foo(arg=np._NoValue):
+        if arg is np._NoValue:
+            ...
+
+That was not the case when the singleton classes were defined in the numpy
+``__init__.py`` file. See gh-7844 for a discussion of the reload problem that
+motivated this module.
+
+"""
+import enum
+
+from ._utils import set_module as _set_module
+
+__all__ = ['_NoValue', '_CopyMode']
+
+
+# Disallow reloading this module so as to preserve the identities of the
+# classes defined here.
+if '_is_loaded' in globals():
+    raise RuntimeError('Reloading numpy._globals is not allowed')
+_is_loaded = True
+
+
+class _NoValueType:
+    """Special keyword value.
+
+    The instance of this class may be used as the default value assigned to a
+    keyword if no other obvious default (e.g., `None`) is suitable,
+
+    Common reasons for using this keyword are:
+
+    - A new keyword is added to a function, and that function forwards its
+      inputs to another function or method which can be defined outside of
+      NumPy. For example, ``np.std(x)`` calls ``x.std``, so when a ``keepdims``
+      keyword was added that could only be forwarded if the user explicitly
+      specified ``keepdims``; downstream array libraries may not have added
+      the same keyword, so adding ``x.std(..., keepdims=keepdims)``
+      unconditionally could have broken previously working code.
+    - A keyword is being deprecated, and a deprecation warning must only be
+      emitted when the keyword is used.
+
+    """
+    __instance = None
+
+    def __new__(cls):
+        # ensure that only one instance exists
+        if not cls.__instance:
+            cls.__instance = super().__new__(cls)
+        return cls.__instance
+
+    def __repr__(self):
+        return "<no value>"
+
+
+_NoValue = _NoValueType()
+
+
+@_set_module("numpy")
+class _CopyMode(enum.Enum):
+    """
+    An enumeration for the copy modes supported
+    by numpy.copy() and numpy.array(). The following three modes are supported,
+
+    - ALWAYS: This means that a deep copy of the input
+              array will always be taken.
+    - IF_NEEDED: This means that a deep copy of the input
+                 array will be taken only if necessary.
+    - NEVER: This means that the deep copy will never be taken.
+             If a copy cannot be avoided then a `ValueError` will be
+             raised.
+
+    Note that the buffer-protocol could in theory do copies.  NumPy currently
+    assumes an object exporting the buffer protocol will never do this.
+    """
+
+    ALWAYS = True
+    NEVER = False
+    IF_NEEDED = 2
+
+    def __bool__(self):
+        # For backwards compatibility
+        if self == _CopyMode.ALWAYS:
+            return True
+
+        if self == _CopyMode.NEVER:
+            return False
+
+        raise ValueError(f"{self} is neither True nor False.")
+
+
+class _SignatureDescriptor:
+    # A descriptor to store on the ufunc __dict__ that avoids definig a
+    # signature for the ufunc class/type but allows the instance to have one.
+    # This is needed because inspect.signature() chokes on normal properties
+    # (as of 3.14 at least).
+    # We could also set __signature__ on the instance but this allows deferred
+    # computation of the signature.
+    def __get__(self, obj, objtype=None):
+        # Delay import, not a critical path but need to avoid circular import.
+        from numpy._core._internal import _ufunc_inspect_signature_builder
+
+        if obj is None:
+            # could also return None, which is accepted as "not set" by
+            # inspect.signature().
+            raise AttributeError(
+                "type object 'numpy.ufunc' has no attribute '__signature__'")
+
+        # Store on the instance, after this the descriptor won't be used.
+        obj.__signature__ = _ufunc_inspect_signature_builder(obj)
+        return obj.__signature__
+
+
+_signature_descriptor = _SignatureDescriptor()

numpy/_globals.pyi

@@ -0,0 +1,17 @@
+__all__ = ["_CopyMode", "_NoValue"]
+
+import enum
+from typing import Final, final
+
+@final
+class _CopyMode(enum.Enum):
+    ALWAYS = True
+    NEVER = False
+    IF_NEEDED = 2
+
+    def __bool__(self, /) -> bool: ...
+
+@final
+class _NoValueType: ...
+
+_NoValue: Final[_NoValueType] = ...

numpy/_pyinstaller/hook-numpy.py

@@ -0,0 +1,36 @@
+"""This hook should collect all binary files and any hidden modules that numpy
+needs.
+
+Our (some-what inadequate) docs for writing PyInstaller hooks are kept here:
+https://pyinstaller.readthedocs.io/en/stable/hooks.html
+
+"""
+from PyInstaller.compat import is_pure_conda
+from PyInstaller.utils.hooks import collect_dynamic_libs
+
+# Collect all DLLs inside numpy's installation folder, dump them into built
+# app's root.
+binaries = collect_dynamic_libs("numpy", ".")
+
+# If using Conda without any non-conda virtual environment manager:
+if is_pure_conda:
+    # Assume running the NumPy from Conda-forge and collect it's DLLs from the
+    # communal Conda bin directory. DLLs from NumPy's dependencies must also be
+    # collected to capture MKL, OpenBlas, OpenMP, etc.
+    from PyInstaller.utils.hooks import conda_support
+    datas = conda_support.collect_dynamic_libs("numpy", dependencies=True)
+
+# Submodules PyInstaller cannot detect.  `_dtype_ctypes` is only imported
+# from C and `_multiarray_tests` is used in tests (which are not packed).
+hiddenimports = ['numpy._core._dtype_ctypes', 'numpy._core._multiarray_tests']
+
+# Remove testing and building code and packages that are referenced throughout
+# NumPy but are not really dependencies.
+excludedimports = [
+    "scipy",
+    "pytest",
+    "f2py",
+    "setuptools",
+    "distutils",
+    "numpy.distutils",
+]

numpy/_pyinstaller/hook-numpy.pyi

@@ -0,0 +1,6 @@
+from typing import Final
+
+binaries: Final[list[tuple[str, str]]] = ...
+
+hiddenimports: Final[list[str]] = ...
+excludedimports: Final[list[str]] = ...

numpy/_pyinstaller/tests/__init__.py

@@ -0,0 +1,16 @@
+import pytest
+
+from numpy.testing import IS_EDITABLE, IS_WASM
+
+if IS_WASM:
+    pytest.skip(
+        "WASM/Pyodide does not use or support Fortran",
+        allow_module_level=True
+    )
+
+
+if IS_EDITABLE:
+    pytest.skip(
+        "Editable install doesn't support tests with a compile step",
+        allow_module_level=True
+    )

numpy/_pyinstaller/tests/pyinstaller-smoke.py

@@ -0,0 +1,32 @@
+"""A crude *bit of everything* smoke test to verify PyInstaller compatibility.
+
+PyInstaller typically goes wrong by forgetting to package modules, extension
+modules or shared libraries. This script should aim to touch as many of those
+as possible in an attempt to trip a ModuleNotFoundError or a DLL load failure
+due to an uncollected resource. Missing resources are unlikely to lead to
+arithmetic errors so there's generally no need to verify any calculation's
+output - merely that it made it to the end OK. This script should not
+explicitly import any of numpy's submodules as that gives PyInstaller undue
+hints that those submodules exist and should be collected (accessing implicitly
+loaded submodules is OK).
+
+"""
+import numpy as np
+
+a = np.arange(1., 10.).reshape((3, 3)) % 5
+np.linalg.det(a)
+a @ a
+a @ a.T
+np.linalg.inv(a)
+np.sin(np.exp(a))
+np.linalg.svd(a)
+np.linalg.eigh(a)
+
+np.unique(np.random.randint(0, 10, 100))
+np.sort(np.random.uniform(0, 10, 100))
+
+np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
+np.ma.masked_array(np.arange(10), np.random.rand(10) < .5).sum()
+np.polynomial.Legendre([7, 8, 9]).roots()
+
+print("I made it!")

numpy/_pyinstaller/tests/test_pyinstaller.py

@@ -0,0 +1,35 @@
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+# PyInstaller has been very unproactive about replacing 'imp' with 'importlib'.
+@pytest.mark.filterwarnings('ignore::DeprecationWarning')
+# It also leaks io.BytesIO()s.
+@pytest.mark.filterwarnings('ignore::ResourceWarning')
+@pytest.mark.parametrize("mode", ["--onedir", "--onefile"])
+@pytest.mark.slow
+def test_pyinstaller(mode, tmp_path):
+    """Compile and run pyinstaller-smoke.py using PyInstaller."""
+
+    pyinstaller_cli = pytest.importorskip("PyInstaller.__main__").run
+
+    source = Path(__file__).with_name("pyinstaller-smoke.py").resolve()
+    args = [
+        # Place all generated files in ``tmp_path``.
+        '--workpath', str(tmp_path / "build"),
+        '--distpath', str(tmp_path / "dist"),
+        '--specpath', str(tmp_path),
+        mode,
+        str(source),
+    ]
+    pyinstaller_cli(args)
+
+    if mode == "--onefile":
+        exe = tmp_path / "dist" / source.stem
+    else:
+        exe = tmp_path / "dist" / source.stem / source.stem
+
+    p = subprocess.run([str(exe)], check=True, stdout=subprocess.PIPE)
+    assert p.stdout.strip() == b"I made it!"

numpy/_pytesttester.py

@@ -0,0 +1,201 @@
+"""
+Pytest test running.
+
+This module implements the ``test()`` function for NumPy modules. The usual
+boiler plate for doing that is to put the following in the module
+``__init__.py`` file::
+
+    from numpy._pytesttester import PytestTester
+    test = PytestTester(__name__)
+    del PytestTester
+
+
+Warnings filtering and other runtime settings should be dealt with in the
+``pytest.ini`` file in the numpy repo root. The behavior of the test depends on
+whether or not that file is found as follows:
+
+* ``pytest.ini`` is present (develop mode)
+    All warnings except those explicitly filtered out are raised as error.
+* ``pytest.ini`` is absent (release mode)
+    DeprecationWarnings and PendingDeprecationWarnings are ignored, other
+    warnings are passed through.
+
+In practice, tests run from the numpy repo are run in development mode with
+``spin``, through the standard ``spin test`` invocation or from an inplace
+build with ``pytest numpy``.
+
+This module is imported by every numpy subpackage, so lies at the top level to
+simplify circular import issues. For the same reason, it contains no numpy
+imports at module scope, instead importing numpy within function calls.
+"""
+import os
+import sys
+
+__all__ = ['PytestTester']
+
+
+def _show_numpy_info():
+    import numpy as np
+
+    print(f"NumPy version {np.__version__}")
+    info = np.lib._utils_impl._opt_info()
+    print("NumPy CPU features: ", (info or 'nothing enabled'))
+
+
+class PytestTester:
+    """
+    Pytest test runner.
+
+    A test function is typically added to a package's __init__.py like so::
+
+      from numpy._pytesttester import PytestTester
+      test = PytestTester(__name__).test
+      del PytestTester
+
+    Calling this test function finds and runs all tests associated with the
+    module and all its sub-modules.
+
+    Attributes
+    ----------
+    module_name : str
+        Full path to the package to test.
+
+    Parameters
+    ----------
+    module_name : module name
+        The name of the module to test.
+
+    Notes
+    -----
+    Unlike the previous ``nose``-based implementation, this class is not
+    publicly exposed as it performs some ``numpy``-specific warning
+    suppression.
+
+    """
+    def __init__(self, module_name):
+        self.module_name = module_name
+        self.__module__ = module_name
+
+    def __call__(self, label='fast', verbose=1, extra_argv=None,
+                 doctests=False, coverage=False, durations=-1, tests=None):
+        """
+        Run tests for module using pytest.
+
+        Parameters
+        ----------
+        label : {'fast', 'full'}, optional
+            Identifies the tests to run. When set to 'fast', tests decorated
+            with `pytest.mark.slow` are skipped, when 'full', the slow marker
+            is ignored.
+        verbose : int, optional
+            Verbosity value for test outputs, in the range 1-3. Default is 1.
+        extra_argv : list, optional
+            List with any extra arguments to pass to pytests.
+        doctests : bool, optional
+            .. note:: Not supported
+        coverage : bool, optional
+            If True, report coverage of NumPy code. Default is False.
+            Requires installation of (pip) pytest-cov.
+        durations : int, optional
+            If < 0, do nothing, If 0, report time of all tests, if > 0,
+            report the time of the slowest `timer` tests. Default is -1.
+        tests : test or list of tests
+            Tests to be executed with pytest '--pyargs'
+
+        Returns
+        -------
+        result : bool
+            Return True on success, false otherwise.
+
+        Notes
+        -----
+        Each NumPy module exposes `test` in its namespace to run all tests for
+        it. For example, to run all tests for numpy.lib:
+
+        >>> np.lib.test() #doctest: +SKIP
+
+        Examples
+        --------
+        >>> result = np.lib.test() #doctest: +SKIP
+        ...
+        1023 passed, 2 skipped, 6 deselected, 1 xfailed in 10.39 seconds
+        >>> result
+        True
+
+        """
+        import warnings
+
+        import pytest
+
+        module = sys.modules[self.module_name]
+        module_path = os.path.abspath(module.__path__[0])
+
+        # setup the pytest arguments
+        pytest_args = ["-l"]
+
+        # offset verbosity. The "-q" cancels a "-v".
+        pytest_args += ["-q"]
+
+        if sys.version_info < (3, 12):
+            with warnings.catch_warnings():
+                warnings.simplefilter("always")
+                # Filter out distutils cpu warnings (could be localized to
+                # distutils tests). ASV has problems with top level import,
+                # so fetch module for suppression here.
+                from numpy.distutils import cpuinfo  # noqa: F401
+
+        # Filter out annoying import messages. Want these in both develop and
+        # release mode.
+        pytest_args += [
+            "-W ignore:Not importing directory",
+            "-W ignore:numpy.dtype size changed",
+            "-W ignore:numpy.ufunc size changed",
+            "-W ignore::UserWarning:cpuinfo",
+            ]
+
+        # When testing matrices, ignore their PendingDeprecationWarnings
+        pytest_args += [
+            "-W ignore:the matrix subclass is not",
+            "-W ignore:Importing from numpy.matlib is",
+            ]
+
+        if doctests:
+            pytest_args += ["--doctest-modules"]
+
+        if extra_argv:
+            pytest_args += list(extra_argv)
+
+        if verbose > 1:
+            pytest_args += ["-" + "v" * (verbose - 1)]
+
+        if coverage:
+            pytest_args += ["--cov=" + module_path]
+
+        if label == "fast":
+            # not importing at the top level to avoid circular import of module
+            from numpy.testing import IS_PYPY
+            if IS_PYPY:
+                pytest_args += ["-m", "not slow and not slow_pypy"]
+            else:
+                pytest_args += ["-m", "not slow"]
+
+        elif label != "full":
+            pytest_args += ["-m", label]
+
+        if durations >= 0:
+            pytest_args += [f"--durations={durations}"]
+
+        if tests is None:
+            tests = [self.module_name]
+
+        pytest_args += ["--pyargs"] + list(tests)
+
+        # run tests.
+        _show_numpy_info()
+
+        try:
+            code = pytest.main(pytest_args)
+        except SystemExit as exc:
+            code = exc.code
+
+        return code == 0

numpy/_pytesttester.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Iterable
+from typing import Literal as L
+
+__all__ = ["PytestTester"]
+
+class PytestTester:
+    module_name: str
+    def __init__(self, module_name: str) -> None: ...
+    def __call__(
+        self,
+        label: L["fast", "full"] = "fast",
+        verbose: int = 1,
+        extra_argv: Iterable[str] | None = None,
+        doctests: L[False] = False,
+        coverage: bool = False,
+        durations: int = -1,
+        tests: Iterable[str] | None = None,
+    ) -> bool: ...