fix build error
This commit is contained in:
parent
6c462d6197
commit
c27e79ea54
|
@ -0,0 +1,2 @@
|
|||
This directory exists so that 3rd party packages can be installed
|
||||
here. Read the source for site.py for more details.
|
|
@ -0,0 +1,2 @@
|
|||
__version__ = 'kivy-ios'
|
||||
from ._sqlite3 import * # noqa: F401, F403
|
|
@ -0,0 +1 @@
|
|||
|
|
@ -0,0 +1,54 @@
|
|||
Metadata-Version: 1.2
|
||||
Name: numpy
|
||||
Version: 1.20.2
|
||||
Summary: NumPy is the fundamental package for array computing with Python.
|
||||
Home-page: https://www.numpy.org
|
||||
Author: Travis E. Oliphant et al.
|
||||
Maintainer: NumPy Developers
|
||||
Maintainer-email: numpy-discussion@python.org
|
||||
License: BSD
|
||||
Download-URL: https://pypi.python.org/pypi/numpy
|
||||
Project-URL: Bug Tracker, https://github.com/numpy/numpy/issues
|
||||
Project-URL: Documentation, https://numpy.org/doc/1.20
|
||||
Project-URL: Source Code, https://github.com/numpy/numpy
|
||||
Description: It provides:
|
||||
|
||||
- a powerful N-dimensional array object
|
||||
- sophisticated (broadcasting) functions
|
||||
- tools for integrating C/C++ and Fortran code
|
||||
- useful linear algebra, Fourier transform, and random number capabilities
|
||||
- and much more
|
||||
|
||||
Besides its obvious scientific uses, NumPy can also be used as an efficient
|
||||
multi-dimensional container of generic data. Arbitrary data-types can be
|
||||
defined. This allows NumPy to seamlessly and speedily integrate with a wide
|
||||
variety of databases.
|
||||
|
||||
All NumPy wheels distributed on PyPI are BSD licensed.
|
||||
|
||||
|
||||
Platform: Windows
|
||||
Platform: Linux
|
||||
Platform: Solaris
|
||||
Platform: Mac OS-X
|
||||
Platform: Unix
|
||||
Classifier: Development Status :: 5 - Production/Stable
|
||||
Classifier: Intended Audience :: Science/Research
|
||||
Classifier: Intended Audience :: Developers
|
||||
Classifier: License :: OSI Approved :: BSD License
|
||||
Classifier: Programming Language :: C
|
||||
Classifier: Programming Language :: Python
|
||||
Classifier: Programming Language :: Python :: 3
|
||||
Classifier: Programming Language :: Python :: 3.7
|
||||
Classifier: Programming Language :: Python :: 3.8
|
||||
Classifier: Programming Language :: Python :: 3.9
|
||||
Classifier: Programming Language :: Python :: 3 :: Only
|
||||
Classifier: Programming Language :: Python :: Implementation :: CPython
|
||||
Classifier: Topic :: Software Development
|
||||
Classifier: Topic :: Scientific/Engineering
|
||||
Classifier: Typing :: Typed
|
||||
Classifier: Operating System :: Microsoft :: Windows
|
||||
Classifier: Operating System :: POSIX
|
||||
Classifier: Operating System :: Unix
|
||||
Classifier: Operating System :: MacOS
|
||||
Requires-Python: >=3.7
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1 @@
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
[console_scripts]
|
||||
f2py = numpy.f2py.f2py2e:main
|
||||
f2py3 = numpy.f2py.f2py2e:main
|
||||
f2py3.8 = numpy.f2py.f2py2e:main
|
||||
|
|
@ -0,0 +1 @@
|
|||
|
|
@ -0,0 +1 @@
|
|||
numpy
|
|
@ -0,0 +1,49 @@
|
|||
Copyright (c) 2005-2021, NumPy Developers.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following
|
||||
disclaimer in the documentation and/or other materials provided
|
||||
with the distribution.
|
||||
|
||||
* Neither the name of the NumPy Developers nor the names of any
|
||||
contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
||||
The NumPy repository and source distributions bundle several libraries that are
|
||||
compatibly licensed. We list these here.
|
||||
|
||||
Name: lapack-lite
|
||||
Files: numpy/linalg/lapack_lite/*
|
||||
License: BSD-3-Clause
|
||||
For details, see numpy/linalg/lapack_lite/LICENSE.txt
|
||||
|
||||
Name: tempita
|
||||
Files: tools/npy_tempita/*
|
||||
License: MIT
|
||||
For details, see tools/npy_tempita/license.txt
|
||||
|
||||
Name: dragon4
|
||||
Files: numpy/core/src/multiarray/dragon4.c
|
||||
License: MIT
|
||||
For license text, see numpy/core/src/multiarray/dragon4.c
|
|
@ -0,0 +1,74 @@
|
|||
# This file is generated by numpy's setup.py
|
||||
# It contains system_info results at the time of building this package.
|
||||
__all__ = ["get_info","show"]
|
||||
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs')
|
||||
|
||||
if sys.platform == 'win32' and os.path.isdir(extra_dll_dir):
|
||||
if sys.version_info >= (3, 8):
|
||||
os.add_dll_directory(extra_dll_dir)
|
||||
else:
|
||||
os.environ.setdefault('PATH', '')
|
||||
os.environ['PATH'] += os.pathsep + extra_dll_dir
|
||||
|
||||
blas_opt_info={}
|
||||
lapack_opt_info={}
|
||||
numpy_linalg_lapack_lite={'language': 'c', 'define_macros': [('HAVE_BLAS_ILP64', None), ('BLAS_SYMBOL_SUFFIX', '64_')]}
|
||||
|
||||
def get_info(name):
|
||||
g = globals()
|
||||
return g.get(name, g.get(name + "_info", {}))
|
||||
|
||||
def show():
|
||||
"""
|
||||
Show libraries in the system on which NumPy was built.
|
||||
|
||||
Print information about various resources (libraries, library
|
||||
directories, include directories, etc.) in the system on which
|
||||
NumPy was built.
|
||||
|
||||
See Also
|
||||
--------
|
||||
get_include : Returns the directory containing NumPy C
|
||||
header files.
|
||||
|
||||
Notes
|
||||
-----
|
||||
Classes specifying the information to be printed are defined
|
||||
in the `numpy.distutils.system_info` module.
|
||||
|
||||
Information may include:
|
||||
|
||||
* ``language``: language used to write the libraries (mostly
|
||||
C or f77)
|
||||
* ``libraries``: names of libraries found in the system
|
||||
* ``library_dirs``: directories containing the libraries
|
||||
* ``include_dirs``: directories containing library header files
|
||||
* ``src_dirs``: directories containing library source files
|
||||
* ``define_macros``: preprocessor macros used by
|
||||
``distutils.setup``
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> import numpy as np
|
||||
>>> np.show_config()
|
||||
blas_opt_info:
|
||||
language = c
|
||||
define_macros = [('HAVE_CBLAS', None)]
|
||||
libraries = ['openblas', 'openblas']
|
||||
library_dirs = ['/usr/local/lib']
|
||||
"""
|
||||
for name,info_dict in globals().items():
|
||||
if name[0] == "_" or type(info_dict) is not type({}): continue
|
||||
print(name + ":")
|
||||
if not info_dict:
|
||||
print(" NOT AVAILABLE")
|
||||
for k,v in info_dict.items():
|
||||
v = str(v)
|
||||
if k == "sources" and len(v) > 200:
|
||||
v = v[:60] + " ...\n... " + v[-60:]
|
||||
print(" %s = %s" % (k,v))
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,410 @@
|
|||
"""
|
||||
NumPy
|
||||
=====
|
||||
|
||||
Provides
|
||||
1. An array object of arbitrary homogeneous items
|
||||
2. Fast mathematical operations over arrays
|
||||
3. Linear Algebra, Fourier Transforms, Random Number Generation
|
||||
|
||||
How to use the documentation
|
||||
----------------------------
|
||||
Documentation is available in two forms: docstrings provided
|
||||
with the code, and a loose standing reference guide, available from
|
||||
`the NumPy homepage <https://www.scipy.org>`_.
|
||||
|
||||
We recommend exploring the docstrings using
|
||||
`IPython <https://ipython.org>`_, an advanced Python shell with
|
||||
TAB-completion and introspection capabilities. See below for further
|
||||
instructions.
|
||||
|
||||
The docstring examples assume that `numpy` has been imported as `np`::
|
||||
|
||||
>>> import numpy as np
|
||||
|
||||
Code snippets are indicated by three greater-than signs::
|
||||
|
||||
>>> x = 42
|
||||
>>> x = x + 1
|
||||
|
||||
Use the built-in ``help`` function to view a function's docstring::
|
||||
|
||||
>>> help(np.sort)
|
||||
... # doctest: +SKIP
|
||||
|
||||
For some objects, ``np.info(obj)`` may provide additional help. This is
|
||||
particularly true if you see the line "Help on ufunc object:" at the top
|
||||
of the help() page. Ufuncs are implemented in C, not Python, for speed.
|
||||
The native Python help() does not know how to view their help, but our
|
||||
np.info() function does.
|
||||
|
||||
To search for documents containing a keyword, do::
|
||||
|
||||
>>> np.lookfor('keyword')
|
||||
... # doctest: +SKIP
|
||||
|
||||
General-purpose documents like a glossary and help on the basic concepts
|
||||
of numpy are available under the ``doc`` sub-module::
|
||||
|
||||
>>> from numpy import doc
|
||||
>>> help(doc)
|
||||
... # doctest: +SKIP
|
||||
|
||||
Available subpackages
|
||||
---------------------
|
||||
doc
|
||||
Topical documentation on broadcasting, indexing, etc.
|
||||
lib
|
||||
Basic functions used by several sub-packages.
|
||||
random
|
||||
Core Random Tools
|
||||
linalg
|
||||
Core Linear Algebra Tools
|
||||
fft
|
||||
Core FFT routines
|
||||
polynomial
|
||||
Polynomial tools
|
||||
testing
|
||||
NumPy testing tools
|
||||
f2py
|
||||
Fortran to Python Interface Generator.
|
||||
distutils
|
||||
Enhancements to distutils with support for
|
||||
Fortran compilers support and more.
|
||||
|
||||
Utilities
|
||||
---------
|
||||
test
|
||||
Run numpy unittests
|
||||
show_config
|
||||
Show numpy build configuration
|
||||
dual
|
||||
Overwrite certain functions with high-performance SciPy tools.
|
||||
Note: `numpy.dual` is deprecated. Use the functions from NumPy or Scipy
|
||||
directly instead of importing them from `numpy.dual`.
|
||||
matlib
|
||||
Make everything matrices.
|
||||
__version__
|
||||
NumPy version string
|
||||
|
||||
Viewing documentation using IPython
|
||||
-----------------------------------
|
||||
Start IPython with the NumPy profile (``ipython -p numpy``), which will
|
||||
import `numpy` under the alias `np`. Then, use the ``cpaste`` command to
|
||||
paste examples into the shell. To see which functions are available in
|
||||
`numpy`, type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
|
||||
``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
|
||||
down the list. To view the docstring for a function, use
|
||||
``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
|
||||
the source code).
|
||||
|
||||
Copies vs. in-place operation
|
||||
-----------------------------
|
||||
Most of the functions in `numpy` return a copy of the array argument
|
||||
(e.g., `np.sort`). In-place versions of these functions are often
|
||||
available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
|
||||
Exceptions to this rule are documented.
|
||||
|
||||
"""
|
||||
import sys
|
||||
import warnings
|
||||
|
||||
from ._globals import ModuleDeprecationWarning, VisibleDeprecationWarning
|
||||
from ._globals import _NoValue
|
||||
|
||||
# We first need to detect if we're being called as part of the numpy setup
|
||||
# procedure itself in a reliable manner.
|
||||
try:
|
||||
__NUMPY_SETUP__
|
||||
except NameError:
|
||||
__NUMPY_SETUP__ = False
|
||||
|
||||
if __NUMPY_SETUP__:
|
||||
sys.stderr.write('Running from numpy source directory.\n')
|
||||
else:
|
||||
try:
|
||||
from numpy.__config__ import show as show_config
|
||||
except ImportError as e:
|
||||
msg = """Error importing numpy: you should not try to import numpy from
|
||||
its source directory; please exit the numpy source tree, and relaunch
|
||||
your python interpreter from there."""
|
||||
raise ImportError(msg) from e
|
||||
|
||||
from .version import git_revision as __git_revision__
|
||||
from .version import version as __version__
|
||||
|
||||
__all__ = ['ModuleDeprecationWarning',
|
||||
'VisibleDeprecationWarning']
|
||||
|
||||
# mapping of {name: (value, deprecation_msg)}
|
||||
__deprecated_attrs__ = {}
|
||||
|
||||
# Allow distributors to run custom init code
|
||||
from . import _distributor_init
|
||||
|
||||
from . import core
|
||||
from .core import *
|
||||
from . import compat
|
||||
from . import lib
|
||||
# NOTE: to be revisited following future namespace cleanup.
|
||||
# See gh-14454 and gh-15672 for discussion.
|
||||
from .lib import *
|
||||
|
||||
from . import linalg
|
||||
from . import fft
|
||||
from . import polynomial
|
||||
from . import random
|
||||
from . import ctypeslib
|
||||
from . import ma
|
||||
from . import matrixlib as _mat
|
||||
from .matrixlib import *
|
||||
|
||||
# Deprecations introduced in NumPy 1.20.0, 2020-06-06
|
||||
import builtins as _builtins
|
||||
|
||||
_msg = (
|
||||
"`np.{n}` is a deprecated alias for the builtin `{n}`. "
|
||||
"To silence this warning, use `{n}` by itself. Doing this will not "
|
||||
"modify any behavior and is safe. {extended_msg}\n"
|
||||
"Deprecated in NumPy 1.20; for more details and guidance: "
|
||||
"https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations")
|
||||
|
||||
_specific_msg = (
|
||||
"If you specifically wanted the numpy scalar type, use `np.{}` here.")
|
||||
|
||||
_int_extended_msg = (
|
||||
"When replacing `np.{}`, you may wish to use e.g. `np.int64` "
|
||||
"or `np.int32` to specify the precision. If you wish to review "
|
||||
"your current use, check the release note link for "
|
||||
"additional information.")
|
||||
|
||||
_type_info = [
|
||||
("object", ""), # The NumPy scalar only exists by name.
|
||||
("bool", _specific_msg.format("bool_")),
|
||||
("float", _specific_msg.format("float64")),
|
||||
("complex", _specific_msg.format("complex128")),
|
||||
("str", _specific_msg.format("str_")),
|
||||
("int", _int_extended_msg.format("int"))]
|
||||
|
||||
__deprecated_attrs__.update({
|
||||
n: (getattr(_builtins, n), _msg.format(n=n, extended_msg=extended_msg))
|
||||
for n, extended_msg in _type_info
|
||||
})
|
||||
|
||||
_msg = (
|
||||
"`np.{n}` is a deprecated alias for `np.compat.{n}`. "
|
||||
"To silence this warning, use `np.compat.{n}` by itself. "
|
||||
"In the likely event your code does not need to work on Python 2 "
|
||||
"you can use the builtin `{n2}` for which `np.compat.{n}` is itself "
|
||||
"an alias. Doing this will not modify any behaviour and is safe. "
|
||||
"{extended_msg}\n"
|
||||
"Deprecated in NumPy 1.20; for more details and guidance: "
|
||||
"https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations")
|
||||
|
||||
__deprecated_attrs__["long"] = (
|
||||
getattr(compat, "long"),
|
||||
_msg.format(n="long", n2="int",
|
||||
extended_msg=_int_extended_msg.format("long")))
|
||||
|
||||
__deprecated_attrs__["unicode"] = (
|
||||
getattr(compat, "unicode"),
|
||||
_msg.format(n="unicode", n2="str",
|
||||
extended_msg=_specific_msg.format("str_")))
|
||||
|
||||
del _msg, _specific_msg, _int_extended_msg, _type_info, _builtins
|
||||
|
||||
from .core import round, abs, max, min
|
||||
# now that numpy modules are imported, can initialize limits
|
||||
core.getlimits._register_known_types()
|
||||
|
||||
__all__.extend(['__version__', 'show_config'])
|
||||
__all__.extend(core.__all__)
|
||||
__all__.extend(_mat.__all__)
|
||||
__all__.extend(lib.__all__)
|
||||
__all__.extend(['linalg', 'fft', 'random', 'ctypeslib', 'ma'])
|
||||
|
||||
# These are exported by np.core, but are replaced by the builtins below
|
||||
# remove them to ensure that we don't end up with `np.long == np.int_`,
|
||||
# which would be a breaking change.
|
||||
del long, unicode
|
||||
__all__.remove('long')
|
||||
__all__.remove('unicode')
|
||||
|
||||
# Remove things that are in the numpy.lib but not in the numpy namespace
|
||||
# Note that there is a test (numpy/tests/test_public_api.py:test_numpy_namespace)
|
||||
# that prevents adding more things to the main namespace by accident.
|
||||
# The list below will grow until the `from .lib import *` fixme above is
|
||||
# taken care of
|
||||
__all__.remove('Arrayterator')
|
||||
del Arrayterator
|
||||
|
||||
# These names were removed in NumPy 1.20. For at least one release,
|
||||
# attempts to access these names in the numpy namespace will trigger
|
||||
# a warning, and calling the function will raise an exception.
|
||||
_financial_names = ['fv', 'ipmt', 'irr', 'mirr', 'nper', 'npv', 'pmt',
|
||||
'ppmt', 'pv', 'rate']
|
||||
__expired_functions__ = {
|
||||
name: (f'In accordance with NEP 32, the function {name} was removed '
|
||||
'from NumPy version 1.20. A replacement for this function '
|
||||
'is available in the numpy_financial library: '
|
||||
'https://pypi.org/project/numpy-financial')
|
||||
for name in _financial_names}
|
||||
|
||||
# Filter out Cython harmless warnings
|
||||
warnings.filterwarnings("ignore", message="numpy.dtype size changed")
|
||||
warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
|
||||
warnings.filterwarnings("ignore", message="numpy.ndarray size changed")
|
||||
|
||||
# oldnumeric and numarray were removed in 1.9. In case some packages import
|
||||
# but do not use them, we define them here for backward compatibility.
|
||||
oldnumeric = 'removed'
|
||||
numarray = 'removed'
|
||||
|
||||
if sys.version_info[:2] >= (3, 7):
|
||||
# module level getattr is only supported in 3.7 onwards
|
||||
# https://www.python.org/dev/peps/pep-0562/
|
||||
def __getattr__(attr):
|
||||
# Warn for expired attributes, and return a dummy function
|
||||
# that always raises an exception.
|
||||
try:
|
||||
msg = __expired_functions__[attr]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
|
||||
def _expired(*args, **kwds):
|
||||
raise RuntimeError(msg)
|
||||
|
||||
return _expired
|
||||
|
||||
# Emit warnings for deprecated attributes
|
||||
try:
|
||||
val, msg = __deprecated_attrs__[attr]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
return val
|
||||
|
||||
# Importing Tester requires importing all of UnitTest which is not a
|
||||
# cheap import Since it is mainly used in test suits, we lazy import it
|
||||
# here to save on the order of 10 ms of import time for most users
|
||||
#
|
||||
# The previous way Tester was imported also had a side effect of adding
|
||||
# the full `numpy.testing` namespace
|
||||
if attr == 'testing':
|
||||
import numpy.testing as testing
|
||||
return testing
|
||||
elif attr == 'Tester':
|
||||
from .testing import Tester
|
||||
return Tester
|
||||
|
||||
raise AttributeError("module {!r} has no attribute "
|
||||
"{!r}".format(__name__, attr))
|
||||
|
||||
def __dir__():
|
||||
return list(globals().keys() | {'Tester', 'testing'})
|
||||
|
||||
else:
|
||||
# We don't actually use this ourselves anymore, but I'm not 100% sure that
|
||||
# no-one else in the world is using it (though I hope not)
|
||||
from .testing import Tester
|
||||
|
||||
# We weren't able to emit a warning about these, so keep them around
|
||||
globals().update({
|
||||
k: v
|
||||
for k, (v, msg) in __deprecated_attrs__.items()
|
||||
})
|
||||
|
||||
|
||||
# Pytest testing
|
||||
from numpy._pytesttester import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
|
||||
|
||||
def _sanity_check():
|
||||
"""
|
||||
Quick sanity checks for common bugs caused by environment.
|
||||
There are some cases e.g. with wrong BLAS ABI that cause wrong
|
||||
results under specific runtime conditions that are not necessarily
|
||||
achieved during test suite runs, and it is useful to catch those early.
|
||||
|
||||
See https://github.com/numpy/numpy/issues/8577 and other
|
||||
similar bug reports.
|
||||
|
||||
"""
|
||||
try:
|
||||
x = ones(2, dtype=float32)
|
||||
if not abs(x.dot(x) - 2.0) < 1e-5:
|
||||
raise AssertionError()
|
||||
except AssertionError:
|
||||
msg = ("The current Numpy installation ({!r}) fails to "
|
||||
"pass simple sanity checks. This can be caused for example "
|
||||
"by incorrect BLAS library being linked in, or by mixing "
|
||||
"package managers (pip, conda, apt, ...). Search closed "
|
||||
"numpy issues for similar problems.")
|
||||
raise RuntimeError(msg.format(__file__)) from None
|
||||
|
||||
_sanity_check()
|
||||
del _sanity_check
|
||||
|
||||
def _mac_os_check():
|
||||
"""
|
||||
Quick Sanity check for Mac OS look for accelerate build bugs.
|
||||
Testing numpy polyfit calls init_dgelsd(LAPACK)
|
||||
"""
|
||||
try:
|
||||
c = array([3., 2., 1.])
|
||||
x = linspace(0, 2, 5)
|
||||
y = polyval(c, x)
|
||||
_ = polyfit(x, y, 2, cov=True)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
import sys
|
||||
if sys.platform == "darwin":
|
||||
with warnings.catch_warnings(record=True) as w:
|
||||
_mac_os_check()
|
||||
# Throw runtime error, if the test failed Check for warning and error_message
|
||||
error_message = ""
|
||||
if len(w) > 0:
|
||||
error_message = "{}: {}".format(w[-1].category.__name__, str(w[-1].message))
|
||||
msg = (
|
||||
"Polyfit sanity test emitted a warning, most likely due "
|
||||
"to using a buggy Accelerate backend. If you compiled "
|
||||
"yourself, more information is available at "
|
||||
"https://numpy.org/doc/stable/user/building.html#accelerated-blas-lapack-libraries "
|
||||
"Otherwise report this to the vendor "
|
||||
"that provided NumPy.\n{}\n".format(error_message))
|
||||
raise RuntimeError(msg)
|
||||
del _mac_os_check
|
||||
|
||||
# We usually use madvise hugepages support, but on some old kernels it
|
||||
# is slow and thus better avoided.
|
||||
# Specifically kernel version 4.6 had a bug fix which probably fixed this:
|
||||
# https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff
|
||||
import os
|
||||
use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None)
|
||||
if sys.platform == "linux" and use_hugepage is None:
|
||||
# If there is an issue with parsing the kernel version,
|
||||
# set use_hugepages to 0. Usage of LooseVersion will handle
|
||||
# the kernel version parsing better, but avoided since it
|
||||
# will increase the import time. See: #16679 for related discussion.
|
||||
try:
|
||||
use_hugepage = 1
|
||||
kernel_version = os.uname().release.split(".")[:2]
|
||||
kernel_version = tuple(int(v) for v in kernel_version)
|
||||
if kernel_version < (4, 6):
|
||||
use_hugepage = 0
|
||||
except ValueError:
|
||||
use_hugepages = 0
|
||||
elif use_hugepage is None:
|
||||
# This is not Linux, so it should not matter, just enable anyway
|
||||
use_hugepage = 1
|
||||
else:
|
||||
use_hugepage = int(use_hugepage)
|
||||
|
||||
# Note that this will currently only make a difference on Linux
|
||||
core.multiarray._set_madvise_hugepage(use_hugepage)
|
File diff suppressed because it is too large
Load Diff
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
@ -0,0 +1,10 @@
|
|||
""" Distributor init file
|
||||
|
||||
Distributors: you can add custom code here to support particular distributions
|
||||
of numpy.
|
||||
|
||||
For example, this is a good place to put any checks for hardware requirements.
|
||||
|
||||
The numpy standard source distribution will not put code in this file, so you
|
||||
can safely replace this file with your own version.
|
||||
"""
|
|
@ -0,0 +1,79 @@
|
|||
"""
|
||||
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.
|
||||
|
||||
"""
|
||||
__ALL__ = [
|
||||
'ModuleDeprecationWarning', 'VisibleDeprecationWarning', '_NoValue'
|
||||
]
|
||||
|
||||
|
||||
# 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 ModuleDeprecationWarning(DeprecationWarning):
|
||||
"""Module deprecation warning.
|
||||
|
||||
The nose tester turns ordinary Deprecation warnings into test failures.
|
||||
That makes it hard to deprecate whole modules, because they get
|
||||
imported by default. So this is a special Deprecation warning that the
|
||||
nose tester will let pass without making tests fail.
|
||||
|
||||
"""
|
||||
|
||||
|
||||
ModuleDeprecationWarning.__module__ = 'numpy'
|
||||
|
||||
|
||||
class VisibleDeprecationWarning(UserWarning):
|
||||
"""Visible deprecation warning.
|
||||
|
||||
By default, python will not show deprecation warnings, so this class
|
||||
can be used when a very visible warning is helpful, for example because
|
||||
the usage is most likely a user bug.
|
||||
|
||||
"""
|
||||
|
||||
|
||||
VisibleDeprecationWarning.__module__ = 'numpy'
|
||||
|
||||
|
||||
class _NoValueType:
|
||||
"""Special keyword value.
|
||||
|
||||
The instance of this class may be used as the default value assigned to a
|
||||
deprecated keyword in order to check if it has been given a user defined
|
||||
value.
|
||||
"""
|
||||
__instance = None
|
||||
def __new__(cls):
|
||||
# ensure that only one instance exists
|
||||
if not cls.__instance:
|
||||
cls.__instance = super(_NoValueType, cls).__new__(cls)
|
||||
return cls.__instance
|
||||
|
||||
# needed for python 2 to preserve identity through a pickle
|
||||
def __reduce__(self):
|
||||
return (self.__class__, ())
|
||||
|
||||
def __repr__(self):
|
||||
return "<no value>"
|
||||
|
||||
|
||||
_NoValue = _NoValueType()
|
|
@ -0,0 +1,213 @@
|
|||
"""
|
||||
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 develop mode. That
|
||||
includes the standard ``python runtests.py`` invocation.
|
||||
|
||||
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 sys
|
||||
import os
|
||||
|
||||
__all__ = ['PytestTester']
|
||||
|
||||
|
||||
|
||||
def _show_numpy_info():
|
||||
from numpy.core._multiarray_umath import (
|
||||
__cpu_features__, __cpu_baseline__, __cpu_dispatch__
|
||||
)
|
||||
import numpy as np
|
||||
|
||||
print("NumPy version %s" % np.__version__)
|
||||
relaxed_strides = np.ones((10, 1), order="C").flags.f_contiguous
|
||||
print("NumPy relaxed strides checking option:", relaxed_strides)
|
||||
|
||||
if len(__cpu_baseline__) == 0 and len(__cpu_dispatch__) == 0:
|
||||
enabled_features = "nothing enabled"
|
||||
else:
|
||||
enabled_features = ' '.join(__cpu_baseline__)
|
||||
for feature in __cpu_dispatch__:
|
||||
if __cpu_features__[feature]:
|
||||
enabled_features += " %s*" % feature
|
||||
else:
|
||||
enabled_features += " %s?" % feature
|
||||
print("NumPy CPU features:", enabled_features)
|
||||
|
||||
|
||||
|
||||
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
|
||||
|
||||
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 pytest
|
||||
import warnings
|
||||
|
||||
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"]
|
||||
|
||||
# Filter out distutils cpu warnings (could be localized to
|
||||
# distutils tests). ASV has problems with top level import,
|
||||
# so fetch module for suppression here.
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("always")
|
||||
from numpy.distutils import cpuinfo
|
||||
|
||||
# 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:
|
||||
raise ValueError("Doctests not supported")
|
||||
|
||||
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 += ["--durations=%s" % 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
|
|
@ -0,0 +1,56 @@
|
|||
from typing import Any, List
|
||||
|
||||
__all__: List[str]
|
||||
|
||||
equal: Any
|
||||
not_equal: Any
|
||||
greater_equal: Any
|
||||
less_equal: Any
|
||||
greater: Any
|
||||
less: Any
|
||||
str_len: Any
|
||||
add: Any
|
||||
multiply: Any
|
||||
mod: Any
|
||||
capitalize: Any
|
||||
center: Any
|
||||
count: Any
|
||||
decode: Any
|
||||
encode: Any
|
||||
endswith: Any
|
||||
expandtabs: Any
|
||||
find: Any
|
||||
index: Any
|
||||
isalnum: Any
|
||||
isalpha: Any
|
||||
isdigit: Any
|
||||
islower: Any
|
||||
isspace: Any
|
||||
istitle: Any
|
||||
isupper: Any
|
||||
join: Any
|
||||
ljust: Any
|
||||
lower: Any
|
||||
lstrip: Any
|
||||
partition: Any
|
||||
replace: Any
|
||||
rfind: Any
|
||||
rindex: Any
|
||||
rjust: Any
|
||||
rpartition: Any
|
||||
rsplit: Any
|
||||
rstrip: Any
|
||||
split: Any
|
||||
splitlines: Any
|
||||
startswith: Any
|
||||
strip: Any
|
||||
swapcase: Any
|
||||
title: Any
|
||||
translate: Any
|
||||
upper: Any
|
||||
zfill: Any
|
||||
isnumeric: Any
|
||||
isdecimal: Any
|
||||
array: Any
|
||||
asarray: Any
|
||||
chararray: Any
|
|
@ -0,0 +1,18 @@
|
|||
"""
|
||||
Compatibility module.
|
||||
|
||||
This module contains duplicated code from Python itself or 3rd party
|
||||
extensions, which may be included for the following reasons:
|
||||
|
||||
* compatibility
|
||||
* we may only need a small subset of the copied library/module
|
||||
|
||||
"""
|
||||
from . import _inspect
|
||||
from . import py3k
|
||||
from ._inspect import getargspec, formatargspec
|
||||
from .py3k import *
|
||||
|
||||
__all__ = []
|
||||
__all__.extend(_inspect.__all__)
|
||||
__all__.extend(py3k.__all__)
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
@ -0,0 +1,191 @@
|
|||
"""Subset of inspect module from upstream python
|
||||
|
||||
We use this instead of upstream because upstream inspect is slow to import, and
|
||||
significantly contributes to numpy import times. Importing this copy has almost
|
||||
no overhead.
|
||||
|
||||
"""
|
||||
import types
|
||||
|
||||
__all__ = ['getargspec', 'formatargspec']
|
||||
|
||||
# ----------------------------------------------------------- type-checking
|
||||
def ismethod(object):
|
||||
"""Return true if the object is an instance method.
|
||||
|
||||
Instance method objects provide these attributes:
|
||||
__doc__ documentation string
|
||||
__name__ name with which this method was defined
|
||||
im_class class object in which this method belongs
|
||||
im_func function object containing implementation of method
|
||||
im_self instance to which this method is bound, or None
|
||||
|
||||
"""
|
||||
return isinstance(object, types.MethodType)
|
||||
|
||||
def isfunction(object):
|
||||
"""Return true if the object is a user-defined function.
|
||||
|
||||
Function objects provide these attributes:
|
||||
__doc__ documentation string
|
||||
__name__ name with which this function was defined
|
||||
func_code code object containing compiled function bytecode
|
||||
func_defaults tuple of any default values for arguments
|
||||
func_doc (same as __doc__)
|
||||
func_globals global namespace in which this function was defined
|
||||
func_name (same as __name__)
|
||||
|
||||
"""
|
||||
return isinstance(object, types.FunctionType)
|
||||
|
||||
def iscode(object):
|
||||
"""Return true if the object is a code object.
|
||||
|
||||
Code objects provide these attributes:
|
||||
co_argcount number of arguments (not including * or ** args)
|
||||
co_code string of raw compiled bytecode
|
||||
co_consts tuple of constants used in the bytecode
|
||||
co_filename name of file in which this code object was created
|
||||
co_firstlineno number of first line in Python source code
|
||||
co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg
|
||||
co_lnotab encoded mapping of line numbers to bytecode indices
|
||||
co_name name with which this code object was defined
|
||||
co_names tuple of names of local variables
|
||||
co_nlocals number of local variables
|
||||
co_stacksize virtual machine stack space required
|
||||
co_varnames tuple of names of arguments and local variables
|
||||
|
||||
"""
|
||||
return isinstance(object, types.CodeType)
|
||||
|
||||
# ------------------------------------------------ argument list extraction
|
||||
# These constants are from Python's compile.h.
|
||||
CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 1, 2, 4, 8
|
||||
|
||||
def getargs(co):
|
||||
"""Get information about the arguments accepted by a code object.
|
||||
|
||||
Three things are returned: (args, varargs, varkw), where 'args' is
|
||||
a list of argument names (possibly containing nested lists), and
|
||||
'varargs' and 'varkw' are the names of the * and ** arguments or None.
|
||||
|
||||
"""
|
||||
|
||||
if not iscode(co):
|
||||
raise TypeError('arg is not a code object')
|
||||
|
||||
nargs = co.co_argcount
|
||||
names = co.co_varnames
|
||||
args = list(names[:nargs])
|
||||
|
||||
# The following acrobatics are for anonymous (tuple) arguments.
|
||||
# Which we do not need to support, so remove to avoid importing
|
||||
# the dis module.
|
||||
for i in range(nargs):
|
||||
if args[i][:1] in ['', '.']:
|
||||
raise TypeError("tuple function arguments are not supported")
|
||||
varargs = None
|
||||
if co.co_flags & CO_VARARGS:
|
||||
varargs = co.co_varnames[nargs]
|
||||
nargs = nargs + 1
|
||||
varkw = None
|
||||
if co.co_flags & CO_VARKEYWORDS:
|
||||
varkw = co.co_varnames[nargs]
|
||||
return args, varargs, varkw
|
||||
|
||||
def getargspec(func):
|
||||
"""Get the names and default values of a function's arguments.
|
||||
|
||||
A tuple of four things is returned: (args, varargs, varkw, defaults).
|
||||
'args' is a list of the argument names (it may contain nested lists).
|
||||
'varargs' and 'varkw' are the names of the * and ** arguments or None.
|
||||
'defaults' is an n-tuple of the default values of the last n arguments.
|
||||
|
||||
"""
|
||||
|
||||
if ismethod(func):
|
||||
func = func.__func__
|
||||
if not isfunction(func):
|
||||
raise TypeError('arg is not a Python function')
|
||||
args, varargs, varkw = getargs(func.__code__)
|
||||
return args, varargs, varkw, func.__defaults__
|
||||
|
||||
def getargvalues(frame):
|
||||
"""Get information about arguments passed into a particular frame.
|
||||
|
||||
A tuple of four things is returned: (args, varargs, varkw, locals).
|
||||
'args' is a list of the argument names (it may contain nested lists).
|
||||
'varargs' and 'varkw' are the names of the * and ** arguments or None.
|
||||
'locals' is the locals dictionary of the given frame.
|
||||
|
||||
"""
|
||||
args, varargs, varkw = getargs(frame.f_code)
|
||||
return args, varargs, varkw, frame.f_locals
|
||||
|
||||
def joinseq(seq):
|
||||
if len(seq) == 1:
|
||||
return '(' + seq[0] + ',)'
|
||||
else:
|
||||
return '(' + ', '.join(seq) + ')'
|
||||
|
||||
def strseq(object, convert, join=joinseq):
|
||||
"""Recursively walk a sequence, stringifying each element.
|
||||
|
||||
"""
|
||||
if type(object) in [list, tuple]:
|
||||
return join([strseq(_o, convert, join) for _o in object])
|
||||
else:
|
||||
return convert(object)
|
||||
|
||||
def formatargspec(args, varargs=None, varkw=None, defaults=None,
|
||||
formatarg=str,
|
||||
formatvarargs=lambda name: '*' + name,
|
||||
formatvarkw=lambda name: '**' + name,
|
||||
formatvalue=lambda value: '=' + repr(value),
|
||||
join=joinseq):
|
||||
"""Format an argument spec from the 4 values returned by getargspec.
|
||||
|
||||
The first four arguments are (args, varargs, varkw, defaults). The
|
||||
other four arguments are the corresponding optional formatting functions
|
||||
that are called to turn names and values into strings. The ninth
|
||||
argument is an optional function to format the sequence of arguments.
|
||||
|
||||
"""
|
||||
specs = []
|
||||
if defaults:
|
||||
firstdefault = len(args) - len(defaults)
|
||||
for i in range(len(args)):
|
||||
spec = strseq(args[i], formatarg, join)
|
||||
if defaults and i >= firstdefault:
|
||||
spec = spec + formatvalue(defaults[i - firstdefault])
|
||||
specs.append(spec)
|
||||
if varargs is not None:
|
||||
specs.append(formatvarargs(varargs))
|
||||
if varkw is not None:
|
||||
specs.append(formatvarkw(varkw))
|
||||
return '(' + ', '.join(specs) + ')'
|
||||
|
||||
def formatargvalues(args, varargs, varkw, locals,
|
||||
formatarg=str,
|
||||
formatvarargs=lambda name: '*' + name,
|
||||
formatvarkw=lambda name: '**' + name,
|
||||
formatvalue=lambda value: '=' + repr(value),
|
||||
join=joinseq):
|
||||
"""Format an argument spec from the 4 values returned by getargvalues.
|
||||
|
||||
The first four arguments are (args, varargs, varkw, locals). The
|
||||
next four arguments are the corresponding optional formatting functions
|
||||
that are called to turn names and values into strings. The ninth
|
||||
argument is an optional function to format the sequence of arguments.
|
||||
|
||||
"""
|
||||
def convert(name, locals=locals,
|
||||
formatarg=formatarg, formatvalue=formatvalue):
|
||||
return formatarg(name) + formatvalue(locals[name])
|
||||
specs = [strseq(arg, convert, join) for arg in args]
|
||||
|
||||
if varargs:
|
||||
specs.append(formatvarargs(varargs) + formatvalue(locals[varargs]))
|
||||
if varkw:
|
||||
specs.append(formatvarkw(varkw) + formatvalue(locals[varkw]))
|
||||
return '(' + ', '.join(specs) + ')'
|
|
@ -0,0 +1,136 @@
|
|||
"""
|
||||
Python 3.X compatibility tools.
|
||||
|
||||
While this file was originally intended for Python 2 -> 3 transition,
|
||||
it is now used to create a compatibility layer between different
|
||||
minor versions of Python 3.
|
||||
|
||||
While the active version of numpy may not support a given version of python, we
|
||||
allow downstream libraries to continue to use these shims for forward
|
||||
compatibility with numpy while they transition their code to newer versions of
|
||||
Python.
|
||||
"""
|
||||
__all__ = ['bytes', 'asbytes', 'isfileobj', 'getexception', 'strchar',
|
||||
'unicode', 'asunicode', 'asbytes_nested', 'asunicode_nested',
|
||||
'asstr', 'open_latin1', 'long', 'basestring', 'sixu',
|
||||
'integer_types', 'is_pathlib_path', 'npy_load_module', 'Path',
|
||||
'pickle', 'contextlib_nullcontext', 'os_fspath', 'os_PathLike']
|
||||
|
||||
import sys
|
||||
import os
|
||||
from pathlib import Path
|
||||
import io
|
||||
|
||||
import abc
|
||||
from abc import ABC as abc_ABC
|
||||
|
||||
try:
|
||||
import pickle5 as pickle
|
||||
except ImportError:
|
||||
import pickle
|
||||
|
||||
long = int
|
||||
integer_types = (int,)
|
||||
basestring = str
|
||||
unicode = str
|
||||
bytes = bytes
|
||||
|
||||
def asunicode(s):
|
||||
if isinstance(s, bytes):
|
||||
return s.decode('latin1')
|
||||
return str(s)
|
||||
|
||||
def asbytes(s):
|
||||
if isinstance(s, bytes):
|
||||
return s
|
||||
return str(s).encode('latin1')
|
||||
|
||||
def asstr(s):
|
||||
if isinstance(s, bytes):
|
||||
return s.decode('latin1')
|
||||
return str(s)
|
||||
|
||||
def isfileobj(f):
|
||||
return isinstance(f, (io.FileIO, io.BufferedReader, io.BufferedWriter))
|
||||
|
||||
def open_latin1(filename, mode='r'):
|
||||
return open(filename, mode=mode, encoding='iso-8859-1')
|
||||
|
||||
def sixu(s):
|
||||
return s
|
||||
|
||||
strchar = 'U'
|
||||
|
||||
def getexception():
|
||||
return sys.exc_info()[1]
|
||||
|
||||
def asbytes_nested(x):
|
||||
if hasattr(x, '__iter__') and not isinstance(x, (bytes, unicode)):
|
||||
return [asbytes_nested(y) for y in x]
|
||||
else:
|
||||
return asbytes(x)
|
||||
|
||||
def asunicode_nested(x):
|
||||
if hasattr(x, '__iter__') and not isinstance(x, (bytes, unicode)):
|
||||
return [asunicode_nested(y) for y in x]
|
||||
else:
|
||||
return asunicode(x)
|
||||
|
||||
def is_pathlib_path(obj):
|
||||
"""
|
||||
Check whether obj is a `pathlib.Path` object.
|
||||
|
||||
Prefer using ``isinstance(obj, os.PathLike)`` instead of this function.
|
||||
"""
|
||||
return isinstance(obj, Path)
|
||||
|
||||
# from Python 3.7
|
||||
class contextlib_nullcontext:
|
||||
"""Context manager that does no additional processing.
|
||||
|
||||
Used as a stand-in for a normal context manager, when a particular
|
||||
block of code is only sometimes used with a normal context manager:
|
||||
|
||||
cm = optional_cm if condition else nullcontext()
|
||||
with cm:
|
||||
# Perform operation, using optional_cm if condition is True
|
||||
"""
|
||||
|
||||
def __init__(self, enter_result=None):
|
||||
self.enter_result = enter_result
|
||||
|
||||
def __enter__(self):
|
||||
return self.enter_result
|
||||
|
||||
def __exit__(self, *excinfo):
|
||||
pass
|
||||
|
||||
|
||||
def npy_load_module(name, fn, info=None):
|
||||
"""
|
||||
Load a module.
|
||||
|
||||
.. versionadded:: 1.11.2
|
||||
|
||||
Parameters
|
||||
----------
|
||||
name : str
|
||||
Full module name.
|
||||
fn : str
|
||||
Path to module file.
|
||||
info : tuple, optional
|
||||
Only here for backward compatibility with Python 2.*.
|
||||
|
||||
Returns
|
||||
-------
|
||||
mod : module
|
||||
|
||||
"""
|
||||
# Explicitly lazy import this to avoid paying the cost
|
||||
# of importing importlib at startup
|
||||
from importlib.machinery import SourceFileLoader
|
||||
return SourceFileLoader(name, fn).load_module()
|
||||
|
||||
|
||||
os_fspath = os.fspath
|
||||
os_PathLike = os.PathLike
|
|
@ -0,0 +1,10 @@
|
|||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('compat', parent_package, top_path)
|
||||
config.add_subpackage('tests')
|
||||
return config
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(configuration=configuration)
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
@ -0,0 +1,19 @@
|
|||
from os.path import join
|
||||
|
||||
from numpy.compat import isfileobj
|
||||
from numpy.testing import assert_
|
||||
from numpy.testing import tempdir
|
||||
|
||||
|
||||
def test_isfileobj():
|
||||
with tempdir(prefix="numpy_test_compat_") as folder:
|
||||
filename = join(folder, 'a.bin')
|
||||
|
||||
with open(filename, 'wb') as f:
|
||||
assert_(isfileobj(f))
|
||||
|
||||
with open(filename, 'ab') as f:
|
||||
assert_(isfileobj(f))
|
||||
|
||||
with open(filename, 'rb') as f:
|
||||
assert_(isfileobj(f))
|
|
@ -0,0 +1,119 @@
|
|||
"""
|
||||
Pytest configuration and fixtures for the Numpy test suite.
|
||||
"""
|
||||
import os
|
||||
import tempfile
|
||||
|
||||
import hypothesis
|
||||
import pytest
|
||||
import numpy
|
||||
|
||||
from numpy.core._multiarray_tests import get_fpu_mode
|
||||
|
||||
|
||||
_old_fpu_mode = None
|
||||
_collect_results = {}
|
||||
|
||||
# Use a known and persistent tmpdir for hypothesis' caches, which
|
||||
# can be automatically cleared by the OS or user.
|
||||
hypothesis.configuration.set_hypothesis_home_dir(
|
||||
os.path.join(tempfile.gettempdir(), ".hypothesis")
|
||||
)
|
||||
|
||||
# We register two custom profiles for Numpy - for details see
|
||||
# https://hypothesis.readthedocs.io/en/latest/settings.html
|
||||
# The first is designed for our own CI runs; the latter also
|
||||
# forces determinism and is designed for use via np.test()
|
||||
hypothesis.settings.register_profile(
|
||||
name="numpy-profile", deadline=None, print_blob=True,
|
||||
)
|
||||
hypothesis.settings.register_profile(
|
||||
name="np.test() profile",
|
||||
deadline=None, print_blob=True, database=None, derandomize=True,
|
||||
suppress_health_check=hypothesis.HealthCheck.all(),
|
||||
)
|
||||
# Note that the default profile is chosen based on the presence
|
||||
# of pytest.ini, but can be overriden by passing the
|
||||
# --hypothesis-profile=NAME argument to pytest.
|
||||
_pytest_ini = os.path.join(os.path.dirname(__file__), "..", "pytest.ini")
|
||||
hypothesis.settings.load_profile(
|
||||
"numpy-profile" if os.path.isfile(_pytest_ini) else "np.test() profile"
|
||||
)
|
||||
|
||||
|
||||
def pytest_configure(config):
|
||||
config.addinivalue_line("markers",
|
||||
"valgrind_error: Tests that are known to error under valgrind.")
|
||||
config.addinivalue_line("markers",
|
||||
"leaks_references: Tests that are known to leak references.")
|
||||
config.addinivalue_line("markers",
|
||||
"slow: Tests that are very slow.")
|
||||
config.addinivalue_line("markers",
|
||||
"slow_pypy: Tests that are very slow on pypy.")
|
||||
|
||||
|
||||
def pytest_addoption(parser):
|
||||
parser.addoption("--available-memory", action="store", default=None,
|
||||
help=("Set amount of memory available for running the "
|
||||
"test suite. This can result to tests requiring "
|
||||
"especially large amounts of memory to be skipped. "
|
||||
"Equivalent to setting environment variable "
|
||||
"NPY_AVAILABLE_MEM. Default: determined"
|
||||
"automatically."))
|
||||
|
||||
|
||||
def pytest_sessionstart(session):
|
||||
available_mem = session.config.getoption('available_memory')
|
||||
if available_mem is not None:
|
||||
os.environ['NPY_AVAILABLE_MEM'] = available_mem
|
||||
|
||||
|
||||
#FIXME when yield tests are gone.
|
||||
@pytest.hookimpl()
|
||||
def pytest_itemcollected(item):
|
||||
"""
|
||||
Check FPU precision mode was not changed during test collection.
|
||||
|
||||
The clumsy way we do it here is mainly necessary because numpy
|
||||
still uses yield tests, which can execute code at test collection
|
||||
time.
|
||||
"""
|
||||
global _old_fpu_mode
|
||||
|
||||
mode = get_fpu_mode()
|
||||
|
||||
if _old_fpu_mode is None:
|
||||
_old_fpu_mode = mode
|
||||
elif mode != _old_fpu_mode:
|
||||
_collect_results[item] = (_old_fpu_mode, mode)
|
||||
_old_fpu_mode = mode
|
||||
|
||||
|
||||
@pytest.fixture(scope="function", autouse=True)
|
||||
def check_fpu_mode(request):
|
||||
"""
|
||||
Check FPU precision mode was not changed during the test.
|
||||
"""
|
||||
old_mode = get_fpu_mode()
|
||||
yield
|
||||
new_mode = get_fpu_mode()
|
||||
|
||||
if old_mode != new_mode:
|
||||
raise AssertionError("FPU precision mode changed from {0:#x} to {1:#x}"
|
||||
" during the test".format(old_mode, new_mode))
|
||||
|
||||
collect_result = _collect_results.get(request.node)
|
||||
if collect_result is not None:
|
||||
old_mode, new_mode = collect_result
|
||||
raise AssertionError("FPU precision mode changed from {0:#x} to {1:#x}"
|
||||
" when collecting the test".format(old_mode,
|
||||
new_mode))
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def add_np(doctest_namespace):
|
||||
doctest_namespace['np'] = numpy
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def env_setup(monkeypatch):
|
||||
monkeypatch.setenv('PYTHONHASHSEED', '0')
|
|
@ -0,0 +1,166 @@
|
|||
"""
|
||||
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.
|
||||
|
||||
"""
|
||||
|
||||
from numpy.version import version as __version__
|
||||
|
||||
import os
|
||||
|
||||
# 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', 'GOTOBLAS_MAIN_FREE']:
|
||||
if envkey not in os.environ:
|
||||
os.environ[envkey] = '1'
|
||||
env_added.append(envkey)
|
||||
|
||||
try:
|
||||
from . import multiarray
|
||||
except ImportError as exc:
|
||||
import sys
|
||||
msg = """
|
||||
|
||||
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.
|
||||
|
||||
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%d.%d from "%s"
|
||||
* The NumPy version is: "%s"
|
||||
|
||||
and make sure that they are the versions you expect.
|
||||
Please carefully study the documentation linked above for further help.
|
||||
|
||||
Original error was: %s
|
||||
""" % (sys.version_info[0], sys.version_info[1], sys.executable,
|
||||
__version__, exc)
|
||||
raise ImportError(msg)
|
||||
finally:
|
||||
for envkey in env_added:
|
||||
del os.environ[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
|
||||
multiarray.set_typeDict(nt.sctypeDict)
|
||||
from . import numeric
|
||||
from .numeric import *
|
||||
from . import fromnumeric
|
||||
from .fromnumeric import *
|
||||
from . import defchararray as char
|
||||
from . import records as rec
|
||||
from .records import *
|
||||
from .memmap import *
|
||||
from .defchararray import chararray
|
||||
from . import function_base
|
||||
from .function_base import *
|
||||
from . import machar
|
||||
from .machar import *
|
||||
from . import getlimits
|
||||
from .getlimits import *
|
||||
from . import shape_base
|
||||
from .shape_base import *
|
||||
from . import einsumfunc
|
||||
from .einsumfunc import *
|
||||
del nt
|
||||
|
||||
from .fromnumeric import amax as max, amin as min, round_ as round
|
||||
from .numeric import absolute as abs
|
||||
|
||||
# do this after everything else, to minimize the chance of this misleadingly
|
||||
# appearing in an import-time traceback
|
||||
from . import _add_newdocs
|
||||
from . import _add_newdocs_scalars
|
||||
# add these for module-freeze analysis (like PyInstaller)
|
||||
from . import _dtype_ctypes
|
||||
from . import _internal
|
||||
from . import _dtype
|
||||
from . import _methods
|
||||
|
||||
__all__ = ['char', 'rec', 'memmap']
|
||||
__all__ += numeric.__all__
|
||||
__all__ += fromnumeric.__all__
|
||||
__all__ += rec.__all__
|
||||
__all__ += ['chararray']
|
||||
__all__ += function_base.__all__
|
||||
__all__ += machar.__all__
|
||||
__all__ += getlimits.__all__
|
||||
__all__ += shape_base.__all__
|
||||
__all__ += einsumfunc.__all__
|
||||
|
||||
# We used to use `np.core._ufunc_reconstruct` to unpickle. This is unnecessary,
|
||||
# but old pickles saved before 1.20 will be using it, and there is no reason
|
||||
# to break loading them.
|
||||
def _ufunc_reconstruct(module, name):
|
||||
# The `fromlist` kwarg is required to ensure that `mod` points to the
|
||||
# inner-most module rather than the parent package when module name is
|
||||
# nested. This makes it possible to pickle non-toplevel ufuncs such as
|
||||
# scipy.special.expit for instance.
|
||||
mod = __import__(module, fromlist=[name])
|
||||
return getattr(mod, name)
|
||||
|
||||
|
||||
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):
|
||||
# To pickle a DType without having to add top-level names, pickle the
|
||||
# scalar type for now (and assume that reconstruction will be possible).
|
||||
if DType is dtype:
|
||||
return "dtype" # must pickle `np.dtype` as a singleton.
|
||||
scalar_type = DType.type # pickle the scalar type for reconstruction
|
||||
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
|
||||
del _ufunc_reduce
|
||||
del _DType_reduce
|
||||
|
||||
from numpy._pytesttester import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue