Apply suggestions from code review

Author: Pierre-Sassoulas

examples/custom_raw.py

@@ -10,7 +10,7 @@
 
 
 class MyRawChecker(BaseChecker):
-    """check for line continuations with '\' instead of using triple quoted string or
+    """Check for line continuations with '\' instead of using triple quoted string or
     parenthesis."""
 
     __implements__ = IRawChecker
@@ -29,7 +29,7 @@ class MyRawChecker(BaseChecker):
     options = ()
 
     def process_module(self, node: nodes.Module) -> None:
-        """process a module.
+        """Process a module.
 
         the module's content is accessible via node.stream() function
         """

pylint/checkers/__init__.py

@@ -19,7 +19,7 @@
 # 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
 
-"""utilities methods and classes for checkers.
+"""Utilities methods and classes for checkers.
 
 Base id of standard checkers (used in msg and report ids):
 01: base
@@ -65,7 +65,7 @@ def table_lines_from_stats(
     old_stats: Optional[LinterStats],
     stat_type: Literal["duplicated_lines", "message_types"],
 ) -> List[str]:
-    """get values listed in <columns> from <stats> and <old_stats>, and return a
+    """Get values listed in <columns> from <stats> and <old_stats>, and return a
     formatted list of values, designed to be given to a ureport.Table object."""
     lines: List[str] = []
     if stat_type == "duplicated_lines":
@@ -126,7 +126,7 @@ def table_lines_from_stats(
 
 
 def initialize(linter):
-    """initialize linter with checkers in this package."""
+    """Initialize linter with checkers in this package."""
     register_plugins(linter, __path__[0])
 
 

pylint/checkers/base.py

@@ -68,7 +68,7 @@
 # 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
 
-"""basic checker for Python code."""
+"""Basic checker for Python code."""
 import collections
 import itertools
 import re
@@ -266,7 +266,7 @@ def in_loop(node: nodes.NodeNG) -> bool:
 
 
 def in_nested_list(nested_list, obj):
-    """return true if the object is an element of <nested_list> or of a nested list."""
+    """Return true if the object is an element of <nested_list> or of a nested list."""
     for elmt in nested_list:
         if isinstance(elmt, (list, tuple)):
             if in_nested_list(elmt, obj):
@@ -398,7 +398,7 @@ def report_by_type_stats(
     stats: LinterStats,
     old_stats: Optional[LinterStats],
 ):
-    """make a report of.
+    """Make a report of.
 
     * percentage of different types documented
     * percentage of different types with a bad name
@@ -838,7 +838,7 @@ def _check_else_on_loop(self, node):
             )
 
     def _check_in_loop(self, node, node_name):
-        """check that a node is inside a for or while loop."""
+        """Check that a node is inside a for or while loop."""
         for parent in node.node_ancestors():
             if isinstance(parent, (nodes.For, nodes.While)):
                 if node not in parent.orelse:
@@ -856,7 +856,7 @@ def _check_in_loop(self, node, node_name):
         self.add_message("not-in-loop", node=node, args=node_name)
 
     def _check_redefinition(self, redeftype, node):
-        """check for redefinition of a function / method / class name."""
+        """Check for redefinition of a function / method / class name."""
         parent_frame = node.parent.frame()
 
         # Ignore function stubs created for type information
@@ -933,7 +933,7 @@ def _check_redefinition(self, redeftype, node):
 
 
 class BasicChecker(_BasicChecker):
-    """checks for :
+    """Checks for :
 
     * doc strings
     * number of arguments, local variables, branches, returns and statements in
@@ -1084,7 +1084,7 @@ def __init__(self, linter):
         self._tryfinallys = None
 
     def open(self):
-        """initialize visit variables and statistics."""
+        """Initialize visit variables and statistics."""
         py_version = get_global_option(self, "py-version")
         self._py38_plus = py_version >= (3, 8)
         self._tryfinallys = []
@@ -1158,11 +1158,11 @@ def _check_using_constant_test(self, node, test):
             self.add_message("using-constant-test", node=node)
 
     def visit_module(self, _: nodes.Module) -> None:
-        """check module name, docstring and required arguments."""
+        """Check module name, docstring and required arguments."""
         self.linter.stats.node_count["module"] += 1
 
     def visit_classdef(self, _: nodes.ClassDef) -> None:
-        """check module name, docstring and redefinition increment branch counter."""
+        """Check module name, docstring and redefinition increment branch counter."""
         self.linter.stats.node_count["klass"] += 1
 
     @utils.check_messages(
@@ -1299,8 +1299,7 @@ def visit_lambda(self, node: nodes.Lambda) -> None:
 
     @utils.check_messages("dangerous-default-value")
     def visit_functiondef(self, node: nodes.FunctionDef) -> None:
-        """check function name, docstring, arguments, redefinition, variable names, max
-        locals."""
+        """Check function name, docstring, args, redefinition, variable names, locals."""
         if node.is_method():
             self.linter.stats.node_count["method"] += 1
         else:
@@ -1362,7 +1361,7 @@ def visit_return(self, node: nodes.Return) -> None:
 
     @utils.check_messages("unreachable")
     def visit_continue(self, node: nodes.Continue) -> None:
-        """check is the node has a right sibling (if so, that's some unreachable
+        """Check is the node has a right sibling (if so, that's some unreachable
         code)"""
         self._check_unreachable(node)
 
@@ -1409,7 +1408,7 @@ def _check_misplaced_format_function(self, call_node):
         "eval-used", "exec-used", "bad-reversed-sequence", "misplaced-format-function"
     )
     def visit_call(self, node: nodes.Call) -> None:
-        """visit a Call node -> check if this is not a disallowed builtin.
+        """Visit a Call node -> check if this is not a disallowed builtin.
 
         call and check for * or ** use
         """
@@ -1445,7 +1444,7 @@ def visit_assert(self, node: nodes.Assert) -> None:
 
     @utils.check_messages("duplicate-key")
     def visit_dict(self, node: nodes.Dict) -> None:
-        """check duplicate key in dictionary."""
+        """Check duplicate key in dictionary."""
         keys = set()
         for k, _ in node.items:
             if isinstance(k, nodes.Const):
@@ -1459,15 +1458,15 @@ def visit_dict(self, node: nodes.Dict) -> None:
             keys.add(key)
 
     def visit_tryfinally(self, node: nodes.TryFinally) -> None:
-        """update try...finally flag."""
+        """Update 'try...finally' flag."""
         self._tryfinallys.append(node)
 
     def leave_tryfinally(self, _: nodes.TryFinally) -> None:
-        """update try...finally flag."""
+        """Update 'try...finally' flag."""
         self._tryfinallys.pop()
 
     def _check_unreachable(self, node):
-        """check unreachable code."""
+        """Check unreachable code."""
         unreach_stmt = node.next_sibling()
         if unreach_stmt is not None:
             if (
@@ -1483,7 +1482,7 @@ def _check_unreachable(self, node):
             self.add_message("unreachable", node=unreach_stmt)
 
     def _check_not_in_finally(self, node, node_name, breaker_classes=()):
-        """check that a node is not inside a 'finally' clause of a 'try...finally'
+        """Check that a node is not inside a 'finally' clause of a 'try...finally'
         statement.
 
         If we find a parent which type is in breaker_classes before a 'try...finally'
@@ -1503,7 +1502,7 @@ def _check_not_in_finally(self, node, node_name, breaker_classes=()):
             _parent = _node.parent
 
     def _check_reversed(self, node):
-        """check that the argument to `reversed` is a sequence."""
+        """Check that the argument to `reversed` is a sequence."""
         try:
             argument = utils.safe_infer(utils.get_argument_from_call(node, position=0))
         except utils.NoSuchArgumentError:
@@ -1960,7 +1959,7 @@ def visit_global(self, node: nodes.Global) -> None:
         "disallowed-name", "invalid-name", "assign-to-new-keyword", "non-ascii-name"
     )
     def visit_assignname(self, node: nodes.AssignName) -> None:
-        """check module level assigned names."""
+        """Check module level assigned names."""
         self._check_assign_to_new_keyword_violation(node.name, node)
         frame = node.frame()
         assign_type = node.assign_type()
@@ -2047,7 +2046,7 @@ def _name_disallowed_by_regex(self, name: str) -> bool:
         )
 
     def _check_name(self, node_type, name, node, confidence=interfaces.HIGH):
-        """check for a name using the type's regexp."""
+        """Check for a name using the type's regexp."""
         non_ascii_match = self._non_ascii_rgx_compiled.match(name)
         if non_ascii_match is not None:
             self._raise_name_warning(
@@ -2266,7 +2265,7 @@ def _check_docstring(
 
 
 class PassChecker(_BasicChecker):
-    """check if the pass statement is really necessary."""
+    """Check if the pass statement is really necessary."""
 
     msgs = {
         "W0107": (
@@ -2457,8 +2456,7 @@ def _is_nan(node) -> bool:
         )
 
     def _check_literal_comparison(self, literal, node: nodes.Compare):
-        """Check if we compare to a literal, which is usually what we do not want to
-        do."""
+        """Check if we compare to a literal, which is not what we usually want to do."""
         is_other_literal = isinstance(literal, (nodes.List, nodes.Dict, nodes.Set))
         is_const = False
         if isinstance(literal, nodes.Const):

pylint/checkers/base_checker.py

@@ -48,7 +48,7 @@ class BaseChecker(OptionsProviderMixIn):
     enabled: bool = True
 
     def __init__(self, linter=None):
-        """checker instances should have the linter as argument.
+        """Checker instances should have the linter as argument.
 
         :param ILinter linter: is an object implementing ILinter.
         """

pylint/checkers/classes/class_checker.py

@@ -352,9 +352,7 @@ def _has_data_descriptor(cls, attr):
 
 
 def _called_in_methods(func, klass, methods):
-    """Check if the func was called in any of the given methods, belonging to the.
-
-    *klass*.
+    """Check if the function was called in any of the methods belonging to 'klass'.
 
     Returns True if so, False otherwise.
     """
@@ -684,7 +682,7 @@ def accessed(self, scope):
 
 
 class ClassChecker(BaseChecker):
-    """checks for :
+    """Checks for :
 
     * methods without self as first argument
     * overridden methods signature
@@ -794,7 +792,7 @@ def _ignore_mixin(self):
         "duplicate-bases",
     )
     def visit_classdef(self, node: nodes.ClassDef) -> None:
-        """init visit variable _accessed."""
+        """Init visit variable _accessed."""
         self._check_bases_classes(node)
         # if not an exception or a metaclass
         if node.type == "class" and has_known_bases(node):
@@ -1069,7 +1067,7 @@ def _check_attribute_defined_outside_init(self, cnode: nodes.ClassDef) -> None:
                             )
 
     def visit_functiondef(self, node: nodes.FunctionDef) -> None:
-        """check method arguments, overriding."""
+        """Check method arguments, overriding."""
         # ignore actual functions
         if not node.is_method():
             return
@@ -1385,9 +1383,9 @@ def _check_slots_elt(self, elt, node):
                 )
 
     def leave_functiondef(self, node: nodes.FunctionDef) -> None:
-        """on method node, check if this method couldn't be a function.
+        """On method node, check if this method couldn't be a function.
 
-        ignore class, static and abstract methods, initializer, methods overridden from
+        Ignore class, static and abstract methods, initializer, methods overridden from
         a parent class.
         """
         if node.is_method():
@@ -1414,7 +1412,7 @@ def leave_functiondef(self, node: nodes.FunctionDef) -> None:
     leave_asyncfunctiondef = leave_functiondef
 
     def visit_attribute(self, node: nodes.Attribute) -> None:
-        """check if the getattr is an access to a class member if so, register it.
+        """Check if the 'getattr' is an access to a class member if so, register it.
 
         Also check for access to protected class member from outside its class (but
         ignore __special__ methods)
@@ -1676,10 +1674,7 @@ def _is_classmethod(func):
 
     @staticmethod
     def _is_inferred_instance(expr, klass):
-        """Check if the inferred value of the given *expr* is an instance of.
-
-        *klass*.
-        """
+        """Check if the inferred value of 'expr' is an instance of 'klass'."""
 
         inferred = safe_infer(expr)
         if not isinstance(inferred, astroid.Instance):
@@ -1689,10 +1684,7 @@ def _is_inferred_instance(expr, klass):
 
     @staticmethod
     def _is_class_attribute(name, klass):
-        """Check if the given attribute *name* is a class or instance member of the
-        given.
-
-        *klass*.
+        """Check if 'name' is a class or instance member of 'klass'.
 
         Returns ``True`` if the name is a property in the given klass,
         ``False`` otherwise.
@@ -1711,14 +1703,14 @@ def _is_class_attribute(name, klass):
             return False
 
     def visit_name(self, node: nodes.Name) -> None:
-        """check if the name handle an access to a class member if so, register it."""
+        """Check if the name handle an access to a class member if so, register it."""
         if self._first_attrs and (
             node.name == self._first_attrs[-1] or not self._first_attrs[-1]
         ):
             self._meth_could_be_func = False
 
     def _check_accessed_members(self, node, accessed):
-        """check that accessed members are defined."""
+        """Check that accessed members are defined."""
         excs = ("AttributeError", "Exception", "BaseException")
         for attr, nodes_lst in accessed.items():
             try:
@@ -1854,8 +1846,7 @@ def _check_first_arg_config(self, first, config, node, message, method_name):
             self.add_message(message, args=(method_name, valid), node=node)
 
     def _check_bases_classes(self, node):
-        """check that the given class node implements abstract methods from base
-        classes."""
+        """Check that 'node' implements abstract methods from base classes."""
 
         def is_abstract(method):
             return method.is_abstract(pass_is_abstract=False)
@@ -1880,7 +1871,7 @@ def is_abstract(method):
             self.add_message("abstract-method", node=node, args=(name, owner.name))
 
     def _check_init(self, node):
-        """check that the __init__ method call super or ancestors'__init__ method
+        """Check that the __init__ method call super or ancestors'__init__ method
         (unless it is used for type hinting with `typing.overload`)"""
         if not self.linter.is_message_enabled(
             "super-init-not-called"
@@ -1938,7 +1929,7 @@ def _check_init(self, node):
             self.add_message("super-init-not-called", args=klass.name, node=node)
 
     def _check_signature(self, method1, refmethod, class_type, cls):
-        """check that the signature of the two given methods match."""
+        """Check that the signature of the two given methods match."""
         if not (
             isinstance(method1, nodes.FunctionDef)
             and isinstance(refmethod, nodes.FunctionDef)
@@ -2035,7 +2026,7 @@ def _is_mandatory_method_param(self, node):
 
 
 def _ancestors_to_call(klass_node, method="__init__"):
-    """return a dictionary where keys are the list of base classes providing the queried
+    """Return a dictionary where keys are the list of base classes providing the queried
     method, and so that should/may be called from the method node."""
     to_call = {}
     for base_node in klass_node.ancestors(recurs=False):

pylint/checkers/deprecated.py

@@ -71,7 +71,7 @@ def visit_call(self, node: nodes.Call) -> None:
         "deprecated-class",
     )
     def visit_import(self, node: nodes.Import) -> None:
-        """triggered when an import statement is seen."""
+        """Triggered when an import statement is seen."""
         for name in (name for name, _ in node.names):
             self.check_deprecated_module(node, name)
             if "." in name:
@@ -107,7 +107,7 @@ def visit_decorators(self, node: nodes.Decorators) -> None:
         "deprecated-class",
     )
     def visit_importfrom(self, node: nodes.ImportFrom) -> None:
-        """triggered when a from statement is seen."""
+        """Triggered when a from statement is seen."""
         basename = node.modname
         basename = get_import_name(node, basename)
         self.check_deprecated_module(node, basename)