Fix typos accross the whole codebase (#5575)

Co-authored-by: Daniël van Noord <[email protected]>
Co-authored-by: Jacob Walls <[email protected]>

Author: 3 people

pylint/checkers/base.py

@@ -298,13 +298,13 @@ def _get_break_loop_node(break_node):
 
 def _loop_exits_early(loop):
     """
-    Returns true if a loop may ends up in a break statement.
+    Returns true if a loop may end with a break statement.
 
     Args:
         loop (astroid.For, astroid.While): the loop node inspected.
 
     Returns:
-        bool: True if the loop may ends up in a break statement, False otherwise.
+        bool: True if the loop may end with a break statement, False otherwise.
     """
     loop_nodes = (nodes.For, nodes.While)
     definition_nodes = (nodes.FunctionDef, nodes.ClassDef)
@@ -349,7 +349,7 @@ def _get_properties(config):
 
 
 def _determine_function_name_type(node: nodes.FunctionDef, config=None):
-    """Determine the name type whose regex the a function's name should match.
+    """Determine the name type whose regex the function's name should match.
 
     :param node: A function node.
     :param config: Configuration from which to pull additional property classes.
@@ -747,7 +747,7 @@ def visit_while(self, node: nodes.While) -> None:
 
     @utils.check_messages("nonexistent-operator")
     def visit_unaryop(self, node: nodes.UnaryOp) -> None:
-        """check use of the non-existent ++ and -- operator operator"""
+        """Check use of the non-existent ++ and -- operators"""
         if (
             (node.op in "+-")
             and isinstance(node.operand, nodes.UnaryOp)
@@ -1244,7 +1244,7 @@ def _has_variadic_argument(args, variadic_name):
 
     @utils.check_messages("unnecessary-lambda")
     def visit_lambda(self, node: nodes.Lambda) -> None:
-        """check whether or not the lambda is suspicious"""
+        """Check whether the lambda is suspicious"""
         # if the body of the lambda is a call expression with the same
         # argument list as the lambda itself, then the lambda is
         # possibly unnecessary and at least suspicious.
@@ -1357,9 +1357,9 @@ def is_iterable(internal_node):
 
     @utils.check_messages("unreachable", "lost-exception")
     def visit_return(self, node: nodes.Return) -> None:
-        """1 - check is the node has a right sibling (if so, that's some
+        """1 - check if the node has a right sibling (if so, that's some
         unreachable code)
-        2 - check is the node is inside the finally clause of a try...finally
+        2 - check if the node is inside the 'finally' clause of a 'try...finally'
         block
         """
         self._check_unreachable(node)
@@ -1375,9 +1375,9 @@ def visit_continue(self, node: nodes.Continue) -> None:
 
     @utils.check_messages("unreachable", "lost-exception")
     def visit_break(self, node: nodes.Break) -> None:
-        """1 - check is the node has a right sibling (if so, that's some
+        """1 - check if the node has a right sibling (if so, that's some
         unreachable code)
-        2 - check is the node is inside the finally clause of a try...finally
+        2 - check if the node is inside the 'finally' clause of a 'try...finally'
         block
         """
         # 1 - Is it right sibling ?
@@ -1490,14 +1490,14 @@ 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 statement.
-        If we found before a try...finally block a parent which its type is
-        in breaker_classes, we skip the whole check."""
+        """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' block we skip the whole check."""
         # if self._tryfinallys is empty, we're not an in try...finally block
         if not self._tryfinallys:
             return
-        # the node could be a grand-grand...-children of the try...finally
+        # the node could be a grand-grand...-child of the 'try...finally'
         _parent = node.parent
         _node = node
         while _parent and not isinstance(_parent, breaker_classes):
@@ -1612,9 +1612,9 @@ def _check_self_assigning_variable(self, node):
                 continue
             if not isinstance(target, nodes.AssignName):
                 continue
+            # Check that the scope is different from a class level, which is usually
+            # a pattern to expose module level attributes as class level ones.
             if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
-                # Check that the scope is different than a class level, which is usually
-                # a pattern to expose module level attributes as class level ones.
                 continue
             if target.name == lhs_name.name:
                 self.add_message(
@@ -2218,7 +2218,7 @@ def _check_docstring(
         report_missing=True,
         confidence=interfaces.HIGH,
     ):
-        """check the node has a non empty docstring"""
+        """Check if the node has a non-empty docstring"""
         docstring = node.doc
         if docstring is None:
             docstring = _infer_dunder_doc_attribute(node)
@@ -2229,7 +2229,7 @@ def _check_docstring(
             lines = utils.get_node_last_lineno(node) - node.lineno
 
             if node_type == "module" and not lines:
-                # If the module has no body, there's no reason
+                # If the module does not have a body, there's no reason
                 # to require a docstring.
                 return
             max_lines = self.config.docstring_min_length
@@ -2469,7 +2469,7 @@ def _check_literal_comparison(self, literal, node: nodes.Compare):
         is_const = False
         if isinstance(literal, nodes.Const):
             if isinstance(literal.value, bool) or literal.value is None:
-                # Not interested in this values.
+                # Not interested in these values.
                 return
             is_const = isinstance(literal.value, (bytes, str, int, float))
 

pylint/checkers/base_checker.py

@@ -86,7 +86,7 @@ def get_full_documentation(self, msgs, options, reports, doc=None, module=None):
             # Provide anchor to link against
             result += get_rst_title(f"{checker_title} Documentation", "^")
             result += f"{cleandoc(doc)}\n\n"
-        # options might be an empty generator and not be False when casted to boolean
+        # options might be an empty generator and not be False when cast to boolean
         options = list(options)
         if options:
             result += get_rst_title(f"{checker_title} Options", "^")
@@ -186,7 +186,7 @@ def get_message_definition(self, msgid):
         raise InvalidMessageError(error_msg)
 
     def open(self):
-        """called before visiting project (i.e set of modules)"""
+        """called before visiting project (i.e. set of modules)"""
 
     def close(self):
         """called after visiting project (i.e set of modules)"""

pylint/checkers/design_analysis.py

@@ -634,9 +634,8 @@ def visit_if(self, node: nodes.If) -> None:
         self._inc_all_stmts(branches)
 
     def _check_boolean_expressions(self, node):
-        """Go through "if" node `node` and counts its boolean expressions
-
-        if the "if" node test is a BoolOp node
+        """Go through "if" node `node` and count its boolean expressions
+        if the 'if' node test is a BoolOp node
         """
         condition = node.test
         if not isinstance(condition, astroid.BoolOp):

pylint/checkers/exceptions.py

@@ -447,7 +447,7 @@ def gather_exceptions_from_handler(
 
         bare_raise = False
         handler_having_bare_raise = None
-        excs_in_bare_handler = []
+        exceptions_in_bare_handler = []
         for handler in node.handlers:
             if bare_raise:
                 # check that subsequent handler is not parent of handler which had bare raise.
@@ -457,14 +457,14 @@ def gather_exceptions_from_handler(
                 excs_in_current_handler = gather_exceptions_from_handler(handler)
                 if not excs_in_current_handler:
                     break
-                if excs_in_bare_handler is None:
+                if exceptions_in_bare_handler is None:
                     # It can be `None` when the inference failed
                     break
                 for exc_in_current_handler in excs_in_current_handler:
                     inferred_current = utils.safe_infer(exc_in_current_handler)
                     if any(
                         utils.is_subclass_of(utils.safe_infer(e), inferred_current)
-                        for e in excs_in_bare_handler
+                        for e in exceptions_in_bare_handler
                     ):
                         bare_raise = False
                         break
@@ -475,7 +475,7 @@ def gather_exceptions_from_handler(
                 if handler.body[0].exc is None:
                     bare_raise = True
                     handler_having_bare_raise = handler
-                    excs_in_bare_handler = gather_exceptions_from_handler(handler)
+                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
         else:
             if bare_raise:
                 self.add_message("try-except-raise", node=handler_having_bare_raise)
@@ -525,50 +525,50 @@ def visit_tryexcept(self, node: nodes.TryExcept) -> None:
                 )
             else:
                 try:
-                    excs = list(_annotated_unpack_infer(handler.type))
+                    exceptions = list(_annotated_unpack_infer(handler.type))
                 except astroid.InferenceError:
                     continue
 
-                for part, exc in excs:
-                    if exc is astroid.Uninferable:
+                for part, exception in exceptions:
+                    if exception is astroid.Uninferable:
                         continue
-                    if isinstance(exc, astroid.Instance) and utils.inherit_from_std_ex(
-                        exc
-                    ):
-                        exc = exc._proxied
+                    if isinstance(
+                        exception, astroid.Instance
+                    ) and utils.inherit_from_std_ex(exception):
+                        exception = exception._proxied
 
-                    self._check_catching_non_exception(handler, exc, part)
+                    self._check_catching_non_exception(handler, exception, part)
 
-                    if not isinstance(exc, nodes.ClassDef):
+                    if not isinstance(exception, nodes.ClassDef):
                         continue
 
                     exc_ancestors = [
                         anc
-                        for anc in exc.ancestors()
+                        for anc in exception.ancestors()
                         if isinstance(anc, nodes.ClassDef)
                     ]
 
                     for previous_exc in exceptions_classes:
                         if previous_exc in exc_ancestors:
-                            msg = f"{previous_exc.name} is an ancestor class of {exc.name}"
+                            msg = f"{previous_exc.name} is an ancestor class of {exception.name}"
                             self.add_message(
                                 "bad-except-order", node=handler.type, args=msg
                             )
                     if (
-                        exc.name in self.config.overgeneral_exceptions
-                        and exc.root().name == utils.EXCEPTIONS_MODULE
+                        exception.name in self.config.overgeneral_exceptions
+                        and exception.root().name == utils.EXCEPTIONS_MODULE
                         and not _is_raising(handler.body)
                     ):
                         self.add_message(
-                            "broad-except", args=exc.name, node=handler.type
+                            "broad-except", args=exception.name, node=handler.type
                         )
 
-                    if exc in exceptions_classes:
+                    if exception in exceptions_classes:
                         self.add_message(
-                            "duplicate-except", args=exc.name, node=handler.type
+                            "duplicate-except", args=exception.name, node=handler.type
                         )
 
-                exceptions_classes += [exc for _, exc in excs]
+                exceptions_classes += [exc for _, exc in exceptions]
 
 
 def register(linter):

pylint/checkers/format.py

@@ -47,7 +47,7 @@
 
 """Python code format's checker.
 
-By default try to follow Guido's style guide :
+By default, try to follow Guido's style guide :
 
 https://www.python.org/doc/essays/styleguide/
 
@@ -594,7 +594,7 @@ def visit_default(self, node: nodes.NodeNG) -> None:
         prev_sibl = node.previous_sibling()
         if prev_sibl is not None:
             prev_line = prev_sibl.fromlineno
-        # The line on which a finally: occurs in a try/finally
+        # The line on which a 'finally': occurs in a 'try/finally'
         # is not directly represented in the AST. We infer it
         # by taking the last line of the body and adding 1, which
         # should be the line of finally:

pylint/checkers/refactoring/recommendation_checker.py

@@ -337,7 +337,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 a f-string"""
+        can be replaced by an f-string"""
         if (
             isinstance(node.parent, nodes.Attribute)
             and node.parent.attrname == "format"

pylint/checkers/strings.py

@@ -518,7 +518,7 @@ def _check_new_format(self, node, func):
                     # only if the .format got at least one keyword argument.
                     # This means that the format strings accepts both
                     # positional and named fields and we should warn
-                    # when one of the them is missing or is extra.
+                    # when one of them is missing or is extra.
                     check_args = True
         else:
             check_args = True
@@ -961,7 +961,7 @@ def _is_long_string(string_token: str) -> bool:
         string_token: The string token to be parsed.
 
     Returns:
-        A boolean representing whether or not this token matches a longstring
+        A boolean representing whether this token matches a longstring
         regex.
     """
     return bool(
@@ -973,15 +973,14 @@ def _is_long_string(string_token: str) -> bool:
 def _get_quote_delimiter(string_token: str) -> str:
     """Returns the quote character used to delimit this token string.
 
-    This function does little checking for whether the token is a well-formed
-    string.
+    This function checks whether the token is a well-formed string.
 
     Args:
         string_token: The token to be parsed.
 
     Returns:
-        A string containing solely the first quote delimiter character in the passed
-        string.
+        A string containing solely the first quote delimiter character in the
+        given string.
 
     Raises:
       ValueError: No quote delimiter characters are present.

pylint/checkers/typecheck.py

@@ -161,7 +161,7 @@ def _is_owner_ignored(owner, attrname, ignored_classes, ignored_modules):
         if fnmatch.fnmatch(module_qname, ignore):
             return True
 
-        # Otherwise we might have a root module name being ignored,
+        # Otherwise, we might have a root module name being ignored,
         # and the qualified owner has more levels of depth.
         parts = deque(module_name.split("."))
         current_module = ""
@@ -1184,14 +1184,14 @@ def _check_dundername_is_string(self, node):
         Check a string is assigned to self.__name__
         """
 
-        # Check the left hand side of the assignment is <something>.__name__
+        # Check the left-hand side of the assignment is <something>.__name__
         lhs = node.targets[0]
         if not isinstance(lhs, nodes.AssignAttr):
             return
         if not lhs.attrname == "__name__":
             return
 
-        # If the right hand side is not a string
+        # If the right-hand side is not a string
         rhs = node.value
         if isinstance(rhs, nodes.Const) and isinstance(rhs.value, str):
             return
@@ -1271,7 +1271,7 @@ def _check_argument_order(self, node, call_site, called, called_param_names):
             # extract argument names, if they have names
             calling_parg_names = [p.name for p in call_site.positional_arguments]
 
-            # Additionally get names of keyword arguments to use in a full match
+            # Additionally, get names of keyword arguments to use in a full match
             # against parameters
             calling_kwarg_names = [
                 arg.name for arg in call_site.keyword_arguments.values()
@@ -1664,7 +1664,7 @@ def _check_invalid_slice_index(self, node: nodes.Slice) -> None:
             if index_type is None or index_type is astroid.Uninferable:
                 continue
 
-            # Constants must of type int or None
+            # Constants must be of type int or None
             if isinstance(index_type, nodes.Const):
                 if isinstance(index_type.value, (int, type(None))):
                     continue
@@ -1733,7 +1733,8 @@ def visit_with(self, node: nodes.With) -> None:
                 # See the test file for not_context_manager for a couple
                 # of self explaining tests.
 
-                # Retrieve node from all previusly visited nodes in the the inference history
+                # Retrieve node from all previously visited nodes in the
+                # inference history
                 context_path_names: Iterator[Any] = filter(
                     None, _unflatten(context.path)
                 )