str_file: IO[str]
bytes_file: IO[bytes]

bag_obj: np.lib.npyio.BagObj[int]
npz_file: np.lib.npyio.NpzFile

AR_i8: npt.NDArray[np.int64]
AR_LIKE_f8: List[float]


            

Reported by Pylint.

              bag_obj: np.lib.npyio.BagObj[int]
npz_file: np.lib.npyio.NpzFile

AR_i8: npt.NDArray[np.int64]
AR_LIKE_f8: List[float]

reveal_type(bag_obj.a)  # E: int
reveal_type(bag_obj.b)  # E: int


            

Reported by Pylint.

              AR_i8: npt.NDArray[np.int64]
AR_LIKE_f8: List[float]

reveal_type(bag_obj.a)  # E: int
reveal_type(bag_obj.b)  # E: int

reveal_type(npz_file.zip)  # E: zipfile.ZipFile
reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]

            

Reported by Pylint.

              AR_LIKE_f8: List[float]

reveal_type(bag_obj.a)  # E: int
reveal_type(bag_obj.b)  # E: int

reveal_type(npz_file.zip)  # E: zipfile.ZipFile
reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool

            

Reported by Pylint.

              reveal_type(bag_obj.a)  # E: int
reveal_type(bag_obj.b)  # E: int

reveal_type(npz_file.zip)  # E: zipfile.ZipFile
reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool
reveal_type(npz_file.pickle_kwargs)  # E: Union[None, typing.Mapping[builtins.str, Any]]
reveal_type(npz_file.f)  # E: numpy.lib.npyio.BagObj[numpy.lib.npyio.NpzFile]

            

Reported by Pylint.

              reveal_type(bag_obj.b)  # E: int

reveal_type(npz_file.zip)  # E: zipfile.ZipFile
reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool
reveal_type(npz_file.pickle_kwargs)  # E: Union[None, typing.Mapping[builtins.str, Any]]
reveal_type(npz_file.f)  # E: numpy.lib.npyio.BagObj[numpy.lib.npyio.NpzFile]
reveal_type(npz_file["test"])  # E: numpy.ndarray[Any, numpy.dtype[Any]]

            

Reported by Pylint.

              
reveal_type(npz_file.zip)  # E: zipfile.ZipFile
reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool
reveal_type(npz_file.pickle_kwargs)  # E: Union[None, typing.Mapping[builtins.str, Any]]
reveal_type(npz_file.f)  # E: numpy.lib.npyio.BagObj[numpy.lib.npyio.NpzFile]
reveal_type(npz_file["test"])  # E: numpy.ndarray[Any, numpy.dtype[Any]]
reveal_type(len(npz_file))  # E: int

            

Reported by Pylint.

              reveal_type(npz_file.zip)  # E: zipfile.ZipFile
reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool
reveal_type(npz_file.pickle_kwargs)  # E: Union[None, typing.Mapping[builtins.str, Any]]
reveal_type(npz_file.f)  # E: numpy.lib.npyio.BagObj[numpy.lib.npyio.NpzFile]
reveal_type(npz_file["test"])  # E: numpy.ndarray[Any, numpy.dtype[Any]]
reveal_type(len(npz_file))  # E: int
with npz_file as f:

            

Reported by Pylint.

              reveal_type(npz_file.fid)  # E: Union[None, typing.IO[builtins.str]]
reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool
reveal_type(npz_file.pickle_kwargs)  # E: Union[None, typing.Mapping[builtins.str, Any]]
reveal_type(npz_file.f)  # E: numpy.lib.npyio.BagObj[numpy.lib.npyio.NpzFile]
reveal_type(npz_file["test"])  # E: numpy.ndarray[Any, numpy.dtype[Any]]
reveal_type(len(npz_file))  # E: int
with npz_file as f:
    reveal_type(f)  # E: numpy.lib.npyio.NpzFile

            

Reported by Pylint.

              reveal_type(npz_file.files)  # E: list[builtins.str]
reveal_type(npz_file.allow_pickle)  # E: bool
reveal_type(npz_file.pickle_kwargs)  # E: Union[None, typing.Mapping[builtins.str, Any]]
reveal_type(npz_file.f)  # E: numpy.lib.npyio.BagObj[numpy.lib.npyio.NpzFile]
reveal_type(npz_file["test"])  # E: numpy.ndarray[Any, numpy.dtype[Any]]
reveal_type(len(npz_file))  # E: int
with npz_file as f:
    reveal_type(f)  # E: numpy.lib.npyio.NpzFile


            

Reported by Pylint.

              import numbers

import numpy as np
from . import polyutils as pu

__all__ = ['ABCPolyBase']

class ABCPolyBase(abc.ABC):
    """An abstract base class for immutable series classes.

            

Reported by Pylint.

                          window = cls.window

        xnew = pu.mapdomain(x, domain, window)
        res = cls._fit(xnew, y, deg, w=w, rcond=rcond, full=full)
        if full:
            [coef, status] = res
            return cls(coef, domain=domain, window=window), status
        else:
            coef = res

            

Reported by Pylint.

              
    @staticmethod
    @abc.abstractmethod
    def _pow(c, pow, maxpower=None):
        pass

    @staticmethod
    @abc.abstractmethod
    def _val(x, c):

            

Reported by Pylint.

                      return f" {cls.basis_name}_{i}({arg_str})"

    @classmethod
    def _repr_latex_term(cls, i, arg_str, needs_parens):
        if cls.basis_name is None:
            raise NotImplementedError(
                "Subclasses must define either a basis name, or override "
                "_repr_latex_term(i, arg_str, needs_parens)")
        # since we always add parens, we don't care if the expression needs them

            

Reported by Pylint.

              
    @staticmethod
    def _repr_latex_scalar(x):
        # TODO: we're stuck with disabling math formatting until we handle
        # exponents in this function
        return r'\text{{{}}}'.format(x)

    def _repr_latex_(self):
        # get the scaled argument string to the basis functions

            

Reported by Pylint.

                      ret['window'] = self.window.copy()
        return ret

    def __setstate__(self, dict):
        self.__dict__ = dict

    # Call

    def __call__(self, arg):

            

Reported by Pylint.

                      othercoef = self._get_coefficients(other)
        try:
            coef = self._add(self.coef, othercoef)
        except Exception:
            return NotImplemented
        return self.__class__(coef, self.domain, self.window)

    def __sub__(self, other):
        othercoef = self._get_coefficients(other)

            

Reported by Pylint.

                      othercoef = self._get_coefficients(other)
        try:
            coef = self._sub(self.coef, othercoef)
        except Exception:
            return NotImplemented
        return self.__class__(coef, self.domain, self.window)

    def __mul__(self, other):
        othercoef = self._get_coefficients(other)

            

Reported by Pylint.

                      othercoef = self._get_coefficients(other)
        try:
            coef = self._mul(self.coef, othercoef)
        except Exception:
            return NotImplemented
        return self.__class__(coef, self.domain, self.window)

    def __truediv__(self, other):
        # there is no true divide if the rhs is not a Number, although it

            

Reported by Pylint.

                          quo, rem = self._div(self.coef, othercoef)
        except ZeroDivisionError:
            raise
        except Exception:
            return NotImplemented
        quo = self.__class__(quo, self.domain, self.window)
        rem = self.__class__(rem, self.domain, self.window)
        return quo, rem


            

Reported by Pylint.

              from .common import Benchmark, get_squares_, get_indexes_, get_indexes_rand_

from os.path import join as pjoin
import shutil
from numpy import memmap, float32, array
import numpy as np
from tempfile import mkdtemp



            

Reported by Pylint.

                      code = "def run():\n    for a in squares_.values(): a[%s]%s"
        code = code % (sel, op)

        exec(code, ns)
        self.func = ns['run']

    def time_op(self, indexes, sel, op):
        self.func()


            

Reported by Bandit.

                      code = "def run():\n    for a in squares_.values(): a[%s]%s"
        code = code % (sel, op)

        exec(code, ns)
        self.func = ns['run']

    def time_op(self, indexes, sel, op):
        self.func()


            

Reported by Pylint.

                      code = code % (sel, op)

        exec(code, ns)
        self.func = ns['run']

    def time_op(self, indexes, sel, op):
        self.func()



            

Reported by Pylint.

                      exec(code, ns)
        self.func = ns['run']

    def time_op(self, indexes, sel, op):
        self.func()


class ScalarIndexing(Benchmark):
    params = [[0, 1, 2]]

            

Reported by Pylint.

                      exec(code, ns)
        self.func = ns['run']

    def time_op(self, indexes, sel, op):
        self.func()


class ScalarIndexing(Benchmark):
    params = [[0, 1, 2]]

            

Reported by Pylint.

                      exec(code, ns)
        self.func = ns['run']

    def time_op(self, indexes, sel, op):
        self.func()


class ScalarIndexing(Benchmark):
    params = [[0, 1, 2]]

            

Reported by Pylint.

                  param_names = ["ndim"]

    def setup(self, ndim):
        self.array = np.ones((5,) * ndim)

    def time_index(self, ndim):
        # time indexing.
        arr = self.array
        indx = (1,) * ndim

            

Reported by Pylint.

                      # time indexing.
        arr = self.array
        indx = (1,) * ndim
        for i in range(100):
            arr[indx]

    def time_assign(self, ndim):
        # time assignment from a python scalar
        arr = self.array

            

Reported by Pylint.

                      arr = self.array
        indx = (1,) * ndim
        for i in range(100):
            arr[indx]

    def time_assign(self, ndim):
        # time assignment from a python scalar
        arr = self.array
        indx = (1,) * ndim

            

Reported by Pylint.

              import platform
import warnings

from .multiarray import dtype, array, ndarray
try:
    import ctypes
except ImportError:
    ctypes = None


            

Reported by Pylint.

                      num = int(obj[1])
        if num < 0:
            raise ValueError("invalid offset.")
        format = dtype(obj[0], align=align)
        if n > 2:
            title = obj[2]
        else:
            title = None
        allfields.append((fname, format, num, title))

            

Reported by Pylint.

              # pickles of ndarrays made with NumPy before release 1.0
# so don't remove the name here, or you'll
# break backward compatibility.
def _reconstruct(subtype, shape, dtype):
    return ndarray.__new__(subtype, shape, dtype)


# format_re was originally from numarray by J. Todd Miller


            

Reported by Pylint.

                  while startindex < len(astr):
        mo = format_re.match(astr, pos=startindex)
        try:
            (order1, repeats, order2, dtype) = mo.groups()
        except (TypeError, AttributeError):
            raise ValueError(
                f'format number {len(result)+1} of "{astr}" is not recognized'
                ) from None
        startindex = mo.end()

            

Reported by Pylint.

              # Used for .ctypes attribute of ndarray

class _missing_ctypes:
    def cast(self, num, obj):
        return num.value

    class c_void_p:
        def __init__(self, ptr):
            self.value = ptr

            

Reported by Pylint.

              

class _ctypes:
    def __init__(self, array, ptr=None):
        self._arr = array

        if ctypes:
            self._ctypes = ctypes
            self._data = self._ctypes.c_void_p(ptr)

            

Reported by Pylint.

                      # it hold the array reference. This is a workaround to circumvent the
        # CPython bug https://bugs.python.org/issue12836
        ptr = self._ctypes.cast(self._data, obj)
        ptr._arr = self._arr
        return ptr

    def shape_as(self, obj):
        """
        Return the shape tuple as an array of some other c-types

            

Reported by Pylint.

              
def _dtype_from_pep3118(spec):
    stream = _Stream(spec)
    dtype, align = __dtype_from_pep3118(stream, is_subdtype=False)
    return dtype

def __dtype_from_pep3118(stream, is_subdtype):
    field_spec = dict(
        names=[],

            

Reported by Pylint.

              
def _dtype_from_pep3118(spec):
    stream = _Stream(spec)
    dtype, align = __dtype_from_pep3118(stream, is_subdtype=False)
    return dtype

def __dtype_from_pep3118(stream, is_subdtype):
    field_spec = dict(
        names=[],

            

Reported by Pylint.

              def _lcm(a, b):
    return a // _gcd(a, b) * b

def array_ufunc_errmsg_formatter(dummy, ufunc, method, *inputs, **kwargs):
    """ Format the error message for when __array_ufunc__ gives up. """
    args_string = ', '.join(['{!r}'.format(arg) for arg in inputs] +
                            ['{}={!r}'.format(k, v)
                             for k, v in kwargs.items()])
    args = inputs + kwargs.get('out', ())

            

Reported by Pylint.

              """Benchmarks for `numpy.lib`."""


from .common import Benchmark

import numpy as np


class Pad(Benchmark):

            

Reported by Pylint.

                      ["constant", "edge", "linear_ramp", "mean", "reflect", "wrap"],
    ]

    def setup(self, shape, pad_width, mode):
        # Make sure to fill the array to make the OS page fault
        # in the setup phase and not the timed phase
        self.array = np.full(shape, fill_value=1, dtype=np.float64)

    def time_pad(self, shape, pad_width, mode):

            

Reported by Pylint.

                      ["constant", "edge", "linear_ramp", "mean", "reflect", "wrap"],
    ]

    def setup(self, shape, pad_width, mode):
        # Make sure to fill the array to make the OS page fault
        # in the setup phase and not the timed phase
        self.array = np.full(shape, fill_value=1, dtype=np.float64)

    def time_pad(self, shape, pad_width, mode):

            

Reported by Pylint.

                  def setup(self, shape, pad_width, mode):
        # Make sure to fill the array to make the OS page fault
        # in the setup phase and not the timed phase
        self.array = np.full(shape, fill_value=1, dtype=np.float64)

    def time_pad(self, shape, pad_width, mode):
        np.pad(self.array, pad_width, mode)



            

Reported by Pylint.

                      # in the setup phase and not the timed phase
        self.array = np.full(shape, fill_value=1, dtype=np.float64)

    def time_pad(self, shape, pad_width, mode):
        np.pad(self.array, pad_width, mode)


class Nan(Benchmark):
    """Benchmarks for nan functions"""

            

Reported by Pylint.

                      # approximate desired percentage np.nan content
        base_array = np.random.uniform(size=array_size)
        base_array[base_array < percent_nans / 100.] = np.nan
        self.arr = base_array

    def time_nanmin(self, array_size, percent_nans):
        np.nanmin(self.arr)

    def time_nanmax(self, array_size, percent_nans):

            

Reported by Pylint.

                      base_array[base_array < percent_nans / 100.] = np.nan
        self.arr = base_array

    def time_nanmin(self, array_size, percent_nans):
        np.nanmin(self.arr)

    def time_nanmax(self, array_size, percent_nans):
        np.nanmax(self.arr)


            

Reported by Pylint.

                      base_array[base_array < percent_nans / 100.] = np.nan
        self.arr = base_array

    def time_nanmin(self, array_size, percent_nans):
        np.nanmin(self.arr)

    def time_nanmax(self, array_size, percent_nans):
        np.nanmax(self.arr)


            

Reported by Pylint.

                  def time_nanmin(self, array_size, percent_nans):
        np.nanmin(self.arr)

    def time_nanmax(self, array_size, percent_nans):
        np.nanmax(self.arr)

    def time_nanargmin(self, array_size, percent_nans):
        np.nanargmin(self.arr)


            

Reported by Pylint.

                  def time_nanmin(self, array_size, percent_nans):
        np.nanmin(self.arr)

    def time_nanmax(self, array_size, percent_nans):
        np.nanmax(self.arr)

    def time_nanargmin(self, array_size, percent_nans):
        np.nanargmin(self.arr)


            

Reported by Pylint.

              f: float

# NOTE: Avoid importing the platform specific `np.float128` type
AR_i8: npt.NDArray[np.int64]
AR_i4: npt.NDArray[np.int32]
AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]

            

Reported by Pylint.

              
# NOTE: Avoid importing the platform specific `np.float128` type
AR_i8: npt.NDArray[np.int64]
AR_i4: npt.NDArray[np.int32]
AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]

            

Reported by Pylint.

              # NOTE: Avoid importing the platform specific `np.float128` type
AR_i8: npt.NDArray[np.int64]
AR_i4: npt.NDArray[np.int32]
AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]


            

Reported by Pylint.

              AR_i8: npt.NDArray[np.int64]
AR_i4: npt.NDArray[np.int32]
AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]

AR_LIKE_f: List[float]

            

Reported by Pylint.

              AR_i4: npt.NDArray[np.int32]
AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]

AR_LIKE_f: List[float]


            

Reported by Pylint.

              AR_i4: npt.NDArray[np.int32]
AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]

AR_LIKE_f: List[float]


            

Reported by Pylint.

              AR_f2: npt.NDArray[np.float16]
AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]

AR_LIKE_f: List[float]

class RealObj:

            

Reported by Pylint.

              AR_f8: npt.NDArray[np.float64]
AR_f16: npt.NDArray[np.floating[npt._128Bit]]
AR_c8: npt.NDArray[np.complex64]
AR_c16: npt.NDArray[np.complex128]

AR_LIKE_f: List[float]

class RealObj:
    real: slice

            

Reported by Pylint.

              class ImagObj:
    imag: slice

reveal_type(np.mintypecode(["f8"], typeset="qfQF"))

reveal_type(np.asfarray(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.asfarray(AR_LIKE_f))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.asfarray(AR_f8, dtype="c16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
reveal_type(np.asfarray(AR_f8, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]

            

Reported by Pylint.

              
reveal_type(np.mintypecode(["f8"], typeset="qfQF"))

reveal_type(np.asfarray(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.asfarray(AR_LIKE_f))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.asfarray(AR_f8, dtype="c16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
reveal_type(np.asfarray(AR_f8, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]

reveal_type(np.real(RealObj()))  # E: slice

            

Reported by Pylint.

              import numpy as np
from numpy.testing import assert_array_equal, assert_equal, assert_raises
import pytest
from itertools import chain

def test_packbits():
    # Copied from the docstring.
    a = [[[1, 0, 1], [0, 1, 0]],
         [[1, 1, 0], [0, 0, 1]]]

            

Reported by Pylint.

                  # result is the same if input is multiplied with a nonzero value
    for dtype in 'bBhHiIlLqQ':
        arr = np.array(a, dtype=dtype)
        rnd = np.random.randint(low=np.iinfo(dtype).min,
                                high=np.iinfo(dtype).max, size=arr.size,
                                dtype=dtype)
        rnd[rnd == 0] = 1
        arr *= rnd.astype(dtype)
        b = np.packbits(arr, axis=-1)

            

Reported by Pylint.

                  # test some with a larger arrays gh-8637
    # code is covered earlier but larger array makes crash on bug more likely
    for s in range(950, 1050):
        for dt in '?bBhHiIlLqQ':
            x = np.ones((200, s), dtype=bool)
            np.packbits(x, axis=1)


def test_unpackbits():

            

Reported by Pylint.

              import numpy as np
from numpy.testing import assert_array_equal, assert_equal, assert_raises
import pytest
from itertools import chain

def test_packbits():
    # Copied from the docstring.
    a = [[[1, 0, 1], [0, 1, 0]],
         [[1, 1, 0], [0, 0, 1]]]

            

Reported by Pylint.

              import numpy as np
from numpy.testing import assert_array_equal, assert_equal, assert_raises
import pytest
from itertools import chain

def test_packbits():
    # Copied from the docstring.
    a = [[[1, 0, 1], [0, 1, 0]],
         [[1, 1, 0], [0, 0, 1]]]

            

Reported by Pylint.

              import pytest
from itertools import chain

def test_packbits():
    # Copied from the docstring.
    a = [[[1, 0, 1], [0, 1, 0]],
         [[1, 1, 0], [0, 0, 1]]]
    for dt in '?bBhHiIlLqQ':
        arr = np.array(a, dtype=dt)

            

Reported by Pylint.

              
def test_packbits():
    # Copied from the docstring.
    a = [[[1, 0, 1], [0, 1, 0]],
         [[1, 1, 0], [0, 0, 1]]]
    for dt in '?bBhHiIlLqQ':
        arr = np.array(a, dtype=dt)
        b = np.packbits(arr, axis=-1)
        assert_equal(b.dtype, np.uint8)

            

Reported by Pylint.

                  # Copied from the docstring.
    a = [[[1, 0, 1], [0, 1, 0]],
         [[1, 1, 0], [0, 0, 1]]]
    for dt in '?bBhHiIlLqQ':
        arr = np.array(a, dtype=dt)
        b = np.packbits(arr, axis=-1)
        assert_equal(b.dtype, np.uint8)
        assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))


            

Reported by Pylint.

                       [[1, 1, 0], [0, 0, 1]]]
    for dt in '?bBhHiIlLqQ':
        arr = np.array(a, dtype=dt)
        b = np.packbits(arr, axis=-1)
        assert_equal(b.dtype, np.uint8)
        assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))

    assert_raises(TypeError, np.packbits, np.array(a, dtype=float))


            

Reported by Pylint.

                  assert_raises(TypeError, np.packbits, np.array(a, dtype=float))


def test_packbits_empty():
    shapes = [
        (0,), (10, 20, 0), (10, 0, 20), (0, 10, 20), (20, 0, 0), (0, 20, 0),
        (0, 0, 20), (0, 0, 0),
    ]
    for dt in '?bBhHiIlLqQ':

            

Reported by Pylint.

              from collections import Counter
from contextlib import nullcontext

from . import numeric as sb
from . import numerictypes as nt
from numpy.compat import os_fspath
from numpy.core.overrides import set_module
from .arrayprint import get_printoptions


            

Reported by Pylint.

              from contextlib import nullcontext

from . import numeric as sb
from . import numerictypes as nt
from numpy.compat import os_fspath
from numpy.core.overrides import set_module
from .arrayprint import get_printoptions

# All of the functions allow formats to be a dtype

            

Reported by Pylint.

              from . import numerictypes as nt
from numpy.compat import os_fspath
from numpy.core.overrides import set_module
from .arrayprint import get_printoptions

# All of the functions allow formats to be a dtype
__all__ = [
    'record', 'recarray', 'format_parser',
    'fromarrays', 'fromrecords', 'fromstring', 'fromfile', 'array',

            

Reported by Pylint.

              numfmt = nt.sctypeDict


def find_duplicate(list):
    """Find duplication in a list, return a list of duplicated elements"""
    return [
        item
        for item, counts in Counter(list).items()
        if counts > 1

            

Reported by Pylint.

                                                    strides=strides, order=order)
        return self

    def __array_finalize__(self, obj):
        if self.dtype.type is not record and self.dtype.names is not None:
            # if self.dtype is not np.record, invoke __setattr__ which will
            # convert it to a record if it is a void dtype.
            self.dtype = self.dtype


            

Reported by Pylint.

                      newattr = attr not in self.__dict__
        try:
            ret = object.__setattr__(self, attr, val)
        except Exception:
            fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
            if attr not in fielddict:
                raise
        else:
            fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}

            

Reported by Pylint.

                              # internal attribute.
                try:
                    object.__delattr__(self, attr)
                except Exception:
                    return ret
        try:
            res = fielddict[attr][:2]
        except (TypeError, KeyError) as e:
            raise AttributeError(

            

Reported by Pylint.

                      if isinstance(shape, int):
            shape = (shape,)
        if len(shape) > 1:
            raise ValueError("Can only deal with 1-d array.")
        _array = recarray(shape, descr)
        for k in range(_array.size):
            _array[k] = tuple(recList[k])
        # list of lists instead of list of tuples ?
        # 2018-02-07, 1.14.1

            

Reported by Pylint.

              """
Record Arrays
=============
Record arrays expose the fields of structured arrays as properties.

Most commonly, ndarrays contain elements of a single type, e.g. floats,
integers, bools etc.  However, it is possible for elements to be combinations
of these using structured types, such as::


            

Reported by Pylint.

              
from . import numeric as sb
from . import numerictypes as nt
from numpy.compat import os_fspath
from numpy.core.overrides import set_module
from .arrayprint import get_printoptions

# All of the functions allow formats to be a dtype
__all__ = [

            

Reported by Pylint.

                      if self.gcc_version is None:
            try:
                out_string  = subprocess.check_output(['gcc', '-dumpversion'])
            except (OSError, CalledProcessError):
                out_string = ""  # ignore failures to match old behavior
            result = re.search(r'(\d+\.\d+)', out_string)
            if result:
                self.gcc_version = StrictVersion(result.group(1))


            

Reported by Pylint.

                  stems = [sys.prefix]
    if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
        stems.append(sys.base_prefix)
    elif hasattr(sys, 'real_prefix') and sys.real_prefix != sys.prefix:
        stems.append(sys.real_prefix)

    sub_dirs = ['', 'lib', 'bin']
    # generate possible combinations of directory trees and sub-directories
    lib_dirs = []

            

Reported by Pylint.

                  if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
        stems.append(sys.base_prefix)
    elif hasattr(sys, 'real_prefix') and sys.real_prefix != sys.prefix:
        stems.append(sys.real_prefix)

    sub_dirs = ['', 'lib', 'bin']
    # generate possible combinations of directory trees and sub-directories
    lib_dirs = []
    for stem in stems:

            

Reported by Pylint.

                  stems = [sys.prefix]
    if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
        stems.append(sys.base_prefix)
    elif hasattr(sys, 'real_prefix') and sys.real_prefix != sys.prefix:
        stems.append(sys.real_prefix)

    # possible subdirectories within those trees where it is placed
    sub_dirs = ['libs', 'lib']


            

Reported by Pylint.

                  if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
        stems.append(sys.base_prefix)
    elif hasattr(sys, 'real_prefix') and sys.real_prefix != sys.prefix:
        stems.append(sys.real_prefix)

    # possible subdirectories within those trees where it is placed
    sub_dirs = ['libs', 'lib']

    # generate a list of candidate locations

            

Reported by Pylint.

                      if hasattr(sys, 'base_prefix'):
            base_lib = os.path.join(sys.base_prefix, 'libs', lib_name)
        elif hasattr(sys, 'real_prefix'):
            base_lib = os.path.join(sys.real_prefix, 'libs', lib_name)
        else:
            base_lib = ''  # os.path.isfile('') == False

        if os.path.isfile(base_lib):
            lib_file = base_lib

            

Reported by Pylint.

              import textwrap

# Overwrite certain distutils.ccompiler functions:
import numpy.distutils.ccompiler  # noqa: F401
from numpy.distutils import log
# NT stuff
# 1. Make sure libpython<version>.a exists for gcc.  If not, build it.
# 2. Force windows to use gcc (we're struggling with MSVC and g77 support)
#    --> this is done in numpy/distutils/ccompiler.py

            

Reported by Pylint.

              
    # __init__ ()

    def link(self,
             target_desc,
             objects,
             output_filename,
             output_dir,
             libraries,

            

Reported by Pylint.

                                                 'winsxs')
        if not os.path.exists(winsxs_path):
            return None
        for root, dirs, files in os.walk(winsxs_path):
            if dll_name in files and arch in root:
                return os.path.join(root, dll_name)
        return None

    def _find_dll_in_path(dll_name):

            

Reported by Pylint.

              # directory, but this requires the manifest for this to work. This is a big
# mess, thanks MS for a wonderful system.

# XXX: ideally, we should use exactly the same version as used by python. I
# submitted a patch to get this version, but it was only included for python
# 2.6.1 and above. So for versions below, we use a "best guess".
_MSVCRVER_TO_FULLVER = {}
if sys.platform == 'win32':
    try:

            

Reported by Pylint.

              
finfo_f8: np.finfo[np.float64]
iinfo_i8: np.iinfo[np.int64]
machar_f4: np.core.getlimits.MachArLike[_32Bit]

reveal_type(np.finfo(f))  # E: numpy.finfo[{double}]
reveal_type(np.finfo(f8))  # E: numpy.finfo[{float64}]
reveal_type(np.finfo(c8))  # E: numpy.finfo[{float32}]
reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

            

Reported by Pylint.

              iinfo_i8: np.iinfo[np.int64]
machar_f4: np.core.getlimits.MachArLike[_32Bit]

reveal_type(np.finfo(f))  # E: numpy.finfo[{double}]
reveal_type(np.finfo(f8))  # E: numpy.finfo[{float64}]
reveal_type(np.finfo(c8))  # E: numpy.finfo[{float32}]
reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]

            

Reported by Pylint.

              machar_f4: np.core.getlimits.MachArLike[_32Bit]

reveal_type(np.finfo(f))  # E: numpy.finfo[{double}]
reveal_type(np.finfo(f8))  # E: numpy.finfo[{float64}]
reveal_type(np.finfo(c8))  # E: numpy.finfo[{float32}]
reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int

            

Reported by Pylint.

              
reveal_type(np.finfo(f))  # E: numpy.finfo[{double}]
reveal_type(np.finfo(f8))  # E: numpy.finfo[{float64}]
reveal_type(np.finfo(c8))  # E: numpy.finfo[{float32}]
reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}

            

Reported by Pylint.

              reveal_type(np.finfo(f))  # E: numpy.finfo[{double}]
reveal_type(np.finfo(f8))  # E: numpy.finfo[{float64}]
reveal_type(np.finfo(c8))  # E: numpy.finfo[{float32}]
reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}
reveal_type(finfo_f8.epsneg)  # E: {float64}

            

Reported by Pylint.

              reveal_type(np.finfo(c8))  # E: numpy.finfo[{float32}]
reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}
reveal_type(finfo_f8.epsneg)  # E: {float64}
reveal_type(finfo_f8.iexp)  # E: int
reveal_type(finfo_f8.machep)  # E: int

            

Reported by Pylint.

              reveal_type(np.finfo('f2'))  # E: numpy.finfo[numpy.floating[Any]]

reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}
reveal_type(finfo_f8.epsneg)  # E: {float64}
reveal_type(finfo_f8.iexp)  # E: int
reveal_type(finfo_f8.machep)  # E: int
reveal_type(finfo_f8.max)  # E: {float64}

            

Reported by Pylint.

              
reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}
reveal_type(finfo_f8.epsneg)  # E: {float64}
reveal_type(finfo_f8.iexp)  # E: int
reveal_type(finfo_f8.machep)  # E: int
reveal_type(finfo_f8.max)  # E: {float64}
reveal_type(finfo_f8.maxexp)  # E: int

            

Reported by Pylint.

              reveal_type(finfo_f8.dtype)  # E: numpy.dtype[{float64}]
reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}
reveal_type(finfo_f8.epsneg)  # E: {float64}
reveal_type(finfo_f8.iexp)  # E: int
reveal_type(finfo_f8.machep)  # E: int
reveal_type(finfo_f8.max)  # E: {float64}
reveal_type(finfo_f8.maxexp)  # E: int
reveal_type(finfo_f8.min)  # E: {float64}

            

Reported by Pylint.

              reveal_type(finfo_f8.bits)  # E: int
reveal_type(finfo_f8.eps)  # E: {float64}
reveal_type(finfo_f8.epsneg)  # E: {float64}
reveal_type(finfo_f8.iexp)  # E: int
reveal_type(finfo_f8.machep)  # E: int
reveal_type(finfo_f8.max)  # E: {float64}
reveal_type(finfo_f8.maxexp)  # E: int
reveal_type(finfo_f8.min)  # E: {float64}
reveal_type(finfo_f8.minexp)  # E: int

            

Reported by Pylint.