FM / core

/opt/imh-python/lib/python3.9/site-packages/numpy/core/

/opt/imh-python/lib/python3.9/site-packages/numpy/core

Name	Size	Mode	Actions
include/	-	0755	rm
lib/	-	0755	rm
tests/	-	0755	rm
__pycache__/	-	0755	rm
arrayprint.py	63608	0644	edit dl rm
arrayprint.pyi	4428	0644	edit dl rm
cversions.py	347	0644	edit dl rm
defchararray.py	73617	0644	edit dl rm
defchararray.pyi	9216	0644	edit dl rm
einsumfunc.py	51868	0644	edit dl rm
einsumfunc.pyi	4860	0644	edit dl rm
fromnumeric.py	128821	0644	edit dl rm
fromnumeric.pyi	23726	0644	edit dl rm
function_base.py	19836	0644	edit dl rm
function_base.pyi	4725	0644	edit dl rm
getlimits.py	25865	0644	edit dl rm
getlimits.pyi	82	0644	edit dl rm
memmap.py	11771	0644	edit dl rm
memmap.pyi	55	0644	edit dl rm
multiarray.py	56097	0644	edit dl rm
multiarray.pyi	24768	0644	edit dl rm
numeric.py	77014	0644	edit dl rm
numeric.pyi	14315	0644	edit dl rm
numerictypes.py	18098	0644	edit dl rm
numerictypes.pyi	3267	0644	edit dl rm
overrides.py	7093	0644	edit dl rm
records.py	37533	0644	edit dl rm
records.pyi	5692	0644	edit dl rm
shape_base.py	29743	0644	edit dl rm
shape_base.pyi	2774	0644	edit dl rm
umath.py	2040	0644	edit dl rm
umath_tests.py	389	0644	edit dl rm
_add_newdocs.py	208972	0644	edit dl rm
_add_newdocs_scalars.py	12106	0644	edit dl rm
_asarray.py	3884	0644	edit dl rm
_asarray.pyi	1086	0644	edit dl rm
_dtype.py	10606	0644	edit dl rm
_dtype_ctypes.py	3673	0644	edit dl rm
_exceptions.py	5379	0644	edit dl rm
_internal.py	28348	0644	edit dl rm
_internal.pyi	1032	0644	edit dl rm
_machar.py	11565	0644	edit dl rm
_methods.py	8613	0644	edit dl rm
_multiarray_tests.cpython-39-x86_64-linux-gnu.so	151008	0755	edit dl rm
_multiarray_umath.cpython-39-x86_64-linux-gnu.so	7382112	0755	edit dl rm
_operand_flag_tests.cpython-39-x86_64-linux-gnu.so	16728	0755	edit dl rm
_rational_tests.cpython-39-x86_64-linux-gnu.so	59640	0755	edit dl rm
_simd.cpython-39-x86_64-linux-gnu.so	3526664	0755	edit dl rm
_string_helpers.py	2852	0644	edit dl rm
_struct_ufunc_tests.cpython-39-x86_64-linux-gnu.so	16832	0755	edit dl rm
_type_aliases.py	7534	0644	edit dl rm
_type_aliases.pyi	404	0644	edit dl rm
_ufunc_config.py	13944	0644	edit dl rm
_ufunc_config.pyi	1066	0644	edit dl rm
_umath_tests.cpython-39-x86_64-linux-gnu.so	42008	0755	edit dl rm
__init__.py	5780	0644	edit dl rm
__init__.pyi	126	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/numpy/core/_exceptions.py (5379B)

"""
Various richly-typed exceptions, that also help us deal with string formatting
in python where it's easier.

By putting the formatting in `__str__`, we also avoid paying the cost for
users who silence the exceptions.
"""
from .._utils import set_module

def _unpack_tuple(tup):
    if len(tup) == 1:
        return tup[0]
    else:
        return tup

def _display_as_base(cls):
    """
    A decorator that makes an exception class look like its base.

We use this to hide subclasses that are implementation details - the user
    should catch the base type, which is what the traceback will show them.

Classes decorated with this decorator are subject to removal without a
    deprecation warning.
    """
    assert issubclass(cls, Exception)
    cls.__name__ = cls.__base__.__name__
    return cls

class UFuncTypeError(TypeError):
    """ Base class for all ufunc exceptions """
    def __init__(self, ufunc):
        self.ufunc = ufunc

@_display_as_base
class _UFuncNoLoopError(UFuncTypeError):
    """ Thrown when a ufunc loop cannot be found """
    def __init__(self, ufunc, dtypes):
        super().__init__(ufunc)
        self.dtypes = tuple(dtypes)

def __str__(self):
        return (
            "ufunc {!r} did not contain a loop with signature matching types "
            "{!r} -> {!r}"
        ).format(
            self.ufunc.__name__,
            _unpack_tuple(self.dtypes[:self.ufunc.nin]),
            _unpack_tuple(self.dtypes[self.ufunc.nin:])
        )

@_display_as_base
class _UFuncBinaryResolutionError(_UFuncNoLoopError):
    """ Thrown when a binary resolution fails """
    def __init__(self, ufunc, dtypes):
        super().__init__(ufunc, dtypes)
        assert len(self.dtypes) == 2

def __str__(self):
        return (
            "ufunc {!r} cannot use operands with types {!r} and {!r}"
        ).format(
            self.ufunc.__name__, *self.dtypes
        )

@_display_as_base
class _UFuncCastingError(UFuncTypeError):
    def __init__(self, ufunc, casting, from_, to):
        super().__init__(ufunc)
        self.casting = casting
        self.from_ = from_
        self.to = to

@_display_as_base
class _UFuncInputCastingError(_UFuncCastingError):
    """ Thrown when a ufunc input cannot be casted """
    def __init__(self, ufunc, casting, from_, to, i):
        super().__init__(ufunc, casting, from_, to)
        self.in_i = i

def __str__(self):
        # only show the number if more than one input exists
        i_str = "{} ".format(self.in_i) if self.ufunc.nin != 1 else ""
        return (
            "Cannot cast ufunc {!r} input {}from {!r} to {!r} with casting "
            "rule {!r}"
        ).format(
            self.ufunc.__name__, i_str, self.from_, self.to, self.casting
        )

@_display_as_base
class _UFuncOutputCastingError(_UFuncCastingError):
    """ Thrown when a ufunc output cannot be casted """
    def __init__(self, ufunc, casting, from_, to, i):
        super().__init__(ufunc, casting, from_, to)
        self.out_i = i

def __str__(self):
        # only show the number if more than one output exists
        i_str = "{} ".format(self.out_i) if self.ufunc.nout != 1 else ""
        return (
            "Cannot cast ufunc {!r} output {}from {!r} to {!r} with casting "
            "rule {!r}"
        ).format(
            self.ufunc.__name__, i_str, self.from_, self.to, self.casting
        )

@_display_as_base
class _ArrayMemoryError(MemoryError):
    """ Thrown when an array cannot be allocated"""
    def __init__(self, shape, dtype):
        self.shape = shape
        self.dtype = dtype

@property
    def _total_size(self):
        num_bytes = self.dtype.itemsize
        for dim in self.shape:
            num_bytes *= dim
        return num_bytes

@staticmethod
    def _size_to_string(num_bytes):
        """ Convert a number of bytes into a binary size string """

# https://en.wikipedia.org/wiki/Binary_prefix
        LOG2_STEP = 10
        STEP = 1024
        units = ['bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB']

unit_i = max(num_bytes.bit_length() - 1, 1) // LOG2_STEP
        unit_val = 1 << (unit_i * LOG2_STEP)
        n_units = num_bytes / unit_val
        del unit_val

# ensure we pick a unit that is correct after rounding
        if round(n_units) == STEP:
            unit_i += 1
            n_units /= STEP

# deal with sizes so large that we don't have units for them
        if unit_i >= len(units):
            new_unit_i = len(units) - 1
            n_units *= 1 << ((unit_i - new_unit_i) * LOG2_STEP)
            unit_i = new_unit_i

unit_name = units[unit_i]
        # format with a sensible number of digits
        if unit_i == 0:
            # no decimal point on bytes
            return '{:.0f} {}'.format(n_units, unit_name)
        elif round(n_units) < 1000:
            # 3 significant figures, if none are dropped to the left of the .
            return '{:#.3g} {}'.format(n_units, unit_name)
        else:
            # just give all the digits otherwise
            return '{:#.0f} {}'.format(n_units, unit_name)

def __str__(self):
        size_str = self._size_to_string(self._total_size)
        return (
            "Unable to allocate {} for an array with shape {} and data type {}"
            .format(size_str, self.shape, self.dtype)
        )

cmd: