__init__.py
"""
Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.
Please note that this module is private. All functions and objects
are available in the main ``numpy`` namespace - use that instead.
"""
import os
from numpy.version import version as __version__
# disables OpenBLAS affinity setting of the main thread that limits
# python threads or processes to one core
env_added = []
for envkey in ['OPENBLAS_MAIN_FREE']:
if envkey not in os.environ:
# Note: using `putenv` (and `unsetenv` further down) instead of updating
# `os.environ` on purpose to avoid a race condition, see gh-30627.
os.putenv(envkey, '1')
env_added.append(envkey)
try:
from . import multiarray
except ImportError as exc:
import sys
# Bypass for the module re-initialization opt-out
if exc.msg == "cannot load module more than once per process":
raise
# Basically always, the problem should be that the C module is wrong/missing...
if (
isinstance(exc, ModuleNotFoundError)
and exc.name == "numpy._core._multiarray_umath"
):
import sys
candidates = []
for path in __path__:
candidates.extend(
f for f in os.listdir(path) if f.startswith("_multiarray_umath"))
if len(candidates) == 0:
bad_c_module_info = (
"We found no compiled module, did NumPy build successfully?\n")
else:
candidate_str = '\n * '.join(candidates)
# cache_tag is documented to be possibly None, so just use name if it is
# this guesses at cache_tag being the same as the extension module scheme
tag = sys.implementation.cache_tag or sys.implementation.name
bad_c_module_info = (
f"The following compiled module files exist, but seem incompatible\n"
f"with with either python '{tag}' or the "
f"platform '{sys.platform}':\n\n * {candidate_str}\n"
)
else:
bad_c_module_info = ""
major, minor, *_ = sys.version_info
msg = f"""
IMPORTANT: PLEASE READ THIS FOR ADVICE ON HOW TO SOLVE THIS ISSUE!
Importing the numpy C-extensions failed. This error can happen for
many reasons, often due to issues with your setup or how NumPy was
installed.
{bad_c_module_info}
We have compiled some common reasons and troubleshooting tips at:
https://numpy.org/devdocs/user/troubleshooting-importerror.html
Please note and check the following:
* The Python version is: Python {major}.{minor} from "{sys.executable}"
* The NumPy version is: "{__version__}"
and make sure that they are the versions you expect.
Please carefully study the information and documentation linked above.
This is unlikely to be a NumPy issue but will be caused by a bad install
or environment on your machine.
Original error was: {exc}
"""
raise ImportError(msg) from exc
finally:
for envkey in env_added:
os.unsetenv(envkey)
del envkey
del env_added
del os
from . import umath
# Check that multiarray,umath are pure python modules wrapping
# _multiarray_umath and not either of the old c-extension modules
if not (hasattr(multiarray, '_multiarray_umath') and
hasattr(umath, '_multiarray_umath')):
import sys
path = sys.modules['numpy'].__path__
msg = ("Something is wrong with the numpy installation. "
"While importing we detected an older version of "
"numpy in {}. One method of fixing this is to repeatedly uninstall "
"numpy until none is found, then reinstall this version.")
raise ImportError(msg.format(path))
from . import numerictypes as nt
from .numerictypes import sctypeDict, sctypes
multiarray.set_typeDict(nt.sctypeDict)
from . import einsumfunc, fromnumeric, function_base, getlimits, numeric, shape_base
from .einsumfunc import *
from .fromnumeric import *
from .function_base import *
from .getlimits import *
# Note: module name memmap is overwritten by a class with same name
from .memmap import *
from .numeric import *
from .records import recarray, record
from .shape_base import *
del nt
# do this after everything else, to minimize the chance of this misleadingly
# appearing in an import-time traceback
# add these for module-freeze analysis (like PyInstaller)
from . import (
_add_newdocs,
_add_newdocs_scalars,
_dtype,
_dtype_ctypes,
_internal,
_methods,
)
from .numeric import absolute as abs
acos = numeric.arccos
acosh = numeric.arccosh
asin = numeric.arcsin
asinh = numeric.arcsinh
atan = numeric.arctan
atanh = numeric.arctanh
atan2 = numeric.arctan2
concat = numeric.concatenate
bitwise_left_shift = numeric.left_shift
bitwise_invert = numeric.invert
bitwise_right_shift = numeric.right_shift
permute_dims = numeric.transpose
pow = numeric.power
__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"
]
__all__ += numeric.__all__
__all__ += function_base.__all__
__all__ += getlimits.__all__
__all__ += shape_base.__all__
__all__ += einsumfunc.__all__
def _ufunc_reduce(func):
# Report the `__name__`. pickle will try to find the module. Note that
# pickle supports for this `__name__` to be a `__qualname__`. It may
# make sense to add a `__qualname__` to ufuncs, to allow this more
# explicitly (Numba has ufuncs as attributes).
# See also: https://github.com/dask/distributed/issues/3450
return func.__name__
def _DType_reconstruct(scalar_type):
# This is a work-around to pickle type(np.dtype(np.float64)), etc.
# and it should eventually be replaced with a better solution, e.g. when
# DTypes become HeapTypes.
return type(dtype(scalar_type))
def _DType_reduce(DType):
# As types/classes, most DTypes can simply be pickled by their name:
if not DType._legacy or DType.__module__ == "numpy.dtypes":
return DType.__name__
# However, user defined legacy dtypes (like rational) do not end up in
# `numpy.dtypes` as module and do not have a public class at all.
# For these, we pickle them by reconstructing them from the scalar type:
scalar_type = DType.type
return _DType_reconstruct, (scalar_type,)
import copyreg
copyreg.pickle(ufunc, _ufunc_reduce)
copyreg.pickle(type(dtype), _DType_reduce, _DType_reconstruct)
# Unclutter namespace (must keep _*_reconstruct for unpickling)
del copyreg, _ufunc_reduce, _DType_reduce
from numpy._pytesttester import PytestTester
test = PytestTester(__name__)
del PytestTester