class PyLinter( config.OptionsManagerMixIn, MessagesHandlerMixIn, reporters.ReportsHandlerMixIn, checkers.BaseTokenChecker, ): """lint Python modules using external checkers. This is the main checker controlling the other ones and the reports generation. It is itself both a raw checker and an astroid checker in order to: * handle message activation / deactivation at the module level * handle some basic but necessary stats'data (number of classes, methods...) IDE plugin developers: you may have to call `astroid.builder.MANAGER.astroid_cache.clear()` across runs if you want to ensure the latest code version is actually checked. This class needs to support pickling for parallel linting to work. The exception is reporter member; see check_parallel function for more details. """ __implements__ = (interfaces.ITokenChecker, ) name = MAIN_CHECKER_NAME priority = 0 level = 0 msgs = MSGS @staticmethod def make_options(): return ( ( "ignore", { "type": "csv", "metavar": "<file>[,<file>...]", "dest": "black_list", "default": ("CVS", ), "help": "Add files or directories to the blacklist. " "They should be base names, not paths.", }, ), ( "ignore-patterns", { "type": "regexp_csv", "metavar": "<pattern>[,<pattern>...]", "dest": "black_list_re", "default": (), "help": "Add files or directories matching the regex patterns to the" " blacklist. The regex matches against base names, not paths.", }, ), ( "persistent", { "default": True, "type": "yn", "metavar": "<y_or_n>", "level": 1, "help": "Pickle collected data for later comparisons.", }, ), ( "load-plugins", { "type": "csv", "metavar": "<modules>", "default": (), "level": 1, "help": "List of plugins (as comma separated values of " "python module names) to load, usually to register " "additional checkers.", }, ), ( "output-format", { "default": "text", "type": "string", "metavar": "<format>", "short": "f", "group": "Reports", "help": "Set the output format. Available formats are text," " parseable, colorized, json and msvs (visual studio)." " You can also give a reporter class, e.g. mypackage.mymodule." "MyReporterClass.", }, ), ( "reports", { "default": False, "type": "yn", "metavar": "<y_or_n>", "short": "r", "group": "Reports", "help": "Tells whether to display a full report or only the " "messages.", }, ), ( "evaluation", { "type": "string", "metavar": "<python_expression>", "group": "Reports", "level": 1, "default": "10.0 - ((float(5 * error + warning + refactor + " "convention) / statement) * 10)", "help": "Python expression which should return a score less " "than or equal to 10. You have access to the variables " "'error', 'warning', 'refactor', and 'convention' which " "contain the number of messages in each category, as well as " "'statement' which is the total number of statements " "analyzed. This score is used by the global " "evaluation report (RP0004).", }, ), ( "score", { "default": True, "type": "yn", "metavar": "<y_or_n>", "short": "s", "group": "Reports", "help": "Activate the evaluation score.", }, ), ( "fail-under", { "default": 10, "type": "float", "metavar": "<score>", "help": "Specify a score threshold to be exceeded before program exits with error.", }, ), ( "confidence", { "type": "multiple_choice", "metavar": "<levels>", "default": "", "choices": [c.name for c in interfaces.CONFIDENCE_LEVELS], "group": "Messages control", "help": "Only show warnings with the listed confidence levels." " Leave empty to show all. Valid levels: %s." % (", ".join(c.name for c in interfaces.CONFIDENCE_LEVELS), ), }, ), ( "enable", { "type": "csv", "metavar": "<msg ids>", "short": "e", "group": "Messages control", "help": "Enable the message, report, category or checker with the " "given id(s). You can either give multiple identifier " "separated by comma (,) or put this option multiple time " "(only on the command line, not in the configuration file " "where it should appear only once). " 'See also the "--disable" option for examples.', }, ), ( "disable", { "type": "csv", "metavar": "<msg ids>", "short": "d", "group": "Messages control", "help": "Disable the message, report, category or checker " "with the given id(s). You can either give multiple identifiers " "separated by comma (,) or put this option multiple times " "(only on the command line, not in the configuration file " "where it should appear only once). " 'You can also use "--disable=all" to disable everything first ' "and then reenable specific checks. For example, if you want " "to run only the similarities checker, you can use " '"--disable=all --enable=similarities". ' "If you want to run only the classes checker, but have no " "Warning level messages displayed, use " '"--disable=all --enable=classes --disable=W".', }, ), ( "msg-template", { "type": "string", "metavar": "<template>", "group": "Reports", "help": ("Template used to display messages. " "This is a python new-style format string " "used to format the message information. " "See doc for all details."), }, ), ( "jobs", { "type": "int", "metavar": "<n-processes>", "short": "j", "default": 1, "help": "Use multiple processes to speed up Pylint. Specifying 0 will " "auto-detect the number of processors available to use.", }, ), ( "unsafe-load-any-extension", { "type": "yn", "metavar": "<yn>", "default": False, "hide": True, "help": ("Allow loading of arbitrary C extensions. Extensions" " are imported into the active Python interpreter and" " may run arbitrary code."), }, ), ( "limit-inference-results", { "type": "int", "metavar": "<number-of-results>", "default": 100, "help": ("Control the amount of potential inferred values when inferring " "a single object. This can help the performance when dealing with " "large functions or complex, nested conditions. "), }, ), ( "extension-pkg-whitelist", { "type": "csv", "metavar": "<pkg[,pkg]>", "default": [], "help": ("A comma-separated list of package or module names" " from where C extensions may be loaded. Extensions are" " loading into the active Python interpreter and may run" " arbitrary code."), }, ), ( "suggestion-mode", { "type": "yn", "metavar": "<yn>", "default": True, "help": ("When enabled, pylint would attempt to guess common " "misconfiguration and emit user-friendly hints instead " "of false-positive error messages."), }, ), ( "exit-zero", { "action": "store_true", "help": ("Always return a 0 (non-error) status code, even if " "lint errors are found. This is primarily useful in " "continuous integration scripts."), }, ), ( "from-stdin", { "action": "store_true", "help": ("Interpret the stdin as a python script, whose filename " "needs to be passed as the module_or_package argument."), }, ), ) option_groups = ( ("Messages control", "Options controlling analysis messages"), ("Reports", "Options related to output formatting and reporting"), ) def __init__(self, options=(), reporter=None, option_groups=(), pylintrc=None): # some stuff has to be done before ancestors initialization... # # messages store / checkers / reporter / astroid manager self.msgs_store = MessageDefinitionStore() self.reporter = None self._reporter_name = None self._reporters = {} self._checkers = collections.defaultdict(list) self._pragma_lineno = {} self._ignore_file = False # visit variables self.file_state = FileState() self.current_name = None self.current_file = None self.stats = None # init options self._external_opts = options self.options = options + PyLinter.make_options() self.option_groups = option_groups + PyLinter.option_groups self._options_methods = { "enable": self.enable, "disable": self.disable } self._bw_options_methods = { "disable-msg": self.disable, "enable-msg": self.enable, } MessagesHandlerMixIn.__init__(self) reporters.ReportsHandlerMixIn.__init__(self) super().__init__( usage=__doc__, config_file=pylintrc or next(config.find_default_config_files(), None), ) checkers.BaseTokenChecker.__init__(self) # provided reports self.reports = ( ("RP0001", "Messages by category", report_total_messages_stats), ( "RP0002", "% errors / warnings by module", report_messages_by_module_stats, ), ("RP0003", "Messages", report_messages_stats), ) self.register_checker(self) self._dynamic_plugins = set() self._python3_porting_mode = False self._error_mode = False self.load_provider_defaults() if reporter: self.set_reporter(reporter) def load_default_plugins(self): checkers.initialize(self) reporters.initialize(self) # Make sure to load the default reporter, because # the option has been set before the plugins had been loaded. if not self.reporter: self._load_reporter() def load_plugin_modules(self, modnames): """take a list of module names which are pylint plugins and load and register them """ for modname in modnames: if modname in self._dynamic_plugins: continue self._dynamic_plugins.add(modname) module = modutils.load_module_from_name(modname) module.register(self) def load_plugin_configuration(self): """Call the configuration hook for plugins This walks through the list of plugins, grabs the "load_configuration" hook, if exposed, and calls it to allow plugins to configure specific settings. """ for modname in self._dynamic_plugins: module = modutils.load_module_from_name(modname) if hasattr(module, "load_configuration"): module.load_configuration(self) def _load_reporter(self): name = self._reporter_name.lower() if name in self._reporters: self.set_reporter(self._reporters[name]()) else: try: reporter_class = self._load_reporter_class() except (ImportError, AttributeError) as e: raise exceptions.InvalidReporterError(name) from e else: self.set_reporter(reporter_class()) def _load_reporter_class(self): qname = self._reporter_name module = modutils.load_module_from_name( modutils.get_module_part(qname)) class_name = qname.split(".")[-1] reporter_class = getattr(module, class_name) return reporter_class def set_reporter(self, reporter): """set the reporter used to display messages and reports""" self.reporter = reporter reporter.linter = self def set_option(self, optname, value, action=None, optdict=None): """overridden from config.OptionsProviderMixin to handle some special options """ if optname in self._options_methods or optname in self._bw_options_methods: if value: try: meth = self._options_methods[optname] except KeyError: meth = self._bw_options_methods[optname] warnings.warn( "%s is deprecated, replace it by %s" % (optname, optname.split("-")[0]), DeprecationWarning, ) value = utils._check_csv(value) if isinstance(value, (list, tuple)): for _id in value: meth(_id, ignore_unknown=True) else: meth(value) return # no need to call set_option, disable/enable methods do it elif optname == "output-format": self._reporter_name = value # If the reporters are already available, load # the reporter class. if self._reporters: self._load_reporter() try: checkers.BaseTokenChecker.set_option(self, optname, value, action, optdict) except config.UnsupportedAction: print("option %s can't be read from config file" % optname, file=sys.stderr) def register_reporter(self, reporter_class): self._reporters[reporter_class.name] = reporter_class def report_order(self): reports = sorted(self._reports, key=lambda x: getattr(x, "name", "")) try: # Remove the current reporter and add it # at the end of the list. reports.pop(reports.index(self)) except ValueError: pass else: reports.append(self) return reports # checkers manipulation methods ############################################ def register_checker(self, checker): """register a new checker checker is an object implementing IRawChecker or / and IAstroidChecker """ assert checker.priority <= 0, "checker priority can't be >= 0" self._checkers[checker.name].append(checker) for r_id, r_title, r_cb in checker.reports: self.register_report(r_id, r_title, r_cb, checker) self.register_options_provider(checker) if hasattr(checker, "msgs"): self.msgs_store.register_messages_from_checker(checker) checker.load_defaults() # Register the checker, but disable all of its messages. if not getattr(checker, "enabled", True): self.disable(checker.name) def disable_noerror_messages(self): for msgcat, msgids in self.msgs_store._msgs_by_category.items(): # enable only messages with 'error' severity and above ('fatal') if msgcat in ["E", "F"]: for msgid in msgids: self.enable(msgid) else: for msgid in msgids: self.disable(msgid) def disable_reporters(self): """disable all reporters""" for _reporters in self._reports.values(): for report_id, _, _ in _reporters: self.disable_report(report_id) def error_mode(self): """error mode: enable only errors; no reports, no persistent""" self._error_mode = True self.disable_noerror_messages() self.disable("miscellaneous") if self._python3_porting_mode: self.disable("all") for msg_id in self._checker_messages("python3"): if msg_id.startswith("E"): self.enable(msg_id) config_parser = self.cfgfile_parser if config_parser.has_option("MESSAGES CONTROL", "disable"): value = config_parser.get("MESSAGES CONTROL", "disable") self.global_set_option("disable", value) else: self.disable("python3") self.set_option("reports", False) self.set_option("persistent", False) self.set_option("score", False) def python3_porting_mode(self): """Disable all other checkers and enable Python 3 warnings.""" self.disable("all") # re-enable some errors, or 'print', 'raise', 'async', 'await' will mistakenly lint fine self.enable("fatal") # F0001 self.enable("astroid-error") # F0002 self.enable("parse-error") # F0010 self.enable("syntax-error") # E0001 self.enable("python3") if self._error_mode: # The error mode was activated, using the -E flag. # So we'll need to enable only the errors from the # Python 3 porting checker. for msg_id in self._checker_messages("python3"): if msg_id.startswith("E"): self.enable(msg_id) else: self.disable(msg_id) config_parser = self.cfgfile_parser if config_parser.has_option("MESSAGES CONTROL", "disable"): value = config_parser.get("MESSAGES CONTROL", "disable") self.global_set_option("disable", value) self._python3_porting_mode = True def list_messages_enabled(self): enabled = [ " %s (%s)" % (message.symbol, message.msgid) for message in self.msgs_store.messages if self.is_message_enabled(message.msgid) ] disabled = [ " %s (%s)" % (message.symbol, message.msgid) for message in self.msgs_store.messages if not self.is_message_enabled(message.msgid) ] print("Enabled messages:") for msg in sorted(enabled): print(msg) print("\nDisabled messages:") for msg in sorted(disabled): print(msg) print("") # block level option handling ############################################# # # see func_block_disable_msg.py test case for expected behaviour def process_tokens(self, tokens): """process tokens from the current module to search for module/block level options """ control_pragmas = {"disable", "enable"} prev_line = None saw_newline = True seen_newline = True for (tok_type, content, start, _, _) in tokens: if prev_line and prev_line != start[0]: saw_newline = seen_newline seen_newline = False prev_line = start[0] if tok_type in (tokenize.NL, tokenize.NEWLINE): seen_newline = True if tok_type != tokenize.COMMENT: continue match = OPTION_PO.search(content) if match is None: continue try: for pragma_repr in parse_pragma(match.group(2)): if pragma_repr.action in ("disable-all", "skip-file"): if pragma_repr.action == "disable-all": self.add_message( "deprecated-pragma", line=start[0], args=("disable-all", "skip-file"), ) self.add_message("file-ignored", line=start[0]) self._ignore_file = True return try: meth = self._options_methods[pragma_repr.action] except KeyError: meth = self._bw_options_methods[pragma_repr.action] # found a "(dis|en)able-msg" pragma deprecated suppression self.add_message( "deprecated-pragma", line=start[0], args=( pragma_repr.action, pragma_repr.action.replace("-msg", ""), ), ) for msgid in pragma_repr.messages: # Add the line where a control pragma was encountered. if pragma_repr.action in control_pragmas: self._pragma_lineno[msgid] = start[0] if (pragma_repr.action, msgid) == ("disable", "all"): self.add_message( "deprecated-pragma", line=start[0], args=("disable=all", "skip-file"), ) self.add_message("file-ignored", line=start[0]) self._ignore_file = True return # If we did not see a newline between the previous line and now, # we saw a backslash so treat the two lines as one. l_start = start[0] if not saw_newline: l_start -= 1 try: meth(msgid, "module", l_start) except exceptions.UnknownMessageError: self.add_message("bad-option-value", args=msgid, line=start[0]) except UnRecognizedOptionError as err: self.add_message("unrecognized-inline-option", args=err.token, line=start[0]) continue except InvalidPragmaError as err: self.add_message("bad-inline-option", args=err.token, line=start[0]) continue # code checking methods ################################################### def get_checkers(self): """return all available checkers as a list""" return [self] + [ c for _checkers in self._checkers.values() for c in _checkers if c is not self ] def get_checker_names(self): """Get all the checker names that this linter knows about.""" current_checkers = self.get_checkers() return sorted({ checker.name for checker in current_checkers if checker.name != MAIN_CHECKER_NAME }) def prepare_checkers(self): """return checkers needed for activated messages and reports""" if not self.config.reports: self.disable_reporters() # get needed checkers needed_checkers = [self] for checker in self.get_checkers()[1:]: messages = { msg for msg in checker.msgs if self.is_message_enabled(msg) } if messages or any( self.report_is_enabled(r[0]) for r in checker.reports): needed_checkers.append(checker) # Sort checkers by priority needed_checkers = sorted(needed_checkers, key=operator.attrgetter("priority"), reverse=True) return needed_checkers # pylint: disable=unused-argument @staticmethod def should_analyze_file(modname, path, is_argument=False): """Returns whether or not a module should be checked. This implementation returns True for all python source file, indicating that all files should be linted. Subclasses may override this method to indicate that modules satisfying certain conditions should not be linted. :param str modname: The name of the module to be checked. :param str path: The full path to the source code of the module. :param bool is_argument: Whetter the file is an argument to pylint or not. Files which respect this property are always checked, since the user requested it explicitly. :returns: True if the module should be checked. :rtype: bool """ if is_argument: return True return path.endswith(".py") # pylint: enable=unused-argument def initialize(self): """Initialize linter for linting This method is called before any linting is done. """ # 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 def check(self, files_or_modules): """main checking entry: check a list of files or modules from their name. files_or_modules is either a string or list of strings presenting modules to check. """ self.initialize() if not isinstance(files_or_modules, (list, tuple)): files_or_modules = (files_or_modules, ) if self.config.from_stdin: if len(files_or_modules) != 1: raise exceptions.InvalidArgsError( "Missing filename required for --from-stdin") filepath = files_or_modules[0] with fix_import_path(files_or_modules): self._check_files( functools.partial(self.get_ast, data=_read_stdin()), [self._get_file_descr_from_stdin(filepath)], ) elif self.config.jobs == 1: with fix_import_path(files_or_modules): self._check_files(self.get_ast, self._iterate_file_descrs(files_or_modules)) else: check_parallel( self, self.config.jobs, self._iterate_file_descrs(files_or_modules), files_or_modules, ) def check_single_file(self, name, filepath, modname): """Check single file The arguments are the same that are documented in _check_files The initialize() method should be called before calling this method """ with self._astroid_module_checker() as check_astroid_module: self._check_file(self.get_ast, check_astroid_module, name, filepath, modname) def _check_files(self, get_ast, file_descrs): """Check all files from file_descrs The file_descrs should be iterable of tuple (name, filepath, modname) where - name: full name of the module - filepath: path of the file - modname: module name """ with self._astroid_module_checker() as check_astroid_module: for name, filepath, modname in file_descrs: self._check_file(get_ast, check_astroid_module, name, filepath, modname) def _check_file(self, get_ast, check_astroid_module, name, filepath, modname): """Check a file using the passed utility functions (get_ast and check_astroid_module) :param callable get_ast: callable returning AST from defined file taking the following arguments - filepath: path to the file to check - name: Python module name :param callable check_astroid_module: callable checking an AST taking the following arguments - ast: AST of the module :param str name: full name of the module :param str filepath: path to checked file :param str modname: name of the checked Python module """ self.set_current_module(name, filepath) # get the module representation ast_node = get_ast(filepath, name) if ast_node is None: return self._ignore_file = False self.file_state = FileState(modname) # 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 check_astroid_module(ast_node) # 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) @staticmethod def _get_file_descr_from_stdin(filepath): """Return file description (tuple of module name, file path, base name) from given file path This method is used for creating suitable file description for _check_files when the source is standard input. """ try: # Note that this function does not really perform an # __import__ but may raise an ImportError exception, which # we want to catch here. modname = ".".join(modutils.modpath_from_file(filepath)) except ImportError: modname = os.path.splitext(os.path.basename(filepath))[0] return (modname, filepath, filepath) def _iterate_file_descrs(self, files_or_modules): """Return generator yielding file descriptions (tuples of module name, file path, base name) The returned generator yield one item for each Python module that should be linted. """ for descr in self._expand_files(files_or_modules): name, filepath, is_arg = descr["name"], descr["path"], descr[ "isarg"] if self.should_analyze_file(name, filepath, is_argument=is_arg): yield (name, filepath, descr["basename"]) def _expand_files(self, modules): """get modules and errors from a list of modules and handle errors """ result, errors = utils.expand_modules(modules, self.config.black_list, self.config.black_list_re) for error in errors: message = modname = error["mod"] key = error["key"] self.set_current_module(modname) if key == "fatal": message = str(error["ex"]).replace(os.getcwd() + os.sep, "") self.add_message(key, args=message) return result def set_current_module(self, modname, filepath=None): """set the name of the currently analyzed module and init statistics for it """ if not modname and filepath is None: return self.reporter.on_set_current_module(modname, filepath) self.current_name = modname self.current_file = filepath or modname self.stats["by_module"][modname] = {} self.stats["by_module"][modname]["statement"] = 0 for msg_cat in MSG_TYPES.values(): self.stats["by_module"][modname][msg_cat] = 0 @contextlib.contextmanager def _astroid_module_checker(self): """Context manager for checking ASTs The value in the context is callable accepting AST as its only argument. """ walker = ASTWalker(self) _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) yield functools.partial( self.check_astroid_module, walker=walker, tokencheckers=tokencheckers, rawcheckers=rawcheckers, ) # notify global end self.stats["statement"] = walker.nbstatements for checker in reversed(_checkers): checker.close() def get_ast(self, filepath, modname, data=None): """Return an ast(roid) representation of a module or a string. :param str filepath: path to checked file. :param str modname: The name of the module to be checked. :param str data: optional contents of the checked file. :returns: the AST :rtype: astroid.nodes.Module """ try: if data is None: return MANAGER.ast_from_file(filepath, modname, source=True) return AstroidBuilder(MANAGER).string_build( data, modname, filepath) except astroid.AstroidSyntaxError as ex: # pylint: disable=no-member self.add_message( "syntax-error", line=getattr(ex.error, "lineno", 0), col_offset=getattr(ex.error, "offset", None), args=str(ex.error), ) except astroid.AstroidBuildingException as ex: self.add_message("parse-error", args=ex) except Exception as ex: # pylint: disable=broad-except traceback.print_exc() self.add_message("astroid-error", args=(ex.__class__, ex)) return None def check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers): """Check a module from its astroid representation. For return value see _check_astroid_module """ before_check_statements = walker.nbstatements retval = self._check_astroid_module(ast_node, walker, rawcheckers, tokencheckers) self.stats["by_module"][self.current_name]["statement"] = ( walker.nbstatements - before_check_statements) return retval def _check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers): """Check given AST node with given walker and checkers :param astroid.nodes.Module ast_node: AST node of the module to check :param pylint.utils.ast_walker.ASTWalker walker: AST walker :param list rawcheckers: List of token checkers to use :param list tokencheckers: List of raw checkers to use :returns: True if the module was checked, False if ignored, None if the module contents could not be parsed :rtype: bool """ try: tokens = utils.tokenize_module(ast_node) except tokenize.TokenError as ex: self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0]) return None if not ast_node.pure_python: self.add_message("raw-checker-failed", args=ast_node.name) else: # assert astroid.file.endswith('.py') # invoke ITokenChecker interface on self to fetch module/block # level options self.process_tokens(tokens) if self._ignore_file: return False # walk ast to collect line numbers self.file_state.collect_block_lines(self.msgs_store, ast_node) # run raw and tokens checkers for checker in rawcheckers: checker.process_module(ast_node) for checker in tokencheckers: checker.process_tokens(tokens) # generate events to astroid checkers walker.walk(ast_node) return True # IAstroidChecker interface ################################################# def open(self): """initialize counters""" self.stats = {"by_module": {}, "by_msg": {}} MANAGER.always_load_extensions = self.config.unsafe_load_any_extension MANAGER.max_inferable_values = self.config.limit_inference_results MANAGER.extension_package_whitelist.update( self.config.extension_pkg_whitelist) for msg_cat in MSG_TYPES.values(): self.stats[msg_cat] = 0 def generate_reports(self): """close the whole package /module, it's time to make reports ! if persistent run, pickle results for later comparison """ # Display whatever messages are left on the reporter. self.reporter.display_messages(report_nodes.Section()) if self.file_state.base_name is not None: # load previous results if any previous_stats = config.load_results(self.file_state.base_name) self.reporter.on_close(self.stats, previous_stats) if self.config.reports: sect = self.make_reports(self.stats, previous_stats) else: sect = report_nodes.Section() if self.config.reports: self.reporter.display_reports(sect) score_value = self._report_evaluation() # save results if persistent run if self.config.persistent: config.save_results(self.stats, self.file_state.base_name) else: self.reporter.on_close(self.stats, {}) score_value = None return score_value def _report_evaluation(self): """make the global evaluation report""" # check with at least check 1 statements (usually 0 when there is a # syntax error preventing pylint from further processing) note = None previous_stats = config.load_results(self.file_state.base_name) if self.stats["statement"] == 0: return note # get a global note for the code evaluation = self.config.evaluation try: note = eval(evaluation, {}, self.stats) # pylint: disable=eval-used except Exception as ex: # pylint: disable=broad-except msg = "An exception occurred while rating: %s" % ex else: self.stats["global_note"] = note msg = "Your code has been rated at %.2f/10" % note pnote = previous_stats.get("global_note") if pnote is not None: msg += " (previous run: %.2f/10, %+.2f)" % (pnote, note - pnote) if self.config.score: sect = report_nodes.EvaluationSection(msg) self.reporter.display_reports(sect) return note
class PyLinter(OptionsManagerMixIn, MessagesHandlerMixIn, ReportsHandlerMixIn, BaseTokenChecker): """lint Python modules using external checkers. This is the main checker controlling the other ones and the reports generation. It is itself both a raw checker and an astroid checker in order to: * handle message activation / deactivation at the module level * handle some basic but necessary stats'data (number of classes, methods...) IDE plugins developpers: you may have to call `astroid.builder.MANAGER.astroid_cache.clear()` accross run if you want to ensure the latest code version is actually checked. """ __implements__ = (ITokenChecker, ) name = 'master' priority = 0 level = 0 msgs = MSGS may_be_disabled = False @staticmethod def make_options(): return ( ('ignore', { 'type': 'csv', 'metavar': '<file>[,<file>...]', 'dest': 'black_list', 'default': ('CVS', ), 'help': 'Add files or directories to the blacklist. ' 'They should be base names, not paths.' }), ('persistent', { 'default': True, 'type': 'yn', 'metavar': '<y_or_n>', 'level': 1, 'help': 'Pickle collected data for later comparisons.' }), ('load-plugins', { 'type': 'csv', 'metavar': '<modules>', 'default': (), 'level': 1, 'help': 'List of plugins (as comma separated values of ' 'python modules names) to load, usually to register ' 'additional checkers.' }), ('output-format', { 'default': 'text', 'type': 'string', 'metavar': '<format>', 'short': 'f', 'group': 'Reports', 'help': 'Set the output format. Available formats are text,' ' parseable, colorized, msvs (visual studio) and html. You ' 'can also give a reporter class, eg mypackage.mymodule.' 'MyReporterClass.' }), ('files-output', { 'default': 0, 'type': 'yn', 'metavar': '<y_or_n>', 'group': 'Reports', 'level': 1, 'help': 'Put messages in a separate file for each module / ' 'package specified on the command line instead of printing ' 'them on stdout. Reports (if any) will be written in a file ' 'name "pylint_global.[txt|html]".' }), ('reports', { 'default': 1, 'type': 'yn', 'metavar': '<y_or_n>', 'short': 'r', 'group': 'Reports', 'help': 'Tells whether to display a full report or only the ' 'messages' }), ('evaluation', { 'type': 'string', 'metavar': '<python_expression>', 'group': 'Reports', 'level': 1, 'default': '10.0 - ((float(5 * error + warning + refactor + ' 'convention) / statement) * 10)', 'help': 'Python expression which should return a note less ' 'than 10 (10 is the highest note). You have access ' 'to the variables errors warning, statement which ' 'respectively contain the number of errors / ' 'warnings messages and the total number of ' 'statements analyzed. This is used by the global ' 'evaluation report (RP0004).' }), ('comment', { 'default': 0, 'type': 'yn', 'metavar': '<y_or_n>', 'group': 'Reports', 'level': 1, 'help': 'Add a comment according to your evaluation note. ' 'This is used by the global evaluation report (RP0004).' }), ('confidence', { 'type': 'multiple_choice', 'metavar': '<levels>', 'default': '', 'choices': [c.name for c in CONFIDENCE_LEVELS], 'group': 'Messages control', 'help': 'Only show warnings with the listed confidence levels.' ' Leave empty to show all. Valid levels: %s' % (', '.join(c.name for c in CONFIDENCE_LEVELS), ) }), ('enable', { 'type': 'csv', 'metavar': '<msg ids>', 'short': 'e', 'group': 'Messages control', 'help': 'Enable the message, report, category or checker with the ' 'given id(s). You can either give multiple identifier ' 'separated by comma (,) or put this option multiple time. ' 'See also the "--disable" option for examples. ' }), ('disable', { 'type': 'csv', 'metavar': '<msg ids>', 'short': 'd', 'group': 'Messages control', 'help': 'Disable the message, report, category or checker ' 'with the given id(s). You can either give multiple identifiers' ' separated by comma (,) or put this option multiple times ' '(only on the command line, not in the configuration file ' 'where it should appear only once).' 'You can also use "--disable=all" to disable everything first ' 'and then reenable specific checks. For example, if you want ' 'to run only the similarities checker, you can use ' '"--disable=all --enable=similarities". ' 'If you want to run only the classes checker, but have no ' 'Warning level messages displayed, use' '"--disable=all --enable=classes --disable=W"' }), ('msg-template', { 'type': 'string', 'metavar': '<template>', 'group': 'Reports', 'help': ('Template used to display messages. ' 'This is a python new-style format string ' 'used to format the message information. ' 'See doc for all details') }), ('include-ids', _deprecated_option('i', 'yn')), ('symbols', _deprecated_option('s', 'yn')), ) option_groups = ( ('Messages control', 'Options controling analysis messages'), ('Reports', 'Options related to output formating and reporting'), ) def __init__(self, options=(), reporter=None, option_groups=(), pylintrc=None): # some stuff has to be done before ancestors initialization... # # messages store / checkers / reporter / astroid manager self.msgs_store = MessagesStore() self.reporter = None self._reporter_name = None self._reporters = {} self._checkers = {} self._ignore_file = False # visit variables self.file_state = FileState() self.current_name = None self.current_file = None self.stats = None # init options self.options = options + PyLinter.make_options() self.option_groups = option_groups + PyLinter.option_groups self._options_methods = { 'enable': self.enable, 'disable': self.disable } self._bw_options_methods = { 'disable-msg': self.disable, 'enable-msg': self.enable } full_version = '%%prog %s, \nastroid %s, common %s\nPython %s' % ( version, astroid_version, common_version, sys.version) OptionsManagerMixIn.__init__(self, usage=__doc__, version=full_version, config_file=pylintrc or config.PYLINTRC) MessagesHandlerMixIn.__init__(self) ReportsHandlerMixIn.__init__(self) BaseTokenChecker.__init__(self) # provided reports self.reports = ( ('RP0001', 'Messages by category', report_total_messages_stats), ('RP0002', '% errors / warnings by module', report_messages_by_module_stats), ('RP0003', 'Messages', report_messages_stats), ('RP0004', 'Global evaluation', self.report_evaluation), ) self.register_checker(self) self._dynamic_plugins = set() self.load_provider_defaults() if reporter: self.set_reporter(reporter) def load_default_plugins(self): checkers_initialize(self) reporters_initialize(self) # Make sure to load the default reporter, because # the option has been set before the plugins had been loaded. if not self.reporter: self._load_reporter() def prepare_import_path(self, args): """Prepare sys.path for running the linter checks.""" if len(args) == 1: sys.path.insert(0, _get_python_path(args[0])) else: sys.path.insert(0, os.getcwd()) def cleanup_import_path(self): """Revert any changes made to sys.path in prepare_import_path.""" sys.path.pop(0) def load_plugin_modules(self, modnames): """take a list of module names which are pylint plugins and load and register them """ for modname in modnames: if modname in self._dynamic_plugins: continue self._dynamic_plugins.add(modname) module = load_module_from_name(modname) module.register(self) def _load_reporter(self): name = self._reporter_name.lower() if name in self._reporters: self.set_reporter(self._reporters[name]()) else: qname = self._reporter_name module = load_module_from_name(get_module_part(qname)) class_name = qname.split('.')[-1] reporter_class = getattr(module, class_name) self.set_reporter(reporter_class()) def set_reporter(self, reporter): """set the reporter used to display messages and reports""" self.reporter = reporter reporter.linter = self def set_option(self, optname, value, action=None, optdict=None): """overridden from configuration.OptionsProviderMixin to handle some special options """ if optname in self._options_methods or \ optname in self._bw_options_methods: if value: try: meth = self._options_methods[optname] except KeyError: meth = self._bw_options_methods[optname] warn( '%s is deprecated, replace it by %s' % (optname, optname.split('-')[0]), DeprecationWarning) value = check_csv(None, optname, value) if isinstance(value, (list, tuple)): for _id in value: meth(_id, ignore_unknown=True) else: meth(value) elif optname == 'output-format': self._reporter_name = value # If the reporters are already available, load # the reporter class. if self._reporters: self._load_reporter() try: BaseTokenChecker.set_option(self, optname, value, action, optdict) except UnsupportedAction: print('option %s can\'t be read from config file' % \ optname, file=sys.stderr) def register_reporter(self, reporter_class): self._reporters[reporter_class.name] = reporter_class def report_order(self): reports = sorted(self._reports, key=lambda x: getattr(x, 'name', '')) try: # Remove the current reporter and add it # at the end of the list. reports.pop(reports.index(self)) except ValueError: pass else: reports.append(self) return reports # checkers manipulation methods ############################################ def register_checker(self, checker): """register a new checker checker is an object implementing IRawChecker or / and IAstroidChecker """ assert checker.priority <= 0, 'checker priority can\'t be >= 0' self._checkers.setdefault(checker.name, []).append(checker) for r_id, r_title, r_cb in checker.reports: self.register_report(r_id, r_title, r_cb, checker) self.register_options_provider(checker) if hasattr(checker, 'msgs'): self.msgs_store.register_messages(checker) checker.load_defaults() def disable_noerror_messages(self): for msgcat, msgids in six.iteritems(self.msgs_store._msgs_by_category): if msgcat == 'E': for msgid in msgids: self.enable(msgid) else: for msgid in msgids: self.disable(msgid) def disable_reporters(self): """disable all reporters""" for reporters in six.itervalues(self._reports): for report_id, _title, _cb in reporters: self.disable_report(report_id) def error_mode(self): """error mode: enable only errors; no reports, no persistent""" self.disable_noerror_messages() self.disable('miscellaneous') self.set_option('reports', False) self.set_option('persistent', False) # block level option handling ############################################# # # see func_block_disable_msg.py test case for expected behaviour def process_tokens(self, tokens): """process tokens from the current module to search for module/block level options """ for (tok_type, content, start, _, _) in tokens: if tok_type != tokenize.COMMENT: continue match = OPTION_RGX.search(content) if match is None: continue if match.group(1).strip() == "disable-all" or \ match.group(1).strip() == 'skip-file': if match.group(1).strip() == "disable-all": self.add_message('deprecated-pragma', line=start[0], args=('disable-all', 'skip-file')) self.add_message('file-ignored', line=start[0]) self._ignore_file = True return try: opt, value = match.group(1).split('=', 1) except ValueError: self.add_message('bad-inline-option', args=match.group(1).strip(), line=start[0]) continue opt = opt.strip() if opt in self._options_methods or opt in self._bw_options_methods: try: meth = self._options_methods[opt] except KeyError: meth = self._bw_options_methods[opt] # found a "(dis|en)able-msg" pragma deprecated suppresssion self.add_message('deprecated-pragma', line=start[0], args=(opt, opt.replace('-msg', ''))) for msgid in splitstrip(value): try: if (opt, msgid) == ('disable', 'all'): self.add_message('deprecated-pragma', line=start[0], args=('disable=all', 'skip-file')) self.add_message('file-ignored', line=start[0]) self._ignore_file = True return meth(msgid, 'module', start[0]) except UnknownMessage: self.add_message('bad-option-value', args=msgid, line=start[0]) else: self.add_message('unrecognized-inline-option', args=opt, line=start[0]) # code checking methods ################################################### def get_checkers(self): """return all available checkers as a list""" return [self] + [ c for checkers in six.itervalues(self._checkers) for c in checkers if c is not self ] def prepare_checkers(self): """return checkers needed for activated messages and reports""" if not self.config.reports: self.disable_reporters() # get needed checkers neededcheckers = [self] for checker in self.get_checkers()[1:]: # fatal errors should not trigger enable / disabling a checker messages = set(msg for msg in checker.msgs if msg[0] != 'F' and self.is_message_enabled(msg)) if (messages or any( self.report_is_enabled(r[0]) for r in checker.reports)): neededcheckers.append(checker) # Sort checkers by priority neededcheckers = sorted(neededcheckers, key=attrgetter('priority'), reverse=True) return neededcheckers def should_analyze_file(self, modname, path): # pylint: disable=unused-argument """Returns whether or not a module should be checked. This implementation returns True for all python source file, indicating that all files should be linted. Subclasses may override this method to indicate that modules satisfying certain conditions should not be linted. :param str modname: The name of the module to be checked. :param str path: The full path to the source code of the module. :returns: True if the module should be checked. :rtype: bool """ return path.endswith('.py') def check(self, files_or_modules): """main checking entry: check a list of files or modules from their name. """ # 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 if not isinstance(files_or_modules, (list, tuple)): files_or_modules = (files_or_modules, ) walker = PyLintASTWalker(self) checkers = self.prepare_checkers() tokencheckers = [ c for c in checkers if implements(c, ITokenChecker) and c is not self ] rawcheckers = [c for c in checkers if implements(c, IRawChecker)] # notify global begin for checker in checkers: checker.open() if implements(checker, IAstroidChecker): walker.add_checker(checker) # build ast and check modules or packages for descr in self.expand_files(files_or_modules): modname, filepath = descr['name'], descr['path'] if not descr['isarg'] and not self.should_analyze_file( modname, filepath): continue if self.config.files_output: reportfile = 'pylint_%s.%s' % (modname, self.reporter.extension) self.reporter.set_output(open(reportfile, 'w')) self.set_current_module(modname, filepath) # get the module representation astroid = self.get_ast(filepath, modname) if astroid is None: continue # XXX to be correct we need to keep module_msgs_state for every # analyzed module (the problem stands with localized messages which # are only detected in the .close step) self.file_state = FileState(descr['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 = astroid.file # pylint: disable=maybe-no-member self.check_astroid_module(astroid, walker, rawcheckers, tokencheckers) # warn about spurious inline messages handling for msgid, line, args in self.file_state.iter_spurious_suppression_messages( self.msgs_store): self.add_message(msgid, line, None, args) # notify global end self.set_current_module('') self.stats['statement'] = walker.nbstatements checkers.reverse() for checker in checkers: checker.close() def expand_files(self, modules): """get modules and errors from a list of modules and handle errors """ result, errors = expand_modules(modules, self.config.black_list) for error in errors: message = modname = error["mod"] key = error["key"] self.set_current_module(modname) if key == "fatal": message = str(error["ex"]).replace(os.getcwd() + os.sep, '') self.add_message(key, args=message) return result def set_current_module(self, modname, filepath=None): """set the name of the currently analyzed module and init statistics for it """ if not modname and filepath is None: return self.reporter.on_set_current_module(modname, filepath) self.current_name = modname self.current_file = filepath or modname self.stats['by_module'][modname] = {} self.stats['by_module'][modname]['statement'] = 0 for msg_cat in six.itervalues(MSG_TYPES): self.stats['by_module'][modname][msg_cat] = 0 def get_ast(self, filepath, modname): """return a ast(roid) representation for a module""" try: return MANAGER.ast_from_file(filepath, modname, source=True) except SyntaxError as ex: self.add_message('syntax-error', line=ex.lineno, args=ex.msg) except AstroidBuildingException as ex: self.add_message('parse-error', args=ex) except Exception as ex: import traceback traceback.print_exc() self.add_message('astroid-error', args=(ex.__class__, ex)) def check_astroid_module(self, astroid, walker, rawcheckers, tokencheckers): """check a module from its astroid representation, real work""" # call raw checkers if possible try: tokens = tokenize_module(astroid) except tokenize.TokenError as ex: self.add_message('syntax-error', line=ex.args[1][0], args=ex.args[0]) return if not astroid.pure_python: self.add_message('raw-checker-failed', args=astroid.name) else: #assert astroid.file.endswith('.py') # invoke ITokenChecker interface on self to fetch module/block # level options self.process_tokens(tokens) if self._ignore_file: return False # walk ast to collect line numbers self.file_state.collect_block_lines(self.msgs_store, astroid) # run raw and tokens checkers for checker in rawcheckers: checker.process_module(astroid) for checker in tokencheckers: checker.process_tokens(tokens) # generate events to astroid checkers walker.walk(astroid) return True # IAstroidChecker interface ################################################# def open(self): """initialize counters""" self.stats = { 'by_module': {}, 'by_msg': {}, } for msg_cat in six.itervalues(MSG_TYPES): self.stats[msg_cat] = 0 def close(self): """close the whole package /module, it's time to make reports ! if persistent run, pickle results for later comparison """ if self.file_state.base_name is not None: # load previous results if any previous_stats = config.load_results(self.file_state.base_name) # XXX code below needs refactoring to be more reporter agnostic self.reporter.on_close(self.stats, previous_stats) if self.config.reports: sect = self.make_reports(self.stats, previous_stats) if self.config.files_output: filename = 'pylint_global.' + self.reporter.extension self.reporter.set_output(open(filename, 'w')) else: sect = Section() if self.config.reports or self.config.output_format == 'html': self.reporter.display_results(sect) # save results if persistent run if self.config.persistent: config.save_results(self.stats, self.file_state.base_name) else: if self.config.output_format == 'html': # No output will be emitted for the html # reporter if the file doesn't exist, so emit # the results here. self.reporter.display_results(Section()) self.reporter.on_close(self.stats, {}) # specific reports ######################################################## def report_evaluation(self, sect, stats, previous_stats): """make the global evaluation report""" # check with at least check 1 statements (usually 0 when there is a # syntax error preventing pylint from further processing) if stats['statement'] == 0: raise EmptyReport() # get a global note for the code evaluation = self.config.evaluation try: note = eval(evaluation, {}, self.stats) except Exception as ex: msg = 'An exception occurred while rating: %s' % ex else: stats['global_note'] = note msg = 'Your code has been rated at %.2f/10' % note pnote = previous_stats.get('global_note') if pnote is not None: msg += ' (previous run: %.2f/10, %+.2f)' % (pnote, note - pnote) if self.config.comment: msg = '%s\n%s' % (msg, config.get_note_message(note)) sect.append(Text(msg))