numpy 2.4.2__cp313-cp313t-win32.whl

numpy/_core/numerictypes.pyi

@@ -0,0 +1,196 @@
+from builtins import bool as py_bool
+from typing import Any, Final, Literal as L, TypedDict, type_check_only
+
+import numpy as np
+from numpy import (
+    bool,
+    bool_,
+    byte,
+    bytes_,
+    cdouble,
+    character,
+    clongdouble,
+    complex64,
+    complex128,
+    complex192,
+    complex256,
+    complexfloating,
+    csingle,
+    datetime64,
+    double,
+    dtype,
+    flexible,
+    float16,
+    float32,
+    float64,
+    float96,
+    float128,
+    floating,
+    generic,
+    half,
+    inexact,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    intc,
+    integer,
+    intp,
+    long,
+    longdouble,
+    longlong,
+    number,
+    object_,
+    short,
+    signedinteger,
+    single,
+    str_,
+    timedelta64,
+    ubyte,
+    uint,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    uintc,
+    uintp,
+    ulong,
+    ulonglong,
+    unsignedinteger,
+    ushort,
+    void,
+)
+from numpy._typing import DTypeLike
+
+from ._type_aliases import sctypeDict as sctypeDict
+from .multiarray import (
+    busday_count,
+    busday_offset,
+    busdaycalendar,
+    datetime_as_string,
+    datetime_data,
+    is_busday,
+)
+
+__all__ = [
+    "ScalarType",
+    "typecodes",
+    "issubdtype",
+    "datetime_data",
+    "datetime_as_string",
+    "busday_offset",
+    "busday_count",
+    "is_busday",
+    "busdaycalendar",
+    "isdtype",
+    "generic",
+    "unsignedinteger",
+    "character",
+    "inexact",
+    "number",
+    "integer",
+    "flexible",
+    "complexfloating",
+    "signedinteger",
+    "floating",
+    "bool",
+    "float16",
+    "float32",
+    "float64",
+    "longdouble",
+    "complex64",
+    "complex128",
+    "clongdouble",
+    "bytes_",
+    "str_",
+    "void",
+    "object_",
+    "datetime64",
+    "timedelta64",
+    "int8",
+    "byte",
+    "uint8",
+    "ubyte",
+    "int16",
+    "short",
+    "uint16",
+    "ushort",
+    "int32",
+    "intc",
+    "uint32",
+    "uintc",
+    "int64",
+    "long",
+    "uint64",
+    "ulong",
+    "longlong",
+    "ulonglong",
+    "intp",
+    "uintp",
+    "double",
+    "cdouble",
+    "single",
+    "csingle",
+    "half",
+    "bool_",
+    "int_",
+    "uint",
+    "float96",
+    "float128",
+    "complex192",
+    "complex256",
+]
+
+@type_check_only
+class _TypeCodes(TypedDict):
+    Character: L["c"]
+    Integer: L["bhilqnp"]
+    UnsignedInteger: L["BHILQNP"]
+    Float: L["efdg"]
+    Complex: L["FDG"]
+    AllInteger: L["bBhHiIlLqQnNpP"]
+    AllFloat: L["efdgFDG"]
+    Datetime: L["Mm"]
+    All: L["?bhilqnpBHILQNPefdgFDGSUVOMm"]
+
+def isdtype(dtype: dtype | type, kind: DTypeLike | tuple[DTypeLike, ...]) -> py_bool: ...
+def issubdtype(arg1: DTypeLike | None, arg2: DTypeLike | None) -> py_bool: ...
+
+typecodes: Final[_TypeCodes] = ...
+ScalarType: Final[
+    tuple[
+        type[int],
+        type[float],
+        type[complex],
+        type[py_bool],
+        type[bytes],
+        type[str],
+        type[memoryview[Any]],
+        type[np.bool],
+        type[complex64],
+        type[complex128],
+        type[complex128 | complex192 | complex256],
+        type[float16],
+        type[float32],
+        type[float64],
+        type[float64 | float96 | float128],
+        type[int8],
+        type[int16],
+        type[int32],
+        type[int32 | int64],
+        type[int64],
+        type[datetime64],
+        type[timedelta64],
+        type[object_],
+        type[bytes_],
+        type[str_],
+        type[uint8],
+        type[uint16],
+        type[uint32],
+        type[uint32 | uint64],
+        type[uint64],
+        type[void],
+    ]
+] = ...
+typeDict: Final = sctypeDict

numpy/_core/overrides.py

@@ -0,0 +1,188 @@
+"""Implementation of __array_function__ overrides from NEP-18."""
+import collections
+import functools
+import inspect
+
+from numpy._core._multiarray_umath import (
+    _ArrayFunctionDispatcher,
+    _get_implementing_args,
+    add_docstring,
+)
+from numpy._utils import set_module  # noqa: F401
+from numpy._utils._inspect import getargspec
+
+ARRAY_FUNCTIONS = set()
+
+array_function_like_doc = (
+    """like : array_like, optional
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument."""
+)
+
+def get_array_function_like_doc(public_api, docstring_template=""):
+    ARRAY_FUNCTIONS.add(public_api)
+    docstring = public_api.__doc__ or docstring_template
+    return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc)
+
+def finalize_array_function_like(public_api):
+    public_api.__doc__ = get_array_function_like_doc(public_api)
+    return public_api
+
+
+add_docstring(
+    _ArrayFunctionDispatcher,
+    """
+    Class to wrap functions with checks for __array_function__ overrides.
+
+    All arguments are required, and can only be passed by position.
+
+    Parameters
+    ----------
+    dispatcher : function or None
+        The dispatcher function that returns a single sequence-like object
+        of all arguments relevant.  It must have the same signature (except
+        the default values) as the actual implementation.
+        If ``None``, this is a ``like=`` dispatcher and the
+        ``_ArrayFunctionDispatcher`` must be called with ``like`` as the
+        first (additional and positional) argument.
+    implementation : function
+        Function that implements the operation on NumPy arrays without
+        overrides.  Arguments passed calling the ``_ArrayFunctionDispatcher``
+        will be forwarded to this (and the ``dispatcher``) as if using
+        ``*args, **kwargs``.
+
+    Attributes
+    ----------
+    _implementation : function
+        The original implementation passed in.
+    """)
+
+
+# exposed for testing purposes; used internally by _ArrayFunctionDispatcher
+add_docstring(
+    _get_implementing_args,
+    """
+    Collect arguments on which to call __array_function__.
+
+    Parameters
+    ----------
+    relevant_args : iterable of array-like
+        Iterable of possibly array-like arguments to check for
+        __array_function__ methods.
+
+    Returns
+    -------
+    Sequence of arguments with __array_function__ methods, in the order in
+    which they should be called.
+    """)
+
+
+ArgSpec = collections.namedtuple('ArgSpec', 'args varargs keywords defaults')
+
+
+def verify_matching_signatures(implementation, dispatcher):
+    """Verify that a dispatcher function has the right signature."""
+    implementation_spec = ArgSpec(*getargspec(implementation))
+    dispatcher_spec = ArgSpec(*getargspec(dispatcher))
+
+    if (implementation_spec.args != dispatcher_spec.args or
+            implementation_spec.varargs != dispatcher_spec.varargs or
+            implementation_spec.keywords != dispatcher_spec.keywords or
+            (bool(implementation_spec.defaults) !=
+             bool(dispatcher_spec.defaults)) or
+            (implementation_spec.defaults is not None and
+             len(implementation_spec.defaults) !=
+             len(dispatcher_spec.defaults))):
+        raise RuntimeError('implementation and dispatcher for %s have '
+                           'different function signatures' % implementation)
+
+    if implementation_spec.defaults is not None:
+        if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults):
+            raise RuntimeError('dispatcher functions can only use None for '
+                               'default argument values')
+
+
+def array_function_dispatch(dispatcher=None, module=None, verify=True,
+                            docs_from_dispatcher=False):
+    """Decorator for adding dispatch with the __array_function__ protocol.
+
+    See NEP-18 for example usage.
+
+    Parameters
+    ----------
+    dispatcher : callable or None
+        Function that when called like ``dispatcher(*args, **kwargs)`` with
+        arguments from the NumPy function call returns an iterable of
+        array-like arguments to check for ``__array_function__``.
+
+        If `None`, the first argument is used as the single `like=` argument
+        and not passed on.  A function implementing `like=` must call its
+        dispatcher with `like` as the first non-keyword argument.
+    module : str, optional
+        __module__ attribute to set on new function, e.g., ``module='numpy'``.
+        By default, module is copied from the decorated function.
+    verify : bool, optional
+        If True, verify the that the signature of the dispatcher and decorated
+        function signatures match exactly: all required and optional arguments
+        should appear in order with the same names, but the default values for
+        all optional arguments should be ``None``. Only disable verification
+        if the dispatcher's signature needs to deviate for some particular
+        reason, e.g., because the function has a signature like
+        ``func(*args, **kwargs)``.
+    docs_from_dispatcher : bool, optional
+        If True, copy docs from the dispatcher function onto the dispatched
+        function, rather than from the implementation. This is useful for
+        functions defined in C, which otherwise don't have docstrings.
+
+    Returns
+    -------
+    Function suitable for decorating the implementation of a NumPy function.
+
+    """
+    def decorator(implementation):
+        if verify:
+            if dispatcher is not None:
+                verify_matching_signatures(implementation, dispatcher)
+            else:
+                # Using __code__ directly similar to verify_matching_signature
+                co = implementation.__code__
+                last_arg = co.co_argcount + co.co_kwonlyargcount - 1
+                last_arg = co.co_varnames[last_arg]
+                if last_arg != "like" or co.co_kwonlyargcount == 0:
+                    raise RuntimeError(
+                        "__array_function__ expects `like=` to be the last "
+                        "argument and a keyword-only argument. "
+                        f"{implementation} does not seem to comply.")
+
+        if docs_from_dispatcher and dispatcher.__doc__ is not None:
+            doc = inspect.cleandoc(dispatcher.__doc__)
+            add_docstring(implementation, doc)
+
+        public_api = _ArrayFunctionDispatcher(dispatcher, implementation)
+        functools.update_wrapper(public_api, implementation)
+
+        if not verify and not getattr(implementation, "__text_signature__", None):
+            public_api.__signature__ = inspect.signature(dispatcher)
+
+        if module is not None:
+            public_api.__module__ = module
+
+        ARRAY_FUNCTIONS.add(public_api)
+
+        return public_api
+
+    return decorator
+
+
+def array_function_from_dispatcher(
+        implementation, module=None, verify=True, docs_from_dispatcher=True):
+    """Like array_function_dispatcher, but with function arguments flipped."""
+
+    def decorator(dispatcher):
+        return array_function_dispatch(
+            dispatcher, module, verify=verify,
+            docs_from_dispatcher=docs_from_dispatcher)(implementation)
+    return decorator

numpy/_core/overrides.pyi

@@ -0,0 +1,47 @@
+from collections.abc import Callable, Iterable
+from typing import Any, Final, NamedTuple, ParamSpec, TypeAlias, TypeVar
+
+from numpy._utils import set_module as set_module
+
+_T = TypeVar("_T")
+_Tss = ParamSpec("_Tss")
+_FuncLikeT = TypeVar("_FuncLikeT", bound=type | Callable[..., object])
+
+_Dispatcher: TypeAlias = Callable[_Tss, Iterable[object]]
+
+###
+
+ARRAY_FUNCTIONS: set[Callable[..., Any]] = ...
+array_function_like_doc: Final[str] = ...
+
+class ArgSpec(NamedTuple):
+    args: list[str]
+    varargs: str | None
+    keywords: str | None
+    defaults: tuple[Any, ...]
+
+def get_array_function_like_doc(public_api: Callable[..., object], docstring_template: str = "") -> str: ...
+def finalize_array_function_like(public_api: _FuncLikeT) -> _FuncLikeT: ...
+
+#
+def verify_matching_signatures(implementation: Callable[_Tss, object], dispatcher: _Dispatcher[_Tss]) -> None: ...
+
+# NOTE: This actually returns a `_ArrayFunctionDispatcher` callable wrapper object, with
+# the original wrapped callable stored in the `._implementation` attribute. It checks
+# for any `__array_function__` of the values of specific arguments that the dispatcher
+# specifies. Since the dispatcher only returns an iterable of passed array-like args,
+# this overridable behaviour is impossible to annotate.
+def array_function_dispatch(
+    dispatcher: _Dispatcher[_Tss] | None = None,
+    module: str | None = None,
+    verify: bool = True,
+    docs_from_dispatcher: bool = False,
+) -> Callable[[_FuncLikeT], _FuncLikeT]: ...
+
+#
+def array_function_from_dispatcher(
+    implementation: Callable[_Tss, _T],
+    module: str | None = None,
+    verify: bool = True,
+    docs_from_dispatcher: bool = True,
+) -> Callable[[_Dispatcher[_Tss]], Callable[_Tss, _T]]: ...

numpy/_core/printoptions.py

@@ -0,0 +1,32 @@
+"""
+Stores and defines the low-level format_options context variable.
+
+This is defined in its own file outside of the arrayprint module
+so we can import it from C while initializing the multiarray
+C module during import without introducing circular dependencies.
+"""
+
+import sys
+from contextvars import ContextVar
+
+__all__ = ["format_options"]
+
+default_format_options_dict = {
+    "edgeitems": 3,  # repr N leading and trailing items of each dimension
+    "threshold": 1000,  # total items > triggers array summarization
+    "floatmode": "maxprec",
+    "precision": 8,  # precision of floating point representations
+    "suppress": False,  # suppress printing small floating values in exp format
+    "linewidth": 75,
+    "nanstr": "nan",
+    "infstr": "inf",
+    "sign": "-",
+    "formatter": None,
+    # Internally stored as an int to simplify comparisons; converted from/to
+    # str/False on the way in/out.
+    'legacy': sys.maxsize,
+    'override_repr': None,
+}
+
+format_options = ContextVar(
+    "format_options", default=default_format_options_dict)

numpy/_core/printoptions.pyi

@@ -0,0 +1,28 @@
+from collections.abc import Callable
+from contextvars import ContextVar
+from typing import Any, Final, TypedDict
+
+from .arrayprint import _FormatDict
+
+__all__ = ["format_options"]
+
+###
+
+class _FormatOptionsDict(TypedDict):
+    edgeitems: int
+    threshold: int
+    floatmode: str
+    precision: int
+    suppress: bool
+    linewidth: int
+    nanstr: str
+    infstr: str
+    sign: str
+    formatter: _FormatDict | None
+    legacy: int
+    override_repr: Callable[[Any], str] | None
+
+###
+
+default_format_options_dict: Final[_FormatOptionsDict] = ...
+format_options: ContextVar[_FormatOptionsDict]