Rebased semi-manual changes on #5787

Author: Pierre-Sassoulas

doc/exts/pylint_extensions.py

@@ -2,7 +2,9 @@
 # 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
 
-"""Script used to generate the extensions file before building the actual documentation."""
+"""Script used to generate the extensions file before building the actual
+documentation.
+"""
 
 import os
 import re

doc/exts/pylint_features.py

@@ -2,7 +2,9 @@
 # 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
 
-"""Script used to generate the features file before building the actual documentation."""
+"""Script used to generate the features file before building the actual
+documentation.
+"""
 
 import os
 

doc/user_guide/message-control.rst

@@ -112,7 +112,7 @@ Here's an example with all these rules in a single place:
             pass
 
         def meth1(self, arg):
-            """this issues a message"""
+            """This issues a message"""
             print(self)
 
         def meth2(self, arg):
@@ -122,14 +122,14 @@ Here's an example with all these rules in a single place:
                   + "foo")
 
         def meth3(self):
-            """test one line disabling"""
+            """Test one line disabling"""
             # no error
             print(self.bla) # pylint: disable=no-member
             # error
             print(self.blop)
 
         def meth4(self):
-            """test re-enabling"""
+            """Test re-enabling"""
             # pylint: disable=no-member
             # no error
             print(self.bla)
@@ -139,7 +139,7 @@ Here's an example with all these rules in a single place:
             print(self.blip)
 
         def meth5(self):
-            """test IF sub-block re-enabling"""
+            """Test IF sub-block re-enabling"""
             # pylint: disable=no-member
             # no error
             print(self.bla)
@@ -154,7 +154,7 @@ Here's an example with all these rules in a single place:
             print(self.blip)
 
         def meth6(self):
-            """test TRY/EXCEPT sub-block re-enabling"""
+            """Test TRY/EXCEPT sub-block re-enabling"""
             # pylint: disable=no-member
             # no error
             print(self.bla)
@@ -169,7 +169,7 @@ Here's an example with all these rules in a single place:
             print(self.blip)
 
         def meth7(self):
-            """test one line block opening disabling"""
+            """Test one line block opening disabling"""
             if self.blop: # pylint: disable=no-member
                 # error
                 print(self.blip)
@@ -180,7 +180,7 @@ Here's an example with all these rules in a single place:
             print(self.blip)
 
         def meth8(self):
-            """test late disabling"""
+            """Test late disabling"""
             # error
             print(self.blip)
             # pylint: disable=no-member
@@ -189,7 +189,7 @@ Here's an example with all these rules in a single place:
             print(self.blop)
 
         def meth9(self):
-            """test next line disabling"""
+            """Test next line disabling"""
             # no error
             # pylint: disable-next=no-member
             print(self.bla)

examples/deprecation_checker.py

@@ -1,6 +1,6 @@
-"""Example checker detecting deprecated functions/methods. Following example searches for usages of
-deprecated function `deprecated_function` and deprecated method `MyClass.deprecated_method`
-from module mymodule:
+"""Example checker detecting deprecated functions/methods. Following example searches
+for usages of deprecated function `deprecated_function` and deprecated method
+`MyClass.deprecated_method` from module mymodule:
 
 .. code-block:: console
     $ cat mymodule.py
@@ -59,7 +59,8 @@ class DeprecationChecker(DeprecatedMixin, BaseChecker):
     name = "deprecated"
 
     def deprecated_methods(self) -> Set[str]:
-        """Callback method called by DeprecatedMixin for every method/function found in the code.
+        """Callback method called by DeprecatedMixin for every method/function found in
+        the code.
 
         Returns:
             collections.abc.Container of deprecated function/method names.

pylint/checkers/classes/special_methods_checker.py

@@ -23,8 +23,8 @@
 def _safe_infer_call_result(node, caller, context=None):
     """Safely infer the return value of a function.
 
-    Returns None if inference failed or if there is some ambiguity (more than
-    one node has been inferred). Otherwise, returns inferred value.
+    Returns None if inference failed or if there is some ambiguity (more than one node
+    has been inferred). Otherwise, returns inferred value.
     """
     try:
         inferit = node.infer_call_result(caller, context=context)

pylint/checkers/refactoring/implicit_booleaness_checker.py

@@ -127,9 +127,8 @@ def instance_has_bool(class_def: nodes.ClassDef) -> bool:
 
     @utils.check_messages("use-implicit-booleaness-not-len")
     def visit_unaryop(self, node: nodes.UnaryOp) -> None:
-        """`not len(S)` must become `not S` regardless if the parent block
-        is a test condition or something else (boolean expression)
-        e.g. `if not len(S):`
+        """`not len(S)` must become `not S` regardless if the parent block is a test
+        condition or something else (boolean expression) e.g. `if not len(S):`
         """
         if (
             isinstance(node, nodes.UnaryOp)

pylint/checkers/refactoring/recommendation_checker.py

@@ -102,7 +102,9 @@ def _check_consider_iterating_dictionary(self, node: nodes.Call) -> None:
             self.add_message("consider-iterating-dictionary", node=node)
 
     def _check_use_maxsplit_arg(self, node: nodes.Call) -> None:
-        """Add message when accessing first or last elements of a str.split() or str.rsplit()."""
+        """Add message when accessing first or last elements of a str.split() or
+        str.rsplit().
+        """
 
         # Check if call is split() or rsplit()
         if not (
@@ -337,7 +339,7 @@ def visit_const(self, node: nodes.Const) -> None:
 
     def _detect_replacable_format_call(self, node: nodes.Const) -> None:
         """Check whether a string is used in a call to format() or '%' and whether it
-        can be replaced by an f-string
+        can be replaced by an f-string.
         """
         if (
             isinstance(node.parent, nodes.Attribute)

pylint/checkers/refactoring/refactoring_checker.py

@@ -118,8 +118,8 @@ def _is_a_return_statement(node: nodes.Call) -> bool:
 
 
 def _is_part_of_with_items(node: nodes.Call) -> bool:
-    """Checks if one of the node's parents is a ``nodes.With`` node and that the node itself is located
-    somewhere under its ``items``.
+    """Checks if one of the node's parents is a ``nodes.With`` node and that the node
+    itself is located somewhere under its ``items``.
     """
     frame = node.frame(future=True)
     current = node
@@ -133,8 +133,8 @@ def _is_part_of_with_items(node: nodes.Call) -> bool:
 
 
 def _will_be_released_automatically(node: nodes.Call) -> bool:
-    """Checks if a call that could be used in a ``with`` statement is used in an alternative
-    construct which would ensure that its __exit__ method is called.
+    """Checks if a call that could be used in a ``with`` statement is used in an
+    alternative construct which would ensure that its __exit__ method is called.
     """
     callables_taking_care_of_exit = frozenset(
         (
@@ -151,8 +151,8 @@ def _will_be_released_automatically(node: nodes.Call) -> bool:
 
 
 class ConsiderUsingWithStack(NamedTuple):
-    """Stack for objects that may potentially trigger a R1732 message
-    if they are not used in a ``with`` block later on.
+    """Stack for objects that may potentially trigger a R1732 message if they are not
+    used in a ``with`` block later on.
     """
 
     module_scope: Dict[str, nodes.NodeNG] = {}
@@ -181,9 +181,9 @@ def clear_all(self) -> None:
 class RefactoringChecker(checkers.BaseTokenChecker):
     """Looks for code which can be refactored.
 
-    This checker also mixes the astroid and the token approaches
-    in order to create knowledge about whether an "else if" node
-    is a true "else if" node, or an "elif" node.
+    This checker also mixes the astroid and the token approaches in order to create
+    knowledge about whether an "else if" node is a true "else if" node, or an "elif"
+    node.
     """
 
     __implements__ = (interfaces.ITokenChecker, interfaces.IAstroidChecker)
@@ -488,10 +488,9 @@ def _is_bool_const(node):
     def _is_actual_elif(self, node):
         """Check if the given node is an actual elif.
 
-        This is a problem we're having with the builtin ast module,
-        which splits `elif` branches into a separate if statement.
-        Unfortunately we need to know the exact type in certain
-        cases.
+        This is a problem we're having with the builtin ast module, which splits `elif`
+        branches into a separate if statement. Unfortunately we need to know the exact
+        type in certain cases.
         """
         if isinstance(node.parent, nodes.If):
             orelse = node.parent.orelse
@@ -504,11 +503,10 @@ def _is_actual_elif(self, node):
     def _check_simplifiable_if(self, node):
         """Check if the given if node can be simplified.
 
-        The if statement can be reduced to a boolean expression
-        in some cases. For instance, if there are two branches
-        and both of them return a boolean value that depends on
-        the result of the statement's test, then this can be reduced
-        to `bool(test)` without losing any functionality.
+        The if statement can be reduced to a boolean expression in some cases. For
+        instance, if there are two branches and both of them return a boolean value that
+        depends on the result of the statement's test, then this can be reduced to
+        `bool(test)` without losing any functionality.
         """
 
         if self._is_actual_elif(node):
@@ -1301,8 +1299,8 @@ def _apply_boolean_simplification_rules(operator, values):
     def _simplify_boolean_operation(self, bool_op):
         """Attempts to simplify a boolean operation.
 
-        Recursively applies simplification on the operator terms,
-        and keeps track of whether reductions have been made.
+        Recursively applies simplification on the operator terms, and keeps track of
+        whether reductions have been made.
         """
         children = list(bool_op.get_children())
         intermediate = [
@@ -1323,8 +1321,8 @@ def _simplify_boolean_operation(self, bool_op):
     def _check_simplifiable_condition(self, node):
         """Check if a boolean condition can be simplified.
 
-        Variables will not be simplified, even in the value can be inferred,
-        and expressions like '3 + 4' will remain expanded.
+        Variables will not be simplified, even in the value can be inferred, and
+        expressions like '3 + 4' will remain expanded.
         """
         if not utils.is_test_condition(node):
             return
@@ -1503,7 +1501,7 @@ def _check_consider_using_with(self, node: nodes.Call):
             self.add_message("consider-using-with", node=node)
 
     def _check_use_list_or_dict_literal(self, node: nodes.Call) -> None:
-        """Check if empty list or dict is created by using the literal [] or {}."""
+        """Check if empty list or dict is created by using '[]' or '{}'."""
         if node.as_string() in {"list()", "dict()"}:
             inferred = utils.safe_infer(node.func)
             if isinstance(inferred, nodes.ClassDef) and not node.args:
@@ -1514,6 +1512,7 @@ def _check_use_list_or_dict_literal(self, node: nodes.Call) -> None:
 
     def _check_consider_using_join(self, aug_assign):
         """We start with the augmented assignment and work our way upwards.
+
         Names of variables for nodes if match successful:
         result = ''  # assign
         for number in ['1', '2', '3']  # for_loop
@@ -1638,7 +1637,8 @@ def _check_unnecessary_comprehension(self, node: nodes.Comprehension) -> None:
     def _is_and_or_ternary(node):
         """Returns true if node is 'condition and true_value or false_value' form.
 
-        All of: condition, true_value and false_value should not be a complex boolean expression
+        All of: condition, true_value and false_value should not be a complex boolean
+        expression
         """
         return (
             isinstance(node, nodes.BoolOp)
@@ -1671,7 +1671,6 @@ def _check_consistent_returns(self, node: nodes.FunctionDef) -> None:
 
         Args:
             node (nodes.FunctionDef): the function holding the return statements.
-
         """
         # explicit return statements are those with a not None value
         explicit_returns = [
@@ -1756,7 +1755,6 @@ def _is_node_return_ended(self, node: nodes.NodeNG) -> bool:
 
         Returns:
             bool: True if the node ends with an explicit statement, False otherwise.
-
         """
         # Recursion base case
         if isinstance(node, nodes.Return):
@@ -1828,9 +1826,9 @@ def _is_function_def_never_returning(self, node: nodes.FunctionDef) -> bool:
             return False
 
     def _check_return_at_the_end(self, node):
-        """Check for presence of a *single* return statement at the end of a
-        function. "return" or "return None" are useless because None is the
-        default return type if they are missing.
+        """Check for presence of a *single* return statement at the end of a function.
+        "return" or "return None" are useless because None is the default return type if
+        they are missing.
 
         NOTE: produces a message only if there is a single return statement
         in the function body. Otherwise _check_consistent_returns() is called!

pylint/checkers/stdlib.py

@@ -625,6 +625,7 @@ def _check_redundant_assert(self, node, infer):
 
     def _check_datetime(self, node):
         """Check that a datetime was inferred.
+
         If so, emit boolean-datetime warning.
         """
         try:

pylint/checkers/strings.py

@@ -226,8 +226,8 @@
 
 
 def get_access_path(key, parts):
-    """Given a list of format specifiers, returns
-    the final access path (e.g. a.b.c[0][1]).
+    """Given a list of format specifiers, returns the final access path (e.g.
+    a.b.c[0][1]).
     """
     path = []
     for is_attribute, specifier in parts:
@@ -256,8 +256,8 @@ def arg_matches_format_type(arg_type, format_type):
 
 
 class StringFormatChecker(BaseChecker):
-    """Checks string formatting operations to ensure that the format string
-    is valid and the arguments match the format string.
+    """Checks string formatting operations to ensure that the format string is valid and
+    the arguments match the format string.
     """
 
     __implements__ = (IAstroidChecker,)
@@ -539,8 +539,8 @@ def _check_new_format(self, node, func):
         self._check_new_format_specifiers(node, fields, named_arguments)
 
     def _check_new_format_specifiers(self, node, fields, named):
-        """Check attribute and index access in the format
-        string ("{0.a}" and "{0[a]}").
+        """Check attribute and index access in the format string ("{0.a}" and
+        "{0[a]}").
         """
         for key, specifiers in fields:
             # Obtain the argument. If it can't be obtained
@@ -933,6 +933,7 @@ def register(linter: "PyLinter") -> None:
 
 def str_eval(token):
     """Mostly replicate `ast.literal_eval(token)` manually to avoid any performance hit.
+
     This supports f-strings, contrary to `ast.literal_eval`.
     We have to support all string literal notations:
     https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals

pylint/checkers/typecheck.py

@@ -1142,7 +1142,9 @@ def visit_assign(self, node: nodes.Assign) -> None:
         self._check_dundername_is_string(node)
 
     def _check_assignment_from_function_call(self, node: nodes.Assign) -> None:
-        """When assigning to a function call, check that the function returns a valid value."""
+        """Check that if assigning to a function call, the function is
+        possibly returning something valuable
+        """
         if not isinstance(node.value, nodes.Call):
             return