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)