"""
import numpy
import io
import warnings
from numpy.lib.utils import safe_eval
from numpy.compat import (
    isfileobj, os_fspath, pickle
    )

            

Reported by Pylint.

              """
import numpy
import io
import warnings
from numpy.lib.utils import safe_eval
from numpy.compat import (
    isfileobj, os_fspath, pickle
    )


            

Reported by Pylint.

                      raise ValueError("minor version must be 0 <= minor < 256")
    return MAGIC_PREFIX + bytes([major, minor])

def read_magic(fp):
    """ Read the magic string to get the version of the file format.

    Parameters
    ----------
    fp : filelike object

            

Reported by Pylint.

                  major, minor = magic_str[-2:]
    return major, minor

def _has_metadata(dt):
    if dt.metadata is not None:
        return True
    elif dt.names is not None:
        return any(_has_metadata(dt[k]) for k in dt.names)
    elif dt.subdtype is not None:

            

Reported by Pylint.

                  return major, minor

def _has_metadata(dt):
    if dt.metadata is not None:
        return True
    elif dt.names is not None:
        return any(_has_metadata(dt[k]) for k in dt.names)
    elif dt.subdtype is not None:
        return _has_metadata(dt.base)

            

Reported by Pylint.

                      warnings.warn("metadata on a dtype may be saved or ignored, but will "
                      "raise if saved when read. Use another form of storage.",
                      UserWarning, stacklevel=2)
    if dtype.names is not None:
        # This is a record array. The .descr is fine.  XXX: parts of the
        # record array with an empty name, like padding bytes, still get
        # fiddled with. This needs to be fixed in the C implementation of
        # dtype().
        return dtype.descr

            

Reported by Pylint.

                      The dtype constructed by the description.

    """
    if isinstance(descr, str):
        # No padding removal needed
        return numpy.dtype(descr)
    elif isinstance(descr, tuple):
        # subtype, will always have a shape descr[1]
        dt = descr_to_dtype(descr[0])

            

Reported by Pylint.

                      return numpy.dtype(descr)
    elif isinstance(descr, tuple):
        # subtype, will always have a shape descr[1]
        dt = descr_to_dtype(descr[0])
        return numpy.dtype((dt, descr[1]))

    titles = []
    names = []
    formats = []

            

Reported by Pylint.

                  for field in descr:
        if len(field) == 2:
            name, descr_str = field
            dt = descr_to_dtype(descr_str)
        else:
            name, descr_str, shape = field
            dt = numpy.dtype((descr_to_dtype(descr_str), shape))

        # Ignore padding bytes, which will be void bytes with '' as name

            

Reported by Pylint.

                          dt = descr_to_dtype(descr_str)
        else:
            name, descr_str, shape = field
            dt = numpy.dtype((descr_to_dtype(descr_str), shape))

        # Ignore padding bytes, which will be void bytes with '' as name
        # Once support for blank names is removed, only "if name == ''" needed)
        is_pad = (name == '' and dt.type is numpy.void and dt.names is None)
        if not is_pad:

            

Reported by Pylint.

                  def from_param(cls, obj):
        if not isinstance(obj, ndarray):
            raise TypeError("argument must be an ndarray")
        if cls._dtype_ is not None \
               and obj.dtype != cls._dtype_:
            raise TypeError("array must have data type %s" % cls._dtype_)
        if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)

            

Reported by Pylint.

                      if not isinstance(obj, ndarray):
            raise TypeError("argument must be an ndarray")
        if cls._dtype_ is not None \
               and obj.dtype != cls._dtype_:
            raise TypeError("array must have data type %s" % cls._dtype_)
        if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \

            

Reported by Pylint.

                          raise TypeError("argument must be an ndarray")
        if cls._dtype_ is not None \
               and obj.dtype != cls._dtype_:
            raise TypeError("array must have data type %s" % cls._dtype_)
        if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:

            

Reported by Pylint.

                      if cls._dtype_ is not None \
               and obj.dtype != cls._dtype_:
            raise TypeError("array must have data type %s" % cls._dtype_)
        if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))

            

Reported by Pylint.

                             and obj.dtype != cls._dtype_:
            raise TypeError("array must have data type %s" % cls._dtype_)
        if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))
        if cls._flags_ is not None \

            

Reported by Pylint.

                          raise TypeError("array must have data type %s" % cls._dtype_)
        if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))
        if cls._flags_ is not None \
               and ((obj.flags.num & cls._flags_) != cls._flags_):

            

Reported by Pylint.

                      if cls._ndim_ is not None \
               and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))
        if cls._flags_ is not None \
               and ((obj.flags.num & cls._flags_) != cls._flags_):
            raise TypeError("array must have flags %s" %

            

Reported by Pylint.

                             and obj.ndim != cls._ndim_:
            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))
        if cls._flags_ is not None \
               and ((obj.flags.num & cls._flags_) != cls._flags_):
            raise TypeError("array must have flags %s" %
                    _flags_fromnum(cls._flags_))

            

Reported by Pylint.

                          raise TypeError("array must have %d dimension(s)" % cls._ndim_)
        if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))
        if cls._flags_ is not None \
               and ((obj.flags.num & cls._flags_) != cls._flags_):
            raise TypeError("array must have flags %s" %
                    _flags_fromnum(cls._flags_))
        return obj.ctypes

            

Reported by Pylint.

                      if cls._shape_ is not None \
               and obj.shape != cls._shape_:
            raise TypeError("array must have shape %s" % str(cls._shape_))
        if cls._flags_ is not None \
               and ((obj.flags.num & cls._flags_) != cls._flags_):
            raise TypeError("array must have flags %s" %
                    _flags_fromnum(cls._flags_))
        return obj.ctypes


            

Reported by Pylint.

              """
__all__ = ['MachAr']

from numpy.core.fromnumeric import any
from numpy.core._ufunc_config import errstate
from numpy.core.overrides import set_module

# Need to speed this up...especially for longfloat


            

Reported by Pylint.

                          xmax = one - beta*epsneg
        xmax = xmax / (xmin*beta*beta*beta)
        i = maxexp + minexp + 3
        for j in range(i):
            if ibeta == 2:
                xmax = xmax + xmax
            else:
                xmax = xmax * beta


            

Reported by Pylint.

              # Need to speed this up...especially for longfloat

@set_module('numpy')
class MachAr:
    """
    Diagnosing machine parameters.

    Attributes
    ----------

            

Reported by Pylint.

              # Need to speed this up...especially for longfloat

@set_module('numpy')
class MachAr:
    """
    Diagnosing machine parameters.

    Attributes
    ----------

            

Reported by Pylint.

              
    """

    def __init__(self, float_conv=float,int_conv=int,
                 float_to_float=float,
                 float_to_str=lambda v:'%24.16e' % v,
                 title='Python floating point number'):
        """


            

Reported by Pylint.

                      with errstate(under='ignore'):
            self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)

    def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
        max_iterN = 10000
        msg = "Did not converge after %d tries with %s"
        one = float_conv(1)
        two = one + one
        zero = one - one

            

Reported by Pylint.

                      with errstate(under='ignore'):
            self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)

    def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
        max_iterN = 10000
        msg = "Did not converge after %d tries with %s"
        one = float_conv(1)
        two = one + one
        zero = one - one

            

Reported by Pylint.

                      with errstate(under='ignore'):
            self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)

    def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
        max_iterN = 10000
        msg = "Did not converge after %d tries with %s"
        one = float_conv(1)
        two = one + one
        zero = one - one

            

Reported by Pylint.

                      with errstate(under='ignore'):
            self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)

    def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
        max_iterN = 10000
        msg = "Did not converge after %d tries with %s"
        one = float_conv(1)
        two = one + one
        zero = one - one

            

Reported by Pylint.

                          self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)

    def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
        max_iterN = 10000
        msg = "Did not converge after %d tries with %s"
        one = float_conv(1)
        two = one + one
        zero = one - one


            

Reported by Pylint.

              class TestMisc:

    def test_trimseq(self):
        for i in range(5):
            tgt = [1]
            res = pu.trimseq([1] + [0]*5)
            assert_equal(res, tgt)

    def test_as_series(self):

            

Reported by Pylint.

                              ci = np.ones(1, types[i])
                cj = np.ones(1, types[j])
                [resi, resj] = pu.as_series([ci, cj])
                assert_(resi.dtype.char == resj.dtype.char)
                assert_(resj.dtype.char == types[i])

    def test_trimcoef(self):
        coef = [2, -1, 1, 0]
        # Test exceptions

            

Reported by Pylint.

                              cj = np.ones(1, types[j])
                [resi, resj] = pu.as_series([ci, cj])
                assert_(resi.dtype.char == resj.dtype.char)
                assert_(resj.dtype.char == types[i])

    def test_trimcoef(self):
        coef = [2, -1, 1, 0]
        # Test exceptions
        assert_raises(ValueError, pu.trimcoef, coef, -1)

            

Reported by Pylint.

              
    def test_vander_nd_exception(self):
        # n_dims != len(points)
        assert_raises(ValueError, pu._vander_nd, (), (1, 2, 3), [90])
        # n_dims != len(degrees)
        assert_raises(ValueError, pu._vander_nd, (), (), [90.65])
        # n_dims == 0
        assert_raises(ValueError, pu._vander_nd, (), (), [])


            

Reported by Pylint.

                      # n_dims != len(points)
        assert_raises(ValueError, pu._vander_nd, (), (1, 2, 3), [90])
        # n_dims != len(degrees)
        assert_raises(ValueError, pu._vander_nd, (), (), [90.65])
        # n_dims == 0
        assert_raises(ValueError, pu._vander_nd, (), (), [])

    def test_div_zerodiv(self):
        # c2[-1] == 0

            

Reported by Pylint.

                      # n_dims != len(degrees)
        assert_raises(ValueError, pu._vander_nd, (), (), [90.65])
        # n_dims == 0
        assert_raises(ValueError, pu._vander_nd, (), (), [])

    def test_div_zerodiv(self):
        # c2[-1] == 0
        assert_raises(ZeroDivisionError, pu._div, pu._div, (1, 2, 3), [0])


            

Reported by Pylint.

              
    def test_div_zerodiv(self):
        # c2[-1] == 0
        assert_raises(ZeroDivisionError, pu._div, pu._div, (1, 2, 3), [0])

    def test_pow_too_large(self):
        # power > maxpower
        assert_raises(ValueError, pu._pow, (), [1, 2, 3], 5, 4)


            

Reported by Pylint.

              
    def test_div_zerodiv(self):
        # c2[-1] == 0
        assert_raises(ZeroDivisionError, pu._div, pu._div, (1, 2, 3), [0])

    def test_pow_too_large(self):
        # power > maxpower
        assert_raises(ValueError, pu._pow, (), [1, 2, 3], 5, 4)


            

Reported by Pylint.

              
    def test_pow_too_large(self):
        # power > maxpower
        assert_raises(ValueError, pu._pow, (), [1, 2, 3], 5, 4)

class TestDomain:

    def test_getdomain(self):
        # test for real values

            

Reported by Pylint.

                      dom2 = [1, 3]
        x = np.array([dom1, dom1]).view(MyNDArray)
        res = pu.mapdomain(x, dom1, dom2)
        assert_(isinstance(res, MyNDArray))

    def test_mapparms(self):
        # test for real values
        dom1 = [0, 4]
        dom2 = [1, 3]

            

Reported by Pylint.

                  # these strings are filled in when 'setup.py versioneer' creates
    # _version.py
    cfg = VersioneerConfig()
    cfg.VCS = "git"
    cfg.style = "pep440"
    cfg.tag_prefix = "v"
    cfg.parentdir_prefix = "numpy-"
    cfg.versionfile_source = "numpy/_version.py"
    cfg.verbose = False

            

Reported by Pylint.

                  # _version.py
    cfg = VersioneerConfig()
    cfg.VCS = "git"
    cfg.style = "pep440"
    cfg.tag_prefix = "v"
    cfg.parentdir_prefix = "numpy-"
    cfg.versionfile_source = "numpy/_version.py"
    cfg.verbose = False
    return cfg

            

Reported by Pylint.

                  cfg = VersioneerConfig()
    cfg.VCS = "git"
    cfg.style = "pep440"
    cfg.tag_prefix = "v"
    cfg.parentdir_prefix = "numpy-"
    cfg.versionfile_source = "numpy/_version.py"
    cfg.verbose = False
    return cfg


            

Reported by Pylint.

                  cfg.VCS = "git"
    cfg.style = "pep440"
    cfg.tag_prefix = "v"
    cfg.parentdir_prefix = "numpy-"
    cfg.versionfile_source = "numpy/_version.py"
    cfg.verbose = False
    return cfg



            

Reported by Pylint.

                  cfg.style = "pep440"
    cfg.tag_prefix = "v"
    cfg.parentdir_prefix = "numpy-"
    cfg.versionfile_source = "numpy/_version.py"
    cfg.verbose = False
    return cfg


class NotThisMethod(Exception):

            

Reported by Pylint.

                  cfg.tag_prefix = "v"
    cfg.parentdir_prefix = "numpy-"
    cfg.versionfile_source = "numpy/_version.py"
    cfg.verbose = False
    return cfg


class NotThisMethod(Exception):
    """Exception raised if a method is not valid for the current scenario."""

            

Reported by Pylint.

                  """
    rootdirs = []

    for i in range(3):
        dirname = os.path.basename(root)
        if dirname.startswith(parentdir_prefix):
            return {"version": dirname[len(parentdir_prefix):],
                    "full-revisionid": None,
                    "dirty": False, "error": None, "date": None}

            

Reported by Pylint.

              

@register_vcs_handler("git", "pieces_from_vcs")
def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
    """Get version from 'git describe' in the root of the source tree.

    This only gets called if the git-archive 'subst' keywords were *not*
    expanded, and _version.py hasn't already been rewritten with a short
    version string, meaning we're inside a checked out source tree.

            

Reported by Pylint.

                  if sys.platform == "win32":
        GITS = ["git.cmd", "git.exe"]

    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
                          hide_stderr=True)
    if rc != 0:
        if verbose:
            print("Directory %s not under git control" % root)
        raise NotThisMethod("'git rev-parse --git-dir' returned error")

            

Reported by Pylint.

                      # versionfile_source is the relative path from the top of the source
        # tree (where the .git directory might live) to this file. Invert
        # this to find the root from __file__.
        for i in cfg.versionfile_source.split('/'):
            root = os.path.dirname(root)
    except NameError:
        return {"version": "0+unknown", "full-revisionid": None,
                "dirty": None,
                "error": "unable to find root of source tree",

            

Reported by Pylint.

              import numpy as np
from numpy.typing import NDArray
from typing import Any, List

i8: np.int64
f8: np.float64

AR_b: NDArray[np.bool_]
AR_i8: NDArray[np.int64]

            

Reported by Pylint.

              
AR_LIKE_f8: List[float]

reveal_type(np.take_along_axis(AR_f8, AR_i8, axis=1))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.take_along_axis(f8, AR_i8, axis=None))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]

reveal_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1))  # E: None

reveal_type(np.expand_dims(AR_i8, 2))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              AR_LIKE_f8: List[float]

reveal_type(np.take_along_axis(AR_f8, AR_i8, axis=1))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.take_along_axis(f8, AR_i8, axis=None))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]

reveal_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1))  # E: None

reveal_type(np.expand_dims(AR_i8, 2))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.expand_dims(AR_LIKE_f8, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

            

Reported by Pylint.

              reveal_type(np.take_along_axis(AR_f8, AR_i8, axis=1))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
reveal_type(np.take_along_axis(f8, AR_i8, axis=None))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]

reveal_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1))  # E: None

reveal_type(np.expand_dims(AR_i8, 2))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.expand_dims(AR_LIKE_f8, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.column_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              
reveal_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1))  # E: None

reveal_type(np.expand_dims(AR_i8, 2))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.expand_dims(AR_LIKE_f8, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.column_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.column_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]


            

Reported by Pylint.

              reveal_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1))  # E: None

reveal_type(np.expand_dims(AR_i8, 2))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.expand_dims(AR_LIKE_f8, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.column_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.column_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.dstack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              reveal_type(np.expand_dims(AR_i8, 2))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.expand_dims(AR_LIKE_f8, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.column_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.column_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.dstack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.dstack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]


            

Reported by Pylint.

              reveal_type(np.expand_dims(AR_LIKE_f8, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.column_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.column_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.dstack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.dstack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.row_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              reveal_type(np.column_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.column_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.dstack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.dstack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.row_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.row_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]


            

Reported by Pylint.

              reveal_type(np.column_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.dstack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.dstack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.row_stack([AR_i8]))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(np.row_stack([AR_LIKE_f8]))  # E: numpy.ndarray[Any, numpy.dtype[Any]]

reveal_type(np.array_split(AR_i8, [3, 5, 6, 10]))  # E: list[numpy.ndarray[Any, numpy.dtype[{int64}]]]

            

Reported by Pylint.

                          pkg = os.path.splitext(path)[0]
            out = read_config(pkg)

        assert_(out.cflags() == simple_d['cflags'])
        assert_(out.libs() == simple_d['libflags'])
        assert_(out.name == simple_d['name'])
        assert_(out.version == simple_d['version'])

    def test_simple_variable(self):

            

Reported by Pylint.

                          out = read_config(pkg)

        assert_(out.cflags() == simple_d['cflags'])
        assert_(out.libs() == simple_d['libflags'])
        assert_(out.name == simple_d['name'])
        assert_(out.version == simple_d['version'])

    def test_simple_variable(self):
        with temppath('foo.ini') as path:

            

Reported by Pylint.

              
        assert_(out.cflags() == simple_d['cflags'])
        assert_(out.libs() == simple_d['libflags'])
        assert_(out.name == simple_d['name'])
        assert_(out.version == simple_d['version'])

    def test_simple_variable(self):
        with temppath('foo.ini') as path:
            with open(path,  'w') as f:

            

Reported by Pylint.

                      assert_(out.cflags() == simple_d['cflags'])
        assert_(out.libs() == simple_d['libflags'])
        assert_(out.name == simple_d['name'])
        assert_(out.version == simple_d['version'])

    def test_simple_variable(self):
        with temppath('foo.ini') as path:
            with open(path,  'w') as f:
                f.write(simple_variable)

            

Reported by Pylint.

                          pkg = os.path.splitext(path)[0]
            out = read_config(pkg)

        assert_(out.cflags() == simple_variable_d['cflags'])
        assert_(out.libs() == simple_variable_d['libflags'])
        assert_(out.name == simple_variable_d['name'])
        assert_(out.version == simple_variable_d['version'])
        out.vars['prefix'] = '/Users/david'
        assert_(out.cflags() == '-I/Users/david/include')

            

Reported by Pylint.

                          out = read_config(pkg)

        assert_(out.cflags() == simple_variable_d['cflags'])
        assert_(out.libs() == simple_variable_d['libflags'])
        assert_(out.name == simple_variable_d['name'])
        assert_(out.version == simple_variable_d['version'])
        out.vars['prefix'] = '/Users/david'
        assert_(out.cflags() == '-I/Users/david/include')


            

Reported by Pylint.

              
        assert_(out.cflags() == simple_variable_d['cflags'])
        assert_(out.libs() == simple_variable_d['libflags'])
        assert_(out.name == simple_variable_d['name'])
        assert_(out.version == simple_variable_d['version'])
        out.vars['prefix'] = '/Users/david'
        assert_(out.cflags() == '-I/Users/david/include')

class TestParseFlags:

            

Reported by Pylint.

                      assert_(out.cflags() == simple_variable_d['cflags'])
        assert_(out.libs() == simple_variable_d['libflags'])
        assert_(out.name == simple_variable_d['name'])
        assert_(out.version == simple_variable_d['version'])
        out.vars['prefix'] = '/Users/david'
        assert_(out.cflags() == '-I/Users/david/include')

class TestParseFlags:
    def test_simple_cflags(self):

            

Reported by Pylint.

                      assert_(out.name == simple_variable_d['name'])
        assert_(out.version == simple_variable_d['version'])
        out.vars['prefix'] = '/Users/david'
        assert_(out.cflags() == '-I/Users/david/include')

class TestParseFlags:
    def test_simple_cflags(self):
        d = parse_flags("-I/usr/include")
        assert_(d['include_dirs'] == ['/usr/include'])

            

Reported by Pylint.

              class TestParseFlags:
    def test_simple_cflags(self):
        d = parse_flags("-I/usr/include")
        assert_(d['include_dirs'] == ['/usr/include'])

        d = parse_flags("-I/usr/include -DFOO")
        assert_(d['include_dirs'] == ['/usr/include'])
        assert_(d['macros'] == ['FOO'])


            

Reported by Pylint.

              import collections.abc
import warnings

from .utils import SkipTest, assert_warns, HAS_REFCOUNT

__all__ = ['slow', 'setastest', 'skipif', 'knownfailureif', 'deprecated',
           'parametrize', '_needs_refcount',]



            

Reported by Pylint.

                  def skip_decorator(f):
        # Local import to avoid a hard nose dependency and only incur the
        # import time overhead at actual test-time.
        import nose

        # Numpy 1.21, 2020-12-20
        warnings.warn('the np.testing.dec decorators are included for nose support, and are '
            'deprecated since NumPy v1.21. Use the nose2 or pytest frameworks instead.', DeprecationWarning, stacklevel=2)


            

Reported by Pylint.

                  def knownfail_decorator(f):
        # Local import to avoid a hard nose dependency and only incur the
        # import time overhead at actual test-time.
        import nose
        from .noseclasses import KnownFailureException

        def knownfailer(*args, **kwargs):
            if fail_val():
                raise KnownFailureException(msg)

            

Reported by Pylint.

                      # Local import to avoid a hard nose dependency and only incur the
        # import time overhead at actual test-time.
        import nose
        from .noseclasses import KnownFailureException

        def knownfailer(*args, **kwargs):
            if fail_val():
                raise KnownFailureException(msg)
            else:

            

Reported by Pylint.

                  def deprecate_decorator(f):
        # Local import to avoid a hard nose dependency and only incur the
        # import time overhead at actual test-time.
        import nose

        # Numpy 1.21, 2020-12-20
        warnings.warn('the np.testing.dec decorators are included for nose support, and are '
            'deprecated since NumPy v1.21. Use the nose2 or pytest frameworks instead.', DeprecationWarning, stacklevel=2)


            

Reported by Pylint.

                  .. versionadded:: 1.14.0

    """
    from .parameterized import parameterized

    # Numpy 1.21, 2020-12-20
    warnings.warn('the np.testing.dec decorators are included for nose support, and are '
            'deprecated since NumPy v1.21. Use the nose2 or pytest frameworks instead.', DeprecationWarning, stacklevel=2)


            

Reported by Pylint.

              
        # Allow for both boolean or callable skip conditions.
        if isinstance(skip_condition, collections.abc.Callable):
            skip_val = lambda: skip_condition()
        else:
            skip_val = lambda: skip_condition

        def get_msg(func,msg=None):
            """Skip message with information about function being skipped."""

            

Reported by Pylint.

              
    # Allow for both boolean or callable known failure conditions.
    if isinstance(fail_condition, collections.abc.Callable):
        fail_val = lambda: fail_condition()
    else:
        fail_val = lambda: fail_condition

    def knownfail_decorator(f):
        # Local import to avoid a hard nose dependency and only incur the

            

Reported by Pylint.

                  return deprecate_decorator


def parametrize(vars, input):
    """
    .. deprecated:: 1.21
        This decorator is retained for compatibility with the nose testing framework, which is being phased out.
        Please use the nose2 or pytest frameworks instead.


            

Reported by Pylint.

                  return deprecate_decorator


def parametrize(vars, input):
    """
    .. deprecated:: 1.21
        This decorator is retained for compatibility with the nose testing framework, which is being phased out.
        Please use the nose2 or pytest frameworks instead.


            

Reported by Pylint.

              import numpy as np
from numpy import f2py

np.char
np.ctypeslib
np.emath
np.fft
np.lib
np.linalg

            

Reported by Pylint.

              from numpy import f2py

np.char
np.ctypeslib
np.emath
np.fft
np.lib
np.linalg
np.ma

            

Reported by Pylint.

              
np.char
np.ctypeslib
np.emath
np.fft
np.lib
np.linalg
np.ma
np.matrixlib

            

Reported by Pylint.

              np.char
np.ctypeslib
np.emath
np.fft
np.lib
np.linalg
np.ma
np.matrixlib
np.polynomial

            

Reported by Pylint.

              np.ctypeslib
np.emath
np.fft
np.lib
np.linalg
np.ma
np.matrixlib
np.polynomial
np.random

            

Reported by Pylint.

              np.emath
np.fft
np.lib
np.linalg
np.ma
np.matrixlib
np.polynomial
np.random
np.rec

            

Reported by Pylint.

              np.fft
np.lib
np.linalg
np.ma
np.matrixlib
np.polynomial
np.random
np.rec
np.testing

            

Reported by Pylint.

              np.lib
np.linalg
np.ma
np.matrixlib
np.polynomial
np.random
np.rec
np.testing
np.version

            

Reported by Pylint.

              np.linalg
np.ma
np.matrixlib
np.polynomial
np.random
np.rec
np.testing
np.version


            

Reported by Pylint.

              np.ma
np.matrixlib
np.polynomial
np.random
np.rec
np.testing
np.version

np.lib.format

            

Reported by Pylint.

              import warnings
import numpy as np

from .utils import import_nose, suppress_warnings


__all__ = ['get_package_name', 'run_module_suite', 'NoseTester',
           '_numpy_tester', 'get_package_name', 'import_nose',
           'suppress_warnings']

            

Reported by Pylint.

                      argv = argv + [file_to_run]

    nose = import_nose()
    from .noseclasses import KnownFailurePlugin
    nose.run(argv=argv, addplugins=[KnownFailurePlugin()])


class NoseTester:
    """

            

Reported by Pylint.

                      print(f'NumPy is installed in {npdir}')

        if 'scipy' in self.package_name:
            import scipy
            print(f'SciPy version {scipy.__version__}')
            spdir = os.path.dirname(scipy.__file__)
            print(f'SciPy is installed in {spdir}')

        pyversion = sys.version.replace('\n', '')

            

Reported by Pylint.

              
        A return value of None means use the nose builtin doctest plugin
        """
        from .noseclasses import NumpyDoctest
        return NumpyDoctest()

    def prepare_test_args(self, label='fast', verbose=1, extra_argv=None,
                          doctests=False, coverage=False, timer=False):
        """

            

Reported by Pylint.

                              argv += ['--with-timer', '--timer-top-n', str(timer)]

        # construct list of plugins
        import nose.plugins.builtin
        from nose.plugins import EntryPointPluginManager
        from .noseclasses import (KnownFailurePlugin, Unplugger,
                                  FPUModeCheckPlugin)
        plugins = [KnownFailurePlugin()]
        plugins += [p() for p in nose.plugins.builtin.plugins]

            

Reported by Pylint.

              
        # construct list of plugins
        import nose.plugins.builtin
        from nose.plugins import EntryPointPluginManager
        from .noseclasses import (KnownFailurePlugin, Unplugger,
                                  FPUModeCheckPlugin)
        plugins = [KnownFailurePlugin()]
        plugins += [p() for p in nose.plugins.builtin.plugins]
        if self.check_fpu_mode:

            

Reported by Pylint.

                      # construct list of plugins
        import nose.plugins.builtin
        from nose.plugins import EntryPointPluginManager
        from .noseclasses import (KnownFailurePlugin, Unplugger,
                                  FPUModeCheckPlugin)
        plugins = [KnownFailurePlugin()]
        plugins += [p() for p in nose.plugins.builtin.plugins]
        if self.check_fpu_mode:
            plugins += [FPUModeCheckPlugin()]

            

Reported by Pylint.

                      # cap verbosity at 3 because nose becomes *very* verbose beyond that
        verbose = min(verbose, 3)

        from . import utils
        utils.verbose = verbose

        argv, plugins = self.prepare_test_args(
                label, verbose, extra_argv, doctests, coverage, timer)


            

Reported by Pylint.

                          # so fetch module for suppression here.
            with warnings.catch_warnings():
                warnings.simplefilter("always")
                from ...distutils import cpuinfo
            sup.filter(category=UserWarning, module=cpuinfo)
            # Filter out some deprecation warnings inside nose 1.3.7 when run
            # on python 3.5b2. See
            #     https://github.com/nose-devs/nose/issues/929
            # Note: it is hard to filter based on module for sup (lineno could

            

Reported by Pylint.

                                                  category=DeprecationWarning,
                                    module=r"nose\.")

            from .noseclasses import NumpyTestProgram

            t = NumpyTestProgram(argv=argv, exit=False, plugins=plugins)

        return t.result


            

Reported by Pylint.