def test_for_while_lineno(self): for code in ( ''' for a in range(4): print (a) break else: print ("bouh") ''', ''' while a: print (a) break else: print ("bouh") ''', ): astroid = builder.AstroidBuilder().string_build( code, __name__, __file__) stmt = astroid.body[0] self.assertEqual(stmt.fromlineno, 2) self.assertEqual(stmt.tolineno, 6) self.assertEqual(stmt.blockstart_tolineno, 2) self.assertEqual(stmt.orelse[0].fromlineno, 6) # XXX self.assertEqual(stmt.orelse[0].tolineno, 6)
def test_build_from_live_module_without_source_file(self) -> None: """Assert that inspect_build() is not called. See comment in module_build() before the call to inspect_build(): "get a partial representation by introspection" This "partial representation" was presumably causing unexpected behavior. """ # Sanity check self.assertIsNone( self.imported_module.__loader__.get_source( self.imported_module_path.stem)) with self.assertRaises(AttributeError): _ = self.imported_module.__file__ my_builder = builder.AstroidBuilder() with unittest.mock.patch.object( self.imported_module.__loader__, "get_source", return_value=self.code_snippet, ): with unittest.mock.patch.object(my_builder, "inspect_build", side_effect=AssertionError): my_builder.module_build(self.imported_module, modname=self.imported_module_path.stem)
def __init__(self, view, document): self._view = view self._document = document # icon, name, class_name, line_no, docstring Gtk.TreeStore.__init__(self, GdkPixbuf.Pixbuf, str, str, int, str) if not builder: self.append(None, [ self.errorIcon, 'logilab.astng missing or invalid', None, -1, None ]) return start, end = document.get_bounds() text = document.get_text(start, end, False) try: tree = builder.AstroidBuilder().string_build(text) except Exception as e: tb = sys.exc_info()[2] lineno = tb.tb_lineno - 1 self.append(None, [ self.errorIcon, '%s\n\t%s' % (e.__class__.__name__, str(e)), None, lineno - 1, self._docstring_error(e) ]) return for n in tree.body: self.append_member(n)
def test_stream_api(self): path = resources.find('data/all.py') astroid = builder.AstroidBuilder().file_build(path, 'all') stream = astroid.stream() self.assertTrue(hasattr(stream, 'close')) with stream: with open(path, 'rb') as file_io: self.assertEqual(stream.read(), file_io.read())
def test_with_lineno(self): astroid = builder.AstroidBuilder().string_build(''' from __future__ import with_statement with file("/tmp/pouet") as f: print (f) ''', __name__, __file__) with_ = astroid.body[1] self.assertEqual(with_.fromlineno, 3) self.assertEqual(with_.tolineno, 4) self.assertEqual(with_.blockstart_tolineno, 3)
def setUp(self): super(ModuleBuildTest, self).setUp() abuilder = builder.AstroidBuilder() try: import data.module except ImportError: # Make pylint happy. self.skipTest('Unable to load data.module') else: self.module = abuilder.module_build(data.module, 'data.module')
def build_module(code, module_name=''): """Parses a string module with a builder. :param code: The code for the module. :type code: str :param module_name: The name for the module :type module_name: str :returns: The module AST. :rtype: astroid.bases.NodeNG """ code = textwrap.dedent(code) return builder.AstroidBuilder(None).string_build(code, modname=module_name)
def test_builder_apply_transforms(self): def transform_function(node): return nodes.const_factory(42) manager = builder.MANAGER with add_transform(manager, nodes.FunctionDef, transform_function): astroid_builder = builder.AstroidBuilder(apply_transforms=False) module = astroid_builder.string_build("""def test(): pass""") # The transform wasn't applied. self.assertIsInstance(module.body[0], nodes.FunctionDef)
def web2py_transform(module): path = module.file if path is None: return if ('controllers' in path or 'views' in path or 'models' in path): fake = builder.AstroidBuilder( manager.AstroidManager()).string_build(PREAMBLE) module.globals.update(fake.locals)
def test_try_finally_lineno(self): astroid = builder.AstroidBuilder().string_build(''' try: print (a) finally: print ("bouh") ''', __name__, __file__) try_ = astroid.body[0] self.assertEqual(try_.fromlineno, 2) self.assertEqual(try_.tolineno, 5) self.assertEqual(try_.blockstart_tolineno, 2) self.assertEqual(try_.finalbody[0].fromlineno, 5) # XXX self.assertEqual(try_.finalbody[0].tolineno, 5)
def test_decorated_function_lineno(self): astroid = builder.AstroidBuilder().string_build(''' @decorator def function( arg): print (arg) ''', __name__, __file__) function = astroid['function'] self.assertEqual(function.fromlineno, 3) # XXX discussable, but that's what is expected by pylint right now self.assertEqual(function.tolineno, 5) self.assertEqual(function.decorators.fromlineno, 2) self.assertEqual(function.decorators.tolineno, 2) if sys.version_info < (3, 0): self.assertEqual(function.blockstart_tolineno, 4) else: self.skipTest('FIXME http://bugs.python.org/issue10445 ' '(no line number on function args)')
def test_file_stream_api(self): path = resources.find('data/all.py') astroid = builder.AstroidBuilder().file_build(path, 'all') if __pkginfo__.numversion >= (1, 6): # file_stream is slated for removal in astroid 1.6. with self.assertRaises(AttributeError): astroid.file_stream else: # Until astroid 1.6, Module.file_stream will emit # PendingDeprecationWarning in 1.4, DeprecationWarning # in 1.5 and finally it will be removed in 1.6, leaving # only Module.stream as the recommended way to retrieve # its file stream. with warnings.catch_warnings(record=True) as cm: warnings.simplefilter("always") self.assertIsNot(astroid.file_stream, astroid.file_stream) self.assertGreater(len(cm), 1) self.assertEqual(cm[0].category, PendingDeprecationWarning)
def test_transforms_are_called_for_builtin_modules(self): # Test that transforms are called for builtin modules. def transform_function(node): name = nodes.AssignName() name.name = "value" node.args.args = [name] return node manager = builder.MANAGER predicate = lambda node: node.root().name == "time" with add_transform(manager, nodes.FunctionDef, transform_function, predicate): builder_instance = builder.AstroidBuilder() module = builder_instance.module_build(time) asctime = module["asctime"] self.assertEqual(len(asctime.args.args), 1) self.assertIsInstance(asctime.args.args[0], nodes.AssignName) self.assertEqual(asctime.args.args[0].name, "value")
def test_try_except_lineno(self): astroid = builder.AstroidBuilder().string_build(''' try: print (a) except: pass else: print ("bouh") ''', __name__, __file__) try_ = astroid.body[0] self.assertEqual(try_.fromlineno, 2) self.assertEqual(try_.tolineno, 7) self.assertEqual(try_.blockstart_tolineno, 2) self.assertEqual(try_.orelse[0].fromlineno, 7) # XXX self.assertEqual(try_.orelse[0].tolineno, 7) hdlr = try_.handlers[0] self.assertEqual(hdlr.fromlineno, 4) self.assertEqual(hdlr.tolineno, 5) self.assertEqual(hdlr.blockstart_tolineno, 4)
def build_file(path, modname=None): return builder.AstroidBuilder().file_build(find(path), modname)
def setUp(self): self.builder = builder.AstroidBuilder()
class FromToLineNoTC(TestCase): astroid = builder.AstroidBuilder().file_build(join(DATA, 'format.py')) def test_callfunc_lineno(self): stmts = self.astroid.body # on line 4: # function('aeozrijz\ # earzer', hop) discard = stmts[0] self.assertIsInstance(discard, nodes.Discard) self.assertEqual(discard.fromlineno, 4) self.assertEqual(discard.tolineno, 5) callfunc = discard.value self.assertIsInstance(callfunc, nodes.CallFunc) self.assertEqual(callfunc.fromlineno, 4) self.assertEqual(callfunc.tolineno, 5) name = callfunc.func self.assertIsInstance(name, nodes.Name) self.assertEqual(name.fromlineno, 4) self.assertEqual(name.tolineno, 4) strarg = callfunc.args[0] self.assertIsInstance(strarg, nodes.Const) if hasattr(sys, 'pypy_version_info'): lineno = 4 else: lineno = 5 # no way for this one in CPython (is 4 actually) self.assertEqual(strarg.fromlineno, lineno) self.assertEqual(strarg.tolineno, lineno) namearg = callfunc.args[1] self.assertIsInstance(namearg, nodes.Name) self.assertEqual(namearg.fromlineno, 5) self.assertEqual(namearg.tolineno, 5) # on line 10: # fonction(1, # 2, # 3, # 4) discard = stmts[2] self.assertIsInstance(discard, nodes.Discard) self.assertEqual(discard.fromlineno, 10) self.assertEqual(discard.tolineno, 13) callfunc = discard.value self.assertIsInstance(callfunc, nodes.CallFunc) self.assertEqual(callfunc.fromlineno, 10) self.assertEqual(callfunc.tolineno, 13) name = callfunc.func self.assertIsInstance(name, nodes.Name) self.assertEqual(name.fromlineno, 10) self.assertEqual(name.tolineno, 10) for i, arg in enumerate(callfunc.args): self.assertIsInstance(arg, nodes.Const) self.assertEqual(arg.fromlineno, 10 + i) self.assertEqual(arg.tolineno, 10 + i) def test_function_lineno(self): stmts = self.astroid.body # on line 15: # def definition(a, # b, # c): # return a + b + c function = stmts[3] self.assertIsInstance(function, nodes.Function) self.assertEqual(function.fromlineno, 15) self.assertEqual(function.tolineno, 18) return_ = function.body[0] self.assertIsInstance(return_, nodes.Return) self.assertEqual(return_.fromlineno, 18) self.assertEqual(return_.tolineno, 18) if sys.version_info < (3, 0): self.assertEqual(function.blockstart_tolineno, 17) else: self.skipTest('FIXME http://bugs.python.org/issue10445 ' '(no line number on function args)') def test_decorated_function_lineno(self): astroid = builder.AstroidBuilder().string_build( ''' @decorator def function( arg): print (arg) ''', __name__, __file__) function = astroid['function'] self.assertEqual( function.fromlineno, 3 ) # XXX discussable, but that's what is expected by pylint right now self.assertEqual(function.tolineno, 5) self.assertEqual(function.decorators.fromlineno, 2) self.assertEqual(function.decorators.tolineno, 2) if sys.version_info < (3, 0): self.assertEqual(function.blockstart_tolineno, 4) else: self.skipTest('FIXME http://bugs.python.org/issue10445 ' '(no line number on function args)') def test_class_lineno(self): stmts = self.astroid.body # on line 20: # class debile(dict, # object): # pass class_ = stmts[4] self.assertIsInstance(class_, nodes.Class) self.assertEqual(class_.fromlineno, 20) self.assertEqual(class_.tolineno, 22) self.assertEqual(class_.blockstart_tolineno, 21) pass_ = class_.body[0] self.assertIsInstance(pass_, nodes.Pass) self.assertEqual(pass_.fromlineno, 22) self.assertEqual(pass_.tolineno, 22) def test_if_lineno(self): stmts = self.astroid.body # on line 20: # if aaaa: pass # else: # aaaa,bbbb = 1,2 # aaaa,bbbb = bbbb,aaaa if_ = stmts[5] self.assertIsInstance(if_, nodes.If) self.assertEqual(if_.fromlineno, 24) self.assertEqual(if_.tolineno, 27) self.assertEqual(if_.blockstart_tolineno, 24) self.assertEqual(if_.orelse[0].fromlineno, 26) self.assertEqual(if_.orelse[1].tolineno, 27) def test_for_while_lineno(self): for code in ( ''' for a in range(4): print (a) break else: print ("bouh") ''', ''' while a: print (a) break else: print ("bouh") ''', ): astroid = builder.AstroidBuilder().string_build( code, __name__, __file__) stmt = astroid.body[0] self.assertEqual(stmt.fromlineno, 2) self.assertEqual(stmt.tolineno, 6) self.assertEqual(stmt.blockstart_tolineno, 2) self.assertEqual(stmt.orelse[0].fromlineno, 6) # XXX self.assertEqual(stmt.orelse[0].tolineno, 6) def test_try_except_lineno(self): astroid = builder.AstroidBuilder().string_build( ''' try: print (a) except: pass else: print ("bouh") ''', __name__, __file__) try_ = astroid.body[0] self.assertEqual(try_.fromlineno, 2) self.assertEqual(try_.tolineno, 7) self.assertEqual(try_.blockstart_tolineno, 2) self.assertEqual(try_.orelse[0].fromlineno, 7) # XXX self.assertEqual(try_.orelse[0].tolineno, 7) hdlr = try_.handlers[0] self.assertEqual(hdlr.fromlineno, 4) self.assertEqual(hdlr.tolineno, 5) self.assertEqual(hdlr.blockstart_tolineno, 4) def test_try_finally_lineno(self): astroid = builder.AstroidBuilder().string_build( ''' try: print (a) finally: print ("bouh") ''', __name__, __file__) try_ = astroid.body[0] self.assertEqual(try_.fromlineno, 2) self.assertEqual(try_.tolineno, 5) self.assertEqual(try_.blockstart_tolineno, 2) self.assertEqual(try_.finalbody[0].fromlineno, 5) # XXX self.assertEqual(try_.finalbody[0].tolineno, 5) def test_try_finally_25_lineno(self): astroid = builder.AstroidBuilder().string_build( ''' try: print (a) except: pass finally: print ("bouh") ''', __name__, __file__) try_ = astroid.body[0] self.assertEqual(try_.fromlineno, 2) self.assertEqual(try_.tolineno, 7) self.assertEqual(try_.blockstart_tolineno, 2) self.assertEqual(try_.finalbody[0].fromlineno, 7) # XXX self.assertEqual(try_.finalbody[0].tolineno, 7) def test_with_lineno(self): astroid = builder.AstroidBuilder().string_build( ''' from __future__ import with_statement with file("/tmp/pouet") as f: print (f) ''', __name__, __file__) with_ = astroid.body[1] self.assertEqual(with_.fromlineno, 3) self.assertEqual(with_.tolineno, 4) self.assertEqual(with_.blockstart_tolineno, 3)
def test_file_stream_physical(self): path = resources.find('data/all.py') astroid = builder.AstroidBuilder().file_build(path, 'all') with open(path, 'rb') as file_io: with warnings.catch_warnings(record=True): self.assertEqual(astroid.file_stream.read(), file_io.read())
def setUp(self): super(ModuleBuildTest, self).setUp() abuilder = builder.AstroidBuilder() import data.module self.module = abuilder.module_build(data.module, 'data.module')
def setUp(self): abuilder = builder.AstroidBuilder() self.module = abuilder.module_build(test_module)
class FileBuildTC(TestCase): module = builder.AstroidBuilder().file_build(join(DATA, 'module.py'), 'data.module') def test_module_base_props(self): """test base properties and method of a astroid module""" module = self.module self.assertEqual(module.name, 'data.module') self.assertEqual(module.doc, "test module for astroid\n") self.assertEqual(module.fromlineno, 0) self.assertIsNone(module.parent) self.assertEqual(module.frame(), module) self.assertEqual(module.root(), module) self.assertEqual(module.file, join(abspath(data.__path__[0]), 'module.py')) self.assertEqual(module.pure_python, 1) self.assertEqual(module.package, 0) self.assertFalse(module.is_statement) self.assertEqual(module.statement(), module) self.assertEqual(module.statement(), module) def test_module_locals(self): """test the 'locals' dictionary of a astroid module""" module = self.module _locals = module.locals self.assertIs(_locals, module.globals) keys = sorted(_locals.keys()) should = [ 'MY_DICT', 'YO', 'YOUPI', '__revision__', 'global_access', 'modutils', 'four_args', 'os', 'redirect', 'spawn', 'LocalsVisitor', 'ASTWalker' ] should.sort() self.assertEqual(keys, should) def test_function_base_props(self): """test base properties and method of a astroid function""" module = self.module function = module['global_access'] self.assertEqual(function.name, 'global_access') self.assertEqual(function.doc, 'function test') self.assertEqual(function.fromlineno, 11) self.assertTrue(function.parent) self.assertEqual(function.frame(), function) self.assertEqual(function.parent.frame(), module) self.assertEqual(function.root(), module) self.assertEqual([n.name for n in function.args.args], ['key', 'val']) self.assertEqual(function.type, 'function') def test_function_locals(self): """test the 'locals' dictionary of a astroid function""" _locals = self.module['global_access'].locals self.assertEqual(len(_locals), 4) keys = sorted(_locals.keys()) self.assertEqual(keys, ['i', 'key', 'local', 'val']) def test_class_base_props(self): """test base properties and method of a astroid class""" module = self.module klass = module['YO'] self.assertEqual(klass.name, 'YO') self.assertEqual(klass.doc, 'hehe') self.assertEqual(klass.fromlineno, 25) self.assertTrue(klass.parent) self.assertEqual(klass.frame(), klass) self.assertEqual(klass.parent.frame(), module) self.assertEqual(klass.root(), module) self.assertEqual(klass.basenames, []) if PY3K: self.assertTrue(klass.newstyle) else: self.assertFalse(klass.newstyle) def test_class_locals(self): """test the 'locals' dictionary of a astroid class""" module = self.module klass1 = module['YO'] locals1 = klass1.locals keys = sorted(locals1.keys()) self.assertEqual(keys, ['__init__', 'a']) klass2 = module['YOUPI'] locals2 = klass2.locals keys = locals2.keys() keys.sort() self.assertEqual(keys, [ '__init__', 'class_attr', 'class_method', 'method', 'static_method' ]) def test_class_instance_attrs(self): module = self.module klass1 = module['YO'] klass2 = module['YOUPI'] self.assertEqual(klass1.instance_attrs.keys(), ['yo']) self.assertEqual(klass2.instance_attrs.keys(), ['member']) def test_class_basenames(self): module = self.module klass1 = module['YO'] klass2 = module['YOUPI'] self.assertEqual(klass1.basenames, []) self.assertEqual(klass2.basenames, ['YO']) def test_method_base_props(self): """test base properties and method of a astroid method""" klass2 = self.module['YOUPI'] # "normal" method method = klass2['method'] self.assertEqual(method.name, 'method') self.assertEqual([n.name for n in method.args.args], ['self']) self.assertEqual(method.doc, 'method test') self.assertEqual(method.fromlineno, 47) self.assertEqual(method.type, 'method') # class method method = klass2['class_method'] self.assertEqual([n.name for n in method.args.args], ['cls']) self.assertEqual(method.type, 'classmethod') # static method method = klass2['static_method'] self.assertEqual(method.args.args, []) self.assertEqual(method.type, 'staticmethod') def test_method_locals(self): """test the 'locals' dictionary of a astroid method""" method = self.module['YOUPI']['method'] _locals = method.locals keys = sorted(_locals) if sys.version_info < (3, 0): self.assertEqual(len(_locals), 5) self.assertEqual(keys, ['a', 'autre', 'b', 'local', 'self']) else: # ListComp variables are no more accessible outside self.assertEqual(len(_locals), 3) self.assertEqual(keys, ['autre', 'local', 'self'])
def build_file(path: str, modname: str | None = None) -> Module: return builder.AstroidBuilder().file_build(find(path), modname)
import six import astroid from astroid import bases from astroid import builder from astroid import context as contextmod from astroid import exceptions from astroid import node_classes from astroid import nodes from astroid import parse from astroid import util from astroid import test_utils from astroid import transforms from . import resources abuilder = builder.AstroidBuilder() BUILTINS = six.moves.builtins.__name__ PY38 = sys.version_info[:2] >= (3, 8) try: import typed_ast # pylint: disable=unused-import HAS_TYPED_AST = True except ImportError: # typed_ast merged in `ast` in Python 3.8 HAS_TYPED_AST = PY38 class AsStringTest(resources.SysPathSetup, unittest.TestCase): def test_tuple_as_string(self): def build(string): return abuilder.string_build(string).body[0].value
def setUp(self) -> None: self.manager = test_utils.brainless_manager() self.builder = builder.AstroidBuilder(self.manager)
def test_module_build_dunder_file(): """Test that module_build() can work with modules that have the *__file__* attribute""" module = builder.AstroidBuilder().module_build(collections) assert module.path[0] == collections.__file__
def get_patched_checker(name=DEFAULT_LINTER): def get_show_msg(err_code, msg, line, col): return "{}: [{},{}] {}".format( "ERROR" if err_code.startswith("E9") else "WARNING", line, col, msg) def read_file_line(fd): try: (coding, lines) = tokenize.detect_encoding(fd.readline) textfd = io.TextIOWrapper(fd, coding, line_buffering=True) return [l.decode(coding) for l in lines] + textfd.readlines() except (LookupError, SyntaxError, UnicodeError): return fd.readlines() if name == "flake8": from flake8.api.legacy import get_style_guide from flake8.checker import FileChecker, processor class PatchedFileChecker(FileChecker): def __init__(self, filename, checks, options, file_lines=None): self.file_lines = file_lines super().__init__(filename, checks, options) def _make_processor(self): return processor.FileProcessor(self.filename, self.options, lines=self.file_lines) sg = get_style_guide() def check_and_get_results(filename, file_content=None): file_content = bytes(file_content) if file_content else b"" py_file = io.BytesIO(file_content) flake8_mngr = sg._file_checker_manager flake8_mngr.options.max_line_length = DEFAULT_LINE_WIDTH checks = flake8_mngr.checks.to_dictionary() file_chk = PatchedFileChecker( filename, checks, flake8_mngr.options, file_lines=read_file_line(py_file)) file_chk.run_checks() g = sg._application.guide for result in file_chk.results: err_code, line, col, msg, code_str = result if g.handle_error( code=err_code, filename=filename, line_number=line, column_number=col, text=msg, physical_line=code_str, ): msg = get_show_msg(err_code, msg, line, col) yield (line, msg) return iter(()) return check_and_get_results elif name == "pycodestyle": from pycodestyle import Checker def check_and_get_results(filename, file_content=None): file_content = bytes(file_content) if file_content else b"" py_file = io.BytesIO(file_content) chk = Checker(filename, lines=read_file_line(py_file)) chk.max_line_length = DEFAULT_LINE_WIDTH results = chk.check_all() results = chk.report._deferred_print if not results: return iter(()) for result in chk.report._deferred_print: line, col, err_code, msg, smry = result msg = get_show_msg(err_code, msg, line, col) yield (line, msg) return check_and_get_results elif name == "pyflakes": from pyflakes.api import check from pyflakes.reporter import Reporter class PyFlakeReporter(Reporter): def __init__(self): self.errors = [] def unexpectedError(self, filename, msg): self.errors.append(("E9", 1, 1, msg)) def syntaxError(self, filename, msg, lineno, offset, text): self.errors.append(("E9", lineno, offset, msg)) def flake(self, message): self.errors.append( ("", message.lineno, message.col, message.message % message.message_args)) def check_and_get_results(filename, file_content=None): rprter = PyFlakeReporter() chk = check(file_content, filename, reporter=rprter) if not chk: return iter(()) for result in rprter.errors: err_code, line, col, msg = result msg = get_show_msg(err_code, msg, line, col) yield (line, msg) return check_and_get_results elif name == "pylint": from pylint.lint import PyLinter from pylint import utils from pylint import interfaces from astroid import MANAGER, builder from pylint import reporters bd = builder.AstroidBuilder(MANAGER) class PatchedPyLinter(PyLinter): def check(self, filename, file_content): # initialize msgs_state now that all messages have been registered into # the store for msg in self.msgs_store.messages: if not msg.may_be_emitted(): self._msgs_state[msg.msgid] = False basename = (os.path.splitext(os.path.basename(filename))[0] if filename else "untitled") walker = utils.PyLintASTWalker(self) self.config.reports = True _checkers = self.prepare_checkers() tokencheckers = [ c for c in _checkers if interfaces.implements(c, interfaces.ITokenChecker) and c is not self ] rawcheckers = [ c for c in _checkers if interfaces.implements(c, interfaces.IRawChecker) ] # notify global begin for checker in _checkers: checker.open() if interfaces.implements(checker, interfaces.IAstroidChecker): walker.add_checker(checker) self.set_current_module(basename, filename) ast_node = bd.string_build(file_content, filename, basename) self.file_state = utils.FileState(basename) self._ignore_file = False # fix the current file (if the source file was not available or # if it's actually a c extension) self.current_file = ast_node.file # pylint: disable=maybe-no-member self.check_astroid_module(ast_node, walker, rawcheckers, tokencheckers) # warn about spurious inline messages handling spurious_messages = self.file_state.iter_spurious_suppression_messages( self.msgs_store) for msgid, line, args in spurious_messages: self.add_message(msgid, line, None, args) # notify global end self.stats["statement"] = walker.nbstatements for checker in reversed(_checkers): checker.close() def check_and_get_results(filename, file_content=None): if not isinstance(file_content, str): file_content = file_content.decode( "utf8") if file_content else "" if not filename: filename = "" linter = PatchedPyLinter() linter.load_default_plugins() rp = reporters.json.JSONReporter() linter.set_reporter(rp) linter.check(filename, file_content) for msg in rp.messages: yield msg[ "line"], "{type}: [{line},{column}] ({message-id}) {message}".format( **msg) return check_and_get_results