From f744f3689d99b669030b32c1f624af3db2813a5e Mon Sep 17 00:00:00 2001 From: jorenham Date: Thu, 18 Jul 2024 05:39:43 +0200 Subject: [PATCH 1/5] TYP: Explicit ``numpy.__all__`` in the stubs --- numpy/__init__.pyi | 121 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 120 insertions(+), 1 deletion(-) diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index e73d6f16765b..6072ea4bf3f6 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -613,6 +613,126 @@ from numpy.matrixlib import ( bmat as bmat, ) +__all__ = [ + "emath", "show_config", "__version__", "__array_namespace_info__", + + # __numpy_submodules__ + "linalg", "fft", "dtypes", "random", "polynomial", "ma", "exceptions", "lib", + "ctypeslib", "testing", "test", "rec", "char", "strings", + "core", "typing", "f2py", + + # _core.__all__ + "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2", "bitwise_invert", + "bitwise_left_shift", "bitwise_right_shift", "concat", "pow", "permute_dims", + "memmap", "sctypeDict", "record", "recarray", + + # _core.numeric.__all__ + "newaxis", "ndarray", "flatiter", "nditer", "nested_iters", "ufunc", "arange", + "array", "asarray", "asanyarray", "ascontiguousarray", "asfortranarray", "zeros", + "count_nonzero", "empty", "broadcast", "dtype", "fromstring", "fromfile", + "frombuffer", "from_dlpack", "where", "argwhere", "copyto", "concatenate", + "lexsort", "astype", "can_cast", "promote_types", "min_scalar_type", "result_type", + "isfortran", "empty_like", "zeros_like", "ones_like", "correlate", "convolve", + "inner", "dot", "outer", "vdot", "roll", "rollaxis", "moveaxis", "cross", + "tensordot", "little_endian", "fromiter", "array_equal", "array_equiv", "indices", + "fromfunction", "isclose", "isscalar", "binary_repr", "base_repr", "ones", + "identity", "allclose", "putmask", "flatnonzero", "inf", "nan", "False_", "True_", + "bitwise_not", "full", "full_like", "matmul", "vecdot", "shares_memory", + "may_share_memory", "_get_promotion_state", "_set_promotion_state", + "all", "amax", "amin", "any", "argmax", "argmin", "argpartition", "argsort", + "around", "choose", "clip", "compress", "cumprod", "cumsum", "cumulative_prod", + "cumulative_sum", "diagonal", "mean", "max", "min", "matrix_transpose", "ndim", + "nonzero", "partition", "prod", "ptp", "put", "ravel", "repeat", "reshape", + "resize", "round", "searchsorted", "shape", "size", "sort", "squeeze", "std", "sum", + "swapaxes", "take", "trace", "transpose", "var", + "absolute", "add", "arccos", "arccosh", "arcsin", "arcsinh", "arctan", "arctan2", + "arctanh", "bitwise_and", "bitwise_or", "bitwise_xor", "cbrt", "ceil", "conj", + "conjugate", "copysign", "cos", "cosh", "bitwise_count", "deg2rad", "degrees", + "divide", "divmod", "e", "equal", "euler_gamma", "exp", "exp2", "expm1", "fabs", + "floor", "floor_divide", "float_power", "fmax", "fmin", "fmod", "frexp", + "frompyfunc", "gcd", "greater", "greater_equal", "heaviside", "hypot", "invert", + "isfinite", "isinf", "isnan", "isnat", "lcm", "ldexp", "left_shift", "less", + "less_equal", "log", "log10", "log1p", "log2", "logaddexp", "logaddexp2", + "logical_and", "logical_not", "logical_or", "logical_xor", "maximum", "minimum", + "mod", "modf", "multiply", "negative", "nextafter", "not_equal", "pi", "positive", + "power", "rad2deg", "radians", "reciprocal", "remainder", "right_shift", "rint", + "sign", "signbit", "sin", "sinh", "spacing", "sqrt", "square", "subtract", "tan", + "tanh", "true_divide", "trunc", "ScalarType", "typecodes", "issubdtype", + "datetime_data", "datetime_as_string", "busday_offset", "busday_count", "is_busday", + "busdaycalendar", "isdtype", + "complexfloating", "character", "unsignedinteger", "inexact", "generic", "floating", + "integer", "signedinteger", "number", "flexible", "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", + "uint128", "uint256", "int128", "int256", "float80", "float96", "float128", + "float256", "complex160", "complex192", "complex256", "complex512", + "array2string", "array_str", "array_repr", "set_printoptions", "get_printoptions", + "printoptions", "format_float_positional", "format_float_scientific", "require", + "seterr", "geterr", "setbufsize", "getbufsize", "seterrcall", "geterrcall", + "errstate", "_no_nep50_warning", + # _core.function_base.__all__ + "logspace", "linspace", "geomspace", + # _core.getlimits.__all__ + "finfo", "iinfo", + # _core.shape_base.__all__ + "atleast_1d", "atleast_2d", "atleast_3d", "block", "hstack", "stack", "unstack", + "vstack", + # _core.einsumfunc.__all__ + "einsum", "einsum_path", + + # lib._histograms_impl.__all__ + "histogram", "histogramdd", "histogram_bin_edges", + # lib._nanfunctions_impl.__all__ + "nansum", "nanmax", "nanmin", "nanargmax", "nanargmin", "nanmean", "nanmedian", + "nanpercentile", "nanvar", "nanstd", "nanprod", "nancumsum", "nancumprod", + "nanquantile", + # lib._function_base_impl.__all__ + "select", "piecewise", "trim_zeros", "copy", "iterable", "percentile", "diff", + "gradient", "angle", "unwrap", "sort_complex", "flip", "rot90", "extract", "place", + "vectorize", "asarray_chkfinite", "average", "bincount", "digitize", "cov", + "corrcoef", "median", "sinc", "hamming", "hanning", "bartlett", "blackman", + "kaiser", "i0", "meshgrid", "delete", "insert", "append", "interp", "quantile", + "trapezoid", # "trapz", + # lib._twodim_base_impl.__all__ + "diag", "diagflat", "eye", "fliplr", "flipud", "tri", "triu", "tril", "vander", + "histogram2d", "mask_indices", "tril_indices", "tril_indices_from", "triu_indices", + "triu_indices_from", + # lib._shape_base_impl.__all__ + "column_stack", "dstack", "array_split", "split", "hsplit", "vsplit", "dsplit", + "apply_over_axes", "expand_dims", "apply_along_axis", "kron", "tile", + "take_along_axis", "put_along_axis", # "row_stack", + # lib._type_check_impl.__all__ + "iscomplexobj", "isrealobj", "imag", "iscomplex", "isreal", "nan_to_num", "real", + "real_if_close", "typename", "mintypecode", "common_type", + # lib._arraysetops_impl.__all__ + "ediff1d", "intersect1d", "isin", "setdiff1d", "setxor1d", "union1d", "unique", + "unique_all", "unique_counts", "unique_inverse", "unique_values", # "in1d", + # lib._ufunclike_impl.__all__ + "fix", "isneginf", "isposinf", + # lib._arraypad_impl.__all__ + "pad", + # lib._utils_impl.__all__ + "get_include", "info", "show_runtime", + # lib._stride_tricks_impl.__all__ + "broadcast_to", "broadcast_arrays", "broadcast_shapes", + # lib._polynomial_impl.__all__ + "poly", "roots", "polyint", "polyder", "polyadd", "polysub", "polymul", "polydiv", + "polyval", "poly1d", "polyfit", + # lib._npyio_impl.__all__ + "savetxt", "loadtxt", "genfromtxt", "load", "save", "savez", "savez_compressed", + "packbits", "unpackbits", "fromregex", + # lib._index_tricks_impl.__all__ + "ravel_multi_index", "unravel_index", "mgrid", "ogrid", "r_", "c_", "s_", + "index_exp", "ix_", "ndenumerate", "ndindex", "fill_diagonal", "diag_indices", + "diag_indices_from", + + # matrixlib.__all__ + "matrix", "bmat", "asmatrix", +] + _AnyStr_contra = TypeVar("_AnyStr_contra", LiteralString, builtins.str, bytes, contravariant=True) # Protocol for representing file-like-objects accepted @@ -637,7 +757,6 @@ class _MemMapIOProtocol(Protocol): class _SupportsWrite(Protocol[_AnyStr_contra]): def write(self, s: _AnyStr_contra, /) -> object: ... -__all__: list[str] def __dir__() -> Sequence[str]: ... __version__: LiteralString From 43081a81f304665245f415d884e9b4302aafc793 Mon Sep 17 00:00:00 2001 From: jorenham Date: Thu, 18 Jul 2024 05:40:56 +0200 Subject: [PATCH 2/5] TYP: Add missing module import in ``numpy`` --- numpy/__init__.pyi | 3 +++ 1 file changed, 3 insertions(+) diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index 6072ea4bf3f6..b9319a4b5e27 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -212,8 +212,10 @@ else: # Ensures that the stubs are picked up from numpy import ( + core as core, ctypeslib as ctypeslib, exceptions as exceptions, + f2py as f2py, fft as fft, lib as lib, linalg as linalg, @@ -221,6 +223,7 @@ from numpy import ( polynomial as polynomial, random as random, testing as testing, + typing as typing, version as version, exceptions as exceptions, dtypes as dtypes, From 1014565fc1d37df15b5b306d0e1421cff11c362c Mon Sep 17 00:00:00 2001 From: jorenham Date: Thu, 18 Jul 2024 05:54:04 +0200 Subject: [PATCH 3/5] TYP: Simplify ``import _ as _`` statements in ``numpy`` --- numpy/__init__.pyi | 662 ++++++++++++++++++++++----------------------- 1 file changed, 330 insertions(+), 332 deletions(-) diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index b9319a4b5e27..db32e6faf8c8 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -160,21 +160,21 @@ from numpy._typing._callable import ( # NOTE: Numpy's mypy plugin is used for removing the types unavailable # to the specific platform from numpy._typing._extended_precision import ( - uint128 as uint128, - uint256 as uint256, - int128 as int128, - int256 as int256, - float80 as float80, - float96 as float96, - float128 as float128, - float256 as float256, - complex160 as complex160, - complex192 as complex192, - complex256 as complex256, - complex512 as complex512, + uint128, + uint256, + int128, + int256, + float80, + float96, + float128, + float256, + complex160, + complex192, + complex256, + complex512, ) -from numpy._array_api_info import __array_namespace_info__ as __array_namespace_info__ +from numpy._array_api_info import __array_namespace_info__ from collections.abc import ( Callable, @@ -210,213 +210,208 @@ elif TYPE_CHECKING: else: LiteralString: TypeAlias = str -# Ensures that the stubs are picked up from numpy import ( - core as core, - ctypeslib as ctypeslib, - exceptions as exceptions, - f2py as f2py, - fft as fft, - lib as lib, - linalg as linalg, - ma as ma, - polynomial as polynomial, - random as random, - testing as testing, - typing as typing, - version as version, - exceptions as exceptions, - dtypes as dtypes, - rec as rec, - char as char, - strings as strings, + core, + ctypeslib, + exceptions, + f2py, + fft, + lib, + linalg, + ma, + polynomial, + random, + testing, + typing, + version, + exceptions, + dtypes, + rec, + char, + strings, ) from numpy._core.records import ( - record as record, - recarray as recarray, -) - -from numpy._core.defchararray import ( - chararray as chararray, + record, + recarray, ) from numpy._core.function_base import ( - linspace as linspace, - logspace as logspace, - geomspace as geomspace, + linspace, + logspace, + geomspace, ) from numpy._core.fromnumeric import ( - take as take, - reshape as reshape, - choose as choose, - repeat as repeat, - put as put, - swapaxes as swapaxes, - transpose as transpose, - matrix_transpose as matrix_transpose, - partition as partition, - argpartition as argpartition, - sort as sort, - argsort as argsort, - argmax as argmax, - argmin as argmin, - searchsorted as searchsorted, - resize as resize, - squeeze as squeeze, - diagonal as diagonal, - trace as trace, - ravel as ravel, - nonzero as nonzero, - shape as shape, - compress as compress, - clip as clip, - sum as sum, - all as all, - any as any, - cumsum as cumsum, - cumulative_sum as cumulative_sum, - ptp as ptp, - max as max, - min as min, - amax as amax, - amin as amin, - prod as prod, - cumprod as cumprod, - cumulative_prod as cumulative_prod, - ndim as ndim, - size as size, - around as around, - round as round, - mean as mean, - std as std, - var as var, + take, + reshape, + choose, + repeat, + put, + swapaxes, + transpose, + matrix_transpose, + partition, + argpartition, + sort, + argsort, + argmax, + argmin, + searchsorted, + resize, + squeeze, + diagonal, + trace, + ravel, + nonzero, + shape, + compress, + clip, + sum, + all, + any, + cumsum, + cumulative_sum, + ptp, + max, + min, + amax, + amin, + prod, + cumprod, + cumulative_prod, + ndim, + size, + around, + round, + mean, + std, + var, ) from numpy._core._asarray import ( - require as require, + require, ) from numpy._core._type_aliases import ( - sctypeDict as sctypeDict, + sctypeDict, ) from numpy._core._ufunc_config import ( - seterr as seterr, - geterr as geterr, - setbufsize as setbufsize, - getbufsize as getbufsize, - seterrcall as seterrcall, - geterrcall as geterrcall, + seterr, + geterr, + setbufsize, + getbufsize, + seterrcall, + geterrcall, _ErrKind, _ErrFunc, ) from numpy._core.arrayprint import ( - set_printoptions as set_printoptions, - get_printoptions as get_printoptions, - array2string as array2string, - format_float_scientific as format_float_scientific, - format_float_positional as format_float_positional, - array_repr as array_repr, - array_str as array_str, - printoptions as printoptions, + set_printoptions, + get_printoptions, + array2string, + format_float_scientific, + format_float_positional, + array_repr, + array_str, + printoptions, ) from numpy._core.einsumfunc import ( - einsum as einsum, - einsum_path as einsum_path, + einsum, + einsum_path, ) from numpy._core.multiarray import ( - array as array, - empty_like as empty_like, - empty as empty, - zeros as zeros, - concatenate as concatenate, - inner as inner, - where as where, - lexsort as lexsort, - can_cast as can_cast, - min_scalar_type as min_scalar_type, - result_type as result_type, - dot as dot, - vdot as vdot, - bincount as bincount, - copyto as copyto, - putmask as putmask, - packbits as packbits, - unpackbits as unpackbits, - shares_memory as shares_memory, - may_share_memory as may_share_memory, - asarray as asarray, - asanyarray as asanyarray, - ascontiguousarray as ascontiguousarray, - asfortranarray as asfortranarray, - arange as arange, - busday_count as busday_count, - busday_offset as busday_offset, - datetime_as_string as datetime_as_string, - datetime_data as datetime_data, - frombuffer as frombuffer, - fromfile as fromfile, - fromiter as fromiter, - is_busday as is_busday, - promote_types as promote_types, - fromstring as fromstring, - frompyfunc as frompyfunc, - nested_iters as nested_iters, + array, + empty_like, + empty, + zeros, + concatenate, + inner, + where, + lexsort, + can_cast, + min_scalar_type, + result_type, + dot, + vdot, + bincount, + copyto, + putmask, + packbits, + unpackbits, + shares_memory, + may_share_memory, + asarray, + asanyarray, + ascontiguousarray, + asfortranarray, + arange, + busday_count, + busday_offset, + datetime_as_string, + datetime_data, + frombuffer, + fromfile, + fromiter, + is_busday, + promote_types, + fromstring, + frompyfunc, + nested_iters, flagsobj, ) from numpy._core.numeric import ( - zeros_like as zeros_like, - ones as ones, - ones_like as ones_like, - full as full, - full_like as full_like, - count_nonzero as count_nonzero, - isfortran as isfortran, - argwhere as argwhere, - flatnonzero as flatnonzero, - correlate as correlate, - convolve as convolve, - outer as outer, - tensordot as tensordot, - roll as roll, - rollaxis as rollaxis, - moveaxis as moveaxis, - cross as cross, - indices as indices, - fromfunction as fromfunction, - isscalar as isscalar, - binary_repr as binary_repr, - base_repr as base_repr, - identity as identity, - allclose as allclose, - isclose as isclose, - array_equal as array_equal, - array_equiv as array_equiv, - astype as astype, + zeros_like, + ones, + ones_like, + full, + full_like, + count_nonzero, + isfortran, + argwhere, + flatnonzero, + correlate, + convolve, + outer, + tensordot, + roll, + rollaxis, + moveaxis, + cross, + indices, + fromfunction, + isscalar, + binary_repr, + base_repr, + identity, + allclose, + isclose, + array_equal, + array_equiv, + astype, ) from numpy._core.numerictypes import ( - isdtype as isdtype, - issubdtype as issubdtype, - ScalarType as ScalarType, - typecodes as typecodes, + isdtype, + issubdtype, + ScalarType, + typecodes, ) from numpy._core.shape_base import ( - atleast_1d as atleast_1d, - atleast_2d as atleast_2d, - atleast_3d as atleast_3d, - block as block, - hstack as hstack, - stack as stack, - vstack as vstack, - unstack as unstack, + atleast_1d, + atleast_2d, + atleast_3d, + block, + hstack, + stack, + vstack, + unstack, ) from numpy.lib import ( @@ -424,200 +419,200 @@ from numpy.lib import ( ) from numpy.lib._arraypad_impl import ( - pad as pad, + pad, ) from numpy.lib._arraysetops_impl import ( - ediff1d as ediff1d, - intersect1d as intersect1d, - isin as isin, - setdiff1d as setdiff1d, - setxor1d as setxor1d, - union1d as union1d, - unique as unique, - unique_all as unique_all, - unique_counts as unique_counts, - unique_inverse as unique_inverse, - unique_values as unique_values, + ediff1d, + intersect1d, + isin, + setdiff1d, + setxor1d, + union1d, + unique, + unique_all, + unique_counts, + unique_inverse, + unique_values, ) from numpy.lib._function_base_impl import ( - select as select, - piecewise as piecewise, - trim_zeros as trim_zeros, - copy as copy, - iterable as iterable, - percentile as percentile, - diff as diff, - gradient as gradient, - angle as angle, - unwrap as unwrap, - sort_complex as sort_complex, - flip as flip, - rot90 as rot90, - extract as extract, - place as place, - asarray_chkfinite as asarray_chkfinite, - average as average, - bincount as bincount, - digitize as digitize, - cov as cov, - corrcoef as corrcoef, - median as median, - sinc as sinc, - hamming as hamming, - hanning as hanning, - bartlett as bartlett, - blackman as blackman, - kaiser as kaiser, - i0 as i0, - meshgrid as meshgrid, - delete as delete, - insert as insert, - append as append, - interp as interp, - quantile as quantile, - trapezoid as trapezoid, + select, + piecewise, + trim_zeros, + copy, + iterable, + percentile, + diff, + gradient, + angle, + unwrap, + sort_complex, + flip, + rot90, + extract, + place, + asarray_chkfinite, + average, + bincount, + digitize, + cov, + corrcoef, + median, + sinc, + hamming, + hanning, + bartlett, + blackman, + kaiser, + i0, + meshgrid, + delete, + insert, + append, + interp, + quantile, + trapezoid, ) from numpy.lib._histograms_impl import ( - histogram_bin_edges as histogram_bin_edges, - histogram as histogram, - histogramdd as histogramdd, + histogram_bin_edges, + histogram, + histogramdd, ) from numpy.lib._index_tricks_impl import ( - ravel_multi_index as ravel_multi_index, - unravel_index as unravel_index, - mgrid as mgrid, - ogrid as ogrid, - r_ as r_, - c_ as c_, - s_ as s_, - index_exp as index_exp, - ix_ as ix_, - fill_diagonal as fill_diagonal, - diag_indices as diag_indices, - diag_indices_from as diag_indices_from, + ravel_multi_index, + unravel_index, + mgrid, + ogrid, + r_, + c_, + s_, + index_exp, + ix_, + fill_diagonal, + diag_indices, + diag_indices_from, ) from numpy.lib._nanfunctions_impl import ( - nansum as nansum, - nanmax as nanmax, - nanmin as nanmin, - nanargmax as nanargmax, - nanargmin as nanargmin, - nanmean as nanmean, - nanmedian as nanmedian, - nanpercentile as nanpercentile, - nanvar as nanvar, - nanstd as nanstd, - nanprod as nanprod, - nancumsum as nancumsum, - nancumprod as nancumprod, - nanquantile as nanquantile, + nansum, + nanmax, + nanmin, + nanargmax, + nanargmin, + nanmean, + nanmedian, + nanpercentile, + nanvar, + nanstd, + nanprod, + nancumsum, + nancumprod, + nanquantile, ) from numpy.lib._npyio_impl import ( - savetxt as savetxt, - loadtxt as loadtxt, - genfromtxt as genfromtxt, - load as load, - save as save, - savez as savez, - savez_compressed as savez_compressed, - packbits as packbits, - unpackbits as unpackbits, - fromregex as fromregex, + savetxt, + loadtxt, + genfromtxt, + load, + save, + savez, + savez_compressed, + packbits, + unpackbits, + fromregex, ) from numpy.lib._polynomial_impl import ( - poly as poly, - roots as roots, - polyint as polyint, - polyder as polyder, - polyadd as polyadd, - polysub as polysub, - polymul as polymul, - polydiv as polydiv, - polyval as polyval, - polyfit as polyfit, + poly, + roots, + polyint, + polyder, + polyadd, + polysub, + polymul, + polydiv, + polyval, + polyfit, ) from numpy.lib._shape_base_impl import ( - column_stack as column_stack, - dstack as dstack, - array_split as array_split, - split as split, - hsplit as hsplit, - vsplit as vsplit, - dsplit as dsplit, - apply_over_axes as apply_over_axes, - expand_dims as expand_dims, - apply_along_axis as apply_along_axis, - kron as kron, - tile as tile, - take_along_axis as take_along_axis, - put_along_axis as put_along_axis, + column_stack, + dstack, + array_split, + split, + hsplit, + vsplit, + dsplit, + apply_over_axes, + expand_dims, + apply_along_axis, + kron, + tile, + take_along_axis, + put_along_axis, ) from numpy.lib._stride_tricks_impl import ( - broadcast_to as broadcast_to, - broadcast_arrays as broadcast_arrays, - broadcast_shapes as broadcast_shapes, + broadcast_to, + broadcast_arrays, + broadcast_shapes, ) from numpy.lib._twodim_base_impl import ( - diag as diag, - diagflat as diagflat, - eye as eye, - fliplr as fliplr, - flipud as flipud, - tri as tri, - triu as triu, - tril as tril, - vander as vander, - histogram2d as histogram2d, - mask_indices as mask_indices, - tril_indices as tril_indices, - tril_indices_from as tril_indices_from, - triu_indices as triu_indices, - triu_indices_from as triu_indices_from, + diag, + diagflat, + eye, + fliplr, + flipud, + tri, + triu, + tril, + vander, + histogram2d, + mask_indices, + tril_indices, + tril_indices_from, + triu_indices, + triu_indices_from, ) from numpy.lib._type_check_impl import ( - mintypecode as mintypecode, - real as real, - imag as imag, - iscomplex as iscomplex, - isreal as isreal, - iscomplexobj as iscomplexobj, - isrealobj as isrealobj, - nan_to_num as nan_to_num, - real_if_close as real_if_close, - typename as typename, - common_type as common_type, + mintypecode, + real, + imag, + iscomplex, + isreal, + iscomplexobj, + isrealobj, + nan_to_num, + real_if_close, + typename, + common_type, ) from numpy.lib._ufunclike_impl import ( - fix as fix, - isposinf as isposinf, - isneginf as isneginf, + fix, + isposinf, + isneginf, ) from numpy.lib._utils_impl import ( - get_include as get_include, - info as info, - show_runtime as show_runtime, + get_include, + info, + show_runtime, ) from numpy.matrixlib import ( - asmatrix as asmatrix, - bmat as bmat, + asmatrix, + bmat, ) __all__ = [ - "emath", "show_config", "__version__", "__array_namespace_info__", + "emath", "show_config", "version", "__version__", "__array_namespace_info__", # __numpy_submodules__ "linalg", "fft", "dtypes", "random", "polynomial", "ma", "exceptions", "lib", @@ -693,26 +688,29 @@ __all__ = [ "nanpercentile", "nanvar", "nanstd", "nanprod", "nancumsum", "nancumprod", "nanquantile", # lib._function_base_impl.__all__ + # NOTE: `trapz` is omitted because it is deprecated + # TODO: add `trapezoid` once type-hinted "select", "piecewise", "trim_zeros", "copy", "iterable", "percentile", "diff", "gradient", "angle", "unwrap", "sort_complex", "flip", "rot90", "extract", "place", "vectorize", "asarray_chkfinite", "average", "bincount", "digitize", "cov", "corrcoef", "median", "sinc", "hamming", "hanning", "bartlett", "blackman", "kaiser", "i0", "meshgrid", "delete", "insert", "append", "interp", "quantile", - "trapezoid", # "trapz", # lib._twodim_base_impl.__all__ "diag", "diagflat", "eye", "fliplr", "flipud", "tri", "triu", "tril", "vander", "histogram2d", "mask_indices", "tril_indices", "tril_indices_from", "triu_indices", "triu_indices_from", # lib._shape_base_impl.__all__ + # NOTE: `row_stack` is omitted because it is deprecated "column_stack", "dstack", "array_split", "split", "hsplit", "vsplit", "dsplit", "apply_over_axes", "expand_dims", "apply_along_axis", "kron", "tile", - "take_along_axis", "put_along_axis", # "row_stack", + "take_along_axis", "put_along_axis", # lib._type_check_impl.__all__ "iscomplexobj", "isrealobj", "imag", "iscomplex", "isreal", "nan_to_num", "real", "real_if_close", "typename", "mintypecode", "common_type", # lib._arraysetops_impl.__all__ + # NOTE: `in1d` is omitted because it is deprecated "ediff1d", "intersect1d", "isin", "setdiff1d", "setxor1d", "union1d", "unique", - "unique_all", "unique_counts", "unique_inverse", "unique_values", # "in1d", + "unique_all", "unique_counts", "unique_inverse", "unique_values", # lib._ufunclike_impl.__all__ "fix", "isneginf", "isposinf", # lib._arraypad_impl.__all__ From 46849ee3b6a8fa9504483948f5d70134a6ab1c10 Mon Sep 17 00:00:00 2001 From: jorenham Date: Thu, 18 Jul 2024 06:01:08 +0200 Subject: [PATCH 4/5] TYP: Remove unused private imports in ``numpy`` --- numpy/__init__.pyi | 3 --- 1 file changed, 3 deletions(-) diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index db32e6faf8c8..051f4385e823 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -32,8 +32,6 @@ from numpy._typing import ( _ArrayLikeTD64_co, _ArrayLikeDT64_co, _ArrayLikeObject_co, - _ArrayLikeStr_co, - _ArrayLikeBytes_co, _ArrayLikeUnknown, _UnknownType, @@ -72,7 +70,6 @@ from numpy._typing import ( _NBitShort, _NBitIntC, _NBitIntP, - _NBitInt, _NBitLong, _NBitLongLong, _NBitHalf, From e51326605bbe726d0aee4d1ff6ff002c84d68b4b Mon Sep 17 00:00:00 2001 From: jorenham Date: Tue, 23 Jul 2024 23:08:28 +0200 Subject: [PATCH 5/5] TYP: Explicitly export ``numpy.trapezoid`` in ``__all__`` --- numpy/__init__.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index 051f4385e823..d881575001fd 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -686,12 +686,12 @@ __all__ = [ "nanquantile", # lib._function_base_impl.__all__ # NOTE: `trapz` is omitted because it is deprecated - # TODO: add `trapezoid` once type-hinted "select", "piecewise", "trim_zeros", "copy", "iterable", "percentile", "diff", "gradient", "angle", "unwrap", "sort_complex", "flip", "rot90", "extract", "place", "vectorize", "asarray_chkfinite", "average", "bincount", "digitize", "cov", "corrcoef", "median", "sinc", "hamming", "hanning", "bartlett", "blackman", "kaiser", "i0", "meshgrid", "delete", "insert", "append", "interp", "quantile", + "trapezoid", # lib._twodim_base_impl.__all__ "diag", "diagflat", "eye", "fliplr", "flipud", "tri", "triu", "tril", "vander", "histogram2d", "mask_indices", "tril_indices", "tril_indices_from", "triu_indices",