Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 __init__.py """Common test support for all numpy test scripts. This single module should provide all the common functionality for numpy tests in a single location, so that test scripts can just import it and work right away. """ from unittest import TestCase from . import _private from ._private.utils import * from ._private.utils import (_assert_valid_refcount, _gen_alignment_data) from ._private import extbuild from . import overrides __all__ = ( _private.utils.__all__ + ['TestCase', 'overrides'] ) from numpy._pytesttester import PytestTester test = PytestTester(__name__) del PytestTester	595 B	2026-01-20 12:58
📄 __init__.pyi from numpy._pytesttester import PytestTester from unittest import ( TestCase as TestCase, ) from numpy.testing._private.utils import ( assert_equal as assert_equal, assert_almost_equal as assert_almost_equal, assert_approx_equal as assert_approx_equal, assert_array_equal as assert_array_equal, assert_array_less as assert_array_less, assert_string_equal as assert_string_equal, assert_array_almost_equal as assert_array_almost_equal, assert_raises as assert_raises, build_err_msg as build_err_msg, decorate_methods as decorate_methods, jiffies as jiffies, memusage as memusage, print_assert_equal as print_assert_equal, rundocs as rundocs, runstring as runstring, verbose as verbose, measure as measure, assert_ as assert_, assert_array_almost_equal_nulp as assert_array_almost_equal_nulp, assert_raises_regex as assert_raises_regex, assert_array_max_ulp as assert_array_max_ulp, assert_warns as assert_warns, assert_no_warnings as assert_no_warnings, assert_allclose as assert_allclose, IgnoreException as IgnoreException, clear_and_catch_warnings as clear_and_catch_warnings, SkipTest as SkipTest, KnownFailureException as KnownFailureException, temppath as temppath, tempdir as tempdir, IS_PYPY as IS_PYPY, IS_PYSTON as IS_PYSTON, HAS_REFCOUNT as HAS_REFCOUNT, suppress_warnings as suppress_warnings, assert_array_compare as assert_array_compare, assert_no_gc_cycles as assert_no_gc_cycles, break_cycles as break_cycles, HAS_LAPACK64 as HAS_LAPACK64, ) __all__: list[str] __path__: list[str] test: PytestTester	1.63 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📁 _private	-	2026-03-21 15:45
📄 overrides.py """Tools for testing implementations of __array_function__ and ufunc overrides """ from numpy.core.overrides import ARRAY_FUNCTIONS as _array_functions from numpy import ufunc as _ufunc import numpy.core.umath as _umath def get_overridable_numpy_ufuncs(): """List all numpy ufuncs overridable via `__array_ufunc__` Parameters ---------- None Returns ------- set A set containing all overridable ufuncs in the public numpy API. """ ufuncs = {obj for obj in _umath.__dict__.values() if isinstance(obj, _ufunc)} return ufuncs def allows_array_ufunc_override(func): """Determine if a function can be overridden via `__array_ufunc__` Parameters ---------- func : callable Function that may be overridable via `__array_ufunc__` Returns ------- bool `True` if `func` is overridable via `__array_ufunc__` and `False` otherwise. Notes ----- This function is equivalent to ``isinstance(func, np.ufunc)`` and will work correctly for ufuncs defined outside of Numpy. """ return isinstance(func, np.ufunc) def get_overridable_numpy_array_functions(): """List all numpy functions overridable via `__array_function__` Parameters ---------- None Returns ------- set A set containing all functions in the public numpy API that are overridable via `__array_function__`. """ # 'import numpy' doesn't import recfunctions, so make sure it's imported # so ufuncs defined there show up in the ufunc listing from numpy.lib import recfunctions return _array_functions.copy() def allows_array_function_override(func): """Determine if a Numpy function can be overridden via `__array_function__` Parameters ---------- func : callable Function that may be overridable via `__array_function__` Returns ------- bool `True` if `func` is a function in the Numpy API that is overridable via `__array_function__` and `False` otherwise. """ return func in _array_functions	2.07 KB	2026-01-20 12:58
📄 print_coercion_tables.py #!/usr/bin/env python3 """Prints type-coercion tables for the built-in NumPy types """ import numpy as np from collections import namedtuple # Generic object that can be added, but doesn't do anything else class GenericObject: def __init__(self, v): self.v = v def __add__(self, other): return self def __radd__(self, other): return self dtype = np.dtype('O') def print_cancast_table(ntypes): print('X', end=' ') for char in ntypes: print(char, end=' ') print() for row in ntypes: print(row, end=' ') for col in ntypes: if np.can_cast(row, col, "equiv"): cast = "#" elif np.can_cast(row, col, "safe"): cast = "=" elif np.can_cast(row, col, "same_kind"): cast = "~" elif np.can_cast(row, col, "unsafe"): cast = "." else: cast = " " print(cast, end=' ') print() def print_coercion_table(ntypes, inputfirstvalue, inputsecondvalue, firstarray, use_promote_types=False): print('+', end=' ') for char in ntypes: print(char, end=' ') print() for row in ntypes: if row == 'O': rowtype = GenericObject else: rowtype = np.obj2sctype(row) print(row, end=' ') for col in ntypes: if col == 'O': coltype = GenericObject else: coltype = np.obj2sctype(col) try: if firstarray: rowvalue = np.array([rowtype(inputfirstvalue)], dtype=rowtype) else: rowvalue = rowtype(inputfirstvalue) colvalue = coltype(inputsecondvalue) if use_promote_types: char = np.promote_types(rowvalue.dtype, colvalue.dtype).char else: value = np.add(rowvalue, colvalue) if isinstance(value, np.ndarray): char = value.dtype.char else: char = np.dtype(type(value)).char except ValueError: char = '!' except OverflowError: char = '@' except TypeError: char = '#' print(char, end=' ') print() def print_new_cast_table(*, can_cast=True, legacy=False, flags=False): """Prints new casts, the values given are default "can-cast" values, not actual ones. """ from numpy.core._multiarray_tests import get_all_cast_information cast_table = { -1: " ", 0: "#", # No cast (classify as equivalent here) 1: "#", # equivalent casting 2: "=", # safe casting 3: "~", # same-kind casting 4: ".", # unsafe casting } flags_table = { 0 : "▗", 7: "█", 1: "▚", 2: "▐", 4: "▄", 3: "▜", 5: "▙", 6: "▟", } cast_info = namedtuple("cast_info", ["can_cast", "legacy", "flags"]) no_cast_info = cast_info(" ", " ", " ") casts = get_all_cast_information() table = {} dtypes = set() for cast in casts: dtypes.add(cast["from"]) dtypes.add(cast["to"]) if cast["from"] not in table: table[cast["from"]] = {} to_dict = table[cast["from"]] can_cast = cast_table[cast["casting"]] legacy = "L" if cast["legacy"] else "." flags = 0 if cast["requires_pyapi"]: flags \|= 1 if cast["supports_unaligned"]: flags \|= 2 if cast["no_floatingpoint_errors"]: flags \|= 4 flags = flags_table[flags] to_dict[cast["to"]] = cast_info(can_cast=can_cast, legacy=legacy, flags=flags) # The np.dtype(x.type) is a bit strange, because dtype classes do # not expose much yet. types = np.typecodes["All"] def sorter(x): # This is a bit weird hack, to get a table as close as possible to # the one printing all typecodes (but expecting user-dtypes). dtype = np.dtype(x.type) try: indx = types.index(dtype.char) except ValueError: indx = np.inf return (indx, dtype.char) dtypes = sorted(dtypes, key=sorter) def print_table(field="can_cast"): print('X', end=' ') for dt in dtypes: print(np.dtype(dt.type).char, end=' ') print() for from_dt in dtypes: print(np.dtype(from_dt.type).char, end=' ') row = table.get(from_dt, {}) for to_dt in dtypes: print(getattr(row.get(to_dt, no_cast_info), field), end=' ') print() if can_cast: # Print the actual table: print() print("Casting: # is equivalent, = is safe, ~ is same-kind, and . is unsafe") print() print_table("can_cast") if legacy: print() print("L denotes a legacy cast . a non-legacy one.") print() print_table("legacy") if flags: print() print(f"{flags_table[0]}: no flags, {flags_table[1]}: PyAPI, " f"{flags_table[2]}: supports unaligned, {flags_table[4]}: no-float-errors") print() print_table("flags") if __name__ == '__main__': print("can cast") print_cancast_table(np.typecodes['All']) print() print("In these tables, ValueError is '!', OverflowError is '@', TypeError is '#'") print() print("scalar + scalar") print_coercion_table(np.typecodes['All'], 0, 0, False) print() print("scalar + neg scalar") print_coercion_table(np.typecodes['All'], 0, -1, False) print() print("array + scalar") print_coercion_table(np.typecodes['All'], 0, 0, True) print() print("array + neg scalar") print_coercion_table(np.typecodes['All'], 0, -1, True) print() print("promote_types") print_coercion_table(np.typecodes['All'], 0, 0, False, True) print("New casting type promotion:") print_new_cast_table(can_cast=True, legacy=True, flags=True)	6.04 KB	2026-01-20 12:58
📄 setup.py #!/usr/bin/env python3 def configuration(parent_package='',top_path=None): from numpy.distutils.misc_util import Configuration config = Configuration('testing', parent_package, top_path) config.add_subpackage('_private') config.add_subpackage('tests') config.add_data_files('.pyi') config.add_data_files('_private/.pyi') return config if __name__ == '__main__': from numpy.distutils.core import setup setup(maintainer="NumPy Developers", maintainer_email="numpy-dev@numpy.org", description="NumPy test module", url="https://www.numpy.org", license="NumPy License (BSD Style)", configuration=configuration, )	709 B	2026-01-20 12:58
📁 tests	-	2026-03-21 15:45

Terminal