name : message_definition_store.py # Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html # For details: https://github.com/PyCQA/pylint/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt from __future__ import annotations import collections import functools import sys from collections.abc import Sequence, ValuesView from typing import TYPE_CHECKING from pylint.exceptions import UnknownMessageError from pylint.message.message_definition import MessageDefinition from pylint.message.message_id_store import MessageIdStore if TYPE_CHECKING: from pylint.checkers import BaseChecker class MessageDefinitionStore: """The messages store knows information about every possible message definition but has no particular state during analysis. """ def __init__( self, py_version: tuple[int, ...] | sys._version_info = sys.version_info ) -> None: self.message_id_store: MessageIdStore = MessageIdStore() # Primary registry for all active messages definitions. # It contains the 1:1 mapping from msgid to MessageDefinition. # Keys are msgid, values are MessageDefinition self._messages_definitions: dict[str, MessageDefinition] = {} # MessageDefinition kept by category self._msgs_by_category: dict[str, list[str]] = collections.defaultdict(list) self.py_version = py_version @property def messages(self) -> ValuesView[MessageDefinition]: """The list of all active messages.""" return self._messages_definitions.values() def register_messages_from_checker(self, checker: BaseChecker) -> None: """Register all messages definitions from a checker.""" checker.check_consistency() for message in checker.messages: self.register_message(message) def register_message(self, message: MessageDefinition) -> None: """Register a MessageDefinition with consistency in mind.""" self.message_id_store.register_message_definition( message.msgid, message.symbol, message.old_names ) self._messages_definitions[message.msgid] = message self._msgs_by_category[message.msgid[0]].append(message.msgid) # Since MessageDefinitionStore is only initialized once # and the arguments are relatively small we do not run the # risk of creating a large memory leak. # See discussion in: https://github.com/PyCQA/pylint/pull/5673 @functools.lru_cache( # pylint: disable=method-cache-max-size-none # noqa: B019 maxsize=None ) def get_message_definitions(self, msgid_or_symbol: str) -> list[MessageDefinition]: """Returns the Message definition for either a numeric or symbolic id. The cache has no limit as its size will likely stay minimal. For each message we store about 1000 characters, so even if we would have 1000 messages the cache would only take up ~= 1 Mb. """ return [ self._messages_definitions[m] for m in self.message_id_store.get_active_msgids(msgid_or_symbol) ] def get_msg_display_string(self, msgid_or_symbol: str) -> str: """Generates a user-consumable representation of a message.""" message_definitions = self.get_message_definitions(msgid_or_symbol) if len(message_definitions) == 1: return repr(message_definitions[0].symbol) return repr([md.symbol for md in message_definitions]) def help_message(self, msgids_or_symbols: Sequence[str]) -> None: """Display help messages for the given message identifiers.""" for msgids_or_symbol in msgids_or_symbols: try: for message_definition in self.get_message_definitions( msgids_or_symbol ): print(message_definition.format_help(checkerref=True)) print("") except UnknownMessageError as ex: print(ex) print("") continue def list_messages(self) -> None: """Output full messages list documentation in ReST format.""" emittable, non_emittable = self.find_emittable_messages() print("Emittable messages with current interpreter:") for msg in emittable: print(msg.format_help(checkerref=False)) print("\nNon-emittable messages with current interpreter:") for msg in non_emittable: print(msg.format_help(checkerref=False)) print("") def find_emittable_messages( self, ) -> tuple[list[MessageDefinition], list[MessageDefinition]]: """Finds all emittable and non-emittable messages.""" messages = sorted(self._messages_definitions.values(), key=lambda m: m.msgid) emittable = [] non_emittable = [] for message in messages: if message.may_be_emitted(self.py_version): emittable.append(message) else: non_emittable.append(message) return emittable, non_emittable