我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.__version__()。
def meta_data(self): import time import sys metadata = {} date = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(time.time())) metadata['date'] = date metadata['Version'] = self.version metadata['Python Version'] = sys.version metadata['Numpy Version'] = np.__version__ metadata['Scipy Version '] = scipy.__version__ metadata['psyFunction'] = self.psyfun metadata['thresholdGrid'] = self.threshold.tolist() metadata['thresholdPrior'] = self.thresholdPrior metadata['slopeGrid'] = self.slope.tolist() metadata['slopePrior'] = self.slopePrior metadata['gammaGrid'] = self.guessRate.tolist() metadata['gammaPrior'] = self.guessPrior metadata['lapseGrid'] = self.lapseRate.tolist() metadata['lapsePrior'] = self.lapsePrior return metadata
def _show_system_info(self): nose = import_nose() import numpy print("NumPy version %s" % numpy.__version__) relaxed_strides = numpy.ones((10, 1), order="C").flags.f_contiguous print("NumPy relaxed strides checking option:", relaxed_strides) npdir = os.path.dirname(numpy.__file__) print("NumPy is installed in %s" % npdir) if 'scipy' in self.package_name: import scipy print("SciPy version %s" % scipy.__version__) spdir = os.path.dirname(scipy.__file__) print("SciPy is installed in %s" % spdir) pyversion = sys.version.replace('\n', '') print("Python version %s" % pyversion) print("nose version %d.%d.%d" % nose.__versioninfo__)
def _has_cython(self): extensions = self.distribution.ext_modules if not USE_CYTHON or not any(_.endswith('.pyx') for ext in extensions for _ in ext.sources): return False try: import Cython except ImportError: print('Cython is not installed, defaulting to C/C++ files.') return False if parse_version(Cython.__version__) < \ parse_version(MIN_VERSION_CYTHON): print("The Cython version is older than that required ('{0}' < '{1" "}'). Defaulting to C/C++ files." .format(Cython.__version__, MIN_VERSION_CYTHON)) return False return True
def get_numpy_status(): """ Returns a dictionary containing a boolean specifying whether NumPy is up-to-date, along with the version string (empty string if not installed). """ numpy_status = {} try: import numpy numpy_version = numpy.__version__ numpy_status['up_to_date'] = parse_version( numpy_version) >= parse_version(NUMPY_MIN_VERSION) numpy_status['version'] = numpy_version except ImportError: traceback.print_exc() numpy_status['up_to_date'] = False numpy_status['version'] = "" return numpy_status
def unorm(data, ord=None, axis=None, keepdims=False): """Matrix or vector norm that preserves units This is a wrapper around np.linalg.norm that preserves units. See the documentation for that function for descriptions of the keyword arguments. The keepdims argument is ignored if the version of numpy installed is older than numpy 1.10.0. """ if LooseVersion(np.__version__) < LooseVersion('1.10.0'): norm = np.linalg.norm(data, ord=ord, axis=axis) else: norm = np.linalg.norm(data, ord=ord, axis=axis, keepdims=keepdims) if norm.shape == (): return YTQuantity(norm, data.units) return YTArray(norm, data.units)
def check_min_versions(): ret = True # pyaudio vers_required = "0.2.7" vers_current = pyaudio.__version__ if StrictVersion(vers_current) < StrictVersion(vers_required): print("Error: minimum pyaudio vers: {}, current vers {}".format(vers_required, vers_current)) ret = False # librosa vers_required = "0.4.3" vers_current = librosa.__version__ if StrictVersion(vers_current) < StrictVersion(vers_required): print("Error: minimum librosa vers: {}, current vers {}".format(vers_required, vers_current)) ret = False # numpy vers_required = "1.9.0" vers_current = np.__version__ if StrictVersion(vers_current) < StrictVersion(vers_required): print("Error: minimum numpy vers: {}, current vers {}".format(vers_required, vers_current)) ret = False return ret
def check(self): try: import dateutil except ImportError: # dateutil 2.1 has a file encoding bug that breaks installation on # python 3.3 # https://github.com/matplotlib/matplotlib/issues/2373 # hack around the problem by installing the (working) v2.0 #major, minor1, _, _, _ = sys.version_info #if self.version is None and (major, minor1) == (3, 3): #self.version = '!=2.1' raise CheckFailed ( "could not be found") major, minor1, _, _, _ = sys.version_info if dateutil.__version__ == '2.1' and (major, minor1) == (3, 3): raise CheckFailed ( "dateutil v. 2.1 has a bug that breaks installation" "on python 3.3.x, use another dateutil version") return "using dateutil version %s" % dateutil.__version__
def check(self): try: import pyparsing except ImportError: raise CheckFailed( "could not be found") required = [1, 5, 6] if [int(x) for x in pyparsing.__version__.split('.')] < required: raise CheckFailed( "matplotlib requires pyparsing >= {0}".format( '.'.join(str(x) for x in required))) if not self.is_ok(): return ( "Your pyparsing contains a bug that will be monkey-patched by " "matplotlib. For best results, upgrade to pyparsing 2.0.1 or " "later.") return "using pyparsing version %s" % pyparsing.__version__
def sanity_check_dependencies(): import numpy import requests import six if distutils.version.LooseVersion(numpy.__version__) < distutils.version.LooseVersion('1.10.4'): logger.warn("You have 'numpy' version %s installed, but 'gym' requires at least 1.10.4. HINT: upgrade via 'pip install -U numpy'.", numpy.__version__) if distutils.version.LooseVersion(requests.__version__) < distutils.version.LooseVersion('2.0'): logger.warn("You have 'requests' version %s installed, but 'gym' requires at least 2.0. HINT: upgrade via 'pip install -U requests'.", requests.__version__) # We automatically configure a logger with a simple stderr handler. If # you'd rather customize logging yourself, run undo_logger_setup. # # (Note: this needs to happen before importing the rest of gym, since # we may print a warning at load time.)
def check_biopython(raise_exception_on_fail=False): # Unpatched Bio.PDB requires md5, which was missing in PyMOL1.2/1.3 # because its Python2.5 was not linked against OpenSSL libraries if not raise_exception_on_fail: try: import Bio.PDB, Bio, Bio.Phylo # Phylo was missing in PyMOL1.5 from Bio.Align.Applications import ClustalwCommandline # This was missing in PyMOL 1.4. from Bio.Align.Applications import MuscleCommandline return Bio.__version__, Bio.__file__ except: return "","" else: import Bio.PDB, Bio, Bio.Phylo from Bio.Align.Applications import ClustalwCommandline from Bio.Align.Applications import MuscleCommandline return Bio.__version__, Bio.__file__
def test_nan_to_nat_conversions(): df = DataFrame(dict({ 'A': np.asarray( lrange(10), dtype='float64'), 'B': Timestamp('20010101') })) df.iloc[3:6, :] = np.nan result = df.loc[4, 'B'].value assert (result == iNaT) s = df['B'].copy() s._data = s._data.setitem(indexer=tuple([slice(8, 9)]), value=np.nan) assert (isnull(s[8])) # numpy < 1.7.0 is wrong from distutils.version import LooseVersion if LooseVersion(np.__version__) >= '1.7.0': assert (s[8].value == np.datetime64('NaT').astype(np.int64))
def test_constructor_unsortable(self): # it works! arr = np.array([1, 2, 3, datetime.now()], dtype='O') factor = Categorical.from_array(arr, ordered=False) self.assertFalse(factor.ordered) if compat.PY3: self.assertRaises( TypeError, lambda: Categorical.from_array(arr, ordered=True)) else: # this however will raise as cannot be sorted (on PY3 or older # numpies) if LooseVersion(np.__version__) < "1.10": self.assertRaises( TypeError, lambda: Categorical.from_array(arr, ordered=True)) else: Categorical.from_array(arr, ordered=True)
def print_versions(): """Print the versions of software that numexpr relies on.""" from pkg_resources import parse_version if parse_version(np.__version__) < parse_version(minimum_numpy_version): print("*Warning*: NumPy version is lower than recommended: %s < %s" % \ (np.__version__, minimum_numpy_version)) print('-=' * 38) print("Numexpr version: %s" % numexpr.__version__) print("NumPy version: %s" % np.__version__) print('Python version: %s' % sys.version) if os.name == 'posix': (sysname, nodename, release, version, machine) = os.uname() print('Platform: %s-%s' % (sys.platform, machine)) print("AMD/Intel CPU? %s" % numexpr.is_cpu_amd_intel) print("VML available? %s" % use_vml) if use_vml: print("VML/MKL version: %s" % numexpr.get_vml_version()) print("Number of threads used by default: %d " "(out of %d detected cores)" % (numexpr.nthreads, numexpr.ncores)) print('-=' * 38)
def get_scipy_status(): """ Return a dictionary containing a boolean specifying whether SciPy is up-to-date, along with the version string (empty string if not installed). """ scipy_status = {} try: import scipy scipy_version = scipy.__version__ scipy_status['up_to_date'] = parse_version( scipy_version) >= parse_version(scipy_min_version) scipy_status['version'] = scipy_version except ImportError: scipy_status['up_to_date'] = False scipy_status['version'] = "" return scipy_status
def get_numpy_status(): """ Return a dictionary containing a boolean specifying whether NumPy is up-to-date, along with the version string (empty string if not installed). """ numpy_status = {} try: import numpy numpy_version = numpy.__version__ numpy_status['up_to_date'] = parse_version( numpy_version) >= parse_version(numpy_min_version) numpy_status['version'] = numpy_version except ImportError: numpy_status['up_to_date'] = False numpy_status['version'] = "" return numpy_status
def test_choice(self): """Test that RandomStreams.choice generates the same results as numpy""" # numpy.random.choice is only available for numpy versions >= 1.7 major, minor, _ = numpy.version.short_version.split('.') if (int(major), int(minor)) < (1, 7): raise utt.SkipTest('choice requires at NumPy version >= 1.7 ' '(%s)' % numpy.__version__) # Check over two calls to see if the random state is correctly updated. random = RandomStreams(utt.fetch_seed()) fn = function([], random.choice((11, 8), 10, 1, 0)) fn_val0 = fn() fn_val1 = fn() rng_seed = numpy.random.RandomState(utt.fetch_seed()).randint(2**30) rng = numpy.random.RandomState(int(rng_seed)) # int() is for 32bit numpy_val0 = rng.choice(10, (11, 8), True, None) numpy_val1 = rng.choice(10, (11, 8), True, None) assert numpy.all(fn_val0 == numpy_val0) assert numpy.all(fn_val1 == numpy_val1)
def test_unique(): """Test unique() replacement """ # skip test for np version < 1.5 if LooseVersion(np.__version__) < LooseVersion('1.5'): return for arr in [np.array([]), rng.rand(10), np.ones(10)]: # basic assert_array_equal(np.unique(arr), _unique(arr)) # with return_index=True x1, x2 = np.unique(arr, return_index=True, return_inverse=False) y1, y2 = _unique(arr, return_index=True, return_inverse=False) assert_array_equal(x1, y1) assert_array_equal(x2, y2) # with return_inverse=True x1, x2 = np.unique(arr, return_index=False, return_inverse=True) y1, y2 = _unique(arr, return_index=False, return_inverse=True) assert_array_equal(x1, y1) assert_array_equal(x2, y2) # with both: x1, x2, x3 = np.unique(arr, return_index=True, return_inverse=True) y1, y2, y3 = _unique(arr, return_index=True, return_inverse=True) assert_array_equal(x1, y1) assert_array_equal(x2, y2) assert_array_equal(x3, y3)
def capture_frame(self, frame): if not isinstance(frame, (np.ndarray, np.generic)): raise error.InvalidFrame( 'Wrong type {} for {} (must be np.ndarray or np.generic)'.format(type(frame), frame)) if frame.shape != self.frame_shape: raise error.InvalidFrame( "Your frame has shape {}, but the VideoRecorder is configured for shape {}.".format( frame.shape, self.frame_shape)) if frame.dtype != np.uint8: raise error.InvalidFrame( "Your frame has data type {}, but we require uint8 (i.e. RGB values from 0-255).".format(frame.dtype)) if distutils.version.LooseVersion(np.__version__) >= distutils.version.LooseVersion('1.9.0'): self.proc.stdin.write(frame.tobytes()) else: self.proc.stdin.write(frame.tostring())
def get_scipy_status(): """ Returns a dictionary containing a boolean specifying whether SciPy is up-to-date, along with the version string (empty string if not installed). """ scipy_status = {} try: import scipy scipy_version = scipy.__version__ scipy_status['up_to_date'] = parse_version( scipy_version) >= parse_version(scipy_min_version) scipy_status['version'] = scipy_version except ImportError: scipy_status['up_to_date'] = False scipy_status['version'] = "" return scipy_status
def get_numpy_status(): """ Returns a dictionary containing a boolean specifying whether NumPy is up-to-date, along with the version string (empty string if not installed). """ numpy_status = {} try: import numpy numpy_version = numpy.__version__ numpy_status['up_to_date'] = parse_version( numpy_version) >= parse_version(numpy_min_version) numpy_status['version'] = numpy_version except ImportError: numpy_status['up_to_date'] = False numpy_status['version'] = "" return numpy_status
def test_timestamp_dictarray(self): if np.__version__ < "1.7": return self.cursor.execute("create table t1(a int, b timestamp, c int)") dates = [datetime.strptime("2008-04-%02d 00:01:02"%i, "%Y-%m-%d %H:%M:%S") for i in range(1,11)] params = [ (i, dates[i-1], i) for i in range(1,11) ] npparams = [ (i, np.datetime64(dates[i-1]), i) for i in range(1,11) ] self.cursor.executemany("insert into t1(a, b, c) values (?,?,?)", params) self.cursor.execute("select a, b, c from t1 order by a") rows = self.cursor.fetchdictarray() for param, row in zip(npparams, zip(rows['a'], rows['b'], rows['c'])): self.assertEqual(param[0], row[0]) self.assertEqual(param[1], row[1]) self.assertEqual(param[2], row[2])
def test_timestamp_sarray(self): if np.__version__ < "1.7": return self.cursor.execute("create table t1(a int, b timestamp, c int)") dates = [datetime.strptime("2008-04-%02d 00:01:02"%i, "%Y-%m-%d %H:%M:%S") for i in range(1,11)] params = [ (i, dates[i-1], i) for i in range(1,11) ] npparams = [ (i, np.datetime64(dates[i-1]), i) for i in range(1,11) ] self.cursor.executemany("insert into t1(a, b, c) values (?,?,?)", params) self.cursor.execute("select a, b, c from t1 order by a") rows = self.cursor.fetchsarray() for param, row in zip(npparams, rows): self.assertEqual(param[0], row[0]) self.assertEqual(param[1], row[1]) self.assertEqual(param[2], row[2])
def test_date_dictarray(self): if np.__version__ < "1.7": return self.cursor.execute("create table t1(a int, b date, c int)") dates = [date(2008, 4, i) for i in range(1,11)] npdates = np.array(dates, dtype='datetime64[D]') params = [ (i, dates[i-1], i) for i in range(1,11) ] npparams = [ (i, npdates[i-1], i) for i in range(1,11) ] self.cursor.executemany("insert into t1(a, b, c) values (?,?,?)", params) self.cursor.execute("select a, b, c from t1 order by a") rows = self.cursor.fetchdictarray() for param, row in zip(npparams, zip(rows['a'], rows['b'], rows['c'])): self.assertEqual(param[0], row[0]) self.assertEqual(param[1], row[1]) self.assertEqual(param[2], row[2])
def test_date_sarray(self): if np.__version__ < "1.7": return self.cursor.execute("create table t1(a int, b date, c int)") dates = [date(2008, 4, i) for i in range(1,11)] npdates = np.array(dates, dtype='datetime64[D]') params = [ (i, dates[i-1], i) for i in range(1,11) ] npparams = [ (i, npdates[i-1], i) for i in range(1,11) ] self.cursor.executemany("insert into t1(a, b, c) values (?,?,?)", params) self.cursor.execute("select a, b, c from t1 order by a") rows = self.cursor.fetchsarray() for param, row in zip(npparams, rows): self.assertEqual(param[0], row[0]) self.assertEqual(param[1], row[1]) self.assertEqual(param[2], row[2])
def test_time_sarray(self): if np.__version__ < "1.7": return self.cursor.execute("create table t1(a int, b time, c int)") N = 60 times = range(N) nptimes = np.array(times, dtype='timedelta64[s]') params = [ (i, time(0, 0, times[i]), i) for i in range(N) ] npparams = [ (i, nptimes[i], i) for i in range(N) ] self.cursor.executemany("insert into t1(a, b, c) values (?,?,?)", params) self.cursor.execute("select a, b, c from t1 order by a") rows = self.cursor.fetchsarray() for param, row in zip(npparams, rows): self.assertEqual(param[0], row[0]) self.assertEqual(param[1], row[1]) self.assertEqual(param[2], row[2]) # # NULL values (particular values) #
def msvc14_gen_lib_options(*args, **kwargs): """ Patched "distutils._msvccompiler.gen_lib_options" for fix compatibility between "numpy.distutils" and "distutils._msvccompiler" (for Numpy < 1.11.2) """ if "numpy.distutils" in sys.modules: import numpy as np if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'): return np.distutils.ccompiler.gen_lib_options(*args, **kwargs) return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)
def resolve_name(self, modname, parents, path, base): if modname is None: if path: mod_cls = path.rstrip('.') else: mod_cls = None # if documenting a class-level object without path, # there must be a current class, either from a parent # auto directive ... mod_cls = self.env.temp_data.get('autodoc:class') # ... or from a class directive if mod_cls is None: mod_cls = self.env.temp_data.get('py:class') # ... if still None, there's no way to know if mod_cls is None: return None, [] # HACK: this is added in comparison to ClassLevelDocumenter # mod_cls still exists of class.accessor, so an extra # rpartition is needed modname, accessor = rpartition(mod_cls, '.') modname, cls = rpartition(modname, '.') parents = [cls, accessor] # if the module name is still missing, get it like above if not modname: modname = self.env.temp_data.get('autodoc:module') if not modname: if sphinx.__version__ > '1.3': modname = self.env.ref_context.get('py:module') else: modname = self.env.temp_data.get('py:module') # ... else, it stays None, which means invalid return modname, parents + [base]
def get_pandas_status(): try: import pandas as pd return _check_version(pd.__version__, pandas_min_version) except ImportError: traceback.print_exc() return default_status
def get_sklearn_status(): try: import sklearn as sk return _check_version(sk.__version__, sklearn_min_version) except ImportError: traceback.print_exc() return default_status
def get_numpy_status(): try: import numpy as np return _check_version(np.__version__, numpy_min_version) except ImportError: traceback.print_exc() return default_status
def get_scipy_status(): try: import scipy as sc return _check_version(sc.__version__, scipy_min_version) except ImportError: traceback.print_exc() return default_status
def get_h2o_status(): try: import h2o return _check_version(h2o.__version__, h2o_min_version) except ImportError: traceback.print_exc() return default_status
def test_valid_numpy_version(): # Verify that the numpy version is a valid one (no .post suffix or other # nonsense). See gh-6431 for an issue caused by an invalid version. version_pattern = r"^[0-9]+\.[0-9]+\.[0-9]+(|a[0-9]|b[0-9]|rc[0-9])" dev_suffix = r"(\.dev0\+([0-9a-f]{7}|Unknown))" if np.version.release: res = re.match(version_pattern, np.__version__) else: res = re.match(version_pattern + dev_suffix, np.__version__) assert_(res is not None, np.__version__)
def _numpy_tester(): if hasattr(np, "__version__") and ".dev0" in np.__version__: mode = "develop" else: mode = "release" return NoseTester(raise_warnings=mode, depth=1)
def test_rfft(self, xp, dtype): # the scaling of old Numpy is incorrect if np.__version__ < np.lib.NumpyVersion('1.13.0'): if self.n is not None: return xp.empty(0) a = testing.shaped_random(self.shape, xp, dtype) out = xp.fft.rfft(a, n=self.n, norm=self.norm) if xp == np and dtype in [np.float16, np.float32, np.complex64]: out = out.astype(np.complex64) return out
def test_rfft2(self, xp, dtype): # the scaling of old Numpy is incorrect if np.__version__ < np.lib.NumpyVersion('1.13.0'): if self.s is not None: return xp.empty(0) a = testing.shaped_random(self.shape, xp, dtype) out = xp.fft.rfft2(a, s=self.s, norm=self.norm) if xp == np and dtype in [np.float16, np.float32, np.complex64]: out = out.astype(np.complex64) return out
