import sys
from typing import get_type_hints, Union, Tuple, NamedTuple

import pytest
import numpy as np
import numpy.typing as npt

try:
    from typing_extensions import get_args, get_origin

            

Reported by Pylint.

              
@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
@pytest.mark.skipif(SKIP, reason="requires typing-extensions")
def test_get_args(name: type, tup: TypeTup) -> None:
    """Test `typing.get_args`."""
    typ, ref = tup.typ, tup.args
    out = get_args(typ)
    assert out == ref


            

Reported by Pylint.

              
@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
@pytest.mark.skipif(SKIP, reason="requires typing-extensions")
def test_get_origin(name: type, tup: TypeTup) -> None:
    """Test `typing.get_origin`."""
    typ, ref = tup.typ, tup.origin
    out = get_origin(typ)
    assert out == ref


            

Reported by Pylint.

              

@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
def test_get_type_hints(name: type, tup: TypeTup) -> None:
    """Test `typing.get_type_hints`."""
    typ = tup.typ

    # Explicitly set `__annotations__` in order to circumvent the
    # stringification performed by `from __future__ import annotations`

            

Reported by Pylint.

              
    # Explicitly set `__annotations__` in order to circumvent the
    # stringification performed by `from __future__ import annotations`
    def func(a): pass
    func.__annotations__ = {"a": typ, "return": None}

    out = get_type_hints(func)
    ref = {"a": typ, "return": type(None)}
    assert out == ref

            

Reported by Pylint.

              
    # Explicitly set `__annotations__` in order to circumvent the
    # stringification performed by `from __future__ import annotations`
    def func(a): pass
    func.__annotations__ = {"a": typ_str, "return": None}

    out = get_type_hints(func)
    ref = {"a": typ, "return": type(None)}
    assert out == ref

            

Reported by Pylint.

                  SKIP = True


class TypeTup(NamedTuple):
    typ: type
    args: Tuple[type, ...]
    origin: None | type



            

Reported by Pylint.

                  """Test `typing.get_args`."""
    typ, ref = tup.typ, tup.args
    out = get_args(typ)
    assert out == ref


@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
@pytest.mark.skipif(SKIP, reason="requires typing-extensions")
def test_get_origin(name: type, tup: TypeTup) -> None:

            

Reported by Bandit.

                  """Test `typing.get_origin`."""
    typ, ref = tup.typ, tup.origin
    out = get_origin(typ)
    assert out == ref


@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
def test_get_type_hints(name: type, tup: TypeTup) -> None:
    """Test `typing.get_type_hints`."""

            

Reported by Bandit.

              
    # Explicitly set `__annotations__` in order to circumvent the
    # stringification performed by `from __future__ import annotations`
    def func(a): pass
    func.__annotations__ = {"a": typ, "return": None}

    out = get_type_hints(func)
    ref = {"a": typ, "return": type(None)}
    assert out == ref

            

Reported by Pylint.

              np.dtype(Test())

# Methods and attributes
dtype_obj.base
dtype_obj.subdtype
dtype_obj.newbyteorder()
dtype_obj.type
dtype_obj.name
dtype_obj.names

            

Reported by Pylint.

              
# Methods and attributes
dtype_obj.base
dtype_obj.subdtype
dtype_obj.newbyteorder()
dtype_obj.type
dtype_obj.name
dtype_obj.names


            

Reported by Pylint.

              dtype_obj.base
dtype_obj.subdtype
dtype_obj.newbyteorder()
dtype_obj.type
dtype_obj.name
dtype_obj.names

dtype_obj * 0
dtype_obj * 2

            

Reported by Pylint.

              dtype_obj.subdtype
dtype_obj.newbyteorder()
dtype_obj.type
dtype_obj.name
dtype_obj.names

dtype_obj * 0
dtype_obj * 2


            

Reported by Pylint.

              dtype_obj.newbyteorder()
dtype_obj.type
dtype_obj.name
dtype_obj.names

dtype_obj * 0
dtype_obj * 2

0 * dtype_obj

            

Reported by Pylint.

              dtype_obj.name
dtype_obj.names

dtype_obj * 0
dtype_obj * 2

0 * dtype_obj
2 * dtype_obj


            

Reported by Pylint.

              dtype_obj.names

dtype_obj * 0
dtype_obj * 2

0 * dtype_obj
2 * dtype_obj

void_dtype_obj["f0"]

            

Reported by Pylint.

              dtype_obj * 0
dtype_obj * 2

0 * dtype_obj
2 * dtype_obj

void_dtype_obj["f0"]
void_dtype_obj[0]
void_dtype_obj[["f0", "f1"]]

            

Reported by Pylint.

              dtype_obj * 2

0 * dtype_obj
2 * dtype_obj

void_dtype_obj["f0"]
void_dtype_obj[0]
void_dtype_obj[["f0", "f1"]]
void_dtype_obj[["f0"]]

            

Reported by Pylint.

              0 * dtype_obj
2 * dtype_obj

void_dtype_obj["f0"]
void_dtype_obj[0]
void_dtype_obj[["f0", "f1"]]
void_dtype_obj[["f0"]]

            

Reported by Pylint.

              
def dos2unix_dir(dir_name):
    modified_files = []
    os.path.walk(dir_name, dos2unix_one_dir, modified_files)
    return modified_files
#----------------------------------

def unix2dos(file):
    "Replace LF with CRLF in argument files.  Print names of changed files."

            

Reported by Pylint.

              
def dos2unix_dir(dir_name):
    modified_files = []
    os.path.walk(dir_name, dos2unix_one_dir, modified_files)
    return modified_files
#----------------------------------

def unix2dos(file):
    "Replace LF with CRLF in argument files.  Print names of changed files."

            

Reported by Pylint.

              
def unix2dos_dir(dir_name):
    modified_files = []
    os.path.walk(dir_name, unix2dos_one_dir, modified_files)
    return modified_files

if __name__ == "__main__":
    dos2unix_dir(sys.argv[1])

            

Reported by Pylint.

              
def unix2dos_dir(dir_name):
    modified_files = []
    os.path.walk(dir_name, unix2dos_one_dir, modified_files)
    return modified_files

if __name__ == "__main__":
    dos2unix_dir(sys.argv[1])

            

Reported by Pylint.

              import sys


def dos2unix(file):
    "Replace CRLF with LF in argument files.  Print names of changed files."
    if os.path.isdir(file):
        print(file, "Directory!")
        return


            

Reported by Pylint.

                      print(file, "Directory!")
        return

    with open(file, "rb") as fp:
        data = fp.read()
    if '\0' in data:
        print(file, "Binary!")
        return


            

Reported by Pylint.

                      return

    newdata = re.sub("\r\n", "\n", data)
    if newdata != data:
        print('dos2unix:', file)
        with open(file, "wb") as f:
            f.write(newdata)
        return file
    else:

            

Reported by Pylint.

                  newdata = re.sub("\r\n", "\n", data)
    if newdata != data:
        print('dos2unix:', file)
        with open(file, "wb") as f:
            f.write(newdata)
        return file
    else:
        print(file, 'ok')


            

Reported by Pylint.

                  else:
        print(file, 'ok')

def dos2unix_one_dir(modified_files, dir_name, file_names):
    for file in file_names:
        full_path = os.path.join(dir_name, file)
        file = dos2unix(full_path)
        if file is not None:
            modified_files.append(file)

            

Reported by Pylint.

                      if file is not None:
            modified_files.append(file)

def dos2unix_dir(dir_name):
    modified_files = []
    os.path.walk(dir_name, dos2unix_one_dir, modified_files)
    return modified_files
#----------------------------------


            

Reported by Pylint.

              Tests which scan for certain occurrences in the code, they may not find
all of these occurrences but should catch almost all.
"""
import pytest

from pathlib import Path
import ast
import tokenize
import numpy

            

Reported by Pylint.

              """
import pytest

from pathlib import Path
import ast
import tokenize
import numpy

class ParseCall(ast.NodeVisitor):

            

Reported by Pylint.

              import pytest

from pathlib import Path
import ast
import tokenize
import numpy

class ParseCall(ast.NodeVisitor):
    def __init__(self):

            

Reported by Pylint.

              
from pathlib import Path
import ast
import tokenize
import numpy

class ParseCall(ast.NodeVisitor):
    def __init__(self):
        self.ls = []

            

Reported by Pylint.

              import tokenize
import numpy

class ParseCall(ast.NodeVisitor):
    def __init__(self):
        self.ls = []

    def visit_Attribute(self, node):
        ast.NodeVisitor.generic_visit(self, node)

            

Reported by Pylint.

              
class ParseCall(ast.NodeVisitor):
    def __init__(self):
        self.ls = []

    def visit_Attribute(self, node):
        ast.NodeVisitor.generic_visit(self, node)
        self.ls.append(node.attr)


            

Reported by Pylint.

                  def __init__(self):
        self.ls = []

    def visit_Attribute(self, node):
        ast.NodeVisitor.generic_visit(self, node)
        self.ls.append(node.attr)

    def visit_Name(self, node):
        self.ls.append(node.id)

            

Reported by Pylint.

                  def __init__(self):
        self.ls = []

    def visit_Attribute(self, node):
        ast.NodeVisitor.generic_visit(self, node)
        self.ls.append(node.attr)

    def visit_Name(self, node):
        self.ls.append(node.id)

            

Reported by Pylint.

                      ast.NodeVisitor.generic_visit(self, node)
        self.ls.append(node.attr)

    def visit_Name(self, node):
        self.ls.append(node.id)


class FindFuncs(ast.NodeVisitor):
    def __init__(self, filename):

            

Reported by Pylint.

                      ast.NodeVisitor.generic_visit(self, node)
        self.ls.append(node.attr)

    def visit_Name(self, node):
        self.ls.append(node.id)


class FindFuncs(ast.NodeVisitor):
    def __init__(self, filename):

            

Reported by Pylint.

              f2py_version = 'See `f2py -v`'


from .auxfuncs import (
    applyrules, dictappend, gentitle, hasnote, outmess
)


usemodule_rules = {

            

Reported by Pylint.

                  return ret


def buildusevar(name, realname, vars, usemodulename):
    outmess('\t\t\tConstructing wrapper function for variable "%s=>%s"...\n' % (
        name, realname))
    ret = {}
    vrd = {'name': name,
           'realname': realname,

            

Reported by Pylint.

              """
__version__ = "$Revision: 1.3 $"[10:-1]

f2py_version = 'See `f2py -v`'


from .auxfuncs import (
    applyrules, dictappend, gentitle, hasnote, outmess
)

            

Reported by Pylint.

              f2py_version = 'See `f2py -v`'


from .auxfuncs import (
    applyrules, dictappend, gentitle, hasnote, outmess
)


usemodule_rules = {

            

Reported by Pylint.

              ################


def buildusevars(m, r):
    ret = {}
    outmess(
        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
    varsmap = {}
    revmap = {}

            

Reported by Pylint.

              ################


def buildusevars(m, r):
    ret = {}
    outmess(
        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
    varsmap = {}
    revmap = {}

            

Reported by Pylint.

              ################


def buildusevars(m, r):
    ret = {}
    outmess(
        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
    varsmap = {}
    revmap = {}

            

Reported by Pylint.

              ################


def buildusevars(m, r):
    ret = {}
    outmess(
        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
    varsmap = {}
    revmap = {}

            

Reported by Pylint.

              def buildusevars(m, r):
    ret = {}
    outmess(
        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
    varsmap = {}
    revmap = {}
    if 'map' in r:
        for k in r['map'].keys():
            if r['map'][k] in revmap:

            

Reported by Pylint.

                          else:
                revmap[r['map'][k]] = k
    if 'only' in r and r['only']:
        for v in r['map'].keys():
            if r['map'][v] in m['vars']:

                if revmap[r['map'][v]] == v:
                    varsmap[v] = r['map'][v]
                else:

            

Reported by Pylint.

              np.float32([1.0, 0.0, 0.0])  # E: incompatible type
np.complex64([])  # E: incompatible type

np.complex64(1, 2)  # E: Too many arguments
# TODO: protocols (can't check for non-existent protocols w/ __getattr__)

np.datetime64(0)  # E: non-matching overload

class A:

            

Reported by Pylint.

              np.bytes_(value=b'test')  # E: No overload variant
np.void(value=b'test')  # E: Unexpected keyword argument
np.bool_(value=True)  # E: Unexpected keyword argument
np.datetime64(value="2019")  # E: No overload variant
np.timedelta64(value=0)  # E: Unexpected keyword argument

np.bytes_(b"hello", encoding='utf-8')  # E: No overload variant
np.str_("hello", encoding='utf-8')  # E: No overload variant


            

Reported by Pylint.

              np.bytes_(value=b'test')  # E: No overload variant
np.void(value=b'test')  # E: Unexpected keyword argument
np.bool_(value=True)  # E: Unexpected keyword argument
np.datetime64(value="2019")  # E: No overload variant
np.timedelta64(value=0)  # E: Unexpected keyword argument

np.bytes_(b"hello", encoding='utf-8')  # E: No overload variant
np.str_("hello", encoding='utf-8')  # E: No overload variant


            

Reported by Pylint.

              np.void(value=b'test')  # E: Unexpected keyword argument
np.bool_(value=True)  # E: Unexpected keyword argument
np.datetime64(value="2019")  # E: No overload variant
np.timedelta64(value=0)  # E: Unexpected keyword argument

np.bytes_(b"hello", encoding='utf-8')  # E: No overload variant
np.str_("hello", encoding='utf-8')  # E: No overload variant

complex(np.bytes_("1"))  # E: No overload variant

            

Reported by Pylint.

              np.void(value=b'test')  # E: Unexpected keyword argument
np.bool_(value=True)  # E: Unexpected keyword argument
np.datetime64(value="2019")  # E: No overload variant
np.timedelta64(value=0)  # E: Unexpected keyword argument

np.bytes_(b"hello", encoding='utf-8')  # E: No overload variant
np.str_("hello", encoding='utf-8')  # E: No overload variant

complex(np.bytes_("1"))  # E: No overload variant

            

Reported by Pylint.

              f2.__getnewargs__()  # E: Invalid self argument
f2.is_integer()  # E: Invalid self argument
f2.hex()  # E: Invalid self argument
np.float16.fromhex("0x0.0p+0")  # E: Invalid self argument
f2.__trunc__()  # E: Invalid self argument
f2.__getformat__("float")  # E: Invalid self argument

            

Reported by Pylint.

              import sys
import numpy as np

f2: np.float16
f8: np.float64
c8: np.complex64

# Construction


            

Reported by Pylint.

              np.complex64([])  # E: incompatible type

np.complex64(1, 2)  # E: Too many arguments
# TODO: protocols (can't check for non-existent protocols w/ __getattr__)

np.datetime64(0)  # E: non-matching overload

class A:
    def __float__(self):

            

Reported by Pylint.

              f8.squeeze(axis=(0, 1))  # E: incompatible type
f8.transpose(1)  # E: incompatible type

def func(a: np.float32) -> None: ...

func(f2)  # E: incompatible type
func(f8)  # E: incompatible type

round(c8)  # E: No overload variant

            

Reported by Pylint.

              import sys
import numpy as np

f2: np.float16
f8: np.float64
c8: np.complex64

# Construction


            

Reported by Pylint.

              import os
import pytest

import numpy as np
from numpy.testing import assert_, assert_raises, assert_equal, assert_string_equal

from . import util



            

Reported by Pylint.

              import numpy as np
from numpy.testing import assert_, assert_raises, assert_equal, assert_string_equal

from . import util


def _path(*a):
    return os.path.join(*((os.path.dirname(__file__),) + a))


            

Reported by Pylint.

                  def test_numpy_version_attribute(self):

        # Check that self.module has an attribute named "__f2py_numpy_version__"
        assert_(hasattr(self.module, "__f2py_numpy_version__"),
                msg="Fortran module does not have __f2py_numpy_version__")

        # Check that the attribute __f2py_numpy_version__ is a string
        assert_(isinstance(self.module.__f2py_numpy_version__, str),
                msg="__f2py_numpy_version__ is not a string")

            

Reported by Pylint.

                              msg="Fortran module does not have __f2py_numpy_version__")

        # Check that the attribute __f2py_numpy_version__ is a string
        assert_(isinstance(self.module.__f2py_numpy_version__, str),
                msg="__f2py_numpy_version__ is not a string")

        # Check that __f2py_numpy_version__ has the value numpy.__version__
        assert_string_equal(np.__version__, self.module.__f2py_numpy_version__)


            

Reported by Pylint.

              import os
import pytest

import numpy as np
from numpy.testing import assert_, assert_raises, assert_equal, assert_string_equal

from . import util



            

Reported by Pylint.

                  return os.path.join(*((os.path.dirname(__file__),) + a))


class TestIntentInOut(util.F2PyTest):
    # Check that intent(in out) translates as intent(inout)
    sources = [_path('src', 'regression', 'inout.f90')]

    @pytest.mark.slow
    def test_inout(self):

            

Reported by Pylint.

                  return os.path.join(*((os.path.dirname(__file__),) + a))


class TestIntentInOut(util.F2PyTest):
    # Check that intent(in out) translates as intent(inout)
    sources = [_path('src', 'regression', 'inout.f90')]

    @pytest.mark.slow
    def test_inout(self):

            

Reported by Pylint.

                  sources = [_path('src', 'regression', 'inout.f90')]

    @pytest.mark.slow
    def test_inout(self):
        # non-contiguous should raise error
        x = np.arange(6, dtype=np.float32)[::2]
        assert_raises(ValueError, self.module.foo, x)

        # check values with contiguous array

            

Reported by Pylint.

                  @pytest.mark.slow
    def test_inout(self):
        # non-contiguous should raise error
        x = np.arange(6, dtype=np.float32)[::2]
        assert_raises(ValueError, self.module.foo, x)

        # check values with contiguous array
        x = np.arange(3, dtype=np.float32)
        self.module.foo(x)

            

Reported by Pylint.

                      assert_raises(ValueError, self.module.foo, x)

        # check values with contiguous array
        x = np.arange(3, dtype=np.float32)
        self.module.foo(x)
        assert_equal(x, [3, 1, 2])


class TestNumpyVersionAttribute(util.F2PyTest):

            

Reported by Pylint.

              from typing import Any
import numpy as np

AR_i: np.ndarray[Any, np.dtype[np.int64]]
AR_f: np.ndarray[Any, np.dtype[np.float64]]
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]


            

Reported by Pylint.

              import numpy as np

AR_i: np.ndarray[Any, np.dtype[np.int64]]
AR_f: np.ndarray[Any, np.dtype[np.float64]]
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]

AR_f > AR_m  # E: Unsupported operand types

            

Reported by Pylint.

              
AR_i: np.ndarray[Any, np.dtype[np.int64]]
AR_f: np.ndarray[Any, np.dtype[np.float64]]
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]

AR_f > AR_m  # E: Unsupported operand types
AR_c > AR_m  # E: Unsupported operand types

            

Reported by Pylint.

              AR_i: np.ndarray[Any, np.dtype[np.int64]]
AR_f: np.ndarray[Any, np.dtype[np.float64]]
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]

AR_f > AR_m  # E: Unsupported operand types
AR_c > AR_m  # E: Unsupported operand types


            

Reported by Pylint.

              AR_f: np.ndarray[Any, np.dtype[np.float64]]
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]

AR_f > AR_m  # E: Unsupported operand types
AR_c > AR_m  # E: Unsupported operand types

AR_m > AR_f  # E: Unsupported operand types

            

Reported by Pylint.

              AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]

AR_f > AR_m  # E: Unsupported operand types
AR_c > AR_m  # E: Unsupported operand types

AR_m > AR_f  # E: Unsupported operand types
AR_m > AR_c  # E: Unsupported operand types


            

Reported by Pylint.

              AR_M: np.ndarray[Any, np.dtype[np.datetime64]]

AR_f > AR_m  # E: Unsupported operand types
AR_c > AR_m  # E: Unsupported operand types

AR_m > AR_f  # E: Unsupported operand types
AR_m > AR_c  # E: Unsupported operand types

AR_i > AR_M  # E: Unsupported operand types

            

Reported by Pylint.

              AR_f > AR_m  # E: Unsupported operand types
AR_c > AR_m  # E: Unsupported operand types

AR_m > AR_f  # E: Unsupported operand types
AR_m > AR_c  # E: Unsupported operand types

AR_i > AR_M  # E: Unsupported operand types
AR_f > AR_M  # E: Unsupported operand types
AR_m > AR_M  # E: Unsupported operand types

            

Reported by Pylint.

              AR_c > AR_m  # E: Unsupported operand types

AR_m > AR_f  # E: Unsupported operand types
AR_m > AR_c  # E: Unsupported operand types

AR_i > AR_M  # E: Unsupported operand types
AR_f > AR_M  # E: Unsupported operand types
AR_m > AR_M  # E: Unsupported operand types


            

Reported by Pylint.

              AR_m > AR_f  # E: Unsupported operand types
AR_m > AR_c  # E: Unsupported operand types

AR_i > AR_M  # E: Unsupported operand types
AR_f > AR_M  # E: Unsupported operand types
AR_m > AR_M  # E: Unsupported operand types

AR_M > AR_i  # E: Unsupported operand types
AR_M > AR_f  # E: Unsupported operand types

            

Reported by Pylint.

              from typing import Any
import numpy as np

AR_i8: np.ndarray[Any, np.dtype[np.int64]]
ar_iter = np.lib.Arrayterator(AR_i8)

reveal_type(ar_iter.var)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]

            

Reported by Pylint.

              AR_i8: np.ndarray[Any, np.dtype[np.int64]]
ar_iter = np.lib.Arrayterator(AR_i8)

reveal_type(ar_iter.var)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]

            

Reported by Pylint.

              ar_iter = np.lib.Arrayterator(AR_i8)

reveal_type(ar_iter.var)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]

            

Reported by Pylint.

              
reveal_type(ar_iter.var)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]


            

Reported by Pylint.

              reveal_type(ar_iter.var)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]

reveal_type(ar_iter.__array__())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              reveal_type(ar_iter.buf_size)  # E: Union[None, builtins.int]
reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]

reveal_type(ar_iter.__array__())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]


            

Reported by Pylint.

              reveal_type(ar_iter.start)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]

reveal_type(ar_iter.__array__())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

for i in ar_iter:

            

Reported by Pylint.

              reveal_type(ar_iter.stop)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.step)  # E: builtins.list[builtins.int]
reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]

reveal_type(ar_iter.__array__())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

for i in ar_iter:
    reveal_type(i)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              reveal_type(ar_iter.shape)  # E: builtins.tuple[builtins.int]
reveal_type(ar_iter.flat)  # E: typing.Generator[{int64}, None, None]

reveal_type(ar_iter.__array__())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

for i in ar_iter:
    reveal_type(i)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

reveal_type(ar_iter[0])  # E: numpy.lib.arrayterator.Arrayterator[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              reveal_type(ar_iter.__array__())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

for i in ar_iter:
    reveal_type(i)  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]

reveal_type(ar_iter[0])  # E: numpy.lib.arrayterator.Arrayterator[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter[...])  # E: numpy.lib.arrayterator.Arrayterator[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter[:])  # E: numpy.lib.arrayterator.Arrayterator[Any, numpy.dtype[{int64}]]
reveal_type(ar_iter[0, 0, 0])  # E: numpy.lib.arrayterator.Arrayterator[Any, numpy.dtype[{int64}]]

            

Reported by Pylint.

              import numpy as np

reveal_type(np.uint128())
reveal_type(np.uint256())

reveal_type(np.int128())
reveal_type(np.int256())

reveal_type(np.float80())

            

Reported by Pylint.

              import numpy as np

reveal_type(np.uint128())
reveal_type(np.uint256())

reveal_type(np.int128())
reveal_type(np.int256())

reveal_type(np.float80())

            

Reported by Pylint.

              reveal_type(np.uint128())
reveal_type(np.uint256())

reveal_type(np.int128())
reveal_type(np.int256())

reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())

            

Reported by Pylint.

              reveal_type(np.uint256())

reveal_type(np.int128())
reveal_type(np.int256())

reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())
reveal_type(np.float256())

            

Reported by Pylint.

              reveal_type(np.int128())
reveal_type(np.int256())

reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())
reveal_type(np.float256())

reveal_type(np.complex160())

            

Reported by Pylint.

              reveal_type(np.int256())

reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())
reveal_type(np.float256())

reveal_type(np.complex160())
reveal_type(np.complex192())

            

Reported by Pylint.

              reveal_type(np.int256())

reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())
reveal_type(np.float256())

reveal_type(np.complex160())
reveal_type(np.complex192())

            

Reported by Pylint.

              
reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())
reveal_type(np.float256())

reveal_type(np.complex160())
reveal_type(np.complex192())
reveal_type(np.complex256())

            

Reported by Pylint.

              reveal_type(np.float80())
reveal_type(np.float96())
reveal_type(np.float128())
reveal_type(np.float256())

reveal_type(np.complex160())
reveal_type(np.complex192())
reveal_type(np.complex256())
reveal_type(np.complex512())

            

Reported by Pylint.

              reveal_type(np.float128())
reveal_type(np.float256())

reveal_type(np.complex160())
reveal_type(np.complex192())
reveal_type(np.complex256())
reveal_type(np.complex512())

            

Reported by Pylint.