def _multiprocessing_transform():
module = astroid.parse('''
from multiprocessing.managers import SyncManager
def Manager():
return SyncManager()
''')
if not PY34:
return module
# On Python 3.4, multiprocessing uses a getattr lookup inside contexts,
# in order to get the attributes they need. Since it's extremely
# dynamic, we use this approach to fake it.
node = astroid.parse('''
from multiprocessing.context import DefaultContext, BaseContext
default = DefaultContext()
base = BaseContext()
''')
try:
context = next(node['default'].infer())
base = next(node['base'].infer())
except exceptions.InferenceError:
return module
for node in (context, base):
for key, value in node.locals.items():
if key.startswith("_"):
continue
value = value[0]
if isinstance(value, astroid.FunctionDef):
# We need to rebound this, since otherwise
# it will have an extra argument (self).
value = astroid.BoundMethod(value, node)
module[key] = value
return module
def test_absolute_import(self):
module_import = astroid.parse(
'from __future__ import absolute_import; import os')
module_from = astroid.parse(
'from __future__ import absolute_import; from os import path')
with self.assertNoMessages():
for module in (module_import, module_from):
self.walk(module)
def test_raise_python_2(self):
first = 'raise'
self.assertEqual(parse(first).as_string().strip(), first)
second = 'raise 1, 2'
self.assertEqual(parse(second).as_string().strip(), second)
third = 'raise 1, 2, 3'
self.assertEqual(parse(third).as_string().strip(), third)
def test_modules_as_string(self):
for name in (os.path.join(p, n) for p, _, ns in os.walk('astroid/') for n in ns if n.endswith('.py')):
with open(name, 'r') as source_file:
ast = parse(source_file.read())
# if ast != parse(ast.as_string()):
# print(name)
# print(ast == ast)
# ast.print_tree()
# parse(ast.as_string()).print_tree()
self.assertEqual(ast, parse(ast.as_string()))
def _hashlib_transform():
template = '''
class %(name)s(object):
def __init__(self, value=''): pass
def digest(self):
return %(digest)s
def copy(self):
return self
def update(self, value): pass
def hexdigest(self):
return ''
@property
def name(self):
return %(name)r
@property
def block_size(self):
return 1
@property
def digest_size(self):
return 1
'''
algorithms = ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
classes = "".join(
template % {'name': hashfunc, 'digest': 'b""' if six.PY3 else '""'}
for hashfunc in algorithms)
return astroid.parse(classes)
def _collections_transform():
return astroid.parse('''
class defaultdict(dict):
default_factory = None
def __missing__(self, key): pass
class deque(object):
maxlen = 0
def __init__(self, iterable=None, maxlen=None):
self.iterable = iterable
def append(self, x): pass
def appendleft(self, x): pass
def clear(self): pass
def count(self, x): return 0
def extend(self, iterable): pass
def extendleft(self, iterable): pass
def pop(self): pass
def popleft(self): pass
def remove(self, value): pass
def reverse(self): pass
def rotate(self, n): pass
def __iter__(self): return self
def __reversed__(self): return self.iterable[::-1]
def __getitem__(self, index): pass
def __setitem__(self, index, value): pass
def __delitem__(self, index): pass
''')
def test_deprecated_methods(self):
class Checker(object):
def __init__(self):
self.called = False
@check_messages('first-message')
def visit_assname(self, node):
self.called = True
linter = self.MockLinter({'first-message': True})
walker = utils.PyLintASTWalker(linter)
checker = Checker()
walker.add_checker(checker)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
walker.walk(astroid.parse("x = 1"))
if __pkginfo__.numversion < (2, 0):
expected = ('Implemented method visit_assname instead of '
'visit_assignname. This will be supported until '
'Pylint 2.0.')
self.assertEqual(len(w), 1)
self.assertIsInstance(w[0].message, PendingDeprecationWarning)
self.assertEqual(str(w[0].message), expected)
self.assertTrue(checker.called)
else:
self.assertNotEqual(len(w), 1)
self.assertFalse(checker.called)
def test_dict_methods_in_iterating_context(self):
iterating_code = [
'for x in {}: pass',
'(x for x in {})',
'[x for x in {}]',
'func({})',
'a, b = {}'
]
non_iterating_code = [
'x = __({}())',
'__({}())[0]'
]
for method in ('keys', 'items', 'values'):
dict_method = '{{}}.{}'.format(method)
for code in iterating_code:
with_value = code.format(dict_method)
module = astroid.parse(with_value)
with self.assertNoMessages():
self.walk(module)
for code in non_iterating_code:
with_value = code.format(dict_method)
node = astroid.extract_node(with_value)
checker = 'dict-{}-not-iterating'.format(method)
message = testutils.Message(checker, node=node)
with self.assertAddsMessages(message):
self.checker.visit_call(node)
def test_ignored_argument_names_starred_args(self):
node = astroid.parse('''
def fooby(*args, **kwargs):
pass
''')
with self.assertNoMessages():
self.walk(node)
def test_module_level_names(self):
assign = astroid.extract_node("""
import collections
Class = collections.namedtuple("a", ("b", "c")) #@
""")
with self.assertNoMessages():
self.checker.visit_assignname(assign.targets[0])
assign = astroid.extract_node("""
class ClassA(object):
pass
ClassB = ClassA
""")
with self.assertNoMessages():
self.checker.visit_assignname(assign.targets[0])
module = astroid.parse("""
def A():
return 1, 2, 3
CONSTA, CONSTB, CONSTC = A()
CONSTD = A()""")
with self.assertNoMessages():
self.checker.visit_assignname(module.body[1].targets[0].elts[0])
self.checker.visit_assignname(module.body[2].targets[0])
assign = astroid.extract_node("""
CONST = "12 34 ".rstrip().split()""")
with self.assertNoMessages():
self.checker.visit_assignname(assign.targets[0])
def test_func_signature_issue_185(self):
code = textwrap.dedent('''
def test(a, b, c=42, *, x=42, **kwargs):
print(a, b, c, args)
''')
node = parse(code)
self.assertEqual(node.as_string().strip(), code.strip())
def test_redefined_builtin_modname_not_ignored(self):
node = astroid.parse('''
from future.builtins import open
''')
with self.assertAddsMessages(
Message('redefined-builtin', node=node.body[0], args='open')):
self.checker.visit_module(node)
def test_invalid_metaclass(self):
module = astroid.parse('''
import six
class InvalidAsMetaclass(object):
pass
@six.add_metaclass(int)
class FirstInvalid(object):
pass
@six.add_metaclass(InvalidAsMetaclass)
class SecondInvalid(object):
pass
@six.add_metaclass(2)
class ThirdInvalid(object):
pass
''')
for class_obj, metaclass_name in (('ThirdInvalid', '2'),
('SecondInvalid', 'InvalidAsMetaclass'),
('FirstInvalid', 'int')):
classdef = module[class_obj]
message = Message('invalid-metaclass', node=classdef, args=(metaclass_name, ))
with self.assertAddsMessages(message):
self.checker.visit_classdef(classdef)
def test_invalid_metaclass(self):
module = astroid.parse(
"""
import six
class InvalidAsMetaclass(object):
pass
@six.add_metaclass(int)
class FirstInvalid(object):
pass
@six.add_metaclass(InvalidAsMetaclass)
class SecondInvalid(object):
pass
@six.add_metaclass(2)
class ThirdInvalid(object):
pass
"""
)
for class_obj, metaclass_name in (
("ThirdInvalid", "2"),
("SecondInvalid", "InvalidAsMetaclass"),
("FirstInvalid", "int"),
):
classdef = module[class_obj]
message = Message(
"invalid-metaclass", node=classdef, args=(metaclass_name,)
)
with self.assertAddsMessages(message):
self.checker.visit_classdef(classdef)
def test_priority_to_local_defined_values(self):
ast_node = astroid.parse('''
__file__ = "mine"
''')
file_value = next(ast_node.igetattr('__file__'))
self.assertIsInstance(file_value, astroid.Const)
self.assertEqual(file_value.value, "mine")
def numpy_core_numerictypes_transform():
return astroid.parse('''
# different types defined in numerictypes.py
uint16 = type('uint16')
uint32 = type('uint32')
uint64 = type('uint64')
int128 = type('int128')
uint128 = type('uint128')
float16 = type('float16')
float32 = type('float32')
float64 = type('float64')
float80 = type('float80')
float96 = type('float96')
float128 = type('float128')
float256 = type('float256')
complex32 = type('complex32')
complex64 = type('complex64')
complex128 = type('complex128')
complex160 = type('complex160')
complex192 = type('complex192')
complex256 = type('complex256')
complex512 = type('complex512')
timedelta64 = type('timedelta64')
datetime64 = type('datetime64')
unicode_ = type('unicode_')
string_ = type('string_')
object_ = type('object_')
''')
def test_check_messages(self):
linter = self.MockLinter({"first-message": True, "second-message": False, "third-message": True})
walker = utils.PyLintASTWalker(linter)
checker = self.Checker()
walker.add_checker(checker)
walker.walk(astroid.parse("x = func()"))
self.assertEqual(set(["module", "assname"]), checker.called)
def test_typing_namedtuple_unsubscriptable_object_issue1295(self):
module = astroid.parse("""
import typing
MyType = typing.Tuple[str, str]
""")
subscript = module.body[-1].value
with self.assertNoMessages():
self.checker.visit_subscript(subscript)
def numpy_funcs():
return astroid.parse(
"""
import builtins
def sum(a, axis=None, dtype=None, out=None, keepdims=None):
return builtins.sum(a)
"""
)
def testFuturePrintStatementWithoutParensWarning(self):
code = """from __future__ import print_function
print('Hello world!')
"""
tree = astroid.parse(code)
with self.assertNoMessages():
self.checker.process_module(tree)
self.checker.process_tokens(tokenize_str(code))
def _collections_transform():
return astroid.parse('''
class defaultdict(dict):
default_factory = None
def __missing__(self, key): pass
def __getitem__(self, key): return default_factory
''' + _deque_mock() + _ordered_dict_mock())
def test_dont_crash_on_invalid_format_string(self):
node = astroid.parse(
"""
import logging
logging.error('0} - {1}'.format(1, 2))
"""
)
self.walk(node)
def test_redefined_builtin_custom_modules(self):
node = astroid.parse(
"""
from os import open
"""
)
with self.assertNoMessages():
self.checker.visit_module(node)
def test_import_as_underscore(self):
node = astroid.parse(
"""
import math as _
"""
)
with self.assertNoMessages():
self.walk(node)
def test_redefined_builtin_ignored(self):
node = astroid.parse(
"""
from future.builtins import open
"""
)
with self.assertNoMessages():
self.checker.visit_module(node)
def pkg_resources_transform():
return parse(
"""
def require(*requirements):
return pkg_resources.working_set.require(*requirements)
def run_script(requires, script_name):
return pkg_resources.working_set.run_script(requires, script_name)
def iter_entry_points(group, name=None):
return pkg_resources.working_set.iter_entry_points(group, name)
def resource_exists(package_or_requirement, resource_name):
return get_provider(package_or_requirement).has_resource(resource_name)
def resource_isdir(package_or_requirement, resource_name):
return get_provider(package_or_requirement).resource_isdir(
resource_name)
def resource_filename(package_or_requirement, resource_name):
return get_provider(package_or_requirement).get_resource_filename(
self, resource_name)
def resource_stream(package_or_requirement, resource_name):
return get_provider(package_or_requirement).get_resource_stream(
self, resource_name)
def resource_string(package_or_requirement, resource_name):
return get_provider(package_or_requirement).get_resource_string(
self, resource_name)
def resource_listdir(package_or_requirement, resource_name):
return get_provider(package_or_requirement).resource_listdir(
resource_name)
def extraction_error():
pass
def get_cache_path(archive_name, names=()):
extract_path = self.extraction_path or get_default_cache()
target_path = os.path.join(extract_path, archive_name+'-tmp', *names)
return target_path
def postprocess(tempname, filename):
pass
def set_extraction_path(path):
pass
def cleanup_resources(force=False):
pass
def get_distribution(dist):
return Distribution(dist)
_namespace_packages = {}
"""
)
def test_checker_disabled_by_default(self):
node = astroid.parse(textwrap.dedent("""
abc = 1l
raise Exception, "test"
raise "test"
`abc`
"""))
with self.assertNoMessages():
self.walk(node)
def test_check_messages(self):
linter = self.MockLinter({'first-message': True,
'second-message': False,
'third-message': True})
walker = utils.PyLintASTWalker(linter)
checker = self.Checker()
walker.add_checker(checker)
walker.walk(astroid.parse("x = func()"))
assert {'module', 'assignname'} == checker.called
def test_check_messages(self):
linter = self.MockLinter(
{"first-message": True, "second-message": False, "third-message": True}
)
walker = ASTWalker(linter)
checker = self.Checker()
walker.add_checker(checker)
walker.walk(astroid.parse("x = func()"))
assert {"module", "assignname"} == checker.called
def test_ignored_argument_names_no_message(self):
"""Make sure is_ignored_argument_names properly ignores
function arguments"""
node = astroid.parse('''
def fooby(arg):
pass
''')
with self.assertNoMessages():
self.walk(node)
def test_redefined_builtin_ignored(self):
node = astroid.parse("""
from future.builtins import open
""")
with self.assertNoMessages():
self.checker.visit_module(node)
def numpy_core_fromnumeric_transform():
return astroid.parse("""
def sum(a, axis=None, dtype=None, out=None, keepdims=None, initial=None):
return numpy.ndarray([0, 0])
""")
def _create_file_backed_module(code):
"""Create an astroid module for the given code, backed by a real file."""
with _create_tempfile() as temp:
module = astroid.parse(code)
module.file = temp
yield module
def test_missing_docstring_module(self):
module = astroid.parse("something")
message = Message("missing-module-docstring", node=module)
with self.assertAddsMessages(message):
self.checker.visit_module(module)
def as_iterable_in_genexp_test(self, fxn):
code = "x = (x for x in {}())".format(fxn)
module = astroid.parse(code)
with self.assertNoMessages():
self.walk(module)
def pairs(self, filepath: Path):
"""
Parses Python source code into AST using Astroid
http://pylint.pycqa.org/projects/astroid/en/latest/api/astroid.nodes.html#id1
Returns key-value pairs
"""
def is_key(node):
types = [
astroid.node_classes.Name, astroid.node_classes.AssignName
]
return type(node) in types
def is_value(node):
types = [astroid.node_classes.Const]
return type(node) in types
def _traverse(tree):
for node in tree.get_children():
yield from _traverse(node)
# Assignment
if isinstance(node, astroid.node_classes.Assign):
if not is_value(node.value):
continue
value = node.value.value
for key in node.targets:
if is_key(key):
yield key.name, value
# Comparison
elif isinstance(node, astroid.node_classes.Compare):
left = node.left
right = node.ops[0][1]
if is_key(left) and is_value(right):
key = left.name
value = right.value
elif is_key(right) and is_value(left):
key = right.name
value = left.value
else:
continue
yield key, value
# Dictionary values
elif isinstance(node, astroid.node_classes.Dict):
for key, value in node.items:
if not is_value(key) or not is_value(value):
continue
yield key.value, value.value
# Keywords
elif isinstance(node, astroid.node_classes.Keyword):
if is_value(node.value):
yield node.arg, node.value.value
# Function call
elif isinstance(node, astroid.node_classes.Call):
key = "function"
value = node.as_string() # Entire function call
yield key, value
try:
tree = astroid.parse(filepath.read_text())
yield from _traverse(tree)
except Exception as e:
debug(f"{type(e)} in {filepath}")
def numpy_funcs():
return astroid.parse("""
import builtins
def sum(a, axis=None, dtype=None, out=None, keepdims=None):
return builtins.sum(a)
""")
def as_argument_to_str_join_test(self, fxn):
code = "x = ''.join({}())".format(fxn)
module = astroid.parse(code)
with self.assertNoMessages():
self.walk(module)
def numpy_core_umath_transform():
ufunc_optional_keyword_arguments = (
"""out=None, where=True, casting='same_kind', order='K', """
"""dtype=None, subok=True""")
return astroid.parse("""
# Constants
e = 2.718281828459045
euler_gamma = 0.5772156649015329
# No arg functions
def geterrobj(): pass
# One arg functions
def seterrobj(errobj): pass
# One arg functions with optional kwargs
def arccos(x, {opt_args:s}): pass
def arccosh(x, {opt_args:s}): pass
def arcsin(x, {opt_args:s}): pass
def arcsinh(x, {opt_args:s}): pass
def arctan(x, {opt_args:s}): pass
def arctanh(x, {opt_args:s}): pass
def cbrt(x, {opt_args:s}): pass
def conj(x, {opt_args:s}): pass
def conjugate(x, {opt_args:s}): pass
def cosh(x, {opt_args:s}): pass
def deg2rad(x, {opt_args:s}): pass
def degrees(x, {opt_args:s}): pass
def exp2(x, {opt_args:s}): pass
def expm1(x, {opt_args:s}): pass
def fabs(x, {opt_args:s}): pass
def frexp(x, {opt_args:s}): pass
def isfinite(x, {opt_args:s}): pass
def isinf(x, {opt_args:s}): pass
def log(x, {opt_args:s}): pass
def log1p(x, {opt_args:s}): pass
def log2(x, {opt_args:s}): pass
def logical_not(x, {opt_args:s}): pass
def modf(x, {opt_args:s}): pass
def negative(x, {opt_args:s}): pass
def rad2deg(x, {opt_args:s}): pass
def radians(x, {opt_args:s}): pass
def reciprocal(x, {opt_args:s}): pass
def rint(x, {opt_args:s}): pass
def sign(x, {opt_args:s}): pass
def signbit(x, {opt_args:s}): pass
def sinh(x, {opt_args:s}): pass
def spacing(x, {opt_args:s}): pass
def square(x, {opt_args:s}): pass
def tan(x, {opt_args:s}): pass
def tanh(x, {opt_args:s}): pass
def trunc(x, {opt_args:s}): pass
# Two args functions with optional kwargs
def bitwise_and(x1, x2, {opt_args:s}): pass
def bitwise_or(x1, x2, {opt_args:s}): pass
def bitwise_xor(x1, x2, {opt_args:s}): pass
def copysign(x1, x2, {opt_args:s}): pass
def divide(x1, x2, {opt_args:s}): pass
def equal(x1, x2, {opt_args:s}): pass
def float_power(x1, x2, {opt_args:s}): pass
def floor_divide(x1, x2, {opt_args:s}): pass
def fmax(x1, x2, {opt_args:s}): pass
def fmin(x1, x2, {opt_args:s}): pass
def fmod(x1, x2, {opt_args:s}): pass
def greater(x1, x2, {opt_args:s}): pass
def hypot(x1, x2, {opt_args:s}): pass
def ldexp(x1, x2, {opt_args:s}): pass
def left_shift(x1, x2, {opt_args:s}): pass
def less(x1, x2, {opt_args:s}): pass
def logaddexp(x1, x2, {opt_args:s}): pass
def logaddexp2(x1, x2, {opt_args:s}): pass
def logical_and(x1, x2, {opt_args:s}): pass
def logical_or(x1, x2, {opt_args:s}): pass
def logical_xor(x1, x2, {opt_args:s}): pass
def maximum(x1, x2, {opt_args:s}): pass
def minimum(x1, x2, {opt_args:s}): pass
def nextafter(x1, x2, {opt_args:s}): pass
def not_equal(x1, x2, {opt_args:s}): pass
def power(x1, x2, {opt_args:s}): pass
def remainder(x1, x2, {opt_args:s}): pass
def right_shift(x1, x2, {opt_args:s}): pass
def subtract(x1, x2, {opt_args:s}): pass
def true_divide(x1, x2, {opt_args:s}): pass
""".format(opt_args=ufunc_optional_keyword_arguments))
def _subprocess_transform():
communicate = (bytes("string", "ascii"), bytes("string", "ascii"))
communicate_signature = "def communicate(self, input=None, timeout=None)"
if PY37:
init = """
def __init__(self, args, bufsize=0, executable=None,
stdin=None, stdout=None, stderr=None,
preexec_fn=None, close_fds=False, shell=False,
cwd=None, env=None, universal_newlines=False,
startupinfo=None, creationflags=0, restore_signals=True,
start_new_session=False, pass_fds=(), *,
encoding=None, errors=None, text=None):
pass
"""
elif PY36:
init = """
def __init__(self, args, bufsize=0, executable=None,
stdin=None, stdout=None, stderr=None,
preexec_fn=None, close_fds=False, shell=False,
cwd=None, env=None, universal_newlines=False,
startupinfo=None, creationflags=0, restore_signals=True,
start_new_session=False, pass_fds=(), *,
encoding=None, errors=None):
pass
"""
else:
init = """
def __init__(self, args, bufsize=0, executable=None,
stdin=None, stdout=None, stderr=None,
preexec_fn=None, close_fds=False, shell=False,
cwd=None, env=None, universal_newlines=False,
startupinfo=None, creationflags=0, restore_signals=True,
start_new_session=False, pass_fds=()):
pass
"""
wait_signature = "def wait(self, timeout=None)"
ctx_manager = """
def __enter__(self): return self
def __exit__(self, *args): pass
"""
py3_args = "args = []"
if PY37:
check_output_signature = """
check_output(
args, *,
stdin=None,
stderr=None,
shell=False,
cwd=None,
encoding=None,
errors=None,
universal_newlines=False,
timeout=None,
env=None,
text=None,
restore_signals=True,
preexec_fn=None,
pass_fds=(),
input=None,
bufsize=0,
executable=None,
close_fds=False,
startupinfo=None,
creationflags=0,
start_new_session=False
):
""".strip()
else:
check_output_signature = """
check_output(
args, *,
stdin=None,
stderr=None,
shell=False,
cwd=None,
encoding=None,
errors=None,
universal_newlines=False,
timeout=None,
env=None,
restore_signals=True,
preexec_fn=None,
pass_fds=(),
input=None,
bufsize=0,
executable=None,
close_fds=False,
startupinfo=None,
creationflags=0,
start_new_session=False
):
""".strip()
code = textwrap.dedent(
"""
def %(check_output_signature)s
if universal_newlines:
return ""
return b""
class Popen(object):
returncode = pid = 0
stdin = stdout = stderr = file()
%(py3_args)s
%(communicate_signature)s:
return %(communicate)r
%(wait_signature)s:
return self.returncode
def poll(self):
return self.returncode
def send_signal(self, signal):
pass
def terminate(self):
pass
def kill(self):
pass
%(ctx_manager)s
""" % {
"check_output_signature": check_output_signature,
"communicate": communicate,
"communicate_signature": communicate_signature,
"wait_signature": wait_signature,
"ctx_manager": ctx_manager,
"py3_args": py3_args,
})
if PY39:
code += """
@classmethod
def __class_getitem__(cls, item):
pass
"""
init_lines = textwrap.dedent(init).splitlines()
indented_init = "\n".join(" " * 4 + line for line in init_lines)
code += indented_init
return astroid.parse(code)
def as_argument_to_callable_constructor_test(self, fxn, callable_fn):
module = astroid.parse("x = {}({}())".format(callable_fn, fxn))
with self.assertNoMessages():
self.walk(module)
def test_get_returns_inference(text, expected):
tree = astroid.parse(text)
print(tree.repr_tree())
returns = tuple(r.value for r in get_returns(body=tree.body))
assert returns == expected
def scipy_signal():
return astroid.parse("""
# different functions defined in scipy.signals
def barthann(M, sym=True):
return numpy.ndarray([0])
def bartlett(M, sym=True):
return numpy.ndarray([0])
def blackman(M, sym=True):
return numpy.ndarray([0])
def blackmanharris(M, sym=True):
return numpy.ndarray([0])
def bohman(M, sym=True):
return numpy.ndarray([0])
def boxcar(M, sym=True):
return numpy.ndarray([0])
def chebwin(M, at, sym=True):
return numpy.ndarray([0])
def cosine(M, sym=True):
return numpy.ndarray([0])
def exponential(M, center=None, tau=1.0, sym=True):
return numpy.ndarray([0])
def flattop(M, sym=True):
return numpy.ndarray([0])
def gaussian(M, std, sym=True):
return numpy.ndarray([0])
def general_gaussian(M, p, sig, sym=True):
return numpy.ndarray([0])
def hamming(M, sym=True):
return numpy.ndarray([0])
def hann(M, sym=True):
return numpy.ndarray([0])
def hanning(M, sym=True):
return numpy.ndarray([0])
def impulse2(system, X0=None, T=None, N=None, **kwargs):
return numpy.ndarray([0]), numpy.ndarray([0])
def kaiser(M, beta, sym=True):
return numpy.ndarray([0])
def nuttall(M, sym=True):
return numpy.ndarray([0])
def parzen(M, sym=True):
return numpy.ndarray([0])
def slepian(M, width, sym=True):
return numpy.ndarray([0])
def step2(system, X0=None, T=None, N=None, **kwargs):
return numpy.ndarray([0]), numpy.ndarray([0])
def triang(M, sym=True):
return numpy.ndarray([0])
def tukey(M, alpha=0.5, sym=True):
return numpy.ndarray([0])
""")
def test_division_with_future_statement(self):
module = astroid.parse('from __future__ import division; 3 / 2')
with self.assertNoMessages():
self.walk(module)
def test_dont_crash_on_invalid_format_string(self):
node = astroid.parse('''
import logging
logging.error('0} - {1}'.format(1, 2))
''')
self.walk(node)
def as_argument_to_materialized_filter(self, callable_fn):
module = astroid.parse("list(filter(None, {}()))".format(callable_fn))
with self.assertNoMessages():
self.walk(module)
def numpy_core_numerictypes_transform():
return astroid.parse('''
# different types defined in numerictypes.py
# np_type_common aggregates all public methods
# that are common between numpy.uint* and numpy.float*
class np_type_common(int):
def all(self): pass
def any(self): pass
def argmax(self): pass
def argmin(self): pass
def argsort(self): pass
def astype(self): pass
def base(self): pass
def byteswap(self): pass
def choose(self): pass
def clip(self): pass
def compress(self): pass
def conj(self): pass
def conjugate(self): pass
def copy(self): pass
def cumprod(self): pass
def cumsum(self): pass
def data(self): pass
def diagonal(self): pass
def dtype(self): pass
def dump(self): pass
def dumps(self): pass
def fill(self): pass
def flags(self): pass
def flat(self): pass
def flatten(self): pass
def getfield(self): pass
def imag(self): pass
def item(self): pass
def itemset(self): pass
def itemsize(self): pass
def max(self): pass
def mean(self): pass
def min(self): pass
def nbytes(self): pass
def ndim(self): pass
def newbyteorder(self): pass
def nonzero(self): pass
def prod(self): pass
def ptp(self): pass
def put(self): pass
def ravel(self): pass
def real(self): pass
def repeat(self): pass
def reshape(self): pass
def resize(self): pass
def round(self): pass
def searchsorted(self): pass
def setfield(self): pass
def setflags(self): pass
def shape(self): pass
def size(self): pass
def sort(self): pass
def squeeze(self): pass
def std(self): pass
def strides(self): pass
def sum(self): pass
def swapaxes(self): pass
def take(self): pass
def tobytes(self): pass
def tofile(self): pass
def tolist(self): pass
def tostring(self): pass
def trace(self): pass
def transpose(self): pass
def var(self): pass
def view(self): pass
# uint_common contains all the public methods present
# inside numpy.uint*
class uint_common(np_type_common):
def denominator(self): pass
def numerator(self): pass
# float_common contains all the public methods present
# inside numpy.float*
class float_common(np_type_common):
def as_integer_ratio(self): pass
def fromhex(self, val): pass
def hex(self): pass
def is_integer(self): pass
class uint16(uint_common): pass
class uint32(uint_common): pass
class uint64(uint_common): pass
class uint128(uint_common): pass
class float16(float_common): pass
class float32(float_common): pass
class float64(float_common): pass
class float80(float_common): pass
class float96(float_common): pass
class float128(float_common): pass
class float256(float_common): pass
class complex32(np_type_common): pass
class complex64(np_type_common): pass
class complex128(np_type_common): pass
class complex160(np_type_common): pass
class complex192(np_type_common): pass
class complex256(np_type_common): pass
class complex512(np_type_common): pass
class int128(uint_common):
def bit_length(self): pass
class timedelta64(uint_common): pass
class datetime64(np_type_common): pass
class string_(np_type_common):
def capitalize(self): pass
def center(self, width, fillchar=' '): pass
def count(self, sub, start=None, end=None): pass
def decode(self, encoding='default', errors='strict'): pass
def encode(self, encoding='default', errors='strict'): pass
def endswith(self, suffix, start=None, end=None): pass
def expandtabs(self, tabsize=8): pass
def find(self, sub, start=None, end=None): pass
def format(self, *args, **kwargs): pass
def index(self, sub, start=None, end=None): pass
def isalnum(self): pass
def isalpha(self): pass
def isdigit(self): pass
def islower(self): pass
def isspace(self): pass
def istitle(self): pass
def isupper(self): pass
def join(self, iterable): pass
def ljust(self, width, fillchar=' '): pass
def lower(self): pass
def lstrip(self, chars=None): pass
def partition(self, sep): pass
def replace(self, old, new, count=None): pass
def rfind(self, sub, start=None, end=None): pass
def rindex(self, sub, start=None, end=None): pass
def rjust(self, width, fillchar=' '): pass
def rpartition(self, sep): pass
def rsplit(self, sep=None, maxsplit=None): pass
def rstrip(self, chars=None): pass
def split(self, sep=None, maxsplit=None): pass
def splitlines(self, keepends=False): pass
def startswith(self, prefix, start=None, end=None): pass
def strip(self, chars=None): pass
def swapcase(self): pass
def title(self): pass
def translate(self, table, deletechars=None): pass
def upper(self): pass
def zfill(self, width): pass
class unicode_(string_):
def isdecimal(self): pass
def isnumeric(self): pass
object_ = type('object_')
''')
def _curses_transform():
return astroid.parse("""
A_ALTCHARSET = 1
A_BLINK = 1
A_BOLD = 1
A_DIM = 1
A_INVIS = 1
A_ITALIC = 1
A_NORMAL = 1
A_PROTECT = 1
A_REVERSE = 1
A_STANDOUT = 1
A_UNDERLINE = 1
A_HORIZONTAL = 1
A_LEFT = 1
A_LOW = 1
A_RIGHT = 1
A_TOP = 1
A_VERTICAL = 1
A_CHARTEXT = 1
A_ATTRIBUTES = 1
A_CHARTEXT = 1
A_COLOR = 1
KEY_MIN = 1
KEY_BREAK = 1
KEY_DOWN = 1
KEY_UP = 1
KEY_LEFT = 1
KEY_RIGHT = 1
KEY_HOME = 1
KEY_BACKSPACE = 1
KEY_F0 = 1
KEY_Fn = 1
KEY_DL = 1
KEY_IL = 1
KEY_DC = 1
KEY_IC = 1
KEY_EIC = 1
KEY_CLEAR = 1
KEY_EOS = 1
KEY_EOL = 1
KEY_SF = 1
KEY_SR = 1
KEY_NPAGE = 1
KEY_PPAGE = 1
KEY_STAB = 1
KEY_CTAB = 1
KEY_CATAB = 1
KEY_ENTER = 1
KEY_SRESET = 1
KEY_RESET = 1
KEY_PRINT = 1
KEY_LL = 1
KEY_A1 = 1
KEY_A3 = 1
KEY_B2 = 1
KEY_C1 = 1
KEY_C3 = 1
KEY_BTAB = 1
KEY_BEG = 1
KEY_CANCEL = 1
KEY_CLOSE = 1
KEY_COMMAND = 1
KEY_COPY = 1
KEY_CREATE = 1
KEY_END = 1
KEY_EXIT = 1
KEY_FIND = 1
KEY_HELP = 1
KEY_MARK = 1
KEY_MESSAGE = 1
KEY_MOVE = 1
KEY_NEXT = 1
KEY_OPEN = 1
KEY_OPTIONS = 1
KEY_PREVIOUS = 1
KEY_REDO = 1
KEY_REFERENCE = 1
KEY_REFRESH = 1
KEY_REPLACE = 1
KEY_RESTART = 1
KEY_RESUME = 1
KEY_SAVE = 1
KEY_SBEG = 1
KEY_SCANCEL = 1
KEY_SCOMMAND = 1
KEY_SCOPY = 1
KEY_SCREATE = 1
KEY_SDC = 1
KEY_SDL = 1
KEY_SELECT = 1
KEY_SEND = 1
KEY_SEOL = 1
KEY_SEXIT = 1
KEY_SFIND = 1
KEY_SHELP = 1
KEY_SHOME = 1
KEY_SIC = 1
KEY_SLEFT = 1
KEY_SMESSAGE = 1
KEY_SMOVE = 1
KEY_SNEXT = 1
KEY_SOPTIONS = 1
KEY_SPREVIOUS = 1
KEY_SPRINT = 1
KEY_SREDO = 1
KEY_SREPLACE = 1
KEY_SRIGHT = 1
KEY_SRSUME = 1
KEY_SSAVE = 1
KEY_SSUSPEND = 1
KEY_SUNDO = 1
KEY_SUSPEND = 1
KEY_UNDO = 1
KEY_MOUSE = 1
KEY_RESIZE = 1
KEY_MAX = 1
ACS_BBSS = 1
ACS_BLOCK = 1
ACS_BOARD = 1
ACS_BSBS = 1
ACS_BSSB = 1
ACS_BSSS = 1
ACS_BTEE = 1
ACS_BULLET = 1
ACS_CKBOARD = 1
ACS_DARROW = 1
ACS_DEGREE = 1
ACS_DIAMOND = 1
ACS_GEQUAL = 1
ACS_HLINE = 1
ACS_LANTERN = 1
ACS_LARROW = 1
ACS_LEQUAL = 1
ACS_LLCORNER = 1
ACS_LRCORNER = 1
ACS_LTEE = 1
ACS_NEQUAL = 1
ACS_PI = 1
ACS_PLMINUS = 1
ACS_PLUS = 1
ACS_RARROW = 1
ACS_RTEE = 1
ACS_S1 = 1
ACS_S3 = 1
ACS_S7 = 1
ACS_S9 = 1
ACS_SBBS = 1
ACS_SBSB = 1
ACS_SBSS = 1
ACS_SSBB = 1
ACS_SSBS = 1
ACS_SSSB = 1
ACS_SSSS = 1
ACS_STERLING = 1
ACS_TTEE = 1
ACS_UARROW = 1
ACS_ULCORNER = 1
ACS_URCORNER = 1
ACS_VLINE = 1
COLOR_BLACK = 1
COLOR_BLUE = 1
COLOR_CYAN = 1
COLOR_GREEN = 1
COLOR_MAGENTA = 1
COLOR_RED = 1
COLOR_WHITE = 1
COLOR_YELLOW = 1
""")
def test_redefined_builtin_custom_modules(self):
node = astroid.parse("""
from os import open
""")
with self.assertNoMessages():
self.checker.visit_module(node)
def test_import_as_underscore(self):
node = astroid.parse("""
import math as _
""")
with self.assertNoMessages():
self.walk(node)
def as_iterable_in_starred_context(self, fxn):
code = "x = test(*{}())".format(fxn)
module = astroid.parse(code)
with self.assertNoMessages():
self.walk(module)
def numpy_core_numerictypes_transform():
return astroid.parse("""
# different types defined in numerictypes.py
class generic(object):
def __init__(self, value):
self.T = None
self.base = None
self.data = None
self.dtype = None
self.flags = None
self.flat = None
self.imag = None
self.itemsize = None
self.nbytes = None
self.ndim = None
self.real = None
self.size = None
self.strides = None
def all(self): pass
def any(self): pass
def argmax(self): pass
def argmin(self): pass
def argsort(self): pass
def astype(self): pass
def base(self): pass
def byteswap(self): pass
def choose(self): pass
def clip(self): pass
def compress(self): pass
def conj(self): pass
def conjugate(self): pass
def copy(self): pass
def cumprod(self): pass
def cumsum(self): pass
def data(self): pass
def diagonal(self): pass
def dtype(self): pass
def dump(self): pass
def dumps(self): pass
def fill(self): pass
def flags(self): pass
def flat(self): pass
def flatten(self): pass
def getfield(self): pass
def imag(self): pass
def item(self): pass
def itemset(self): pass
def itemsize(self): pass
def max(self): pass
def mean(self): pass
def min(self): pass
def nbytes(self): pass
def ndim(self): pass
def newbyteorder(self): pass
def nonzero(self): pass
def prod(self): pass
def ptp(self): pass
def put(self): pass
def ravel(self): pass
def real(self): pass
def repeat(self): pass
def reshape(self): pass
def resize(self): pass
def round(self): pass
def searchsorted(self): pass
def setfield(self): pass
def setflags(self): pass
def shape(self): pass
def size(self): pass
def sort(self): pass
def squeeze(self): pass
def std(self): pass
def strides(self): pass
def sum(self): pass
def swapaxes(self): pass
def take(self): pass
def tobytes(self): pass
def tofile(self): pass
def tolist(self): pass
def tostring(self): pass
def trace(self): pass
def transpose(self): pass
def var(self): pass
def view(self): pass
class dtype(object):
def __init__(self, obj, align=False, copy=False):
self.alignment = None
self.base = None
self.byteorder = None
self.char = None
self.descr = None
self.fields = None
self.flags = None
self.hasobject = None
self.isalignedstruct = None
self.isbuiltin = None
self.isnative = None
self.itemsize = None
self.kind = None
self.metadata = None
self.name = None
self.names = None
self.num = None
self.shape = None
self.str = None
self.subdtype = None
self.type = None
def newbyteorder(self, new_order='S'): pass
class ndarray(object):
def __init__(self, shape, dtype=float, buffer=None, offset=0,
strides=None, order=None):
self.T = None
self.base = None
self.ctypes = None
self.data = None
self.dtype = None
self.flags = None
self.flat = None
self.imag = None
self.itemsize = None
self.nbytes = None
self.ndim = None
self.real = None
self.shape = None
self.size = None
self.strides = None
def all(self): pass
def any(self): pass
def argmax(self): pass
def argmin(self): pass
def argpartition(self): pass
def argsort(self): pass
def astype(self): pass
def byteswap(self): pass
def choose(self): pass
def clip(self): pass
def compress(self): pass
def conj(self): pass
def conjugate(self): pass
def copy(self): pass
def cumprod(self): pass
def cumsum(self): pass
def diagonal(self): pass
def dot(self): pass
def dump(self): pass
def dumps(self): pass
def fill(self): pass
def flatten(self): pass
def getfield(self): pass
def item(self): pass
def itemset(self): pass
def max(self): pass
def mean(self): pass
def min(self): pass
def newbyteorder(self): pass
def nonzero(self): pass
def partition(self): pass
def prod(self): pass
def ptp(self): pass
def put(self): pass
def ravel(self): pass
def repeat(self): pass
def reshape(self): pass
def resize(self): pass
def round(self): pass
def searchsorted(self): pass
def setfield(self): pass
def setflags(self): pass
def sort(self): pass
def squeeze(self): pass
def std(self): pass
def sum(self): pass
def swapaxes(self): pass
def take(self): pass
def tobytes(self): pass
def tofile(self): pass
def tolist(self): pass
def tostring(self): pass
def trace(self): pass
def transpose(self): pass
def var(self): pass
def view(self): pass
class busdaycalendar(object):
def __init__(self, weekmask='1111100', holidays=None):
self.holidays = None
self.weekmask = None
class flexible(generic): pass
class bool_(generic): pass
class number(generic): pass
class datetime64(generic): pass
class void(flexible):
def __init__(self, *args, **kwargs):
self.base = None
self.dtype = None
self.flags = None
def getfield(self): pass
def setfield(self): pass
class character(flexible): pass
class integer(number):
def __init__(self, value):
self.denominator = None
self.numerator = None
class inexact(number): pass
class str_(str, character):
def maketrans(self, x, y=None, z=None): pass
class bytes_(bytes, character):
def fromhex(self, string): pass
def maketrans(self, frm, to): pass
class signedinteger(integer): pass
class unsignedinteger(integer): pass
class complexfloating(inexact): pass
class floating(inexact): pass
class float64(floating, float):
def fromhex(self, string): pass
class uint64(unsignedinteger): pass
class complex64(complexfloating): pass
class int16(signedinteger): pass
class float96(floating): pass
class int8(signedinteger): pass
class uint32(unsignedinteger): pass
class uint8(unsignedinteger): pass
class _typedict(dict): pass
class complex192(complexfloating): pass
class timedelta64(signedinteger): pass
class int32(signedinteger): pass
class uint16(unsignedinteger): pass
class float32(floating): pass
class complex128(complexfloating, complex): pass
class float16(floating): pass
class int64(signedinteger): pass
buffer_type = memoryview
bool8 = bool_
byte = int8
bytes0 = bytes_
cdouble = complex128
cfloat = complex128
clongdouble = complex192
clongfloat = complex192
complex_ = complex128
csingle = complex64
double = float64
float_ = float64
half = float16
int0 = int32
int_ = int32
intc = int32
intp = int32
long = int32
longcomplex = complex192
longdouble = float96
longfloat = float96
longlong = int64
object0 = object_
object_ = object_
short = int16
single = float32
singlecomplex = complex64
str0 = str_
string_ = bytes_
ubyte = uint8
uint = uint32
uint0 = uint32
uintc = uint32
uintp = uint32
ulonglong = uint64
unicode = str_
unicode_ = str_
ushort = uint16
void0 = void
""")
def as_iterable_in_yield_from(self, fxn):
code = "yield from {}()".format(fxn)
module = astroid.parse(code)
with self.assertNoMessages():
self.walk(module)
def _test_await_async_as_string(self, code):
ast_node = parse(code)
self.assertEqual(ast_node.as_string().strip(), code.strip())
def parse_transform(self, code):
module = parse(code, apply_transforms=False)
return self.transformer.visit(module)
def as_iterable_in_listcomp_test(self, fxn):
code = "x = [x for x in {}(None, [1])]".format(fxn)
module = astroid.parse(code)
with self.assertNoMessages():
self.walk(module)
def test_empty_docstring_module(self):
module = astroid.parse("''''''")
message = Message("empty-docstring", node=module, args=("module", ))
with self.assertAddsMessages(message):
self.checker.visit_module(module)
def test_missing_docstring_empty_module(self):
module = astroid.parse("")
with self.assertNoMessages():
self.checker.visit_module(module)
def test_metaclass_global_assignment(self):
module = astroid.parse('__metaclass__ = type')
with self.assertNoMessages():
self.walk(module)
def as_iterable_in_for_loop_test(self, fxn):
code = "for x in {}(): pass".format(fxn)
module = astroid.parse(code)
with self.assertNoMessages():
self.walk(module)
