back to Claude Sonnet 3.5 - Fill-in summary
Claude Sonnet 3.5 - Fill-in: pylint
Failed to run pytests for test tests
ImportError while loading conftest '/testbed/tests/conftest.py'.
tests/conftest.py:15: in <module>
from pylint import checkers
pylint/checkers/__init__.py:47: in <module>
from pylint.checkers.base_checker import (
pylint/checkers/base_checker.py:9: in <module>
from pylint.config.arguments_provider import _ArgumentsProvider
pylint/config/arguments_provider.py:5: in <module>
from pylint.config.arguments_manager import _ArgumentsManager
pylint/config/arguments_manager.py:11: in <module>
from pylint import utils
pylint/utils/__init__.py:13: in <module>
from pylint.utils.utils import (
E ImportError: cannot import name '_check_csv' from 'pylint.utils.utils' (/testbed/pylint/utils/utils.py)
Patch diff
diff --git a/doc/requirements.txt b/doc/requirements.txt
index f4373c3de..a61c04145 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -2,4 +2,5 @@ Sphinx==7.3.7
sphinx-reredirects<1
towncrier~=23.11
furo==2024.5.6
+psutil==5.9.5
-e .
diff --git a/pylint/__pkginfo__.py b/pylint/__pkginfo__.py
index 74986243c..2aa1e84f7 100644
--- a/pylint/__pkginfo__.py
+++ b/pylint/__pkginfo__.py
@@ -12,7 +12,7 @@ def get_numversion_from_version(v: str) ->tuple[int, int, int]:
See https://github.com/pylint-dev/pylint/issues/4399
https://github.com/pylint-dev/pylint/issues/4420,
"""
- pass
+ return tuple(map(int, v.split('.')))
numversion = get_numversion_from_version(__version__)
diff --git a/pylint/checkers/base/basic_checker.py b/pylint/checkers/base/basic_checker.py
index 2c39eeb46..2fe8a4704 100644
--- a/pylint/checkers/base/basic_checker.py
+++ b/pylint/checkers/base/basic_checker.py
@@ -131,25 +131,36 @@ class BasicChecker(_BasicChecker):
def open(self) ->None:
"""Initialize visit variables and statistics."""
- pass
+ self._try_finally_nodes = []
+ self._init_branch_stack()
@staticmethod
- def _name_holds_generator(test: nodes.Name) ->tuple[bool, nodes.Call | None
- ]:
+ def _name_holds_generator(test: nodes.Name) ->tuple[bool, nodes.Call | None]:
"""Return whether `test` tests a name certain to hold a generator, or optionally
a call that should be then tested to see if *it* returns only generators.
"""
- pass
-
- def visit_module(self, _: nodes.Module) ->None:
+ if isinstance(test, nodes.Name):
+ if test.name in ('iter', 'generator'):
+ return True, None
+ inferred = utils.safe_infer(test)
+ if isinstance(inferred, astroid.FunctionDef) and inferred.is_generator():
+ return True, None
+ elif isinstance(test, nodes.Call):
+ return False, test
+ return False, None
+
+ def visit_module(self, node: nodes.Module) ->None:
"""Check module name, docstring and required arguments."""
- pass
+ self._check_docstring(node)
+ self._check_required_attributes(node)
- def visit_classdef(self, _: nodes.ClassDef) ->None:
+ def visit_classdef(self, node: nodes.ClassDef) ->None:
"""Check module name, docstring and redefinition
increment branch counter.
"""
- pass
+ self._check_docstring(node)
+ self._check_redefinition(node)
+ self._init_branch_stack()
@utils.only_required_for_messages('pointless-statement',
'pointless-exception-statement', 'pointless-string-statement',
@@ -173,90 +184,119 @@ class BasicChecker(_BasicChecker):
def _check_dangerous_default(self, node: nodes.FunctionDef) ->None:
"""Check for dangerous default values as arguments."""
- pass
+ for default in node.args.defaults:
+ if isinstance(default, (nodes.List, nodes.Dict, nodes.Set)):
+ self.add_message('dangerous-default-value', node=default, args=(default.as_string(),))
@utils.only_required_for_messages('unreachable', 'lost-exception')
def visit_return(self, node: nodes.Return) ->None:
- """Return node visitor.
-
- 1 - check if the node has a right sibling (if so, that's some
- unreachable code)
- 2 - check if the node is inside the 'finally' clause of a 'try...finally'
- block
- """
- pass
+ """Return node visitor."""
+ self._check_unreachable(node)
+ self._check_not_in_finally(node, 'return')
@utils.only_required_for_messages('unreachable')
def visit_continue(self, node: nodes.Continue) ->None:
- """Check is the node has a right sibling (if so, that's some unreachable
- code).
- """
- pass
+ """Check if the node has a right sibling (if so, that's some unreachable code)."""
+ self._check_unreachable(node)
@utils.only_required_for_messages('unreachable', 'lost-exception')
def visit_break(self, node: nodes.Break) ->None:
- """Break node visitor.
-
- 1 - check if the node has a right sibling (if so, that's some
- unreachable code)
- 2 - check if the node is inside the 'finally' clause of a 'try...finally'
- block
- """
- pass
+ """Break node visitor."""
+ self._check_unreachable(node)
+ self._check_not_in_finally(node, 'break')
@utils.only_required_for_messages('unreachable')
def visit_raise(self, node: nodes.Raise) ->None:
- """Check if the node has a right sibling (if so, that's some unreachable
- code).
- """
- pass
+ """Check if the node has a right sibling (if so, that's some unreachable code)."""
+ self._check_unreachable(node)
@utils.only_required_for_messages('eval-used', 'exec-used',
'bad-reversed-sequence', 'misplaced-format-function', 'unreachable')
def visit_call(self, node: nodes.Call) ->None:
"""Visit a Call node."""
- pass
+ if isinstance(node.func, nodes.Name):
+ if node.func.name == 'eval':
+ self.add_message('eval-used', node=node)
+ elif node.func.name == 'exec':
+ self.add_message('exec-used', node=node)
+ elif node.func.name == 'reversed':
+ self._check_reversed(node)
+ self._check_unreachable(node)
@utils.only_required_for_messages('assert-on-tuple',
'assert-on-string-literal')
def visit_assert(self, node: nodes.Assert) ->None:
"""Check whether assert is used on a tuple or string literal."""
- pass
+ if isinstance(node.test, nodes.Tuple) and node.test.elts:
+ self.add_message('assert-on-tuple', node=node)
+ elif isinstance(node.test, nodes.Const) and isinstance(node.test.value, str):
+ self.add_message('assert-on-string-literal', node=node, args=('always' if node.test.value else 'never',))
@utils.only_required_for_messages('duplicate-key')
def visit_dict(self, node: nodes.Dict) ->None:
"""Check duplicate key in dictionary."""
- pass
+ keys = set()
+ for key, _ in node.items:
+ if isinstance(key, nodes.Const):
+ if key.value in keys:
+ self.add_message('duplicate-key', node=key, args=(key.value,))
+ keys.add(key.value)
@utils.only_required_for_messages('duplicate-value')
def visit_set(self, node: nodes.Set) ->None:
"""Check duplicate value in set."""
- pass
+ values = set()
+ for elt in node.elts:
+ if isinstance(elt, nodes.Const):
+ if elt.value in values:
+ self.add_message('duplicate-value', node=elt, args=(elt.value,))
+ values.add(elt.value)
def visit_try(self, node: nodes.Try) ->None:
"""Update try block flag."""
- pass
+ self._trys.append(node)
def leave_try(self, _: nodes.Try) ->None:
"""Update try block flag."""
- pass
+ self._trys.pop()
def _check_unreachable(self, node: (nodes.Return | nodes.Continue |
nodes.Break | nodes.Raise | nodes.Call), confidence: Confidence=HIGH
) ->None:
"""Check unreachable code."""
- pass
+ if isinstance(node.parent, nodes.If):
+ return
+ if isinstance(node.parent, (nodes.ExceptHandler, nodes.TryExcept)):
+ return
+ if isinstance(node.parent, nodes.Try) and node.parent.finalbody:
+ return
+ siblings = list(node.parent.get_children())
+ index = siblings.index(node)
+ if index < len(siblings) - 1:
+ self.add_message('unreachable', node=siblings[index + 1], confidence=confidence)
def _check_not_in_finally(self, node: (nodes.Break | nodes.Return),
node_name: str, breaker_classes: tuple[nodes.NodeNG, ...]=()) ->None:
- """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.
- """
- pass
+ """Check that a node is not inside a 'finally' clause of a 'try...finally' statement."""
+ current = node
+ while current and not isinstance(current, breaker_classes):
+ if isinstance(current, nodes.TryFinally):
+ if current.finalbody and node in current.finalbody:
+ self.add_message('lost-exception', node=node, args=(node_name,))
+ return
+ current = current.parent
def _check_reversed(self, node: nodes.Call) ->None:
"""Check that the argument to `reversed` is a sequence."""
- pass
+ if len(node.args) != 1:
+ return
+ arg = utils.safe_infer(node.args[0])
+ if arg:
+ if isinstance(arg, astroid.Instance):
+ if arg.getattr('__reversed__'):
+ return
+ if arg.getattr('__getitem__') and arg.getattr('__len__'):
+ return
+ elif isinstance(arg, nodes.List):
+ return
+ self.add_message('bad-reversed-sequence', node=node)
diff --git a/pylint/checkers/base/basic_error_checker.py b/pylint/checkers/base/basic_error_checker.py
index 14c962bfb..90c4b6f2f 100644
--- a/pylint/checkers/base/basic_error_checker.py
+++ b/pylint/checkers/base/basic_error_checker.py
@@ -25,7 +25,10 @@ def _get_break_loop_node(break_node: nodes.Break) ->(nodes.For | nodes.
Returns:
astroid.For or astroid.While: the loop node holding the break node.
"""
- pass
+ parent = break_node.parent
+ while parent and not isinstance(parent, (nodes.For, nodes.While)):
+ parent = parent.parent
+ return parent
def _loop_exits_early(loop: (nodes.For | nodes.While)) ->bool:
@@ -37,7 +40,24 @@ def _loop_exits_early(loop: (nodes.For | nodes.While)) ->bool:
Returns:
bool: True if the loop may end with a break statement, False otherwise.
"""
- pass
+ for child in loop.get_children():
+ if isinstance(child, nodes.Break):
+ return True
+ if isinstance(child, (nodes.For, nodes.While)):
+ continue
+ if isinstance(child, nodes.If) and _if_statement_exits_early(child):
+ return True
+ return False
+
+def _if_statement_exits_early(if_node: nodes.If) ->bool:
+ """Helper function to check if an if statement contains a break."""
+ for child in if_node.get_children():
+ if isinstance(child, nodes.Break):
+ return True
+ if isinstance(child, nodes.If):
+ if _if_statement_exits_early(child):
+ return True
+ return False
def _has_abstract_methods(node: nodes.ClassDef) ->bool:
@@ -46,7 +66,16 @@ def _has_abstract_methods(node: nodes.ClassDef) ->bool:
The methods should be made abstract by decorating them
with `abc` decorators.
"""
- pass
+ for method in node.mymethods():
+ if method.decorators:
+ for decorator in method.decorators.nodes:
+ if isinstance(decorator, nodes.Name):
+ if decorator.name in ('abstractmethod', 'abstractproperty'):
+ return True
+ elif isinstance(decorator, nodes.Attribute):
+ if decorator.attrname in ('abstractmethod', 'abstractproperty'):
+ return True
+ return False
def redefined_by_decorator(node: nodes.FunctionDef) ->bool:
@@ -58,7 +87,13 @@ def redefined_by_decorator(node: nodes.FunctionDef) ->bool:
@x.setter
def x(self, value): self._x = value
"""
- pass
+ if not node.decorators:
+ return False
+ for decorator in node.decorators.nodes:
+ if (isinstance(decorator, nodes.Attribute) and
+ decorator.attrname in ('setter', 'deleter')):
+ return True
+ return False
class BasicErrorChecker(_BasicChecker):
@@ -116,24 +151,50 @@ class BasicErrorChecker(_BasicChecker):
@utils.only_required_for_messages('star-needs-assignment-target')
def visit_starred(self, node: nodes.Starred) ->None:
"""Check that a Starred expression is used in an assignment target."""
- pass
+ if not isinstance(node.parent, (nodes.Assign, nodes.AnnAssign)):
+ self.add_message('star-needs-assignment-target', node=node)
visit_asyncfunctiondef = visit_functiondef
def _check_nonlocal_and_global(self, node: nodes.FunctionDef) ->None:
"""Check that a name is both nonlocal and global."""
- pass
+ nonlocal_names = set()
+ global_names = set()
+
+ for child in node.body:
+ if isinstance(child, nodes.Global):
+ global_names.update(child.names)
+ elif isinstance(child, nodes.Nonlocal):
+ nonlocal_names.update(child.names)
+
+ for name in nonlocal_names.intersection(global_names):
+ self.add_message('nonlocal-and-global', args=name, node=node)
@utils.only_required_for_messages('nonexistent-operator')
def visit_unaryop(self, node: nodes.UnaryOp) ->None:
"""Check use of the non-existent ++ and -- operators."""
- pass
+ if node.op in ('++', '--'):
+ self.add_message('nonexistent-operator', args=node.op, node=node)
@utils.only_required_for_messages('abstract-class-instantiated')
def visit_call(self, node: nodes.Call) ->None:
"""Check instantiating abstract class with
abc.ABCMeta as metaclass.
"""
- pass
+ if isinstance(node.func, nodes.Name):
+ inferred = utils.safe_infer(node.func)
+ if (isinstance(inferred, nodes.ClassDef) and
+ _has_abstract_methods(inferred) and
+ _is_abc_metaclass(inferred)):
+ self.add_message('abstract-class-instantiated',
+ args=inferred.name, node=node)
+
+def _is_abc_metaclass(node: nodes.ClassDef) ->bool:
+ """Check if the class uses ABC as a metaclass."""
+ metaclass = node.metaclass()
+ if metaclass:
+ return (utils.is_node_in_typing_guarded_import_block(metaclass) and
+ metaclass.qname() in ABC_METACLASSES)
+ return False
def _check_else_on_loop(self, node: (nodes.For | nodes.While)) ->None:
"""Check that any loop with an else clause has a break statement."""
diff --git a/pylint/checkers/base/comparison_checker.py b/pylint/checkers/base/comparison_checker.py
index 5eefa2387..d354d8ffc 100644
--- a/pylint/checkers/base/comparison_checker.py
+++ b/pylint/checkers/base/comparison_checker.py
@@ -12,7 +12,11 @@ TYPE_QNAME = 'builtins.type'
def _is_one_arg_pos_call(call: nodes.NodeNG) ->bool:
"""Is this a call with exactly 1 positional argument ?"""
- pass
+ return (
+ isinstance(call, nodes.Call)
+ and len(call.args) == 1
+ and not call.keywords
+ )
class ComparisonChecker(_BasicChecker):
@@ -50,12 +54,41 @@ class ComparisonChecker(_BasicChecker):
right_value: nodes.NodeNG, root_node: nodes.Compare,
checking_for_absence: bool=False) ->None:
"""Check if == or != is being used to compare a singleton value."""
- pass
+ singleton_values = (True, False, None)
+ for value in (left_value, right_value):
+ if isinstance(value, nodes.Const) and value.value in singleton_values:
+ singleton = value.value
+ if checking_for_absence:
+ suggestion = "is not" if singleton is not None else "is"
+ bad_op = "!="
+ else:
+ suggestion = "is"
+ bad_op = "=="
+ self.add_message(
+ 'singleton-comparison',
+ node=root_node,
+ args=(bad_op, suggestion),
+ confidence=HIGH,
+ )
+ break
def _check_literal_comparison(self, literal: nodes.NodeNG, node: nodes.
Compare) ->None:
"""Check if we compare to a literal, which is usually what we do not want to do."""
- pass
+ if isinstance(literal, LITERAL_NODE_TYPES):
+ operator = node.ops[0][0]
+ left = node.left
+ right = node.ops[0][1]
+
+ if operator in COMPARISON_OPERATORS:
+ if isinstance(left, LITERAL_NODE_TYPES) and not isinstance(right, LITERAL_NODE_TYPES):
+ suggested = f"{right.as_string()} {operator} {left.as_string()}"
+ self.add_message(
+ 'literal-comparison',
+ node=node,
+ args=(node.as_string(), suggested, operator, left.as_string()),
+ confidence=HIGH,
+ )
def _check_logical_tautology(self, node: nodes.Compare) ->None:
"""Check if identifier is compared against itself.
@@ -66,13 +99,42 @@ class ComparisonChecker(_BasicChecker):
if val == val: # [comparison-with-itself]
pass
"""
- pass
+ left = node.left
+ for operator, right in node.ops:
+ if isinstance(left, nodes.Name) and isinstance(right, nodes.Name):
+ if left.name == right.name:
+ self.add_message(
+ 'comparison-with-itself',
+ node=node,
+ args=node.as_string(),
+ confidence=HIGH,
+ )
+ left = right
def _check_constants_comparison(self, node: nodes.Compare) ->None:
"""When two constants are being compared it is always a logical tautology."""
- pass
+ left = node.left
+ for operator, right in node.ops:
+ if (isinstance(left, nodes.Const) and isinstance(right, nodes.Const) and
+ left.value.__class__ == right.value.__class__):
+ self.add_message(
+ 'comparison-of-constants',
+ node=node,
+ args=(left.value, operator, right.value),
+ confidence=HIGH,
+ )
+ left = right
def _check_type_x_is_y(self, node: nodes.Compare, left: nodes.NodeNG,
operator: str, right: nodes.NodeNG) ->None:
"""Check for expressions like type(x) == Y."""
- pass
+ if (isinstance(left, nodes.Call) and
+ isinstance(left.func, nodes.Name) and
+ left.func.name == 'type' and
+ operator in TYPECHECK_COMPARISON_OPERATORS):
+ if _is_one_arg_pos_call(left):
+ self.add_message(
+ 'unidiomatic-typecheck',
+ node=node,
+ confidence=HIGH,
+ )
diff --git a/pylint/checkers/base/docstring_checker.py b/pylint/checkers/base/docstring_checker.py
index c691ef0c0..9368c66f1 100644
--- a/pylint/checkers/base/docstring_checker.py
+++ b/pylint/checkers/base/docstring_checker.py
@@ -39,4 +39,35 @@ class DocStringChecker(_BasicChecker):
FunctionDef), report_missing: bool=True, confidence: interfaces.
Confidence=interfaces.HIGH) ->None:
"""Check if the node has a non-empty docstring."""
- pass
+ docstring = node.doc_node.value if node.doc_node else None
+ if docstring is None:
+ if not report_missing:
+ return
+ if node_type == 'module' and not node.body:
+ # Empty module, don't require docstring
+ return
+ if node_type in ('function', 'method'):
+ if node.name.startswith('_') and not node.name.endswith('__'):
+ # Don't require docstrings for non-public methods
+ return
+ if is_property_setter(node) or is_property_deleter(node):
+ # Don't require docstrings for property setters/deleters
+ return
+ if is_overload_stub(node):
+ # Don't require docstrings for overload stubs
+ return
+
+ # Check if the node matches the no-docstring-rgx
+ if self.linter.config.no_docstring_rgx.match(node.name):
+ return
+
+ # Check if the node is shorter than docstring-min-length
+ if self.linter.config.docstring_min_length > -1:
+ if node.end_lineno - node.lineno + 1 < self.linter.config.docstring_min_length:
+ return
+
+ # Report missing docstring
+ self.add_message(f'missing-{node_type}-docstring', node=node, confidence=confidence)
+ elif not docstring.strip():
+ # Report empty docstring
+ self.add_message('empty-docstring', node=node, args=(node_type,))
diff --git a/pylint/checkers/base/function_checker.py b/pylint/checkers/base/function_checker.py
index 8a0108704..03a04dd0e 100644
--- a/pylint/checkers/base/function_checker.py
+++ b/pylint/checkers/base/function_checker.py
@@ -23,7 +23,19 @@ class FunctionChecker(_BasicChecker):
:param node: FunctionDef node to check
:type node: nodes.FunctionDef
"""
- pass
+ if not node.is_generator():
+ return
+
+ yield_nodes = list(node.nodes_of_class(nodes.Yield))
+ if not yield_nodes:
+ return
+
+ if self._node_fails_contextmanager_cleanup(node, yield_nodes):
+ self.add_message(
+ 'contextmanager-generator-missing-cleanup',
+ node=node,
+ args=(node.name,)
+ )
@staticmethod
def _node_fails_contextmanager_cleanup(node: nodes.FunctionDef,
@@ -42,4 +54,20 @@ class FunctionChecker(_BasicChecker):
:type yield_nodes: list[nodes.Yield]
:rtype: bool
"""
- pass
+ # Check if the yield value is non-constant
+ if any(not utils.is_const_node(yield_node.value) for yield_node in yield_nodes):
+ # Check if there's a finally block or GeneratorExit is caught
+ try_finally = next(node.nodes_of_class(nodes.TryFinally), None)
+ if not try_finally:
+ # Check if GeneratorExit is caught
+ try_except = next(node.nodes_of_class(nodes.TryExcept), None)
+ if not try_except or not any(
+ isinstance(handler.type, nodes.Name) and handler.type.name == 'GeneratorExit'
+ for handler in try_except.handlers
+ ):
+ # Check if there are statements after the yield
+ for yield_node in yield_nodes:
+ if any(isinstance(sibling, (nodes.Assign, nodes.Expr))
+ for sibling in yield_node.get_siblings()):
+ return True
+ return False
diff --git a/pylint/checkers/base/name_checker/checker.py b/pylint/checkers/base/name_checker/checker.py
index 1ef68f6ca..8ba6d4c9a 100644
--- a/pylint/checkers/base/name_checker/checker.py
+++ b/pylint/checkers/base/name_checker/checker.py
@@ -42,7 +42,9 @@ def _get_properties(config: argparse.Namespace) ->tuple[set[str], set[str]]:
Property classes are fully qualified, such as 'abc.abstractproperty' and
property names are the actual names, such as 'abstract_property'.
"""
- pass
+ property_classes = set(config.property_classes)
+ property_names = {prop.rsplit('.', 1)[-1] for prop in property_classes}
+ return property_classes, property_names
def _redefines_import(node: nodes.AssignName) ->bool:
@@ -51,7 +53,23 @@ def _redefines_import(node: nodes.AssignName) ->bool:
Returns True if the node redefines an import, False otherwise.
"""
- pass
+ current = node
+ while current and not isinstance(current, (nodes.ExceptHandler, nodes.TryExcept)):
+ current = current.parent
+
+ if not isinstance(current, (nodes.ExceptHandler, nodes.TryExcept)):
+ return False
+
+ try_block = current.body if isinstance(current, nodes.TryExcept) else current.parent.body
+ for import_node in try_block:
+ if isinstance(import_node, (nodes.Import, nodes.ImportFrom)):
+ for name, alias in import_node.names:
+ if alias:
+ if alias == node.name:
+ return True
+ elif name == node.name:
+ return True
+ return False
def _determine_function_name_type(node: nodes.FunctionDef, config: argparse
@@ -63,7 +81,37 @@ def _determine_function_name_type(node: nodes.FunctionDef, config: argparse
:returns: One of ('function', 'method', 'attr')
"""
- pass
+ if not node.is_method():
+ return 'function'
+
+ if node.decorators:
+ decorators = node.decorators.nodes
+ else:
+ decorators = []
+
+ property_classes, property_names = _get_properties(config)
+
+ for decorator in decorators:
+ if (isinstance(decorator, nodes.Name) and decorator.name in property_names or
+ isinstance(decorator, nodes.Attribute) and decorator.attrname in property_names or
+ isinstance(decorator, nodes.Call) and isinstance(decorator.func, nodes.Name) and
+ decorator.func.name in property_names):
+ return 'attr'
+
+ if isinstance(decorator, nodes.Attribute):
+ if decorator.attrname in ('setter', 'deleter'):
+ return 'attr'
+ if (decorator.expr.name == 'property' and decorator.attrname in ('getter', 'setter', 'deleter')):
+ return 'attr'
+
+ if (node.name == '__new__' or
+ node.name.startswith('__') and node.name.endswith('__')):
+ return 'method'
+
+ if node.name == '__init_subclass__':
+ return 'classmethod'
+
+ return 'method'
EXEMPT_NAME_CATEGORIES = {'exempt', 'ignore'}
diff --git a/pylint/checkers/base_checker.py b/pylint/checkers/base_checker.py
index 7979baa3b..d10d398f4 100644
--- a/pylint/checkers/base_checker.py
+++ b/pylint/checkers/base_checker.py
@@ -84,15 +84,30 @@ class BaseChecker(_ArgumentsProvider):
:raises InvalidMessageError: If the checker id in the messages are not
always the same.
"""
- pass
+ checker_id = None
+ for msgid, msg in self.msgs.items():
+ if len(msgid) != 4:
+ raise InvalidMessageError(
+ f"Message id '{msgid}' should be a string of length 4"
+ )
+ if checker_id is None:
+ checker_id = msgid[:2]
+ elif msgid[:2] != checker_id:
+ raise InvalidMessageError(
+ f"Inconsistent checker id in message '{msgid}'"
+ )
def open(self) ->None:
"""Called before visiting project (i.e. set of modules)."""
- pass
+ # This method can be used for initialization if needed
+ # For now, we'll keep it as a no-op
+ return
def close(self) ->None:
"""Called after visiting project (i.e set of modules)."""
- pass
+ # This method can be used for cleanup if needed
+ # For now, we'll keep it as a no-op
+ return
class BaseTokenChecker(BaseChecker):
diff --git a/pylint/checkers/classes/class_checker.py b/pylint/checkers/classes/class_checker.py
index 01bad6883..cf8fa636d 100644
--- a/pylint/checkers/classes/class_checker.py
+++ b/pylint/checkers/classes/class_checker.py
@@ -299,23 +299,54 @@ class ClassChecker(BaseChecker):
'subclassed-final-class', 'implicit-flag-alias')
def visit_classdef(self, node: nodes.ClassDef) ->None:
"""Init visit variable _accessed."""
- pass
+ self._accessed = ScopeAccessMap()
+ self._check_bases_classes(node)
+ self._check_classmethod_declaration(node)
+ self._check_proper_bases(node)
+ self._check_consistent_mro(node)
+ self._check_redefined_slots(node)
+ self._check_typing_final(node)
def _check_consistent_mro(self, node: nodes.ClassDef) ->None:
"""Detect that a class has a consistent mro or duplicate bases."""
- pass
+ try:
+ node.mro()
+ except astroid.exceptions.InconsistentMroError:
+ self.add_message('inconsistent-mro', args=(node.name,), node=node)
+ except astroid.exceptions.DuplicateBasesError:
+ self.add_message('duplicate-bases', args=(node.name,), node=node)
def _check_proper_bases(self, node: nodes.ClassDef) ->None:
"""Detect that a class inherits something which is not
a class or a type.
"""
- pass
+ for base in node.bases:
+ ancestor = safe_infer(base)
+ if ancestor in (astroid.Uninferable, None):
+ continue
+ if (isinstance(ancestor, astroid.Instance) and
+ ancestor.is_subtype_of('builtins.type')):
+ continue
+ if not isinstance(ancestor, astroid.ClassDef):
+ self.add_message('inherit-non-class',
+ args=(ancestor.name,),
+ node=node)
def _check_typing_final(self, node: nodes.ClassDef) ->None:
"""Detect that a class does not subclass a class decorated with
`typing.final`.
"""
- pass
+ for base in node.bases:
+ ancestor = safe_infer(base)
+ if ancestor in (astroid.Uninferable, None):
+ continue
+ if isinstance(ancestor, astroid.ClassDef):
+ if utils.is_node_in_typing_guarded_import_block(ancestor):
+ continue
+ if utils.is_decorated_with_final(ancestor):
+ self.add_message('subclassed-final-class',
+ args=(node.name, ancestor.name),
+ node=node)
@only_required_for_messages('unused-private-member',
'attribute-defined-outside-init', 'access-member-before-definition')
diff --git a/pylint/checkers/classes/special_methods_checker.py b/pylint/checkers/classes/special_methods_checker.py
index 98a772892..1fc6b039f 100644
--- a/pylint/checkers/classes/special_methods_checker.py
+++ b/pylint/checkers/classes/special_methods_checker.py
@@ -19,7 +19,11 @@ def _safe_infer_call_result(node: nodes.FunctionDef, caller: nodes.
Returns None if inference failed or if there is some ambiguity (more than
one node has been inferred). Otherwise, returns inferred value.
"""
- pass
+ try:
+ inferit = node.infer_call_result(caller, context=context)
+ return next(inferit, None)
+ except astroid.InferenceError:
+ return None
class SpecialMethodsChecker(BaseChecker):
@@ -82,4 +86,76 @@ class SpecialMethodsChecker(BaseChecker):
_check_length_hint, '__format__': self._check_format,
'__getnewargs__': self._check_getnewargs, '__getnewargs_ex__':
self._check_getnewargs_ex}
+
+ def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+ if not node.is_method():
+ return
+
+ if node.name in self._protocol_map:
+ result = _safe_infer_call_result(node, node)
+ if result:
+ self._protocol_map[node.name](node, result)
+
+ if node.name in PYMETHODS:
+ expected_params = SPECIAL_METHODS_PARAMS[node.name]
+ actual_params = len(node.args.args) - 1 # Subtract 1 for 'self'
+ if actual_params != expected_params:
+ self.add_message(
+ 'unexpected-special-method-signature',
+ args=(node.name, expected_params, actual_params, 'was' if actual_params == 1 else 'were'),
+ node=node,
+ )
+
visit_asyncfunctiondef = visit_functiondef
+
+ def _check_iter(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not hasattr(result, NEXT_METHOD) and not hasattr(result, '__iter__'):
+ self.add_message('non-iterator-returned', node=node)
+
+ def _check_len(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (bases.Instance, nodes.ClassDef)):
+ return
+ if not isinstance(result, (int, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, int)):
+ self.add_message('invalid-length-returned', node=node)
+
+ def _check_bool(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (bool, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, bool)):
+ self.add_message('invalid-bool-returned', node=node)
+
+ def _check_index(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (int, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, int)):
+ self.add_message('invalid-index-returned', node=node)
+
+ def _check_repr(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (str, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, str)):
+ self.add_message('invalid-repr-returned', node=node)
+
+ def _check_str(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (str, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, str)):
+ self.add_message('invalid-str-returned', node=node)
+
+ def _check_bytes(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (bytes, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, bytes)):
+ self.add_message('invalid-bytes-returned', node=node)
+
+ def _check_hash(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (int, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, int)):
+ self.add_message('invalid-hash-returned', node=node)
+
+ def _check_length_hint(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (int, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, int)):
+ self.add_message('invalid-length-hint-returned', node=node)
+
+ def _check_format(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (str, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, str)):
+ self.add_message('invalid-format-returned', node=node)
+
+ def _check_getnewargs(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (tuple, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, tuple)):
+ self.add_message('invalid-getnewargs-returned', node=node)
+
+ def _check_getnewargs_ex(self, node: nodes.FunctionDef, result: InferenceResult) -> None:
+ if not isinstance(result, (tuple, bases.Instance)) or (isinstance(result, bases.Instance) and not issubclass(result._proxied.type, tuple)):
+ self.add_message('invalid-getnewargs-ex-returned', node=node)
+ elif isinstance(result, tuple) and (len(result) != 2 or not isinstance(result[0], tuple) or not isinstance(result[1], dict)):
+ self.add_message('invalid-getnewargs-ex-returned', node=node)
diff --git a/pylint/checkers/dataclass_checker.py b/pylint/checkers/dataclass_checker.py
index bf68dc00a..189f9a788 100644
--- a/pylint/checkers/dataclass_checker.py
+++ b/pylint/checkers/dataclass_checker.py
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
def _is_dataclasses_module(node: nodes.Module) ->bool:
"""Utility function to check if node is from dataclasses_module."""
- pass
+ return node.name in DATACLASS_MODULES
def _check_name_or_attrname_eq_to(node: (nodes.Name | nodes.Attribute),
@@ -19,7 +19,9 @@ def _check_name_or_attrname_eq_to(node: (nodes.Name | nodes.Attribute),
"""Utility function to check either a Name/Attribute node's name/attrname with a
given string.
"""
- pass
+ if isinstance(node, nodes.Name):
+ return node.name == check_with
+ return node.attrname == check_with
class DataclassChecker(BaseChecker):
@@ -42,11 +44,29 @@ class DataclassChecker(BaseChecker):
@dataclass decorator and outside make_dataclass() function, or when it
is used improperly within a dataclass.
"""
- pass
+ if not _check_name_or_attrname_eq_to(node.func, "field"):
+ return
+
+ scope = node.scope()
+ if isinstance(scope, nodes.ClassDef):
+ if not utils.is_dataclass(scope):
+ self.add_message("invalid-field-call", node=node, args="used outside of a dataclass")
+ elif not isinstance(node.parent, nodes.Assign):
+ self.add_message("invalid-field-call", node=node, args="not used as a class variable")
+ elif isinstance(scope, nodes.FunctionDef):
+ self._check_invalid_field_call_within_call(node, scope)
+ else:
+ self.add_message("invalid-field-call", node=node, args="used outside of a dataclass or make_dataclass()")
def _check_invalid_field_call_within_call(self, node: nodes.Call,
scope_node: nodes.Call) ->None:
"""Checks for special case where calling field is valid as an argument of the
make_dataclass() function.
"""
- pass
+ if not _check_name_or_attrname_eq_to(scope_node.func, "make_dataclass"):
+ self.add_message("invalid-field-call", node=node, args="used outside of make_dataclass()")
+ elif node not in scope_node.args and not any(
+ isinstance(kw.value, nodes.Call) and kw.value == node
+ for kw in scope_node.keywords
+ ):
+ self.add_message("invalid-field-call", node=node, args="not used as an argument to make_dataclass()")
diff --git a/pylint/checkers/deprecated.py b/pylint/checkers/deprecated.py
index fbe3222fa..fb0f76d25 100644
--- a/pylint/checkers/deprecated.py
+++ b/pylint/checkers/deprecated.py
@@ -50,18 +50,21 @@ class DeprecatedMixin(BaseChecker):
@utils.only_required_for_messages('deprecated-attribute')
def visit_attribute(self, node: astroid.Attribute) ->None:
"""Called when an `astroid.Attribute` node is visited."""
- pass
+ self.check_deprecated_attribute(node)
@utils.only_required_for_messages('deprecated-method',
'deprecated-argument', 'deprecated-class')
def visit_call(self, node: nodes.Call) ->None:
"""Called when a :class:`nodes.Call` node is visited."""
- pass
+ for inferred in infer_all(node.func):
+ self.check_deprecated_method(node, inferred)
+ self.check_deprecated_class_in_call(node)
@utils.only_required_for_messages('deprecated-module', 'deprecated-class')
def visit_import(self, node: nodes.Import) ->None:
"""Triggered when an import statement is seen."""
- pass
+ for name, _ in node.names:
+ self.check_deprecated_module(node, name.split('.')[0])
def deprecated_decorators(self) ->Iterable[str]:
"""Callback returning the deprecated decorators.
@@ -69,17 +72,25 @@ class DeprecatedMixin(BaseChecker):
Returns:
collections.abc.Container of deprecated decorator names.
"""
- pass
+ return [] # Implement this in the subclass if needed
@utils.only_required_for_messages('deprecated-decorator')
def visit_decorators(self, node: nodes.Decorators) ->None:
"""Triggered when a decorator statement is seen."""
- pass
+ for decorator in node.nodes:
+ if isinstance(decorator, nodes.Call):
+ for inferred in infer_all(decorator.func):
+ if isinstance(inferred, ACCEPTABLE_NODES):
+ qname = inferred.qname()
+ if any(qname.endswith('.' + name) or qname == name for name in self.deprecated_decorators()):
+ self.add_message('deprecated-decorator', node=decorator, args=qname)
@utils.only_required_for_messages('deprecated-module', 'deprecated-class')
def visit_importfrom(self, node: nodes.ImportFrom) ->None:
"""Triggered when a from statement is seen."""
- pass
+ self.check_deprecated_module(node, node.modname)
+ for name, _ in node.names:
+ self.check_deprecated_class(node, node.modname, [name])
def deprecated_methods(self) ->Container[str]:
"""Callback returning the deprecated methods/functions.
@@ -87,7 +98,7 @@ class DeprecatedMixin(BaseChecker):
Returns:
collections.abc.Container of deprecated function/method names.
"""
- pass
+ return [] # Implement this in the subclass if needed
def deprecated_arguments(self, method: str) ->Iterable[tuple[int | None,
str]]:
@@ -113,7 +124,7 @@ class DeprecatedMixin(BaseChecker):
.. code-block:: python
((1, 'arg2'), (3, 'arg4'))
"""
- pass
+ return [] # Implement this in the subclass if needed
def deprecated_modules(self) ->Iterable[str]:
"""Callback returning the deprecated modules.
@@ -121,7 +132,7 @@ class DeprecatedMixin(BaseChecker):
Returns:
collections.abc.Container of deprecated module names.
"""
- pass
+ return [] # Implement this in the subclass if needed
def deprecated_classes(self, module: str) ->Iterable[str]:
"""Callback returning the deprecated classes of module.
@@ -132,20 +143,23 @@ class DeprecatedMixin(BaseChecker):
Returns:
collections.abc.Container of deprecated class names.
"""
- pass
+ return [] # Implement this in the subclass if needed
def deprecated_attributes(self) ->Iterable[str]:
"""Callback returning the deprecated attributes."""
- pass
+ return [] # Implement this in the subclass if needed
def check_deprecated_attribute(self, node: astroid.Attribute) ->None:
"""Checks if the attribute is deprecated."""
- pass
+ for attr_name in self.deprecated_attributes():
+ if node.attrname == attr_name:
+ self.add_message('deprecated-attribute', node=node, args=attr_name)
def check_deprecated_module(self, node: nodes.Import, mod_path: (str |
None)) ->None:
"""Checks if the module is deprecated."""
- pass
+ if mod_path in self.deprecated_modules():
+ self.add_message('deprecated-module', node=node, args=mod_path)
def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG
) ->None:
@@ -153,13 +167,35 @@ class DeprecatedMixin(BaseChecker):
This method should be called from the checker implementing this mixin.
"""
- pass
+ if isinstance(inferred, ACCEPTABLE_NODES):
+ qname = inferred.qname()
+ if any(qname.endswith('.' + name) or qname == name for name in self.deprecated_methods()):
+ self.add_message('deprecated-method', node=node, args=qname)
+
+ # Check for deprecated arguments
+ if isinstance(node.func, astroid.Attribute):
+ method_name = node.func.attrname
+ elif isinstance(node.func, astroid.Name):
+ method_name = node.func.name
+ else:
+ return
+
+ for pos, kw in chain(enumerate(node.args), ((None, arg) for arg in node.keywords)):
+ argname = kw.arg if isinstance(kw, nodes.Keyword) else None
+ for deprecated_pos, deprecated_name in self.deprecated_arguments(method_name):
+ if (argname and argname == deprecated_name) or (pos == deprecated_pos):
+ self.add_message('deprecated-argument', node=node, args=(deprecated_name, method_name))
def check_deprecated_class(self, node: nodes.NodeNG, mod_name: str,
class_names: Iterable[str]) ->None:
"""Checks if the class is deprecated."""
- pass
+ for class_name in class_names:
+ if class_name in self.deprecated_classes(mod_name):
+ self.add_message('deprecated-class', node=node, args=(class_name, mod_name))
def check_deprecated_class_in_call(self, node: nodes.Call) ->None:
"""Checks if call the deprecated class."""
- pass
+ if isinstance(node.func, astroid.Name):
+ inferred = safe_infer(node.func)
+ if isinstance(inferred, nodes.ClassDef):
+ self.check_deprecated_class(node, inferred.root().name, [inferred.name])
diff --git a/pylint/checkers/design_analysis.py b/pylint/checkers/design_analysis.py
index 0c785dc35..d3a3c9575 100644
--- a/pylint/checkers/design_analysis.py
+++ b/pylint/checkers/design_analysis.py
@@ -83,7 +83,21 @@ STDLIB_CLASSES_IGNORE_ANCESTOR = frozenset(('builtins.object',
def _is_exempt_from_public_methods(node: astroid.ClassDef) ->bool:
"""Check if a class is exempt from too-few-public-methods."""
- pass
+ # Check if the class is a dataclass
+ if any(decorator.name in DATACLASSES_DECORATORS for decorator in node.decorators.nodes):
+ return True
+
+ # Check if the class is an Enum
+ if is_enum(node):
+ return True
+
+ # Check if the class is a NamedTuple or TypedDict
+ if node.bases:
+ base_qname = node.bases[0].qname()
+ if base_qname in (TYPING_NAMEDTUPLE, TYPING_TYPEDDICT, TYPING_EXTENSIONS_TYPEDDICT):
+ return True
+
+ return False
def _count_boolean_expressions(bool_op: nodes.BoolOp) ->int:
@@ -91,7 +105,13 @@ def _count_boolean_expressions(bool_op: nodes.BoolOp) ->int:
example: a and (b or c or (d and e)) ==> 5 boolean expressions
"""
- pass
+ count = 0
+ for value in bool_op.values:
+ if isinstance(value, nodes.BoolOp):
+ count += _count_boolean_expressions(value)
+ else:
+ count += 1
+ return count
def _get_parents_iter(node: nodes.ClassDef, ignored_parents: frozenset[str]
@@ -111,7 +131,17 @@ def _get_parents_iter(node: nodes.ClassDef, ignored_parents: frozenset[str]
And ``ignored_parents`` is ``{"E"}``, then this function will return
``{A, B, C, D}`` -- both ``E`` and its ancestors are excluded.
"""
- pass
+ def _get_parents(cls: nodes.ClassDef) ->Iterator[nodes.ClassDef]:
+ for parent in cls.bases:
+ if isinstance(parent, nodes.Name):
+ parent = parent.infer().next()
+ if isinstance(parent, nodes.ClassDef):
+ if parent.qname() not in ignored_parents:
+ yield parent
+ yield from _get_parents(parent)
+
+ yield node
+ yield from _get_parents(node)
class MisdesignChecker(BaseChecker):
@@ -164,7 +194,9 @@ class MisdesignChecker(BaseChecker):
def open(self) ->None:
"""Initialize visit variables."""
- pass
+ self._returns = []
+ self._branches = defaultdict(int)
+ self._stmts = []
@only_required_for_messages('too-many-ancestors',
'too-many-instance-attributes', 'too-few-public-methods',
@@ -201,17 +233,18 @@ class MisdesignChecker(BaseChecker):
def visit_return(self, _: nodes.Return) ->None:
"""Count number of returns."""
- pass
+ self._returns[-1] += 1
def visit_default(self, node: nodes.NodeNG) ->None:
"""Default visit method -> increments the statements counter if
necessary.
"""
- pass
+ if isinstance(node, (nodes.Statement, nodes.ExceptHandler)):
+ self._stmts[-1] += 1
def visit_try(self, node: nodes.Try) ->None:
"""Increments the branches counter."""
- pass
+ self._inc_branch(node, len(node.handlers) + len(node.orelse) + bool(node.finalbody))
@only_required_for_messages('too-many-boolean-expressions',
'too-many-branches')
@@ -223,7 +256,14 @@ class MisdesignChecker(BaseChecker):
"""Go through "if" node `node` and count its boolean expressions
if the 'if' node test is a BoolOp node.
"""
- pass
+ if isinstance(node.test, nodes.BoolOp):
+ num_bool_expr = _count_boolean_expressions(node.test)
+ if num_bool_expr > self.linter.config.max_bool_expr:
+ self.add_message(
+ "too-many-boolean-expressions",
+ node=node,
+ args=(num_bool_expr, self.linter.config.max_bool_expr),
+ )
def visit_while(self, node: nodes.While) ->None:
"""Increments the branches counter."""
@@ -232,4 +272,4 @@ class MisdesignChecker(BaseChecker):
def _inc_branch(self, node: nodes.NodeNG, branchesnum: int=1) ->None:
"""Increments the branches counter."""
- pass
+ self._branches[node.scope()] += branchesnum
diff --git a/pylint/checkers/dunder_methods.py b/pylint/checkers/dunder_methods.py
index 461ad9d7e..85a536cf7 100644
--- a/pylint/checkers/dunder_methods.py
+++ b/pylint/checkers/dunder_methods.py
@@ -34,8 +34,43 @@ class DunderCallChecker(BaseChecker):
@staticmethod
def within_dunder_or_lambda_def(node: nodes.NodeNG) ->bool:
"""Check if dunder method call is within a dunder method definition."""
- pass
+ parent = node.parent
+ while parent:
+ if isinstance(parent, (nodes.FunctionDef, nodes.Lambda)):
+ if isinstance(parent, nodes.FunctionDef) and parent.name.startswith('__') and parent.name.endswith('__'):
+ return True
+ if isinstance(parent, nodes.Lambda) and parent.parent and isinstance(parent.parent, nodes.Call):
+ func = parent.parent.func
+ if isinstance(func, nodes.Attribute) and func.attrname in UNNECESSARY_DUNDER_CALL_LAMBDA_EXCEPTIONS:
+ return True
+ parent = parent.parent
+ return False
def visit_call(self, node: nodes.Call) ->None:
"""Check if method being called is an unnecessary dunder method."""
- pass
+ if not isinstance(node.func, nodes.Attribute):
+ return
+
+ if node.func.attrname not in DUNDER_METHODS:
+ return
+
+ if self.within_dunder_or_lambda_def(node):
+ return
+
+ inferred = safe_infer(node.func)
+ if isinstance(inferred, UninferableBase):
+ return
+
+ if not isinstance(inferred, Instance):
+ return
+
+ if isinstance(node.func.expr, nodes.Call) and isinstance(node.func.expr.func, nodes.Name) and node.func.expr.func.name == 'super':
+ return
+
+ alternative = DUNDER_METHODS[node.func.attrname]
+ self.add_message(
+ 'unnecessary-dunder-call',
+ node=node,
+ args=(node.func.attrname, alternative),
+ confidence=HIGH,
+ )
diff --git a/pylint/checkers/ellipsis_checker.py b/pylint/checkers/ellipsis_checker.py
index 95b4666d6..16dde23b1 100644
--- a/pylint/checkers/ellipsis_checker.py
+++ b/pylint/checkers/ellipsis_checker.py
@@ -16,7 +16,7 @@ class EllipsisChecker(BaseChecker):
)}
@only_required_for_messages('unnecessary-ellipsis')
- def visit_const(self, node: nodes.Const) ->None:
+ def visit_const(self, node: nodes.Const) -> None:
"""Check if the ellipsis constant is used unnecessarily.
Emits a warning when:
@@ -25,4 +25,19 @@ class EllipsisChecker(BaseChecker):
For example: A function consisting of an ellipsis followed by a
return statement on the next line.
"""
- pass
+ if node.value is Ellipsis:
+ parent = node.parent
+ if isinstance(parent, nodes.Expr) and parent.lineno == node.lineno:
+ # Check if the ellipsis is preceded by a docstring
+ if isinstance(parent.previous_sibling(), nodes.Expr) and \
+ isinstance(parent.previous_sibling().value, nodes.Const) and \
+ isinstance(parent.previous_sibling().value.value, str):
+ self.add_message('unnecessary-ellipsis', node=node)
+ return
+
+ # Check if there's another statement in the same scope
+ scope = node.scope()
+ for child in scope.body:
+ if child is not parent and not isinstance(child, nodes.Pass):
+ self.add_message('unnecessary-ellipsis', node=node)
+ return
diff --git a/pylint/checkers/exceptions.py b/pylint/checkers/exceptions.py
index fe18d2c24..af80b256b 100644
--- a/pylint/checkers/exceptions.py
+++ b/pylint/checkers/exceptions.py
@@ -25,12 +25,20 @@ def _annotated_unpack_infer(stmt: nodes.NodeNG, context: (InferenceContext |
Returns an iterator which yields tuples in the format
('original node', 'inferred node').
"""
- pass
+ if isinstance(stmt, (nodes.List, nodes.Tuple)):
+ for elt in stmt.elts:
+ yield from _annotated_unpack_infer(elt, context)
+ else:
+ for inferred in stmt.infer(context):
+ if isinstance(inferred, (nodes.List, nodes.Tuple)):
+ yield from _annotated_unpack_infer(inferred, context)
+ elif not isinstance(inferred, util.Uninferable):
+ yield stmt, inferred
def _is_raising(body: list[nodes.NodeNG]) ->bool:
"""Return whether the given statement node raises an exception."""
- pass
+ return any(isinstance(node, nodes.Raise) for node in body)
MSGS: dict[str, MessageDefinitionTuple] = {'E0701': (
@@ -123,15 +131,89 @@ class ExceptionsChecker(checkers.BaseChecker):
An exception cause can be only `None` or an exception.
"""
- pass
+ if node.cause is None:
+ return
+
+ cause = utils.safe_infer(node.cause)
+ if cause in (None, util.Uninferable):
+ return
+
+ if isinstance(cause, nodes.Const) and cause.value is None:
+ return
+
+ if not isinstance(cause, nodes.ClassDef) and not utils.inherit_from_std_ex(cause):
+ self.add_message('bad-exception-cause', node=node)
@utils.only_required_for_messages('bare-except',
'broad-exception-caught', 'try-except-raise', 'binary-op-exception',
'bad-except-order', 'catching-non-exception', 'duplicate-except')
def visit_trystar(self, node: nodes.TryStar) ->None:
"""Check for empty except*."""
- pass
+ for handler in node.handlers:
+ if handler.type is None:
+ self.add_message('bare-except', node=handler)
+ elif isinstance(handler.type, nodes.BoolOp):
+ self.add_message('binary-op-exception', node=handler, args=handler.type.op)
+ else:
+ try:
+ excs = list(_annotated_unpack_infer(handler.type))
+ except astroid.InferenceError:
+ continue
+
+ for exc in excs:
+ if not utils.inherit_from_std_ex(exc[1]):
+ self.add_message('catching-non-exception', node=handler.type, args=exc[1].name)
+
+ # Check for duplicate except handlers
+ seen_exc_types = set()
+ for handler in node.handlers:
+ if handler.type is None:
+ continue
+ exc_type = handler.type.as_string()
+ if exc_type in seen_exc_types:
+ self.add_message('duplicate-except', node=handler, args=exc_type)
+ else:
+ seen_exc_types.add(exc_type)
+
+ # Check for try-except-raise
+ if len(node.handlers) == 1 and len(node.handlers[0].body) == 1:
+ if isinstance(node.handlers[0].body[0], nodes.Raise):
+ self.add_message('try-except-raise', node=node.handlers[0])
def visit_try(self, node: nodes.Try) ->None:
"""Check for empty except."""
- pass
+ for handler in node.handlers:
+ if handler.type is None:
+ self.add_message('bare-except', node=handler)
+ elif isinstance(handler.type, nodes.BoolOp):
+ self.add_message('binary-op-exception', node=handler, args=handler.type.op)
+ else:
+ try:
+ excs = list(_annotated_unpack_infer(handler.type))
+ except astroid.InferenceError:
+ continue
+
+ for exc in excs:
+ if not utils.inherit_from_std_ex(exc[1]):
+ self.add_message('catching-non-exception', node=handler.type, args=exc[1].name)
+
+ # Check for bad except clauses order
+ handlers = node.handlers
+ for index, handler in enumerate(handlers[:-1]):
+ if handler.type is None:
+ continue
+ for next_handler in handlers[index + 1:]:
+ if next_handler.type is None:
+ continue
+ if _is_exception_tuple(handler.type):
+ if _is_exception_tuple(next_handler.type):
+ if _exception_tuple_contains(handler.type, next_handler.type):
+ self.add_message('bad-except-order', node=next_handler, args=handler.type.as_string())
+ elif not _is_exception_tuple(next_handler.type):
+ if utils.is_subclass_of(handler.type, next_handler.type):
+ self.add_message('bad-except-order', node=next_handler, args=handler.type.as_string())
+
+ # Check for try-except-raise
+ if len(node.handlers) == 1 and len(node.handlers[0].body) == 1:
+ if isinstance(node.handlers[0].body[0], nodes.Raise):
+ self.add_message('try-except-raise', node=node.handlers[0])
diff --git a/pylint/checkers/format.py b/pylint/checkers/format.py
index 1b31de075..755d0b23b 100644
--- a/pylint/checkers/format.py
+++ b/pylint/checkers/format.py
@@ -102,7 +102,8 @@ class FormatChecker(BaseTokenChecker, BaseRawFileChecker):
def new_line(self, tokens: TokenWrapper, line_end: int, line_start: int
) ->None:
"""A new line has been encountered, process it if necessary."""
- pass
+ line = tokens._tokens[line_start:line_end]
+ self.check_lines(tokens, line_start, ''.join(tok.string for tok in line), tokens._tokens[line_start].start[0])
def _check_keyword_parentheses(self, tokens: list[tokenize.TokenInfo],
start: int) ->None:
@@ -115,7 +116,32 @@ class FormatChecker(BaseTokenChecker, BaseRawFileChecker):
tokens: The entire list of Tokens.
start: The position of the keyword in the token list.
"""
- pass
+ if start >= len(tokens) - 2:
+ return # Not enough tokens remaining.
+
+ if tokens[start + 1].string != '(':
+ return # Next token is not an opening parenthesis.
+
+ found_closing = False
+ opening_count = 0
+ has_comma = False
+ for token in tokens[start + 1:]:
+ if token.string == '(':
+ opening_count += 1
+ elif token.string == ')':
+ opening_count -= 1
+ if opening_count == 0:
+ found_closing = True
+ break
+ elif token.string == ',' and opening_count == 1:
+ has_comma = True
+ elif token.type == tokenize.NEWLINE:
+ break
+
+ if found_closing and not has_comma:
+ self.add_message('superfluous-parens',
+ line=tokens[start].start[0],
+ args=(tokens[start].string,))
def process_tokens(self, tokens: list[tokenize.TokenInfo]) ->None:
"""Process tokens and search for:
@@ -124,43 +150,112 @@ class FormatChecker(BaseTokenChecker, BaseRawFileChecker):
- optionally bad construct (if given, bad_construct must be a compiled
regular expression).
"""
- pass
+ token_wrapper = TokenWrapper(tokens)
+ indents = [0]
+ check_equal = False
+ line_num = 0
+ line_start = 0
+ for idx, token in enumerate(tokens):
+ if token.type == tokenize.NEWLINE:
+ line_num = token.end[0]
+ self.new_line(token_wrapper, idx, line_start)
+ line_start = idx + 1
+ elif token.type == tokenize.INDENT:
+ indents.append(indents[-1] + 1)
+ check_equal = True
+ elif token.type == tokenize.DEDENT:
+ if len(indents) > 1:
+ indents.pop()
+ check_equal = True
+ elif token.type == tokenize.NAME and token.string in _KEYWORD_TOKENS:
+ self._check_keyword_parentheses(tokens, idx)
+
+ self.check_lines(token_wrapper, line_start, '', line_num)
@only_required_for_messages('multiple-statements')
def visit_default(self, node: nodes.NodeNG) ->None:
"""Check the node line number and check it if not yet done."""
- pass
+ if isinstance(node, (nodes.Module, nodes.ClassDef, nodes.FunctionDef)):
+ return
+ if node.root().file.endswith('__init__.py'):
+ return
+ line = node.fromlineno
+ if line in self._visited_lines:
+ return
+ self._visited_lines[line] = 1
+ self._check_multi_statement_line(node, line)
def _check_multi_statement_line(self, node: nodes.NodeNG, line: int
) ->None:
"""Check for lines containing multiple statements."""
- pass
+ if isinstance(node.parent, nodes.If):
+ if node.parent.body[0] is node and node.parent.orelse and node.parent.orelse[0].fromlineno == line:
+ return
+ if isinstance(node, (nodes.Lambda, nodes.ListComp, nodes.SetComp, nodes.GeneratorExp)):
+ return
+ if isinstance(node, nodes.Expr) and isinstance(node.value, nodes.Yield):
+ return
+ sibling = node.next_sibling()
+ if sibling is not None and sibling.fromlineno == line:
+ self.add_message('multiple-statements', node=node)
def check_trailing_whitespace_ending(self, line: str, i: int) ->None:
"""Check that there is no trailing white-space."""
- pass
+ stripped_line = line.rstrip('\n\r')
+ if stripped_line != line.rstrip():
+ self.add_message('trailing-whitespace', line=i)
def check_line_length(self, line: str, i: int, checker_off: bool) ->None:
"""Check that the line length is less than the authorized value."""
- pass
+ max_chars = self.config.max_line_length
+ ignore_long_line = self.config.ignore_long_lines
+ line = line.rstrip()
+ if len(line) > max_chars and not checker_off:
+ if not ignore_long_line.search(line):
+ self.add_message('line-too-long', line=i, args=(len(line), max_chars))
@staticmethod
def remove_pylint_option_from_lines(options_pattern_obj: Match[str]) ->str:
"""Remove the `# pylint ...` pattern from lines."""
- pass
+ return options_pattern_obj.group(1)
@staticmethod
def is_line_length_check_activated(pylint_pattern_match_object: Match[str]
) ->bool:
"""Return True if the line length check is activated."""
- pass
+ try:
+ for pragma in parse_pragma(pylint_pattern_match_object.group(2)):
+ if pragma.action == OPTION_PO.disable and 'line-too-long' in pragma.messages:
+ return False
+ if pragma.action == OPTION_PO.enable and 'line-too-long' in pragma.messages:
+ return True
+ except PragmaParserError:
+ pass
+ return True
@staticmethod
def specific_splitlines(lines: str) ->list[str]:
"""Split lines according to universal newlines except those in a specific
sets.
"""
- pass
+ unsplit_ends = {'\v', '\x0b', '\f', '\x0c', '\x1c', '\x1d', '\x1e', '\x85', '\u2028', '\u2029'}
+ res = []
+ buffer = []
+ for char in lines:
+ if char in '\n\r':
+ if buffer:
+ res.append(''.join(buffer))
+ buffer = []
+ if (not res) or (res[-1] != '\n'):
+ res.append('\n')
+ elif char in unsplit_ends:
+ if buffer:
+ buffer.append(char)
+ else:
+ buffer.append(char)
+ if buffer:
+ res.append(''.join(buffer))
+ return res
def check_lines(self, tokens: TokenWrapper, line_start: int, lines: str,
lineno: int) ->None:
@@ -171,9 +266,38 @@ class FormatChecker(BaseTokenChecker, BaseRawFileChecker):
- no trailing white-space
- less than a maximum number of characters
"""
- pass
+ lines = self.specific_splitlines(lines)
+ if lines and not lines[-1].endswith('\n'):
+ self.add_message('missing-final-newline', line=lineno)
+
+ for i, line in enumerate(lines, start=lineno):
+ self.check_trailing_whitespace_ending(line, i)
+
+ if line.endswith('\n'):
+ line = line[:-1]
+
+ checker_off = False
+ pylint_pattern_match = OPTION_PO.search(line)
+ if pylint_pattern_match:
+ checker_off = not self.is_line_length_check_activated(pylint_pattern_match)
+ line = self.remove_pylint_option_from_lines(pylint_pattern_match)
+
+ self.check_line_length(line, i, checker_off)
def check_indent_level(self, string: str, expected: int, line_num: int
) ->None:
- """Return the indent level of the string."""
- pass
+ """Check the indent level of the string."""
+ indent = self.config.indent_string
+ if indent == '\\t':
+ indent = '\t'
+ level = 0
+ for char in string:
+ if char == ' ':
+ level += 1
+ elif char == '\t':
+ level += len(indent)
+ else:
+ break
+ if level != expected:
+ self.add_message('bad-indentation', line=line_num,
+ args=(level, 'spaces' if indent == ' ' else 'tabs', expected))
diff --git a/pylint/checkers/imports.py b/pylint/checkers/imports.py
index 14add5d0f..11b540b65 100644
--- a/pylint/checkers/imports.py
+++ b/pylint/checkers/imports.py
@@ -167,27 +167,61 @@ class ImportsChecker(DeprecatedMixin, BaseChecker):
def open(self) ->None:
"""Called before visiting project (i.e set of modules)."""
- pass
+ self._allow_any_import_level = set(self.linter.config.allow_any_import_level)
def close(self) ->None:
"""Called before visiting project (i.e set of modules)."""
- pass
+ self._module_pkg.clear()
+ self._imports_stack.clear()
+ self._first_non_import_node = None
def deprecated_modules(self) ->set[str]:
"""Callback returning the deprecated modules."""
- pass
+ python_version = sys.version_info[:3]
+ deprecated = set(self.linter.config.deprecated_modules)
+ for since_version, modules in DEPRECATED_MODULES.items():
+ if python_version >= since_version:
+ deprecated.update(modules)
+ return deprecated
def visit_module(self, node: nodes.Module) ->None:
"""Store if current module is a package, i.e. an __init__ file."""
- pass
+ self._module_pkg[node] = node.package
def visit_import(self, node: nodes.Import) ->None:
"""Triggered when an import statement is seen."""
- pass
+ self._check_imports(node)
+ self._check_position(node)
+
+ for name, alias in node.names:
+ self._check_reimport(node, name, alias)
+ imported_module = self._get_imported_module(node, name)
+ if imported_module is None:
+ continue
+ self._check_deprecated_module(node, name)
+ self._add_imported_module(node, name)
+ self._check_preferred_module(node, name)
def visit_importfrom(self, node: nodes.ImportFrom) ->None:
"""Triggered when a from statement is seen."""
- pass
+ self._check_imports(node)
+ self._check_position(node)
+
+ basename = node.modname
+ imported_module = self._get_imported_module(node, basename)
+
+ if imported_module is None:
+ return
+
+ self._check_deprecated_module(node, basename)
+ self._add_imported_module(node, basename)
+ self._check_preferred_module(node, basename)
+
+ for name, alias in node.names:
+ self._check_reimport(node, name, alias, basename, node.level)
+
+ if node.names[0][0] == '*':
+ self._check_wildcard_imports(node, imported_module)
(visit_try) = (visit_assignattr) = (visit_assign) = (visit_ifexp) = (
visit_comprehension) = (visit_expr) = (visit_if
) = compute_first_non_import_node
diff --git a/pylint/checkers/lambda_expressions.py b/pylint/checkers/lambda_expressions.py
index a4466072b..1337e9e59 100644
--- a/pylint/checkers/lambda_expressions.py
+++ b/pylint/checkers/lambda_expressions.py
@@ -24,8 +24,19 @@ class LambdaExpressionChecker(BaseChecker):
def visit_assign(self, node: nodes.Assign) ->None:
"""Check if lambda expression is assigned to a variable."""
- pass
+ for target in node.targets:
+ if isinstance(node.value, nodes.Lambda):
+ self.add_message(
+ 'unnecessary-lambda-assignment',
+ node=target,
+ confidence=HIGH
+ )
def visit_call(self, node: nodes.Call) ->None:
"""Check if lambda expression is called directly."""
- pass
+ if isinstance(node.func, nodes.Lambda):
+ self.add_message(
+ 'unnecessary-direct-lambda-call',
+ node=node,
+ confidence=HIGH
+ )
diff --git a/pylint/checkers/logging.py b/pylint/checkers/logging.py
index e7eeb4359..d03066638 100644
--- a/pylint/checkers/logging.py
+++ b/pylint/checkers/logging.py
@@ -52,7 +52,13 @@ def is_method_call(func: bases.BoundMethod, types: tuple[str, ...]=(),
true if the node represents a method call for the given type and
method names, False otherwise.
"""
- pass
+ if isinstance(func, bases.BoundMethod):
+ if types and func.bound.name not in types:
+ return False
+ if methods and func.name not in methods:
+ return False
+ return True
+ return False
class LoggingChecker(checkers.BaseChecker):
@@ -70,41 +76,90 @@ class LoggingChecker(checkers.BaseChecker):
def visit_module(self, _: nodes.Module) ->None:
"""Clears any state left in this checker from last module checked."""
- pass
+ # No state to clear in this implementation
+ return
def visit_importfrom(self, node: nodes.ImportFrom) ->None:
"""Checks to see if a module uses a non-Python logging module."""
- pass
+ if node.modname in self.options.logging_modules:
+ self._logging_modules.add(node.modname)
def visit_import(self, node: nodes.Import) ->None:
"""Checks to see if this module uses Python's built-in logging."""
- pass
+ for name, _ in node.names:
+ if name in self.options.logging_modules:
+ self._logging_modules.add(name)
def visit_call(self, node: nodes.Call) ->None:
"""Checks calls to logging methods."""
- pass
+ if isinstance(node.func, nodes.Attribute):
+ for logging_module in self._logging_modules:
+ if node.func.attrname in CHECKED_CONVENIENCE_FUNCTIONS:
+ if isinstance(node.func.expr, nodes.Name):
+ if node.func.expr.name == logging_module:
+ self._check_log_method(node, node.func.attrname)
+ elif node.func.attrname == 'log':
+ if isinstance(node.func.expr, nodes.Name):
+ if node.func.expr.name == logging_module:
+ self._check_log_method(node, 'log')
def _check_log_method(self, node: nodes.Call, name: str) ->None:
"""Checks calls to logging.log(level, format, *format_args)."""
- pass
+ if name == 'log' and len(node.args) >= 2:
+ format_pos = 1
+ elif len(node.args) >= 1:
+ format_pos = 0
+ else:
+ return
+
+ if isinstance(node.args[format_pos], nodes.JoinedStr):
+ self.add_message('logging-fstring-interpolation', node=node,
+ args=(self._helper_string(node),))
+ elif isinstance(node.args[format_pos], nodes.Call):
+ self._check_call_func(node.args[format_pos])
+ elif isinstance(node.args[format_pos], nodes.Const):
+ self._check_format_string(node, format_pos)
def _helper_string(self, node: nodes.Call) ->str:
"""Create a string that lists the valid types of formatting for this node."""
- pass
+ valid_formats = []
+ if not self.linter.is_message_enabled('logging-not-lazy'):
+ valid_formats.append('%')
+ if not self.linter.is_message_enabled('logging-format-interpolation'):
+ valid_formats.append('.format()')
+ if not self.linter.is_message_enabled('logging-fstring-interpolation'):
+ valid_formats.append('f-string')
+
+ if len(valid_formats) > 1:
+ return f"{', '.join(valid_formats[:-1])} or {valid_formats[-1]}"
+ elif len(valid_formats) == 1:
+ return valid_formats[0]
+ else:
+ return "another type of string formatting"
@staticmethod
def _is_operand_literal_str(operand: (InferenceResult | None)) ->bool:
"""Return True if the operand in argument is a literal string."""
- pass
+ if isinstance(operand, nodes.Const):
+ return isinstance(operand.value, str)
+ return False
@staticmethod
def _is_node_explicit_str_concatenation(node: nodes.NodeNG) ->bool:
"""Return True if the node represents an explicitly concatenated string."""
- pass
+ if isinstance(node, nodes.BinOp) and node.op == '+':
+ left_operand = node.left
+ right_operand = node.right
+ return (LoggingChecker._is_operand_literal_str(left_operand) and
+ LoggingChecker._is_operand_literal_str(right_operand))
+ return False
def _check_call_func(self, node: nodes.Call) ->None:
"""Checks that function call is not format_string.format()."""
- pass
+ if isinstance(node.func, nodes.Attribute):
+ if node.func.attrname == 'format':
+ self.add_message('logging-format-interpolation', node=node,
+ args=(self._helper_string(node),))
def _check_format_string(self, node: nodes.Call, format_arg: Literal[0, 1]
) ->None:
@@ -114,12 +169,34 @@ class LoggingChecker(checkers.BaseChecker):
node: AST node to be checked.
format_arg: Index of the format string in the node arguments.
"""
- pass
+ format_string = node.args[format_arg].value
+ if not isinstance(format_string, str):
+ return
+
+ try:
+ required_args = tuple(string.Formatter().parse(format_string))
+ except ValueError:
+ self.add_message('logging-format-truncated', node=node)
+ return
+
+ positional_args = len(node.args) - format_arg - 1
+ keyword_args = len(node.keywords)
+
+ if positional_args + keyword_args > len(required_args):
+ self.add_message('logging-too-many-args', node=node)
+ elif positional_args + keyword_args < len(required_args):
+ self.add_message('logging-too-few-args', node=node)
def is_complex_format_str(node: nodes.NodeNG) ->bool:
"""Return whether the node represents a string with complex formatting specs."""
- pass
+ if isinstance(node, nodes.Const) and isinstance(node.value, str):
+ try:
+ format_specs = [spec for _, _, spec, _ in string.Formatter().parse(node.value) if spec]
+ return any(spec for spec in format_specs if set(spec) - set(string.digits))
+ except ValueError:
+ return False
+ return False
def _count_supplied_tokens(args: list[nodes.NodeNG]) ->int:
@@ -135,7 +212,7 @@ def _count_supplied_tokens(args: list[nodes.NodeNG]) ->int:
Returns:
Number of AST nodes that aren't keywords.
"""
- pass
+ return sum(1 for arg in args if not isinstance(arg, nodes.Keyword))
def str_formatting_in_f_string(node: nodes.JoinedStr) ->bool:
@@ -143,4 +220,7 @@ def str_formatting_in_f_string(node: nodes.JoinedStr) ->bool:
For example: `f'Hello %s'`
"""
- pass
+ for value in node.values:
+ if isinstance(value, nodes.Const) and '%' in value.value:
+ return True
+ return False
diff --git a/pylint/checkers/method_args.py b/pylint/checkers/method_args.py
index b9264d586..ac2c641a2 100644
--- a/pylint/checkers/method_args.py
+++ b/pylint/checkers/method_args.py
@@ -40,11 +40,38 @@ class MethodArgsChecker(BaseChecker):
Package uses inferred node in order to know the package imported.
"""
- pass
+ try:
+ func = node.func.inferred()[0]
+ qname = func.qname()
+ if qname in self.linter.config.timeout_methods:
+ if 'timeout' not in node.keywords and len(node.args) < func.argnames().index('timeout') + 1:
+ self.add_message('missing-timeout', node=node, args=(qname,))
+ except astroid.InferenceError:
+ return
def _check_positional_only_arguments_expected(self, node: nodes.Call
) ->None:
"""Check if positional only arguments have been passed as keyword arguments by
inspecting its method definition.
"""
- pass
+ try:
+ func = node.func.inferred()[0]
+ if isinstance(func, astroid.BoundMethod):
+ func = func._proxied
+
+ if not isinstance(func, (astroid.FunctionDef, astroid.UnboundMethod)):
+ return
+
+ positional_only = []
+ for arg in func.args.posonlyargs:
+ if arg.name in node.keywords:
+ positional_only.append(arg.name)
+
+ if positional_only:
+ self.add_message(
+ 'positional-only-arguments-expected',
+ node=node,
+ args=(func.name, ", ".join(positional_only))
+ )
+ except astroid.InferenceError:
+ return
diff --git a/pylint/checkers/misc.py b/pylint/checkers/misc.py
index c7fce6781..ab3596c9a 100644
--- a/pylint/checkers/misc.py
+++ b/pylint/checkers/misc.py
@@ -20,7 +20,20 @@ class ByIdManagedMessagesChecker(BaseRawFileChecker):
def process_module(self, node: nodes.Module) ->None:
"""Inspect the source file to find messages activated or deactivated by id."""
- pass
+ for comment in node.file_encoding.encoding_line, node.file_encoding.shebang:
+ if comment and comment.strip().lower().startswith('pylint:'):
+ self._check_message_id(comment)
+
+ def _check_message_id(self, comment):
+ """Check if the comment contains a message enabled or disabled by id."""
+ match = re.search(r'(?:enable|disable)=([^,\s]+)', comment)
+ if match:
+ messages = match.group(1).split(',')
+ for message in messages:
+ if message.startswith('C') or message.startswith('R'):
+ self.add_message('use-symbolic-message-instead',
+ line=1,
+ args=f"Message '{message}' is referred to by its id, use its symbolic name instead")
class EncodingChecker(BaseTokenChecker, BaseRawFileChecker):
@@ -43,8 +56,24 @@ class EncodingChecker(BaseTokenChecker, BaseRawFileChecker):
def process_module(self, node: nodes.Module) ->None:
"""Inspect the source file to find encoding problem."""
- pass
+ encoding = node.file_encoding.encoding
+ if encoding is None:
+ self.add_message('no-encoding-declaration', line=1)
+ elif encoding.lower() != 'utf-8':
+ self.add_message('non-utf8-encoding', line=1, args=encoding)
def process_tokens(self, tokens: list[tokenize.TokenInfo]) ->None:
"""Inspect the source to find fixme problems."""
- pass
+ notes_re = '|'.join(map(re.escape, self.config.notes))
+ if self.config.notes_rgx:
+ notes_re = f'({notes_re}|{self.config.notes_rgx})'
+ else:
+ notes_re = f'({notes_re})'
+
+ for token in tokens:
+ if token.type == tokenize.COMMENT:
+ comment = token.string.lstrip('#')
+ match = re.search(notes_re, comment, re.IGNORECASE)
+ if match:
+ note = match.group(1)
+ self.add_message('fixme', args=comment, line=token.start[0])
diff --git a/pylint/checkers/modified_iterating_checker.py b/pylint/checkers/modified_iterating_checker.py
index a2395f574..9f6062e6b 100644
--- a/pylint/checkers/modified_iterating_checker.py
+++ b/pylint/checkers/modified_iterating_checker.py
@@ -33,4 +33,28 @@ class ModifiedIterationChecker(checkers.BaseChecker):
def _modified_iterating_check_on_node_and_children(self, body_node:
nodes.NodeNG, iter_obj: nodes.NodeNG) ->None:
"""See if node or any of its children raises modified iterating messages."""
- pass
+ if isinstance(body_node, nodes.Call):
+ self._check_call_node(body_node, iter_obj)
+ elif isinstance(body_node, (nodes.Assign, nodes.AugAssign)):
+ self._check_assign_node(body_node, iter_obj)
+
+ for child in body_node.get_children():
+ self._modified_iterating_check_on_node_and_children(child, iter_obj)
+
+ def _check_call_node(self, call_node: nodes.Call, iter_obj: nodes.NodeNG) -> None:
+ if isinstance(call_node.func, nodes.Attribute):
+ if isinstance(call_node.func.expr, nodes.Name) and call_node.func.expr.name == iter_obj.name:
+ if isinstance(iter_obj, nodes.List) and call_node.func.attrname in _LIST_MODIFIER_METHODS:
+ self.add_message('modified-iterating-list', node=call_node, args=iter_obj.name)
+ elif isinstance(iter_obj, nodes.Dict) and call_node.func.attrname in _SET_MODIFIER_METHODS:
+ self.add_message('modified-iterating-dict', node=call_node, args=iter_obj.name)
+ elif isinstance(iter_obj, nodes.Set) and call_node.func.attrname in _SET_MODIFIER_METHODS:
+ self.add_message('modified-iterating-set', node=call_node, args=iter_obj.name)
+
+ def _check_assign_node(self, assign_node: nodes.Assign, iter_obj: nodes.NodeNG) -> None:
+ if isinstance(assign_node.targets[0], nodes.Subscript):
+ if isinstance(assign_node.targets[0].value, nodes.Name) and assign_node.targets[0].value.name == iter_obj.name:
+ if isinstance(iter_obj, nodes.Dict):
+ self.add_message('modified-iterating-dict', node=assign_node, args=iter_obj.name)
+ elif isinstance(iter_obj, nodes.List):
+ self.add_message('modified-iterating-list', node=assign_node, args=iter_obj.name)
diff --git a/pylint/checkers/nested_min_max.py b/pylint/checkers/nested_min_max.py
index 043bee27a..cf882da99 100644
--- a/pylint/checkers/nested_min_max.py
+++ b/pylint/checkers/nested_min_max.py
@@ -32,4 +32,12 @@ class NestedMinMaxChecker(BaseChecker):
"""Returns true if expression under min/max could be converted to splat
expression.
"""
- pass
+ if isinstance(arg, nodes.Call):
+ inferred = safe_infer(arg.func)
+ if isinstance(inferred, nodes.FunctionDef):
+ return inferred.qname() in self.FUNC_NAMES
+ elif isinstance(arg, (nodes.List, nodes.Tuple, nodes.Set)):
+ return True
+ elif isinstance(arg, DICT_TYPES):
+ return PY39_PLUS
+ return False
diff --git a/pylint/checkers/newstyle.py b/pylint/checkers/newstyle.py
index c0588ddc5..8a0f47a3a 100644
--- a/pylint/checkers/newstyle.py
+++ b/pylint/checkers/newstyle.py
@@ -28,5 +28,23 @@ class NewStyleConflictChecker(BaseChecker):
@only_required_for_messages('bad-super-call')
def visit_functiondef(self, node: nodes.FunctionDef) ->None:
"""Check use of super."""
- pass
+ if node.is_method():
+ klass = node_frame_class(node)
+ for stmt in node.body:
+ if isinstance(stmt, nodes.Expr):
+ call = stmt.value
+ if isinstance(call, nodes.Call) and isinstance(call.func, nodes.Name):
+ if call.func.name == 'super':
+ if not call.args:
+ continue
+
+ # Check if the first argument to super() is the current class
+ arg = call.args[0]
+ if isinstance(arg, nodes.Name):
+ if arg.name != klass.name:
+ self.add_message('bad-super-call', node=call, args=(arg.name,))
+ elif isinstance(arg, nodes.Attribute):
+ if arg.attrname != klass.name:
+ self.add_message('bad-super-call', node=call, args=(arg.attrname,))
+
visit_asyncfunctiondef = visit_functiondef
diff --git a/pylint/checkers/non_ascii_names.py b/pylint/checkers/non_ascii_names.py
index 3105ba332..a248f9f1b 100644
--- a/pylint/checkers/non_ascii_names.py
+++ b/pylint/checkers/non_ascii_names.py
@@ -34,15 +34,18 @@ class NonAsciiNameChecker(base_checker.BaseChecker):
def _check_name(self, node_type: str, name: (str | None), node: nodes.
NodeNG) ->None:
"""Check whether a name is using non-ASCII characters."""
- pass
+ if name and not name.isascii():
+ self.add_message('non-ascii-name', node=node, args=(node_type, name))
visit_asyncfunctiondef = visit_functiondef
@utils.only_required_for_messages('non-ascii-name')
def visit_assignname(self, node: nodes.AssignName) ->None:
"""Check module level assigned names."""
- pass
+ if not isinstance(node.parent, nodes.AssignAttr):
+ self._check_name('Variable', node.name, node)
@utils.only_required_for_messages('non-ascii-name')
def visit_call(self, node: nodes.Call) ->None:
"""Check if the used keyword args are correct."""
- pass
+ for keyword in node.keywords:
+ self._check_name('Keyword argument', keyword.arg, keyword)
diff --git a/pylint/checkers/raw_metrics.py b/pylint/checkers/raw_metrics.py
index 205644431..134096696 100644
--- a/pylint/checkers/raw_metrics.py
+++ b/pylint/checkers/raw_metrics.py
@@ -11,7 +11,23 @@ if TYPE_CHECKING:
def report_raw_stats(sect: Section, stats: LinterStats, old_stats: (
LinterStats | None)) ->None:
"""Calculate percentage of code / doc / comment / empty."""
- pass
+ total_lines = stats.code_lines + stats.docstring_lines + stats.comment_lines + stats.empty_lines
+ sect.append(Table(children=[
+ ["type", "number", "%", "previous", "difference"],
+ ["code", stats.code_lines, f"{stats.code_lines / total_lines:.2%}",
+ old_stats.code_lines if old_stats else "NC",
+ diff_string(old_stats.code_lines if old_stats else 0, stats.code_lines)],
+ ["docstring", stats.docstring_lines, f"{stats.docstring_lines / total_lines:.2%}",
+ old_stats.docstring_lines if old_stats else "NC",
+ diff_string(old_stats.docstring_lines if old_stats else 0, stats.docstring_lines)],
+ ["comment", stats.comment_lines, f"{stats.comment_lines / total_lines:.2%}",
+ old_stats.comment_lines if old_stats else "NC",
+ diff_string(old_stats.comment_lines if old_stats else 0, stats.comment_lines)],
+ ["empty", stats.empty_lines, f"{stats.empty_lines / total_lines:.2%}",
+ old_stats.empty_lines if old_stats else "NC",
+ diff_string(old_stats.empty_lines if old_stats else 0, stats.empty_lines)],
+ ]))
+ sect.append(Paragraph([Text(f"Total lines: {total_lines}")]))
class RawMetricsChecker(BaseTokenChecker):
@@ -31,11 +47,23 @@ class RawMetricsChecker(BaseTokenChecker):
def open(self) ->None:
"""Init statistics."""
- pass
+ self.stats = LinterStats()
+ self.stats.reset_code_type_count()
def process_tokens(self, tokens: list[tokenize.TokenInfo]) ->None:
"""Update stats."""
- pass
+ for index, token in enumerate(tokens):
+ if token.type == tokenize.NEWLINE:
+ self.stats.total_lines += 1
+ _, _, line_type = get_type(tokens, index)
+ if line_type == 'code':
+ self.stats.code_lines += 1
+ elif line_type == 'docstring':
+ self.stats.docstring_lines += 1
+ elif line_type == 'comment':
+ self.stats.comment_lines += 1
+ elif line_type == 'empty':
+ self.stats.empty_lines += 1
JUNK = tokenize.NL, tokenize.INDENT, tokenize.NEWLINE, tokenize.ENDMARKER
@@ -44,4 +72,16 @@ JUNK = tokenize.NL, tokenize.INDENT, tokenize.NEWLINE, tokenize.ENDMARKER
def get_type(tokens: list[tokenize.TokenInfo], start_index: int) ->tuple[
int, int, Literal['code', 'docstring', 'comment', 'empty']]:
"""Return the line type : docstring, comment, code, empty."""
- pass
+ i = start_index
+ while i >= 0 and tokens[i].type in JUNK:
+ i -= 1
+ if i < 0:
+ return 0, 0, 'empty'
+
+ tok = tokens[i]
+ if tok.type == tokenize.STRING:
+ return tok.start[0], tok.end[0], 'docstring'
+ if tok.type == tokenize.COMMENT:
+ return tok.start[0], tok.end[0], 'comment'
+
+ return tok.start[0], tok.end[0], 'code'
diff --git a/pylint/checkers/refactoring/implicit_booleaness_checker.py b/pylint/checkers/refactoring/implicit_booleaness_checker.py
index b7c28e71f..4d8e54c79 100644
--- a/pylint/checkers/refactoring/implicit_booleaness_checker.py
+++ b/pylint/checkers/refactoring/implicit_booleaness_checker.py
@@ -73,17 +73,48 @@ class ImplicitBooleanessChecker(checkers.BaseChecker):
"""`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):`.
"""
- pass
+ if isinstance(node, nodes.UnaryOp) and node.op == 'not':
+ operand = node.operand
+ if isinstance(operand, nodes.Call) and isinstance(operand.func, nodes.Name):
+ if operand.func.name == 'len' and len(operand.args) == 1:
+ self.add_message(
+ 'use-implicit-booleaness-not-len',
+ node=node,
+ confidence=INFERENCE,
+ )
def _check_use_implicit_booleaness_not_comparison(self, node: nodes.Compare
) ->None:
"""Check for left side and right side of the node for empty literals."""
- pass
+ if len(node.ops) != 1:
+ return
+
+ operator, right = node.ops[0]
+ if operator not in self._operators:
+ return
+
+ left = node.left
+ empty_literals = (nodes.List, nodes.Tuple, nodes.Dict)
+
+ if isinstance(left, empty_literals) and not left.elts:
+ message_args = self._implicit_booleaness_message_args(left, operator, right)
+ self.add_message('use-implicit-booleaness-not-comparison', node=node, args=message_args)
+ elif isinstance(right, empty_literals) and not right.elts:
+ message_args = self._implicit_booleaness_message_args(right, operator, left)
+ self.add_message('use-implicit-booleaness-not-comparison', node=node, args=message_args)
def _implicit_booleaness_message_args(self, literal_node: nodes.NodeNG,
operator: str, target_node: nodes.NodeNG) ->tuple[str, str, str]:
"""Helper to get the right message for "use-implicit-booleaness-not-comparison"."""
- pass
+ literal_type = type(literal_node).__name__.lower()
+ original = f"{target_node.as_string()} {operator} {literal_node.as_string()}"
+
+ if operator in ('==', 'is'):
+ suggestion = f"not {target_node.as_string()}"
+ else: # operator in ('!=', 'is not')
+ suggestion = f"{target_node.as_string()}"
+
+ return original, suggestion, literal_type
@staticmethod
def base_names_of_instance(node: (util.UninferableBase | bases.Instance)
@@ -93,4 +124,14 @@ class ImplicitBooleanessChecker(checkers.BaseChecker):
The inherited names include 'object'.
"""
- pass
+ if isinstance(node, util.UninferableBase):
+ return []
+
+ try:
+ class_node = node._proxied
+ except AttributeError:
+ return []
+
+ return [
+ base.name for base in itertools.chain([class_node], class_node.ancestors())
+ ]
diff --git a/pylint/checkers/refactoring/recommendation_checker.py b/pylint/checkers/refactoring/recommendation_checker.py
index 187ef26fc..61cce4b39 100644
--- a/pylint/checkers/refactoring/recommendation_checker.py
+++ b/pylint/checkers/refactoring/recommendation_checker.py
@@ -34,20 +34,49 @@ class RecommendationChecker(checkers.BaseChecker):
"""Add message when accessing first or last elements of a str.split() or
str.rsplit().
"""
- pass
+ if isinstance(node.func, nodes.Attribute) and node.func.attrname in ('split', 'rsplit'):
+ if len(node.args) == 0 or (len(node.args) == 1 and not isinstance(node.args[0], nodes.Const)):
+ parent = node.parent
+ if isinstance(parent, nodes.Subscript):
+ if isinstance(parent.slice, nodes.Const):
+ index = parent.slice.value
+ if index in (0, -1):
+ method = 'split' if index == 0 else 'rsplit'
+ suggestion = f"str.{method}(sep, maxsplit=1)[{index}]"
+ self.add_message('use-maxsplit-arg', node=parent, args=(suggestion,))
def _check_consider_using_enumerate(self, node: nodes.For) ->None:
"""Emit a convention whenever range and len are used for indexing."""
- pass
+ if isinstance(node.iter, nodes.Call) and isinstance(node.iter.func, nodes.Name):
+ if node.iter.func.name == 'range':
+ if len(node.iter.args) == 1 and isinstance(node.iter.args[0], nodes.Call):
+ if isinstance(node.iter.args[0].func, nodes.Name) and node.iter.args[0].func.name == 'len':
+ self.add_message('consider-using-enumerate', node=node)
def _check_consider_using_dict_items(self, node: nodes.For) ->None:
"""Add message when accessing dict values by index lookup."""
- pass
+ if isinstance(node.iter, nodes.Name):
+ dict_name = node.iter.name
+ for child in node.body:
+ if isinstance(child, nodes.Assign):
+ if isinstance(child.targets[0], nodes.AssignName) and isinstance(child.value, nodes.Subscript):
+ if isinstance(child.value.value, nodes.Name) and child.value.value.name == dict_name:
+ self.add_message('consider-using-dict-items', node=node)
+ break
def _check_consider_using_dict_items_comprehension(self, node: nodes.
Comprehension) ->None:
"""Add message when accessing dict values by index lookup."""
- pass
+ if isinstance(node.iter, nodes.Name):
+ dict_name = node.iter.name
+ parent = node.parent
+ if isinstance(parent, (nodes.ListComp, nodes.DictComp, nodes.SetComp, nodes.GeneratorExp)):
+ if isinstance(parent.elt, nodes.Tuple):
+ if len(parent.elt.elts) == 2:
+ key, value = parent.elt.elts
+ if isinstance(value, nodes.Subscript) and isinstance(value.value, nodes.Name):
+ if value.value.name == dict_name:
+ self.add_message('consider-using-dict-items', node=parent)
def _check_use_sequence_for_iteration(self, node: (nodes.For | nodes.
Comprehension)) ->None:
@@ -55,10 +84,17 @@ class RecommendationChecker(checkers.BaseChecker):
Sets using `*` are not considered in-place.
"""
- pass
+ if isinstance(node.iter, nodes.Set):
+ if not any(isinstance(elt, nodes.Starred) for elt in node.iter.elts):
+ self.add_message('use-sequence-for-iteration', node=node)
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.
"""
- pass
+ if isinstance(node.parent, nodes.Call):
+ if isinstance(node.parent.func, nodes.Attribute):
+ if node.parent.func.attrname == 'format':
+ self.add_message('consider-using-f-string', node=node)
+ elif isinstance(node.parent, nodes.BinOp) and node.parent.op == '%':
+ self.add_message('consider-using-f-string', node=node)
diff --git a/pylint/checkers/refactoring/refactoring_checker.py b/pylint/checkers/refactoring/refactoring_checker.py
index bfd096850..21e8ad55a 100644
--- a/pylint/checkers/refactoring/refactoring_checker.py
+++ b/pylint/checkers/refactoring/refactoring_checker.py
@@ -255,7 +255,11 @@ class RefactoringChecker(checkers.BaseTokenChecker):
Unfortunately we need to know the exact type in certain
cases.
"""
- pass
+ parent = node.parent
+ if not isinstance(parent, (nodes.If, nodes.Try)):
+ return False
+ return (parent.orelse and parent.orelse[0] is node and
+ parent.lineno == node.lineno)
def _check_simplifiable_if(self, node: nodes.If) ->None:
"""Check if the given if node can be simplified.
@@ -275,13 +279,34 @@ class RefactoringChecker(checkers.BaseTokenChecker):
def _check_stop_iteration_inside_generator(self, node: nodes.Raise) ->None:
"""Check if an exception of type StopIteration is raised inside a generator."""
- pass
+ frame = node.frame()
+ if not isinstance(frame, nodes.FunctionDef) or not frame.is_generator():
+ return
+
+ if isinstance(node.exc, nodes.Call):
+ exc = utils.safe_infer(node.exc.func)
+ else:
+ exc = utils.safe_infer(node.exc)
+
+ if exc and self._check_exception_inherit_from_stopiteration(exc):
+ self.add_message('stop-iteration-return', node=node)
@staticmethod
def _check_exception_inherit_from_stopiteration(exc: (nodes.ClassDef |
bases.Instance)) ->bool:
"""Return True if the exception node in argument inherit from StopIteration."""
- pass
+ if isinstance(exc, nodes.ClassDef):
+ return any(
+ base.name == 'StopIteration' or
+ RefactoringChecker._check_exception_inherit_from_stopiteration(base)
+ for base in exc.bases
+ )
+ if isinstance(exc, bases.Instance):
+ return exc.name == 'StopIteration' or any(
+ RefactoringChecker._check_exception_inherit_from_stopiteration(base)
+ for base in exc.mro()[1:]
+ )
+ return False
def _check_raising_stopiteration_in_generator_next_call(self, node:
nodes.Call) ->None:
@@ -296,7 +321,19 @@ class RefactoringChecker(checkers.BaseTokenChecker):
def _check_nested_blocks(self, node: NodesWithNestedBlocks) ->None:
"""Update and check the number of nested blocks."""
- pass
+ nested_blocks = 1
+ parent = node.parent
+ while parent and not isinstance(parent, nodes.FunctionDef):
+ if isinstance(parent, (nodes.If, nodes.While, nodes.For, nodes.Try)):
+ nested_blocks += 1
+ parent = parent.parent
+
+ if nested_blocks > self.linter.config.max_nested_blocks:
+ self.add_message(
+ 'too-many-nested-blocks',
+ node=node,
+ args=(nested_blocks, self.linter.config.max_nested_blocks),
+ )
@staticmethod
def _duplicated_isinstance_types(node: nodes.BoolOp) ->dict[str, set[str]]:
@@ -307,7 +344,30 @@ class RefactoringChecker(checkers.BaseTokenChecker):
to duplicate values from consecutive calls.
:rtype: dict
"""
- pass
+ duplicated_types = {}
+ all_types = set()
+
+ for call in node.values:
+ if not isinstance(call, nodes.Call) or not call.func or not isinstance(call.func, nodes.Name):
+ continue
+
+ if call.func.name != 'isinstance':
+ continue
+
+ if len(call.args) != 2:
+ continue
+
+ obj = call.args[0].as_string()
+ if isinstance(call.args[1], nodes.Tuple):
+ types = {arg.as_string() for arg in call.args[1].elts}
+ else:
+ types = {call.args[1].as_string()}
+
+ duplicated_types.setdefault(obj, set())
+ duplicated_types[obj].update(all_types.intersection(types))
+ all_types.update(types)
+
+ return {key: value for key, value in duplicated_types.items() if value}
def _check_consider_merging_isinstance(self, node: nodes.BoolOp) ->None:
"""Check isinstance calls which can be merged together."""
@@ -335,7 +395,15 @@ class RefactoringChecker(checkers.BaseTokenChecker):
2) False values in OR expressions are only relevant if all values are
false, and the reverse for AND
"""
- pass
+ if operator == 'or':
+ if any(isinstance(value, nodes.Const) and value.value is True for value in values):
+ return [nodes.Const(True)]
+ return [value for value in values if not (isinstance(value, nodes.Const) and value.value is False)]
+ elif operator == 'and':
+ if any(isinstance(value, nodes.Const) and value.value is False for value in values):
+ return [nodes.Const(False)]
+ return [value for value in values if not (isinstance(value, nodes.Const) and value.value is True)]
+ return values
def _simplify_boolean_operation(self, bool_op: nodes.BoolOp
) ->nodes.BoolOp:
@@ -365,11 +433,31 @@ class RefactoringChecker(checkers.BaseTokenChecker):
@staticmethod
def _dict_literal_suggestion(node: nodes.Call) ->str:
"""Return a suggestion of reasonable length."""
- pass
+ if not node.args:
+ return '{}'
+ if len(node.args) == 1 and isinstance(node.args[0], nodes.Dict):
+ items = node.args[0].items
+ if len(items) <= 3:
+ return '{' + ', '.join(f'{k.as_string()}: {v.as_string()}' for k, v in items) + '}'
+ return '{...}' # for longer dicts
+ return '{...}' # for other cases
def _name_to_concatenate(self, node: nodes.NodeNG) ->(str | None):
"""Try to extract the name used in a concatenation loop."""
- pass
+ if isinstance(node, nodes.Name):
+ return node.name
+ if isinstance(node, nodes.Subscript):
+ return self._name_to_concatenate(node.value)
+ if isinstance(node, nodes.Attribute):
+ names = []
+ current = node
+ while isinstance(current, nodes.Attribute):
+ names.append(current.attrname)
+ current = current.expr
+ if isinstance(current, nodes.Name):
+ names.append(current.name)
+ return '.'.join(reversed(names))
+ return None
def _check_consider_using_join(self, aug_assign: nodes.AugAssign) ->None:
"""We start with the augmented assignment and work our way upwards.
@@ -437,7 +525,11 @@ class RefactoringChecker(checkers.BaseTokenChecker):
@staticmethod
def _has_return_in_siblings(node: nodes.NodeNG) ->bool:
"""Returns True if there is at least one return in the node's siblings."""
- pass
+ siblings = node.parent.get_children()
+ return any(
+ isinstance(sibling, nodes.Return)
+ for sibling in itertools.dropwhile(lambda n: n != node, siblings)
+ )
def _is_function_def_never_returning(self, node: (nodes.FunctionDef |
astroid.BoundMethod)) ->bool:
diff --git a/pylint/checkers/similar.py b/pylint/checkers/similar.py
index b85648de9..2d2c6576c 100644
--- a/pylint/checkers/similar.py
+++ b/pylint/checkers/similar.py
@@ -164,7 +164,19 @@ def hash_lineset(lineset: LineSet, min_common_lines: int=
:return: a dict linking hashes to corresponding start index and a dict that links this
index to the start and end lines in the file
"""
- pass
+ hash_to_index = defaultdict(list)
+ index_to_lines = {}
+
+ for i in range(len(lineset) - min_common_lines + 1):
+ lines = [lineset[j].text for j in range(i, i + min_common_lines)]
+ chunk = LinesChunk(lineset.name, i, *lines)
+ hash_to_index[chunk].append(Index(i))
+ index_to_lines[Index(i)] = SuccessiveLinesLimits(
+ LineNumber(lineset[i].line_number),
+ LineNumber(lineset[i + min_common_lines - 1].line_number)
+ )
+
+ return hash_to_index, index_to_lines
def remove_successive(all_couples: CplIndexToCplLines_T) ->None:
@@ -192,7 +204,17 @@ def remove_successive(all_couples: CplIndexToCplLines_T) ->None:
{(11, 34): ([5, 10], [27, 32]),
(23, 79): ([15, 19], [45, 49])}
"""
- pass
+ keys = sorted(all_couples.keys())
+ for i in range(len(keys) - 1):
+ current_key, next_key = keys[i], keys[i + 1]
+ if (current_key[0] + 1 == next_key[0] and
+ current_key[1] + 1 == next_key[1]):
+ current_value = all_couples[current_key]
+ next_value = all_couples[next_key]
+ current_value.first_file._end = next_value.first_file._end
+ current_value.second_file._end = next_value.second_file._end
+ current_value.effective_cmn_lines_nb += next_value.effective_cmn_lines_nb - 1
+ del all_couples[next_key]
def filter_noncode_lines(ls_1: LineSet, stindex_1: Index, ls_2: LineSet,
@@ -211,7 +233,13 @@ def filter_noncode_lines(ls_1: LineSet, stindex_1: Index, ls_2: LineSet,
:param common_lines_nb: number of common successive stripped lines before being filtered from non code lines
:return: the number of common successive stripped lines that contain code
"""
- pass
+ effective_common_lines = 0
+ for i in range(common_lines_nb):
+ line1 = ls_1[stindex_1 + i].text
+ line2 = ls_2[stindex_2 + i].text
+ if REGEX_FOR_LINES_WITH_CONTENT.match(line1) and REGEX_FOR_LINES_WITH_CONTENT.match(line2):
+ effective_common_lines += 1
+ return effective_common_lines
class Commonality(NamedTuple):
diff --git a/pylint/checkers/spelling.py b/pylint/checkers/spelling.py
index 110818045..eab3c1efe 100644
--- a/pylint/checkers/spelling.py
+++ b/pylint/checkers/spelling.py
@@ -98,7 +98,7 @@ def _strip_code_flanked_in_backticks(line: str) ->str:
Pyenchant automatically strips back-ticks when parsing tokens,
so this cannot be done at the individual filter level.
"""
- pass
+ return CODE_FLANKED_IN_BACKTICK_REGEX.sub(r'\1\5', line)
class SpellingChecker(BaseTokenChecker):
@@ -143,4 +143,17 @@ Did you mean: '%s'?"""
def _check_docstring(self, node: (nodes.FunctionDef | nodes.
AsyncFunctionDef | nodes.ClassDef | nodes.Module)) ->None:
"""Check if the node has any spelling errors."""
- pass
+ if not node.doc:
+ return
+
+ for lineno, line in enumerate(node.doc.splitlines(), node.lineno):
+ stripped_line = _strip_code_flanked_in_backticks(line)
+ for word, pos in self.tokenize_string(stripped_line):
+ if not self.check_spelling(word):
+ suggestions = self.spelling_dict.suggest(word)[:self.max_spelling_suggestions]
+ misspelled = line[pos:pos+len(word)]
+ self.add_message(
+ 'wrong-spelling-in-docstring',
+ args=(misspelled, line, ' ' * pos + '^', ' or '.join(suggestions)),
+ line=lineno
+ )
diff --git a/pylint/checkers/stdlib.py b/pylint/checkers/stdlib.py
index 0baac8efa..1650d33df 100644
--- a/pylint/checkers/stdlib.py
+++ b/pylint/checkers/stdlib.py
@@ -248,17 +248,62 @@ class StdlibChecker(DeprecatedMixin, BaseChecker):
'forgotten-debug-statement')
def visit_call(self, node: nodes.Call) ->None:
"""Visit a Call node."""
- pass
+ if isinstance(node.func, nodes.Attribute):
+ self._check_deprecated_method(node)
+ self._check_subprocess_run(node)
+ self._check_subprocess_popen(node)
+ self._check_shallow_copy_environ(node)
+ elif isinstance(node.func, nodes.Name):
+ self._check_open_call(node, "", node.func.name)
+ self._check_bad_thread_instantiation(node)
+ self._check_env_function(node)
+ self._check_forgotten_debug_statement(node)
+ self._check_deprecated_argument(node)
+ self._check_redundant_assert(node)
+ self._check_datetime(node)
def _check_lru_cache_decorators(self, node: nodes.FunctionDef) ->None:
"""Check if instance methods are decorated with functools.lru_cache."""
- pass
+ if not node.decorators:
+ return
+ for decorator in node.decorators.nodes:
+ if isinstance(decorator, nodes.Call):
+ if isinstance(decorator.func, nodes.Name) and decorator.func.name in LRU_CACHE:
+ self.add_message('method-cache-max-size-none', node=node)
+ elif isinstance(decorator, nodes.Name) and decorator.name in LRU_CACHE:
+ self.add_message('method-cache-max-size-none', node=node)
def _check_datetime(self, node: nodes.NodeNG) ->None:
"""Check that a datetime was inferred, if so, emit boolean-datetime warning."""
- pass
+ try:
+ inferred = next(node.infer())
+ except astroid.InferenceError:
+ return
+ if (isinstance(inferred, nodes.Instance) and
+ inferred.qname() == 'datetime.time' and
+ isinstance(node.parent, (nodes.If, nodes.IfExp, nodes.BoolOp))):
+ self.add_message('boolean-datetime', node=node)
def _check_open_call(self, node: nodes.Call, open_module: str,
func_name: str) ->None:
"""Various checks for an open call."""
- pass
+ if func_name not in OPEN_FILES_FUNCS:
+ return
+ if node.keywords:
+ kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
+ if 'encoding' not in kwargs and open_module not in OPEN_MODULE:
+ self.add_message('unspecified-encoding', node=node)
+ elif len(node.args) < 3 and open_module not in OPEN_MODULE:
+ self.add_message('unspecified-encoding', node=node)
+
+ if not node.args:
+ return
+ mode = node.args[1] if len(node.args) >= 2 else None
+ if not mode:
+ return
+ if not isinstance(mode, nodes.Const) or not isinstance(mode.value, str):
+ return
+ mode_value = mode.value
+ if mode_value not in ('r', 'w', 'a', 'x', 'r+', 'w+', 'a+', 'x+',
+ 'rb', 'wb', 'ab', 'xb', 'r+b', 'w+b', 'a+b', 'x+b'):
+ self.add_message('bad-open-mode', node=node, args=(mode_value,))
diff --git a/pylint/checkers/strings.py b/pylint/checkers/strings.py
index bb0cd648f..a47c4280b 100644
--- a/pylint/checkers/strings.py
+++ b/pylint/checkers/strings.py
@@ -98,7 +98,13 @@ def get_access_path(key: (str | Literal[0]), parts: list[tuple[bool, str]]
"""Given a list of format specifiers, returns
the final access path (e.g. a.b.c[0][1]).
"""
- pass
+ path = str(key)
+ for is_attribute, part in parts:
+ if is_attribute:
+ path += f".{part}"
+ else:
+ path += f"[{part}]"
+ return path
class StringFormatChecker(BaseChecker):
@@ -111,7 +117,35 @@ class StringFormatChecker(BaseChecker):
def _check_new_format(self, node: nodes.Call, func: bases.BoundMethod
) ->None:
"""Check the new string formatting."""
- pass
+ if isinstance(node.func, nodes.Attribute):
+ format_string = node.func.expr
+ else:
+ format_string = node.args[0]
+
+ if not isinstance(format_string, nodes.Const):
+ return
+
+ try:
+ fields, num_args, manual_pos = utils.parse_format_string(format_string.value)
+ except utils.IncompleteFormatString:
+ self.add_message('bad-format-string', node=node)
+ return
+
+ named = {}
+ for name, nested, pos in fields:
+ if name is not None:
+ named[name] = nested
+
+ if num_args and manual_pos:
+ self.add_message('format-combined-specification', node=node)
+ return
+
+ args = node.args[1:]
+ if isinstance(func, nodes.Attribute) and args:
+ args = args[1:]
+
+ if named:
+ self._check_new_format_specifiers(node, fields, named)
def _check_new_format_specifiers(self, node: nodes.Call, fields: list[
tuple[str, list[tuple[bool, str]]]], named: dict[str,
@@ -119,7 +153,42 @@ class StringFormatChecker(BaseChecker):
"""Check attribute and index access in the format
string ("{0.a}" and "{0[a]}").
"""
- pass
+ for key, parts in fields:
+ if key is None:
+ continue
+
+ if not parts:
+ continue
+
+ try:
+ arg = named[key]
+ except KeyError:
+ continue
+
+ if not hasattr(arg, 'value'):
+ continue
+
+ previous = arg.value
+ for is_attribute, attr in parts:
+ if is_attribute:
+ if not hasattr(previous, attr):
+ self.add_message(
+ 'missing-format-attribute',
+ node=node,
+ args=(attr, get_access_path(key, parts))
+ )
+ break
+ previous = getattr(previous, attr)
+ else:
+ try:
+ previous = previous[attr]
+ except (TypeError, KeyError):
+ self.add_message(
+ 'invalid-format-index',
+ node=node,
+ args=(attr, get_access_path(key, parts))
+ )
+ break
class StringConstantChecker(BaseTokenChecker, BaseRawFileChecker):
@@ -174,7 +243,23 @@ class StringConstantChecker(BaseTokenChecker, BaseRawFileChecker):
Args:
tokens: The tokens to be checked against for consistent usage.
"""
- pass
+ string_tokens = [t for t in tokens if t.type == tokenize.STRING]
+ if not string_tokens:
+ return
+
+ quote_delimiter = _get_quote_delimiter(string_tokens[0].string)
+ for token in string_tokens[1:]:
+ if _is_long_string(token.string):
+ continue
+
+ current_delimiter = _get_quote_delimiter(token.string)
+ if current_delimiter != quote_delimiter:
+ if _is_quote_delimiter_chosen_freely(token.string):
+ self.add_message(
+ 'inconsistent-quotes',
+ line=token.start[0],
+ args=(current_delimiter,)
+ )
def process_non_raw_string_token(self, prefix: str, string_body: str,
start_row: int, string_start_col: int) ->None:
@@ -186,11 +271,28 @@ class StringConstantChecker(BaseTokenChecker, BaseRawFileChecker):
start_row: line number in the source.
string_start_col: col number of the string start in the source.
"""
- pass
+ for match in re.finditer(r'[^\\]\\(?P<char>.)', string_body):
+ char = match.group('char')
+ if char not in self.ESCAPE_CHARACTERS:
+ col_offset = string_start_col + match.start() + 1
+ if 'u' in prefix:
+ if char not in self.UNICODE_ESCAPE_CHARACTERS:
+ self.add_message('anomalous-unicode-escape-in-string',
+ line=start_row,
+ args=(char,),
+ col_offset=col_offset)
+ else:
+ self.add_message('anomalous-backslash-in-string',
+ line=start_row,
+ args=(char,),
+ col_offset=col_offset)
def _detect_u_string_prefix(self, node: nodes.Const) ->None:
"""Check whether strings include a 'u' prefix like u'String'."""
- pass
+ if isinstance(node.value, str) and node.raw_string:
+ prefix = node.raw_string.split("'")[0].lower()
+ if 'u' in prefix:
+ self.add_message('redundant-u-string-prefix', node=node)
def str_eval(token: str) ->str:
@@ -200,7 +302,31 @@ def str_eval(token: str) ->str:
We have to support all string literal notations:
https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
"""
- pass
+ if token.startswith(('f', 'F')):
+ # For f-strings, we can't evaluate them, so we return the raw string
+ return token[2:-1] if token[1] in "\"'" else token[1:-1]
+
+ prefix = ''
+ while token and token[0] in 'rRbBuU':
+ prefix += token[0].lower()
+ token = token[1:]
+
+ if token.startswith("'''") or token.startswith('"""'):
+ quote = token[:3]
+ token = token[3:-3]
+ elif token.startswith("'") or token.startswith('"'):
+ quote = token[0]
+ token = token[1:-1]
+ else:
+ raise ValueError("Invalid string token")
+
+ if 'r' in prefix:
+ return token
+
+ result = token.encode('ascii', 'backslashreplace').decode('unicode-escape')
+ if 'b' in prefix:
+ return result.encode('ascii')
+ return result
def _is_long_string(string_token: str) ->bool:
@@ -220,7 +346,7 @@ def _is_long_string(string_token: str) ->bool:
A boolean representing whether this token matches a longstring
regex.
"""
- pass
+ return bool(SINGLE_QUOTED_REGEX.match(string_token) or DOUBLE_QUOTED_REGEX.match(string_token))
def _get_quote_delimiter(string_token: str) ->str:
@@ -238,7 +364,10 @@ def _get_quote_delimiter(string_token: str) ->str:
Raises:
ValueError: No quote delimiter characters are present.
"""
- pass
+ match = QUOTE_DELIMITER_REGEX.match(string_token)
+ if not match:
+ raise ValueError("No quote delimiter found in string token.")
+ return match.group(2)
def _is_quote_delimiter_chosen_freely(string_token: str) ->bool:
@@ -253,4 +382,11 @@ def _is_quote_delimiter_chosen_freely(string_token: str) ->bool:
strings are excepted from this analysis under the assumption that their
quote characters are set by policy.
"""
- pass
+ if _is_long_string(string_token):
+ return False
+
+ delimiter = _get_quote_delimiter(string_token)
+ other_delimiter = '"' if delimiter == "'" else "'"
+
+ # Check if the string contains the other delimiter without a backslash before it
+ return not re.search(r'(?<!\\)' + re.escape(other_delimiter), string_token)
diff --git a/pylint/checkers/typecheck.py b/pylint/checkers/typecheck.py
index f7ac53ca5..a39f6d294 100644
--- a/pylint/checkers/typecheck.py
+++ b/pylint/checkers/typecheck.py
@@ -58,7 +58,17 @@ def _is_owner_ignored(owner: SuccessfulInferenceResult, attrname: (str |
matches any name from the *ignored_classes* or if its qualified
name can be found in *ignored_classes*.
"""
- pass
+ if isinstance(owner, nodes.Module):
+ return (owner.name in ignored_modules or
+ owner.qname() in ignored_modules or
+ any(owner.qname().startswith(mod) for mod in ignored_modules))
+
+ if isinstance(owner, nodes.ClassDef):
+ return (owner.name in ignored_classes or
+ owner.qname() in ignored_classes or
+ any(owner.qname().startswith(cls) for cls in ignored_classes))
+
+ return False
def _similar_names(owner: SuccessfulInferenceResult, attrname: (str | None),
@@ -68,7 +78,25 @@ def _similar_names(owner: SuccessfulInferenceResult, attrname: (str | None),
The similar names are searched given a distance metric and only
a given number of choices will be returned.
"""
- pass
+ from difflib import SequenceMatcher
+
+ if attrname is None:
+ return []
+
+ attributes = owner.getattr('__dict__', [])
+ if not attributes:
+ return []
+
+ similar_names = []
+ for attr in attributes:
+ if not isinstance(attr, nodes.AssignName):
+ continue
+ similarity = SequenceMatcher(None, attrname, attr.name).ratio()
+ if similarity >= distance_threshold:
+ similar_names.append((similarity, attr.name))
+
+ similar_names.sort(reverse=True)
+ return [name for _, name in similar_names[:max_choices]]
MSGS: dict[str, MessageDefinitionTuple] = {'E1101': (
@@ -186,13 +214,47 @@ def _emit_no_member(node: (nodes.Attribute | nodes.AssignAttr | nodes.
AttributeError, Exception or bare except.
* The node is guarded behind and `IF` or `IFExp` node
"""
- pass
+ if isinstance(owner, astroid.FunctionDef) and owner.decorators:
+ return False
+
+ if isinstance(owner, astroid.Instance):
+ if owner.has_dynamic_getattr():
+ return False
+ if any(owner.getattr(attr) for attr in ('__getattr__', '__getattribute__')):
+ return False
+
+ if isinstance(owner, astroid.Module) and owner.name in node.root().file_ignored_lines:
+ return False
+
+ if isinstance(owner, astroid.ClassDef):
+ metaclass = owner.metaclass()
+ if metaclass and node.attrname in metaclass.locals:
+ return False
+
+ if utils.node_ignores_exception(node, AttributeError):
+ return False
+
+ if utils.is_node_in_guarded_import_block(node):
+ return False
+
+ if ignored_mixins and mixin_class_rgx.match(owner_name or ''):
+ return False
+
+ if ignored_none and isinstance(owner, nodes.Const) and owner.value is None:
+ return False
+
+ return True
def _has_parent_of_type(node: nodes.Call, node_type: (nodes.Keyword | nodes
.Starred), statement: _base_nodes.Statement) ->bool:
"""Check if the given node has a parent of the given type."""
- pass
+ parent = node.parent
+ while parent and parent != statement:
+ if isinstance(parent, node_type):
+ return True
+ parent = parent.parent
+ return False
def _no_context_variadic(node: nodes.Call, variadic_name: (str | None),
@@ -208,7 +270,18 @@ def _no_context_variadic(node: nodes.Call, variadic_name: (str | None),
This can lead pylint to believe that a function call receives
too few arguments.
"""
- pass
+ if not variadic_name:
+ return False
+
+ for variadic in variadics:
+ if not isinstance(variadic, variadic_type):
+ continue
+
+ inferred = safe_infer(variadic.value)
+ if isinstance(inferred, (astroid.Tuple, astroid.Dict)) and not inferred.elts:
+ return True
+
+ return False
def _infer_from_metaclass_constructor(cls: nodes.ClassDef, func: nodes.
@@ -229,7 +302,17 @@ def _infer_from_metaclass_constructor(cls: nodes.ClassDef, func: nodes.
if we couldn't infer it.
:rtype: astroid.ClassDef
"""
- pass
+ if len(func.args.args) != 3:
+ return None
+
+ name = cls.name
+ bases = [base for base in cls.bases if isinstance(base, nodes.Name)]
+ attrs = cls.locals
+
+ try:
+ return next(func.infer_call_result(func, [nodes.Const(name), nodes.List(bases), nodes.Dict(attrs)]))
+ except astroid.InferenceError:
+ return None
class TypeChecker(BaseChecker):
diff --git a/pylint/checkers/unicode.py b/pylint/checkers/unicode.py
index b6fd71f21..176b760d7 100644
--- a/pylint/checkers/unicode.py
+++ b/pylint/checkers/unicode.py
@@ -35,11 +35,11 @@ class _BadChar(NamedTuple):
def description(self) ->str:
"""Used for the detailed error message description."""
- pass
+ return f"Found {self.name} character ({self.escaped})"
def human_code(self) ->str:
"""Used to generate the human readable error message."""
- pass
+ return f"bad-{self.name}-character"
BAD_CHARS = [_BadChar('backspace', '\x08', '\\b', 'E2510',
@@ -59,7 +59,9 @@ BAD_ASCII_SEARCH_DICT = {char.unescaped: char for char in BAD_CHARS}
def _line_length(line: _StrLike, codec: str) ->int:
"""Get the length of a string like line as displayed in an editor."""
- pass
+ if isinstance(line, bytes):
+ return len(line.decode(codec))
+ return len(line)
def _map_positions_to_result(line: _StrLike, search_dict: dict[_StrLike,
@@ -71,7 +73,11 @@ def _map_positions_to_result(line: _StrLike, search_dict: dict[_StrLike,
Also takes care of encodings for which the length of an encoded code point does not
default to 8 Bit.
"""
- pass
+ result = {}
+ for i, char in enumerate(line):
+ if char in search_dict:
+ result[i * byte_str_length] = search_dict[char]
+ return result
UNICODE_BOMS = {'utf-8': codecs.BOM_UTF8, 'utf-16': codecs.BOM_UTF16,
@@ -86,28 +92,40 @@ UTF_NAME_REGEX_COMPILED = re.compile('utf[ -]?(8|16|32)[ -]?(le|be|)?(sig)?',
def _normalize_codec_name(codec: str) ->str:
"""Make sure the codec name is always given as defined in the BOM dict."""
- pass
+ match = UTF_NAME_REGEX_COMPILED.match(codec)
+ if match:
+ utf, endian, _ = match.groups()
+ return f"utf-{utf}{endian or ''}".lower()
+ return codec.lower()
def _remove_bom(encoded: bytes, encoding: str) ->bytes:
"""Remove the bom if given from a line."""
- pass
+ bom = UNICODE_BOMS.get(_normalize_codec_name(encoding))
+ if bom and encoded.startswith(bom):
+ return encoded[len(bom):]
+ return encoded
def _encode_without_bom(string: str, encoding: str) ->bytes:
"""Encode a string but remove the BOM."""
- pass
+ encoded = string.encode(encoding)
+ return _remove_bom(encoded, encoding)
def _byte_to_str_length(codec: str) ->int:
"""Return how many byte are usually(!) a character point."""
- pass
+ if codec.startswith('utf-16'):
+ return 2
+ if codec.startswith('utf-32'):
+ return 4
+ return 1
@lru_cache(maxsize=1000)
def _cached_encode_search(string: str, encoding: str) ->bytes:
"""A cached version of encode used for search pattern."""
- pass
+ return string.encode(encoding)
def _fix_utf16_32_line_stream(steam: Iterable[bytes], codec: str) ->Iterable[
@@ -117,7 +135,11 @@ def _fix_utf16_32_line_stream(steam: Iterable[bytes], codec: str) ->Iterable[
Currently, Python simply strips the required zeros after \\n after the
line ending. Leading to lines that can't be decoded properly
"""
- pass
+ byte_length = _byte_to_str_length(codec)
+ for line in steam:
+ if len(line) % byte_length != 0:
+ line += b'\x00' * (byte_length - (len(line) % byte_length))
+ yield line
def extract_codec_from_bom(first_line: bytes) ->str:
@@ -134,7 +156,10 @@ def extract_codec_from_bom(first_line: bytes) ->str:
Raises:
ValueError: if no codec was found
"""
- pass
+ for bom, codec in BOM_SORTED_TO_CODEC.items():
+ if first_line.startswith(bom):
+ return codec
+ raise ValueError("No BOM found")
class UnicodeChecker(checkers.BaseRawFileChecker):
@@ -185,7 +210,8 @@ https://trojansource.codes/"""
Return:
A dictionary with the column offset and the BadASCIIChar
"""
- pass
+ decoded_line = line.decode(codec)
+ return _map_positions_to_result(decoded_line, BAD_ASCII_SEARCH_DICT, line, _byte_to_str_length(codec))
@staticmethod
def _determine_codec(stream: io.BytesIO) ->tuple[str, int]:
@@ -205,21 +231,50 @@ https://trojansource.codes/"""
Raises:
SyntaxError: if failing to detect codec
"""
- pass
+ try:
+ encoding, lines = detect_encoding(stream.readline)
+ return _normalize_codec_name(encoding), lines
+ except SyntaxError:
+ stream.seek(0)
+ first_line = stream.readline()
+ try:
+ codec = extract_codec_from_bom(first_line)
+ return _normalize_codec_name(codec), 1
+ except ValueError as e:
+ raise SyntaxError("Unable to determine file encoding") from e
def _check_codec(self, codec: str, codec_definition_line: int) ->None:
"""Check validity of the codec."""
- pass
+ if codec.startswith(('utf-16', 'utf-32')):
+ self.add_message('invalid-unicode-codec', line=codec_definition_line)
+ elif codec != 'utf-8':
+ self.add_message('bad-file-encoding', line=codec_definition_line)
def _check_invalid_chars(self, line: bytes, lineno: int, codec: str
) ->None:
"""Look for chars considered bad."""
- pass
+ for col, bad_char in self._find_line_matches(line, codec).items():
+ self.add_message(bad_char.code, line=lineno, col_offset=col, args=(bad_char.escaped,))
def _check_bidi_chars(self, line: bytes, lineno: int, codec: str) ->None:
"""Look for Bidirectional Unicode, if we use unicode."""
- pass
+ decoded_line = line.decode(codec)
+ for col, char in enumerate(decoded_line):
+ if char in BIDI_UNICODE:
+ self.add_message('bidirectional-unicode', line=lineno, col_offset=col)
def process_module(self, node: nodes.Module) ->None:
"""Perform the actual check by checking module stream."""
- pass
+ with node.stream() as stream:
+ try:
+ codec, codec_line = self._determine_codec(stream)
+ except SyntaxError:
+ self.add_message('invalid-unicode-codec', line=1)
+ return
+
+ self._check_codec(codec, codec_line)
+
+ stream.seek(0)
+ for lineno, line in enumerate(stream, start=1):
+ self._check_invalid_chars(line, lineno, codec)
+ self._check_bidi_chars(line, lineno, codec)
diff --git a/pylint/checkers/unsupported_version.py b/pylint/checkers/unsupported_version.py
index 8be4654c4..712b426d4 100644
--- a/pylint/checkers/unsupported_version.py
+++ b/pylint/checkers/unsupported_version.py
@@ -27,20 +27,28 @@ class UnsupportedVersionChecker(BaseChecker):
def open(self) ->None:
"""Initialize visit variables and statistics."""
- pass
+ self.py_version = self.linter.config.py_version
@only_required_for_messages('using-f-string-in-unsupported-version')
def visit_joinedstr(self, node: nodes.JoinedStr) ->None:
"""Check f-strings."""
- pass
+ if self.py_version < (3, 6):
+ self.add_message('using-f-string-in-unsupported-version', node=node)
@only_required_for_messages('using-final-decorator-in-unsupported-version')
def visit_decorators(self, node: nodes.Decorators) ->None:
"""Check decorators."""
- pass
+ self._check_typing_final(node)
def _check_typing_final(self, node: nodes.Decorators) ->None:
"""Add a message when the `typing.final` decorator is used and the
py-version is lower than 3.8.
"""
- pass
+ if self.py_version < (3, 8):
+ for decorator in node.nodes:
+ if isinstance(decorator, nodes.Name) and decorator.name == 'final':
+ self.add_message('using-final-decorator-in-unsupported-version', node=decorator)
+ elif isinstance(decorator, nodes.Attribute) and decorator.attrname == 'final':
+ inferred = safe_infer(decorator)
+ if inferred and inferred.qname() == 'typing.final':
+ self.add_message('using-final-decorator-in-unsupported-version', node=decorator)
diff --git a/pylint/checkers/utils.py b/pylint/checkers/utils.py
index 83788746a..47259637c 100644
--- a/pylint/checkers/utils.py
+++ b/pylint/checkers/utils.py
@@ -102,17 +102,24 @@ class InferredTypeError(Exception):
def get_all_elements(node: nodes.NodeNG) ->Iterable[nodes.NodeNG]:
"""Recursively returns all atoms in nested lists and tuples."""
- pass
+ if isinstance(node, (nodes.List, nodes.Tuple)):
+ for child in node.elts:
+ yield from get_all_elements(child)
+ else:
+ yield node
def is_super(node: nodes.NodeNG) ->bool:
"""Return True if the node is referencing the "super" builtin function."""
- pass
+ if isinstance(node, nodes.Name):
+ return node.name == 'super' and node.root().name == 'builtins'
+ return False
def is_error(node: nodes.FunctionDef) ->bool:
"""Return true if the given function node only raises an exception."""
- pass
+ return (len(node.body) == 1 and
+ isinstance(node.body[0], nodes.Raise))
builtins = builtins.__dict__.copy()
@@ -121,12 +128,14 @@ SPECIAL_BUILTINS = '__builtins__',
def is_builtin_object(node: nodes.NodeNG) ->bool:
"""Returns True if the given node is an object from the __builtin__ module."""
- pass
+ return (isinstance(node, nodes.Name) and
+ node.name in builtins and
+ node.root().name == 'builtins')
def is_builtin(name: str) ->bool:
"""Return true if <name> could be considered as a builtin defined by python."""
- pass
+ return name in builtins or name in SPECIAL_BUILTINS
def is_defined_before(var_node: nodes.Name) ->bool:
@@ -138,7 +147,19 @@ def is_defined_before(var_node: nodes.Name) ->bool:
or in a previous sibling node on the same line
(statement_defining ; statement_using).
"""
- pass
+ stmt = var_node.statement()
+ stmt_parent = stmt.parent
+ for child in stmt_parent.get_children():
+ if child is stmt:
+ break
+ if isinstance(child, (nodes.Assign, nodes.AnnAssign, nodes.With)):
+ for target in child.targets:
+ if isinstance(target, nodes.AssignName) and target.name == var_node.name:
+ return True
+ elif isinstance(child, (nodes.ListComp, nodes.SetComp, nodes.DictComp, nodes.GeneratorExp, nodes.Lambda)):
+ if var_node.name in child.locals:
+ return True
+ return False
def is_default_argument(node: nodes.NodeNG, scope: (nodes.NodeNG | None)=None
diff --git a/pylint/checkers/variables.py b/pylint/checkers/variables.py
index 822aebe55..81379481c 100644
--- a/pylint/checkers/variables.py
+++ b/pylint/checkers/variables.py
@@ -59,7 +59,7 @@ class VariableVisitConsumerAction(Enum):
def _is_from_future_import(stmt: nodes.ImportFrom, name: str) ->(bool | None):
"""Check if the name is a future import from another module."""
- pass
+ return stmt.modname == FUTURE and name in stmt.names
def _get_unpacking_extra_info(node: nodes.Assign, inferred: InferenceResult
@@ -67,7 +67,14 @@ def _get_unpacking_extra_info(node: nodes.Assign, inferred: InferenceResult
"""Return extra information to add to the message for unpacking-non-sequence
and unbalanced-tuple/dict-unpacking errors.
"""
- pass
+ more = ""
+ if isinstance(inferred, astroid.Instance):
+ actual_type = inferred._proxied.name
+ expected_type = "sequence" if isinstance(node.targets[0], nodes.Tuple) else "mapping"
+ more = f" (type is {actual_type}, expected {expected_type})"
+ elif isinstance(inferred, astroid.ClassDef):
+ more = f" (type is {inferred.name})"
+ return more
def _detect_global_scope(node: nodes.Name, frame: nodes.LocalsDictNodeNG,
@@ -94,7 +101,18 @@ def _detect_global_scope(node: nodes.Name, frame: nodes.LocalsDictNodeNG,
class B(C): ...
class C: ...
"""
- pass
+ def_scope = defframe.scope()
+ frame_scope = frame.scope()
+
+ while def_scope and frame_scope:
+ if isinstance(def_scope, nodes.FunctionDef) or isinstance(frame_scope, nodes.FunctionDef):
+ return False
+ if def_scope == frame_scope:
+ return True
+ def_scope = def_scope.parent
+ frame_scope = frame_scope.parent
+
+ return True
def _fix_dot_imports(not_consumed: dict[str, list[nodes.NodeNG]]) ->list[tuple
@@ -106,7 +124,19 @@ def _fix_dot_imports(not_consumed: dict[str, list[nodes.NodeNG]]) ->list[tuple
like 'xml' (when we have both 'xml.etree' and 'xml.sax'), to 'xml.etree'
and 'xml.sax' respectively.
"""
- pass
+ def expand_import(name, node):
+ for child_name, child_node in list(not_consumed.items()):
+ if child_name.startswith(name + '.'):
+ # Remove the child from not_consumed
+ del not_consumed[child_name]
+ # Expand the name
+ return child_name, node
+ return name, node
+
+ # Create a new list of expanded imports
+ expanded_imports = [expand_import(name, nodes[0]) for name, nodes in not_consumed.items()]
+
+ return expanded_imports
def _find_frame_imports(name: str, frame: nodes.LocalsDictNodeNG) ->bool:
@@ -115,12 +145,21 @@ def _find_frame_imports(name: str, frame: nodes.LocalsDictNodeNG) ->bool:
Such imports can be considered assignments if they are not globals.
Returns True if an import for the given name was found.
"""
- pass
+ imports = frame.nodes_of_class((nodes.Import, nodes.ImportFrom))
+ for import_node in imports:
+ if isinstance(import_node, nodes.Import):
+ if name in [alias[0] for alias in import_node.names]:
+ return True
+ elif isinstance(import_node, nodes.ImportFrom):
+ if name in [alias[0] for alias in import_node.names]:
+ return True
+ return False
def _assigned_locally(name_node: nodes.Name) ->bool:
"""Checks if name_node has corresponding assign statement in same scope."""
- pass
+ assign_nodes = name_node.scope().nodes_of_class(nodes.AssignName)
+ return any(a.name == name_node.name for a in assign_nodes)
MSGS: dict[str, MessageDefinitionTuple] = {'E0601': (
diff --git a/pylint/config/_pylint_config/generate_command.py b/pylint/config/_pylint_config/generate_command.py
index 51798cfff..f07e642f4 100644
--- a/pylint/config/_pylint_config/generate_command.py
+++ b/pylint/config/_pylint_config/generate_command.py
@@ -10,4 +10,7 @@ if TYPE_CHECKING:
def handle_generate_command(linter: PyLinter) ->int:
"""Handle 'pylint-config generate'."""
- pass
+ output = StringIO()
+ utils.print_full_documentation(linter, output)
+ print(output.getvalue())
+ return 0
diff --git a/pylint/config/_pylint_config/help_message.py b/pylint/config/_pylint_config/help_message.py
index ef3e26de2..eed14cfed 100644
--- a/pylint/config/_pylint_config/help_message.py
+++ b/pylint/config/_pylint_config/help_message.py
@@ -8,7 +8,17 @@ if TYPE_CHECKING:
def get_subparser_help(linter: PyLinter, command: str) ->str:
"""Get the help message for one of the subcommands."""
- pass
+ parser = argparse.ArgumentParser()
+ subparsers = parser.add_subparsers()
+ linter.register_plugins(parser, subparsers)
+
+ for action in subparsers._actions:
+ if isinstance(action, argparse._SubParsersAction):
+ for choice, subparser in action.choices.items():
+ if choice == command:
+ return subparser.format_help()
+
+ return f"No help available for command: {command}"
def get_help(parser: argparse.ArgumentParser) ->str:
@@ -16,4 +26,24 @@ def get_help(parser: argparse.ArgumentParser) ->str:
Taken from argparse.ArgumentParser.format_help.
"""
- pass
+ formatter = parser._get_formatter()
+
+ # usage
+ formatter.add_usage(parser.usage, parser._actions,
+ parser._mutually_exclusive_groups)
+
+ # description
+ formatter.add_text(parser.description)
+
+ # positionals, optionals and user-defined groups
+ for action_group in parser._action_groups:
+ formatter.start_section(action_group.title)
+ formatter.add_text(action_group.description)
+ formatter.add_arguments(action_group._group_actions)
+ formatter.end_section()
+
+ # epilog
+ formatter.add_text(parser.epilog)
+
+ # determine help from format above
+ return formatter.format_help()
diff --git a/pylint/config/_pylint_config/main.py b/pylint/config/_pylint_config/main.py
index 37f7adc06..82b18ec72 100644
--- a/pylint/config/_pylint_config/main.py
+++ b/pylint/config/_pylint_config/main.py
@@ -9,4 +9,11 @@ if TYPE_CHECKING:
def _handle_pylint_config_commands(linter: PyLinter) ->int:
"""Handle whichever command is passed to 'pylint-config'."""
- pass
+ if linter.config.generate:
+ return handle_generate_command(linter)
+ elif linter.config.help_message:
+ print(get_help(linter.option_manager.parser))
+ return 0
+ else:
+ print("Error: No valid command specified for pylint-config.")
+ return 1
diff --git a/pylint/config/_pylint_config/setup.py b/pylint/config/_pylint_config/setup.py
index def43d8bc..85104174d 100644
--- a/pylint/config/_pylint_config/setup.py
+++ b/pylint/config/_pylint_config/setup.py
@@ -17,4 +17,22 @@ class _HelpAction(_AccessParserAction):
def _register_generate_config_options(parser: argparse.ArgumentParser) ->None:
"""Registers the necessary arguments on the parser."""
- pass
+ parser.add_argument(
+ "--output-format",
+ dest="output_format",
+ default="text",
+ choices=["text", "toml"],
+ help="Output format for the generated config (default: text)",
+ )
+ parser.add_argument(
+ "--rcfile",
+ dest="rcfile",
+ default=None,
+ help="Specify a configuration file to load",
+ )
+ parser.add_argument(
+ "--include-all",
+ dest="include_all",
+ action="store_true",
+ help="Include all options in the generated config",
+ )
diff --git a/pylint/config/_pylint_config/utils.py b/pylint/config/_pylint_config/utils.py
index d36cab5cc..22d9ddfd5 100644
--- a/pylint/config/_pylint_config/utils.py
+++ b/pylint/config/_pylint_config/utils.py
@@ -27,27 +27,61 @@ class InvalidUserInput(Exception):
def should_retry_after_invalid_input(func: Callable[_P, _ReturnValueT]
) ->Callable[_P, _ReturnValueT]:
"""Decorator that handles InvalidUserInput exceptions and retries."""
- pass
+ def wrapper(*args: _P.args, **kwargs: _P.kwargs) ->_ReturnValueT:
+ while True:
+ try:
+ return func(*args, **kwargs)
+ except InvalidUserInput as e:
+ print(f"Invalid input. {e.valid}. You entered: {e.input}")
+ print("Please try again.")
+ return wrapper
@should_retry_after_invalid_input
def get_and_validate_format() ->Literal['toml', 'ini']:
"""Make sure that the output format is either .toml or .ini."""
- pass
+ format_input = input("Enter the output format (toml/ini): ").lower().strip()
+ if format_input in {'t', 'toml'}:
+ return 'toml'
+ if format_input in {'i', 'ini'}:
+ return 'ini'
+ raise InvalidUserInput("Valid inputs are 'toml' or 'ini'", format_input)
@should_retry_after_invalid_input
def validate_yes_no(question: str, default: (Literal['yes', 'no'] | None)
) ->bool:
"""Validate that a yes or no answer is correct."""
- pass
+ if default is None:
+ prompt = f"{question} (yes/no): "
+ elif default == 'yes':
+ prompt = f"{question} [Y/n]: "
+ else:
+ prompt = f"{question} [y/N]: "
+
+ answer = input(prompt).lower().strip()
+ if not answer and default:
+ return default == 'yes'
+ if answer in {'y', 'yes'}:
+ return True
+ if answer in {'n', 'no'}:
+ return False
+ raise InvalidUserInput("Please answer 'yes' or 'no'", answer)
def get_minimal_setting() ->bool:
"""Ask the user if they want to use the minimal setting."""
- pass
+ return validate_yes_no("Do you want to use the minimal setting?", default='no')
def get_and_validate_output_file() ->tuple[bool, Path]:
"""Make sure that the output file is correct."""
- pass
+ file_path = Path(input("Enter the output file path: ").strip())
+
+ if file_path.exists():
+ overwrite = validate_yes_no(f"The file {file_path} already exists. Do you want to overwrite it?", default='no')
+ return overwrite, file_path
+
+ # Ensure the directory exists
+ file_path.parent.mkdir(parents=True, exist_ok=True)
+ return True, file_path
diff --git a/pylint/config/argument.py b/pylint/config/argument.py
index 0ac2e1955..6209ed226 100644
--- a/pylint/config/argument.py
+++ b/pylint/config/argument.py
@@ -21,12 +21,12 @@ _ArgumentTypes = Union[str, int, float, bool, Pattern[str], Sequence[str],
def _confidence_transformer(value: str) ->Sequence[str]:
"""Transforms a comma separated string of confidence values."""
- pass
+ return [v.strip().upper() for v in value.split(',') if v.strip()]
def _csv_transformer(value: str) ->Sequence[str]:
"""Transforms a comma separated string."""
- pass
+ return [v.strip() for v in value.split(',') if v.strip()]
YES_VALUES = {'y', 'yes', 'true'}
@@ -35,44 +35,59 @@ NO_VALUES = {'n', 'no', 'false'}
def _yn_transformer(value: str) ->bool:
"""Transforms a yes/no or stringified bool into a bool."""
- pass
+ value = value.lower()
+ if value in YES_VALUES:
+ return True
+ if value in NO_VALUES:
+ return False
+ raise ValueError(f"Invalid yes/no value: {value}")
def _non_empty_string_transformer(value: str) ->str:
"""Check that a string is not empty and remove quotes."""
- pass
+ value = value.strip()
+ if not value:
+ raise ValueError("Empty string is not allowed")
+ return pylint_utils._unquote(value)
def _path_transformer(value: str) ->str:
"""Expand user and variables in a path."""
- pass
+ return os.path.expandvars(os.path.expanduser(value))
def _glob_paths_csv_transformer(value: str) ->Sequence[str]:
"""Transforms a comma separated list of paths while expanding user and
variables and glob patterns.
"""
- pass
+ paths = _csv_transformer(value)
+ expanded_paths = []
+ for path in paths:
+ expanded_path = _path_transformer(path)
+ globbed_paths = glob(expanded_path, recursive=True)
+ expanded_paths.extend(globbed_paths if globbed_paths else [expanded_path])
+ return expanded_paths
def _py_version_transformer(value: str) ->tuple[int, ...]:
"""Transforms a version string into a version tuple."""
- pass
+ return tuple(int(v) for v in re.findall(r'\d+', value))
def _regex_transformer(value: str) ->Pattern[str]:
"""Return `re.compile(value)`."""
- pass
+ return re.compile(value)
def _regexp_csv_transfomer(value: str) ->Sequence[Pattern[str]]:
"""Transforms a comma separated list of regular expressions."""
- pass
+ return [_regex_transformer(v) for v in _csv_transformer(value)]
def _regexp_paths_csv_transfomer(value: str) ->Sequence[Pattern[str]]:
"""Transforms a comma separated list of regular expressions paths."""
- pass
+ paths = _glob_paths_csv_transformer(value)
+ return [_regex_transformer(re.escape(str(pathlib.Path(p)))) for p in paths]
_TYPE_TRANSFORMERS: dict[str, Callable[[str], _ArgumentTypes]] = {'choice':
diff --git a/pylint/config/arguments_manager.py b/pylint/config/arguments_manager.py
index c9417f90a..6a9f01ea1 100644
--- a/pylint/config/arguments_manager.py
+++ b/pylint/config/arguments_manager.py
@@ -51,53 +51,181 @@ class _ArgumentsManager:
@property
def config(self) ->argparse.Namespace:
"""Namespace for all options."""
- pass
+ return self._config
def _register_options_provider(self, provider: _ArgumentsProvider) ->None:
"""Register an options provider and load its defaults."""
- pass
+ for section, options in provider.options:
+ for option in options:
+ argument = _convert_option_to_argument(option)
+ self._add_arguments_to_parser(section, provider.name, argument)
+ self._option_dicts[option.name] = option.__dict__
+ self._load_default_argument_values()
def _add_arguments_to_parser(self, section: str, section_desc: (str |
None), argument: _Argument) ->None:
"""Add an argument to the correct argument section/group."""
- pass
+ if section not in self._argument_groups_dict:
+ self._argument_groups_dict[section] = self._arg_parser.add_argument_group(
+ title=section.capitalize(), description=section_desc)
+ section_group = self._argument_groups_dict[section]
+ self._add_parser_option(section_group, argument)
@staticmethod
def _add_parser_option(section_group: argparse._ArgumentGroup, argument:
_Argument) ->None:
"""Add an argument."""
- pass
+ if isinstance(argument, _StoreArgument):
+ section_group.add_argument(
+ *argument.flags,
+ dest=argument.dest,
+ action=argument.action,
+ default=argument.default,
+ type=argument.type,
+ help=argument.help,
+ metavar=argument.metavar,
+ choices=argument.choices,
+ )
+ elif isinstance(argument, _StoreTrueArgument):
+ section_group.add_argument(
+ *argument.flags,
+ dest=argument.dest,
+ action="store_true",
+ default=argument.default,
+ help=argument.help,
+ )
+ elif isinstance(argument, (_StoreOldNamesArgument, _StoreNewNamesArgument)):
+ section_group.add_argument(
+ *argument.flags,
+ dest=argument.dest,
+ action=argument.action,
+ default=argument.default,
+ type=argument.type,
+ help=argument.help,
+ metavar=argument.metavar,
+ choices=argument.choices,
+ )
+ elif isinstance(argument, _ExtendArgument):
+ section_group.add_argument(
+ *argument.flags,
+ dest=argument.dest,
+ action="extend",
+ default=argument.default,
+ type=argument.type,
+ help=argument.help,
+ metavar=argument.metavar,
+ )
+ elif isinstance(argument, _CallableArgument):
+ section_group.add_argument(
+ *argument.flags,
+ dest=argument.dest,
+ action=argument.action,
+ default=argument.default,
+ type=argument.type,
+ help=argument.help,
+ metavar=argument.metavar,
+ )
+ else:
+ raise UnrecognizedArgumentAction(
+ f"Unrecognized argument action: {type(argument)}"
+ )
def _load_default_argument_values(self) ->None:
"""Loads the default values of all registered options."""
- pass
+ defaults = {}
+ for option_dict in self._option_dicts.values():
+ dest = option_dict['dest']
+ if dest not in defaults:
+ defaults[dest] = option_dict.get('default')
+ self._config.__dict__.update(defaults)
def _parse_configuration_file(self, arguments: list[str]) ->None:
"""Parse the arguments found in a configuration file into the namespace."""
- pass
+ config_file = None
+ for arg in arguments:
+ if arg.startswith('--rcfile='):
+ config_file = arg.split('=')[1]
+ break
+
+ if config_file:
+ try:
+ with open(config_file, 'rb') as file:
+ if config_file.endswith('.toml'):
+ config = tomlkit.load(file)
+ else:
+ config = tomllib.load(file)
+
+ for section, options in config.items():
+ for option, value in options.items():
+ self.set_option(f"{section}-{option}", value)
+ except (FileNotFoundError, PermissionError) as e:
+ warnings.warn(f"Error reading configuration file: {e}")
def _parse_command_line_configuration(self, arguments: (Sequence[str] |
None)=None) ->list[str]:
"""Parse the arguments found on the command line into the namespace."""
- pass
+ args = self._arg_parser.parse_args(args=arguments)
+ self._config.__dict__.update(args.__dict__)
+ return args.__dict__.get('files', [])
def _generate_config(self, stream: (TextIO | None)=None, skipsections:
tuple[str, ...]=()) ->None:
"""Write a configuration file according to the current configuration
into the given stream or stdout.
"""
- pass
+ if stream is None:
+ stream = sys.stdout
+
+ config = {}
+ for option_name, option_dict in self._option_dicts.items():
+ section = option_dict.get('group', MAIN_CHECKER_NAME).lower()
+ if section in skipsections:
+ continue
+
+ if section not in config:
+ config[section] = {}
+
+ value = getattr(self._config, option_dict['dest'])
+ if value != option_dict.get('default'):
+ config[section][option_name] = value
+
+ tomlkit.dump(config, stream)
def help(self) ->str:
"""Return the usage string based on the available options."""
- pass
+ return self._arg_parser.format_help()
def _generate_config_file(self, *, minimal: bool=False) ->str:
"""Write a configuration file according to the current configuration into
stdout.
"""
- pass
+ config = {}
+ for option_name, option_dict in self._option_dicts.items():
+ section = option_dict.get('group', MAIN_CHECKER_NAME).lower()
+ if section not in config:
+ config[section] = {}
+
+ value = getattr(self._config, option_dict['dest'])
+ if not minimal or value != option_dict.get('default'):
+ config[section][option_name] = value
+
+ return tomlkit.dumps(config)
def set_option(self, optname: str, value: Any) ->None:
"""Set an option on the namespace object."""
- pass
+ if '-' in optname:
+ section, option = optname.split('-', 1)
+ if section in self._option_dicts:
+ if option in self._option_dicts[section]:
+ dest = self._option_dicts[section][option]['dest']
+ setattr(self._config, dest, value)
+ else:
+ raise _UnrecognizedOptionError(f"Unrecognized option: {optname}")
+ else:
+ raise _UnrecognizedOptionError(f"Unrecognized section: {section}")
+ else:
+ if optname in self._option_dicts:
+ dest = self._option_dicts[optname]['dest']
+ setattr(self._config, dest, value)
+ else:
+ raise _UnrecognizedOptionError(f"Unrecognized option: {optname}")
diff --git a/pylint/config/arguments_provider.py b/pylint/config/arguments_provider.py
index 2aa77d702..3b36df60c 100644
--- a/pylint/config/arguments_provider.py
+++ b/pylint/config/arguments_provider.py
@@ -22,7 +22,7 @@ class _ArgumentsProvider:
def _option_value(self, opt: str) ->Any:
"""Get the current value for the given option."""
- pass
+ return self._arguments_manager.get_option_value(opt)
def _options_by_section(self) ->Iterator[tuple[str, list[tuple[str,
OptionDict, Any]]] | tuple[None, dict[str, list[tuple[str,
@@ -31,9 +31,20 @@ class _ArgumentsProvider:
(section, [list of (optname, optdict, optvalue)])
"""
- pass
+ sections = {}
+ for optname, optdict in self.options:
+ section = optdict.get('group')
+ if section not in sections:
+ sections[section] = []
+ sections[section].append((optname, optdict, self._option_value(optname)))
+
+ if len(sections) == 1 and None in sections:
+ return None, sections[None]
+ return ((section, values) for section, values in sections.items())
def _options_and_values(self, options: (Options | None)=None) ->Iterator[
tuple[str, OptionDict, Any]]:
"""DEPRECATED."""
- pass
+ options_to_use = options if options is not None else self.options
+ for optname, optdict in options_to_use:
+ yield optname, optdict, self._option_value(optname)
diff --git a/pylint/config/config_file_parser.py b/pylint/config/config_file_parser.py
index 1f6cefb0d..f472390a8 100644
--- a/pylint/config/config_file_parser.py
+++ b/pylint/config/config_file_parser.py
@@ -24,12 +24,24 @@ class _RawConfParser:
Raises ``configparser.Error``.
"""
- pass
+ parser = configparser.ConfigParser()
+ parser.read(file_path)
+
+ if _RawConfParser._ini_file_with_sections(file_path):
+ config_data = {f"{section}.{option}": value
+ for section in parser.sections()
+ for option, value in parser.items(section)}
+ else:
+ config_data = dict(parser.items("DEFAULT"))
+
+ return config_data, []
@staticmethod
def _ini_file_with_sections(file_path: Path) ->bool:
"""Return whether the file uses sections."""
- pass
+ with open(file_path, "r") as file:
+ return any(line.strip().startswith("[") and line.strip().endswith("]")
+ for line in file)
@staticmethod
def parse_toml_file(file_path: Path) ->PylintConfigFileData:
@@ -37,7 +49,18 @@ class _RawConfParser:
Raises ``tomllib.TOMLDecodeError``.
"""
- pass
+ with open(file_path, "rb") as file:
+ toml_dict = tomllib.load(file)
+
+ config_data = {}
+ for section, options in toml_dict.items():
+ if isinstance(options, dict):
+ for option, value in options.items():
+ config_data[f"{section}.{option}"] = _parse_rich_type_value(value)
+ else:
+ config_data[section] = _parse_rich_type_value(options)
+
+ return config_data, []
@staticmethod
def parse_config_file(file_path: (Path | None), verbose: bool
@@ -46,7 +69,16 @@ class _RawConfParser:
Raises ``tomllib.TOMLDecodeError``, ``configparser.Error``.
"""
- pass
+ if file_path is None:
+ return {}, []
+
+ if verbose:
+ print(f"Using config file {file_path}")
+
+ if file_path.suffix.lower() == ".toml":
+ return _RawConfParser.parse_toml_file(file_path)
+ else:
+ return _RawConfParser.parse_ini_file(file_path)
class _ConfigurationFileParser:
@@ -59,4 +91,8 @@ class _ConfigurationFileParser:
def parse_config_file(self, file_path: (Path | None)
) ->PylintConfigFileData:
"""Parse a config file and return str-str pairs."""
- pass
+ try:
+ return _RawConfParser.parse_config_file(file_path, self.verbose_mode)
+ except (tomllib.TOMLDecodeError, configparser.Error) as exc:
+ self.linter.add_message("config-parse-error", line=0, args=(file_path, exc))
+ return {}, []
diff --git a/pylint/config/config_initialization.py b/pylint/config/config_initialization.py
index 526dbe95e..88898948d 100644
--- a/pylint/config/config_initialization.py
+++ b/pylint/config/config_initialization.py
@@ -20,7 +20,29 @@ def _config_initialization(linter: PyLinter, args_list: list[str], reporter:
"""Parse all available options, read config files and command line arguments and
set options accordingly.
"""
- pass
+ config_parser = _ConfigurationFileParser()
+
+ # Read configuration from file if specified
+ if config_file:
+ config_file = Path(config_file)
+ if config_file.is_file():
+ config_parser.read_config_file(config_file)
+
+ # Parse command line arguments
+ try:
+ args_list = linter.option_manager.parse_command_line(args_list)
+ except _UnrecognizedOptionError as e:
+ raise ArgumentPreprocessingError(str(e)) from e
+
+ # Set reporter if provided
+ if reporter:
+ linter.set_reporter(reporter)
+
+ # Apply configuration
+ linter.read_config_file(config_parser=config_parser)
+ linter.load_configuration_from_config(verbose=verbose_mode)
+
+ return args_list
def _order_all_first(config_args: list[str], *, joined: bool) ->list[str]:
@@ -31,4 +53,32 @@ def _order_all_first(config_args: list[str], *, joined: bool) ->list[str]:
If joined is True, expect args in the form '--enable=all,for-any-all'.
If joined is False, expect args in the form '--enable', 'all,for-any-all'.
"""
- pass
+ enable_all = None
+ disable_all = None
+ other_args = []
+
+ for arg in config_args:
+ if joined:
+ if arg.startswith('--enable=all'):
+ enable_all = arg
+ elif arg.startswith('--disable=all'):
+ disable_all = arg
+ else:
+ other_args.append(arg)
+ else:
+ if arg == '--enable' and 'all' in config_args[config_args.index(arg) + 1].split(','):
+ enable_all = arg
+ elif arg == '--disable' and 'all' in config_args[config_args.index(arg) + 1].split(','):
+ disable_all = arg
+ else:
+ other_args.append(arg)
+
+ if enable_all and disable_all:
+ raise ValueError("Cannot use both --enable=all and --disable=all")
+
+ if enable_all:
+ return [enable_all] + other_args
+ elif disable_all:
+ return [disable_all] + other_args
+ else:
+ return other_args
diff --git a/pylint/config/find_default_config_files.py b/pylint/config/find_default_config_files.py
index feee8e083..b271e89af 100644
--- a/pylint/config/find_default_config_files.py
+++ b/pylint/config/find_default_config_files.py
@@ -14,32 +14,64 @@ PYPROJECT_NAME = Path('pyproject.toml')
CONFIG_NAMES = *RC_NAMES, PYPROJECT_NAME, Path('setup.cfg')
-def _find_pyproject() ->Path:
+def _find_pyproject() -> Path:
"""Search for file pyproject.toml in the parent directories recursively.
It resolves symlinks, so if there is any symlink up in the tree, it does not respect them
"""
- pass
+ current_dir = Path.cwd().resolve()
+ while current_dir != current_dir.parent:
+ pyproject = current_dir / PYPROJECT_NAME
+ if pyproject.is_file():
+ return pyproject
+ current_dir = current_dir.parent
+ return Path()
-def _yield_default_files() ->Iterator[Path]:
+def _yield_default_files() -> Iterator[Path]:
"""Iterate over the default config file names and see if they exist."""
- pass
+ for config_name in CONFIG_NAMES:
+ config_path = Path.cwd() / config_name
+ if config_path.is_file():
+ yield config_path
-def _find_project_config() ->Iterator[Path]:
+def _find_project_config() -> Iterator[Path]:
"""Traverse up the directory tree to find a config file.
Stop if no '__init__' is found and thus we are no longer in a package.
"""
- pass
+ current_dir = Path.cwd()
+ while current_dir != current_dir.parent:
+ if not (current_dir / '__init__.py').exists():
+ break
+ for config_name in CONFIG_NAMES:
+ config_path = current_dir / config_name
+ if config_path.is_file():
+ yield config_path
+ current_dir = current_dir.parent
-def _find_config_in_home_or_environment() ->Iterator[Path]:
+def _find_config_in_home_or_environment() -> Iterator[Path]:
"""Find a config file in the specified environment var or the home directory."""
- pass
+ env_config = os.environ.get('PYLINTRC')
+ if env_config:
+ env_path = Path(env_config)
+ if env_path.is_file():
+ yield env_path
+ home = Path.home()
+ for rc_name in RC_NAMES:
+ rc_path = home / rc_name
+ if rc_path.is_file():
+ yield rc_path
-def find_default_config_files() ->Iterator[Path]:
+
+def find_default_config_files() -> Iterator[Path]:
"""Find all possible config files."""
- pass
+ yield from _yield_default_files()
+ yield from _find_project_config()
+ yield from _find_config_in_home_or_environment()
+ pyproject = _find_pyproject()
+ if pyproject.is_file():
+ yield pyproject
diff --git a/pylint/config/help_formatter.py b/pylint/config/help_formatter.py
index 0bcc08da4..53893f2c9 100644
--- a/pylint/config/help_formatter.py
+++ b/pylint/config/help_formatter.py
@@ -7,6 +7,12 @@ from pylint.constants import DEFAULT_PYLINT_HOME
class _HelpFormatter(argparse.RawDescriptionHelpFormatter):
"""Formatter for the help message emitted by argparse."""
- def _get_help_string(self, action: argparse.Action) ->(str | None):
+ def _get_help_string(self, action: argparse.Action) -> str | None:
"""Copied from argparse.ArgumentDefaultsHelpFormatter."""
- pass
+ help_text = action.help
+ if '%(default)' not in action.help:
+ if action.default is not argparse.SUPPRESS:
+ defaulting_nargs = [argparse.OPTIONAL, argparse.ZERO_OR_MORE]
+ if action.option_strings or action.nargs in defaulting_nargs:
+ help_text += ' (default: %(default)s)'
+ return help_text
diff --git a/pylint/config/utils.py b/pylint/config/utils.py
index 3da9282b3..7ec176f2c 100644
--- a/pylint/config/utils.py
+++ b/pylint/config/utils.py
@@ -16,12 +16,29 @@ def _convert_option_to_argument(opt: str, optdict: dict[str, Any]) ->(
_StoreArgument | _StoreTrueArgument | _CallableArgument |
_StoreOldNamesArgument | _StoreNewNamesArgument | _ExtendArgument):
"""Convert an optdict to an Argument class instance."""
- pass
+ action = optdict.get('action')
+ if action == 'store_true':
+ return _StoreTrueArgument(opt, **optdict)
+ elif action == 'callback':
+ return _CallableArgument(opt, **optdict)
+ elif action == 'store_old_names':
+ return _StoreOldNamesArgument(opt, **optdict)
+ elif action == 'store_new_names':
+ return _StoreNewNamesArgument(opt, **optdict)
+ elif action == 'extend':
+ return _ExtendArgument(opt, **optdict)
+ else:
+ return _StoreArgument(opt, **optdict)
def _parse_rich_type_value(value: Any) ->str:
"""Parse rich (toml) types into strings."""
- pass
+ if isinstance(value, (list, tuple)):
+ return ','.join(str(item) for item in value)
+ elif isinstance(value, dict):
+ return ','.join(f"{k}={v}" for k, v in value.items())
+ else:
+ return str(value)
def _init_hook(run: Run, value: (str | None)) ->None:
@@ -29,27 +46,31 @@ def _init_hook(run: Run, value: (str | None)) ->None:
This can be used to set the 'sys.path' for example.
"""
- pass
+ if value:
+ exec(value)
def _set_rcfile(run: Run, value: (str | None)) ->None:
"""Set the rcfile."""
- pass
+ if value:
+ run.rcfile = Path(value).expanduser().resolve()
def _set_output(run: Run, value: (str | None)) ->None:
"""Set the output."""
- pass
+ if value:
+ run.reporter.set_output(value)
def _add_plugins(run: Run, value: (str | None)) ->None:
"""Add plugins to the list of loadable plugins."""
- pass
+ if value:
+ run.plugins.extend(utils._splitstrip(value))
def _enable_all_extensions(run: Run, value: (str | None)) ->None:
"""Enable all extensions."""
- pass
+ run.plugins.extend(extensions.all())
PREPROCESSABLE_OPTIONS: dict[str, tuple[bool, Callable[[Run, str | None],
@@ -62,4 +83,36 @@ PREPROCESSABLE_OPTIONS: dict[str, tuple[bool, Callable[[Run, str | None],
def _preprocess_options(run: Run, args: Sequence[str]) ->list[str]:
"""Pre-process options before full config parsing has started."""
- pass
+ remaining_args = list(args)
+ i = 0
+ while i < len(remaining_args):
+ arg = remaining_args[i]
+ if arg.startswith('--'):
+ option = arg.split('=')[0]
+ elif arg.startswith('-'):
+ option = arg[:2]
+ else:
+ i += 1
+ continue
+
+ if option in PREPROCESSABLE_OPTIONS:
+ is_option_with_value, callback, _ = PREPROCESSABLE_OPTIONS[option]
+ if is_option_with_value:
+ if '=' in arg:
+ _, value = arg.split('=', 1)
+ else:
+ i += 1
+ if i >= len(remaining_args):
+ raise ArgumentPreprocessingError(f"Option {option} requires a value.")
+ value = remaining_args[i]
+ callback(run, value)
+ remaining_args.pop(i)
+ if is_option_with_value:
+ remaining_args.pop(i - 1)
+ i -= 1
+ else:
+ callback(run, None)
+ remaining_args.pop(i)
+ i -= 1
+ i += 1
+ return remaining_args
diff --git a/pylint/constants.py b/pylint/constants.py
index 915082479..4391e5076 100644
--- a/pylint/constants.py
+++ b/pylint/constants.py
@@ -45,9 +45,15 @@ INCOMPATIBLE_WITH_USELESS_SUPPRESSION = frozenset(['R0401', 'W0402',
'W1505', 'W1511', 'W1512', 'W1513', 'R0801'])
-def _get_pylint_home() ->str:
+def _get_pylint_home() -> str:
"""Return the pylint home."""
- pass
+ if 'PYLINTHOME' in os.environ:
+ return os.environ['PYLINTHOME']
+
+ if os.path.isfile('.pylint.d'):
+ return os.path.abspath('.pylint.d')
+
+ return DEFAULT_PYLINT_HOME
PYLINT_HOME = _get_pylint_home()
diff --git a/pylint/extensions/_check_docs_utils.py b/pylint/extensions/_check_docs_utils.py
index 4e60e6372..c9f92ff4f 100644
--- a/pylint/extensions/_check_docs_utils.py
+++ b/pylint/extensions/_check_docs_utils.py
@@ -17,7 +17,7 @@ def space_indentation(s: str) ->int:
:rtype: int
:return: number of leading spaces
"""
- pass
+ return len(s) - len(s.lstrip())
def get_setters_property_name(node: nodes.FunctionDef) ->(str | None):
@@ -30,7 +30,14 @@ def get_setters_property_name(node: nodes.FunctionDef) ->(str | None):
:returns: The name of the property that the node is a setter for,
or None if one could not be found.
"""
- pass
+ if not node.decorators:
+ return None
+ for decorator in node.decorators.nodes:
+ if (isinstance(decorator, nodes.Attribute) and
+ decorator.attrname == "setter" and
+ isinstance(decorator.expr, nodes.Name)):
+ return decorator.expr.name
+ return None
def get_setters_property(node: nodes.FunctionDef) ->(nodes.FunctionDef | None):
@@ -43,7 +50,17 @@ def get_setters_property(node: nodes.FunctionDef) ->(nodes.FunctionDef | None):
:returns: The node relating to the property of the given setter node,
or None if one could not be found.
"""
- pass
+ property_name = get_setters_property_name(node)
+ if property_name is None:
+ return None
+
+ class_node = node.parent.frame()
+ for member in class_node.body:
+ if (isinstance(member, nodes.FunctionDef) and
+ member.name == property_name and
+ utils.decorated_with_property(member)):
+ return member
+ return None
def returns_something(return_node: nodes.Return) ->bool:
@@ -56,7 +73,9 @@ def returns_something(return_node: nodes.Return) ->bool:
:return: True if the return node returns a value other than None,
False otherwise.
"""
- pass
+ if return_node.value is None:
+ return False
+ return not (isinstance(return_node.value, nodes.Const) and return_node.value.value is None)
def possible_exc_types(node: nodes.NodeNG) ->set[nodes.ClassDef]:
@@ -70,7 +89,21 @@ def possible_exc_types(node: nodes.NodeNG) ->set[nodes.ClassDef]:
:returns: A list of exception types possibly raised by :param:`node`.
"""
- pass
+ exc_types = set()
+ if isinstance(node, nodes.Raise):
+ if node.exc is not None:
+ inferred = utils.safe_infer(node.exc)
+ if inferred:
+ exc_types.add(inferred)
+ elif node.cause is not None:
+ inferred = utils.safe_infer(node.cause)
+ if inferred:
+ exc_types.add(inferred)
+ elif isinstance(node, nodes.Call):
+ inferred = utils.safe_infer(node.func)
+ if inferred and isinstance(inferred, nodes.ClassDef):
+ exc_types.add(inferred)
+ return {exc for exc in exc_types if isinstance(exc, nodes.ClassDef)}
def _annotations_list(args_node: nodes.Arguments) ->list[nodes.NodeNG]:
@@ -85,7 +118,23 @@ def _annotations_list(args_node: nodes.Arguments) ->list[nodes.NodeNG]:
:param args_node: The node to get the annotations for.
:returns: The annotations.
"""
- pass
+ annotations = []
+
+ # Real type annotations
+ if args_node.annotations:
+ annotations.extend(args_node.annotations)
+
+ # Type comment on the function
+ if args_node.parent and isinstance(args_node.parent, nodes.FunctionDef):
+ if args_node.parent.type_comment_args:
+ annotations.extend(args_node.parent.type_comment_args)
+
+ # Type comment on individual arguments
+ for arg in args_node.args + args_node.kwonlyargs:
+ if arg.type_comment:
+ annotations.append(arg.type_comment)
+
+ return annotations
class Docstring:
@@ -109,7 +158,7 @@ class Docstring:
def matching_sections(self) ->int:
"""Returns the number of matching docstring sections."""
- pass
+ return sum(1 for _ in re.finditer(self.re_for_parameters_see, self.doc))
class SphinxDocstring(Docstring):
diff --git a/pylint/extensions/check_elif.py b/pylint/extensions/check_elif.py
index b9e5190a4..f500b7a0d 100644
--- a/pylint/extensions/check_elif.py
+++ b/pylint/extensions/check_elif.py
@@ -25,9 +25,24 @@ class ElseifUsedChecker(BaseTokenChecker):
def process_tokens(self, tokens: list[TokenInfo]) ->None:
"""Process tokens and look for 'if' or 'elif'."""
- pass
+ for index, token in enumerate(tokens):
+ if token.type == tokenize.NAME and token.string == 'else':
+ # Check if the next non-whitespace token is 'if'
+ next_token = self._find_next_token(tokens, index + 1)
+ if next_token and next_token.type == tokenize.NAME and next_token.string == 'if':
+ self.add_message('else-if-used', line=token.start[0])
@only_required_for_messages('else-if-used')
def visit_if(self, node: nodes.If) ->None:
"""Current if node must directly follow an 'else'."""
- pass
+ parent = node.parent
+ if isinstance(parent, nodes.If) and parent.orelse == [node]:
+ # This 'if' is part of an 'else if' statement
+ self.add_message('else-if-used', node=node)
+
+ def _find_next_token(self, tokens: list[TokenInfo], start_index: int) -> TokenInfo | None:
+ """Find the next non-whitespace token."""
+ for token in tokens[start_index:]:
+ if token.type != tokenize.NEWLINE and token.type != tokenize.INDENT:
+ return token
+ return None
diff --git a/pylint/extensions/code_style.py b/pylint/extensions/code_style.py
index cc8634462..f16e5b53d 100644
--- a/pylint/extensions/code_style.py
+++ b/pylint/extensions/code_style.py
@@ -56,7 +56,15 @@ Disabled by default!"""
def _check_dict_consider_namedtuple_dataclass(self, node: nodes.Dict
) ->None:
"""Check if dictionary values can be replaced by Namedtuple or Dataclass."""
- pass
+ if not isinstance(node.parent, (nodes.Assign, nodes.AnnAssign)):
+ return
+
+ if len(node.items) < 2:
+ return
+
+ values = [item[1] for item in node.items]
+ if all(isinstance(value, (nodes.List, nodes.Tuple)) for value in values):
+ self.add_message('consider-using-namedtuple-or-dataclass', node=node)
def _check_consider_using_assignment_expr(self, node: nodes.If) ->None:
"""Check if an assignment expression (walrus operator) can be used.
@@ -72,7 +80,30 @@ Disabled by default!"""
Note: Assignment expressions were added in Python 3.8
"""
- pass
+ if sys.version_info < (3, 8):
+ return
+
+ prev_sibling = node.previous_sibling()
+ if not isinstance(prev_sibling, (nodes.Assign, nodes.AnnAssign)):
+ return
+
+ if len(prev_sibling.targets) != 1:
+ return
+
+ target = prev_sibling.targets[0]
+ if not isinstance(target, nodes.AssignName):
+ return
+
+ name = target.name
+ if not self._check_prev_sibling_to_if_stmt(prev_sibling, name):
+ return
+
+ if self._check_ignore_assignment_expr_suggestion(node, name):
+ return
+
+ value = prev_sibling.value
+ suggestion = f"if ({name} := {value.as_string()}):"
+ self.add_message('consider-using-assignment-expr', node=node, args=(suggestion,))
@staticmethod
def _check_prev_sibling_to_if_stmt(prev_sibling: (nodes.NodeNG | None),
@@ -81,7 +112,17 @@ Disabled by default!"""
Ignore statements which span multiple lines.
"""
- pass
+ if not isinstance(prev_sibling, (nodes.Assign, nodes.AnnAssign)):
+ return False
+
+ if prev_sibling.lineno != prev_sibling.end_lineno:
+ return False
+
+ if len(prev_sibling.targets) != 1:
+ return False
+
+ target = prev_sibling.targets[0]
+ return isinstance(target, nodes.AssignName) and target.name == name
@staticmethod
def _check_ignore_assignment_expr_suggestion(node: nodes.If, name: (str |
@@ -91,4 +132,22 @@ Disabled by default!"""
E.g., in cases where a match statement would be a better fit
(multiple conditions).
"""
- pass
+ if not isinstance(node.test, nodes.Compare):
+ return False
+
+ if len(node.test.ops) != 1:
+ return False
+
+ left = node.test.left
+ if not isinstance(left, nodes.Name) or left.name != name:
+ return False
+
+ # Check if there are multiple conditions (e.g., elif statements)
+ current = node
+ while current.orelse:
+ if len(current.orelse) == 1 and isinstance(current.orelse[0], nodes.If):
+ current = current.orelse[0]
+ else:
+ break
+
+ return len(node.orelse) > 0 or current != node
diff --git a/pylint/extensions/consider_refactoring_into_while_condition.py b/pylint/extensions/consider_refactoring_into_while_condition.py
index c2135c90d..8ef02f5a5 100644
--- a/pylint/extensions/consider_refactoring_into_while_condition.py
+++ b/pylint/extensions/consider_refactoring_into_while_condition.py
@@ -27,6 +27,26 @@ class ConsiderRefactorIntoWhileConditionChecker(checkers.BaseChecker):
'Emitted when `while True:` loop is used and the first statement is a break condition. The ``if / break`` construct can be removed if the check is inverted and moved to the ``while`` statement.'
)}
- def _check_breaking_after_while_true(self, node: nodes.While) ->None:
+ def _check_breaking_after_while_true(self, node: nodes.While) -> None:
"""Check that any loop with an ``if`` clause has a break statement."""
- pass
+ if not isinstance(node.test, nodes.Const) or not node.test.value:
+ return
+
+ if not node.body:
+ return
+
+ first_stmt = node.body[0]
+ if not isinstance(first_stmt, nodes.If):
+ return
+
+ if_body = first_stmt.body
+ if not if_body or not isinstance(if_body[0], nodes.Break):
+ return
+
+ condition = utils.node_to_string(first_stmt.test)
+ self.add_message(
+ 'consider-refactoring-into-while-condition',
+ node=node,
+ args=(f"not ({condition})", node.test.value),
+ confidence=HIGH,
+ )
diff --git a/pylint/extensions/dict_init_mutate.py b/pylint/extensions/dict_init_mutate.py
index e54d20198..a473dc550 100644
--- a/pylint/extensions/dict_init_mutate.py
+++ b/pylint/extensions/dict_init_mutate.py
@@ -24,4 +24,25 @@ class DictInitMutateChecker(BaseChecker):
At this time, detecting nested mutation is not supported.
"""
- pass
+ if isinstance(node.value, nodes.Dict):
+ # Dictionary initialization
+ for target in node.targets:
+ if isinstance(target, nodes.AssignName):
+ dict_name = target.name
+ self._check_dict_mutation(node.parent, dict_name)
+
+ def _check_dict_mutation(self, parent: nodes.NodeNG, dict_name: str) ->None:
+ """Check for dictionary mutation in the next statements."""
+ for sibling in parent.get_children():
+ if isinstance(sibling, nodes.Assign) and sibling.targets[0].as_string() == dict_name:
+ break
+ if isinstance(sibling, nodes.AugAssign) and sibling.target.as_string() == dict_name:
+ self.add_message('dict-init-mutate', node=sibling)
+ if isinstance(sibling, (nodes.Call, nodes.Subscript)):
+ if sibling.func.as_string() == f"{dict_name}.update" or \
+ (isinstance(sibling.func, nodes.Attribute) and
+ sibling.func.expr.as_string() == dict_name and
+ sibling.func.attrname in ('setdefault', 'pop', 'popitem', 'clear')):
+ self.add_message('dict-init-mutate', node=sibling)
+ elif isinstance(sibling, nodes.Subscript) and sibling.value.as_string() == dict_name:
+ self.add_message('dict-init-mutate', node=sibling)
diff --git a/pylint/extensions/docparams.py b/pylint/extensions/docparams.py
index 2c5c09d6b..92596154d 100644
--- a/pylint/extensions/docparams.py
+++ b/pylint/extensions/docparams.py
@@ -100,7 +100,23 @@ class DocstringParameterChecker(BaseChecker):
:param node: Node for a function or method definition in the AST
:type node: :class:`astroid.scoped_nodes.Function`
"""
- pass
+ function_name = node.name
+ if node.decorators and checker_utils.decorated_with(node, ['property']):
+ return
+
+ doc = utils.docstring_find_by_name(node.doc, "sphinx")
+ if doc is None:
+ doc = utils.docstring_find_by_name(node.doc, self.config.default_docstring_type)
+
+ if not doc:
+ return
+
+ if node.name in self.constructor_names:
+ self._check_constructor_params(node, doc)
+
+ self.check_arguments_in_docstring(doc, node.args, node)
+ self._check_raises(node, doc)
+ self._check_returns(node, doc)
visit_asyncfunctiondef = visit_functiondef
visit_yieldfrom = visit_yield
@@ -120,7 +136,12 @@ class DocstringParameterChecker(BaseChecker):
:param warning_node: The node to be analyzed
"""
- pass
+ missing_args = (expected_argument_names - found_argument_names -
+ not_needed_names)
+ if missing_args:
+ for missing_arg in sorted(missing_args):
+ self.add_message(message_id, args=(missing_arg,),
+ node=warning_node)
def _compare_different_args(self, found_argument_names: set[str],
message_id: str, not_needed_names: set[str],
@@ -138,7 +159,12 @@ class DocstringParameterChecker(BaseChecker):
:param warning_node: The node to be analyzed
"""
- pass
+ different_args = (found_argument_names - expected_argument_names -
+ not_needed_names)
+ if different_args:
+ for different_arg in sorted(different_args):
+ self.add_message(message_id, args=(different_arg,),
+ node=warning_node)
def _compare_ignored_args(self, found_argument_names: set[str],
message_id: str, ignored_argument_names: set[str], warning_node:
@@ -151,7 +177,11 @@ class DocstringParameterChecker(BaseChecker):
:param ignored_argument_names: Expected argument names
:param warning_node: The node to be analyzed
"""
- pass
+ ignored_args = found_argument_names & ignored_argument_names
+ if ignored_args:
+ for ignored_arg in sorted(ignored_args):
+ self.add_message(message_id, args=(ignored_arg,),
+ node=warning_node)
def check_arguments_in_docstring(self, doc: Docstring, arguments_node:
astroid.Arguments, warning_node: astroid.NodeNG,
@@ -186,7 +216,52 @@ class DocstringParameterChecker(BaseChecker):
documented. If None then this value is read from the configuration.
:type accept_no_param_doc: bool or None
"""
- pass
+ if accept_no_param_doc is None:
+ accept_no_param_doc = self.config.accept_no_param_doc
+
+ expected_argument_names = set(arguments_node.arguments)
+ expected_argument_names.update(arguments_node.kwonlyargs)
+
+ if arguments_node.vararg:
+ expected_argument_names.add(arguments_node.vararg)
+ if arguments_node.kwarg:
+ expected_argument_names.add(arguments_node.kwarg)
+
+ found_argument_names = set(doc.params.keys())
+ found_argument_types = set(doc.types.keys())
+
+ if not found_argument_names and not found_argument_types:
+ if not accept_no_param_doc:
+ self.add_message(
+ 'missing-any-param-doc',
+ args=(warning_node.name,),
+ node=warning_node,
+ )
+ return
+
+ self._compare_missing_args(
+ found_argument_names, 'missing-param-doc',
+ self.not_needed_param_in_docstring, expected_argument_names,
+ warning_node
+ )
+
+ self._compare_different_args(
+ found_argument_names, 'differing-param-doc',
+ self.not_needed_param_in_docstring, expected_argument_names,
+ warning_node
+ )
+
+ self._compare_missing_args(
+ found_argument_types, 'missing-type-doc',
+ self.not_needed_param_in_docstring, expected_argument_names,
+ warning_node
+ )
+
+ self._compare_different_args(
+ found_argument_types, 'differing-type-doc',
+ self.not_needed_param_in_docstring, expected_argument_names,
+ warning_node
+ )
def _add_raise_message(self, missing_exceptions: set[str], node: nodes.
FunctionDef) ->None:
@@ -195,4 +270,7 @@ class DocstringParameterChecker(BaseChecker):
:param missing_exceptions: A list of missing exception types.
:param node: The node show the message on.
"""
- pass
+ for missing in sorted(missing_exceptions):
+ self.add_message('missing-raises-doc',
+ args=(missing,),
+ node=node)
diff --git a/pylint/extensions/dunder.py b/pylint/extensions/dunder.py
index 40e8f7fe8..a89058058 100644
--- a/pylint/extensions/dunder.py
+++ b/pylint/extensions/dunder.py
@@ -23,4 +23,15 @@ class DunderChecker(BaseChecker):
"""Check if known dunder method is misspelled or dunder name is not one
of the pre-defined names.
"""
- pass
+ name = node.name
+ if name.startswith('__') and name.endswith('__'):
+ if len(name) > 4: # Ignore '__'
+ valid_dunder_names = set(DUNDER_METHODS + DUNDER_PROPERTIES + EXTRA_DUNDER_METHODS + self.linter.config.good_dunder_names)
+ if name not in valid_dunder_names:
+ # Check for possible misspellings
+ for valid_name in valid_dunder_names:
+ if name.lower() == valid_name.lower():
+ self.add_message('bad-dunder-name', node=node, args=(name,), confidence=HIGH)
+ return
+ # If not a misspelling, it's an unknown dunder name
+ self.add_message('bad-dunder-name', node=node, args=(name,), confidence=HIGH)
diff --git a/pylint/extensions/empty_comment.py b/pylint/extensions/empty_comment.py
index 54f595eb6..e6a0157e7 100644
--- a/pylint/extensions/empty_comment.py
+++ b/pylint/extensions/empty_comment.py
@@ -8,12 +8,32 @@ if TYPE_CHECKING:
def is_line_commented(line: bytes) ->bool:
"""Checks if a `# symbol that is not part of a string was found in line."""
- pass
+ for i, char in enumerate(line):
+ if char == ord(b'#'):
+ if not comment_part_of_string(line, i):
+ return True
+ return False
def comment_part_of_string(line: bytes, comment_idx: int) ->bool:
"""Checks if the symbol at comment_idx is part of a string."""
- pass
+ in_single_quote = False
+ in_double_quote = False
+ escape_next = False
+
+ for i, char in enumerate(line[:comment_idx]):
+ if escape_next:
+ escape_next = False
+ continue
+
+ if char == ord(b'\\'):
+ escape_next = True
+ elif char == ord(b"'") and not in_double_quote:
+ in_single_quote = not in_single_quote
+ elif char == ord(b'"') and not in_single_quote:
+ in_double_quote = not in_double_quote
+
+ return in_single_quote or in_double_quote
class CommentChecker(BaseRawFileChecker):
diff --git a/pylint/extensions/for_any_all.py b/pylint/extensions/for_any_all.py
index 8176cac2e..e1b7a7b4b 100644
--- a/pylint/extensions/for_any_all.py
+++ b/pylint/extensions/for_any_all.py
@@ -28,7 +28,23 @@ class ConsiderUsingAnyOrAllChecker(BaseChecker):
return True
return False
"""
- pass
+ if len(if_children) != 1:
+ return False
+
+ if_child = if_children[0]
+ if not isinstance(if_child, nodes.Return):
+ return False
+
+ if not isinstance(if_child.value, nodes.Const) or not isinstance(if_child.value.value, bool):
+ return False
+
+ if not isinstance(node_after_loop, nodes.Return):
+ return False
+
+ if not isinstance(node_after_loop.value, nodes.Const) or not isinstance(node_after_loop.value.value, bool):
+ return False
+
+ return if_child.value.value != node_after_loop.value.value
@staticmethod
def _assigned_reassigned_returned(node: nodes.For, if_children: list[
@@ -44,7 +60,36 @@ class ConsiderUsingAnyOrAllChecker(BaseChecker):
# no elif / else statement
return long_line
"""
- pass
+ if not isinstance(node.parent, nodes.FunctionDef):
+ return False
+
+ # Check for boolean assignment before the loop
+ if len(node.parent.body) < 2 or not isinstance(node.parent.body[0], nodes.Assign):
+ return False
+
+ assign_node = node.parent.body[0]
+ if not assigned_bool(assign_node):
+ return False
+
+ # Check if the loop reassigns the boolean
+ if len(if_children) != 1 or not isinstance(if_children[0], nodes.Assign):
+ return False
+
+ reassign_node = if_children[0]
+ if not isinstance(reassign_node.targets[0], nodes.AssignName) or reassign_node.targets[0].name != assign_node.targets[0].name:
+ return False
+
+ if not isinstance(reassign_node.value, nodes.Const) or not isinstance(reassign_node.value.value, bool):
+ return False
+
+ # Check if the boolean is returned after the loop
+ if not isinstance(node_after_loop, nodes.Return):
+ return False
+
+ if not isinstance(node_after_loop.value, nodes.Name) or node_after_loop.value.name != assign_node.targets[0].name:
+ return False
+
+ return True
@staticmethod
def _build_suggested_string(node: nodes.For, final_return_bool: bool
@@ -55,4 +100,16 @@ class ConsiderUsingAnyOrAllChecker(BaseChecker):
'final_return_bool' is the boolean literal returned after the for loop if all
conditions fail.
"""
- pass
+ if_node = node.body[0]
+ condition = if_node.test
+
+ # Determine if we should use 'any' or 'all'
+ func = 'any' if not final_return_bool else 'all'
+
+ # If the condition is a 'not' operation, we need to adjust
+ if isinstance(condition, nodes.UnaryOp) and condition.op == 'not':
+ func = 'all' if func == 'any' else 'any'
+ condition = condition.operand
+
+ # Build the suggested string
+ return f"{func}({condition} for {node.target.as_string()} in {node.iter.as_string()})"
diff --git a/pylint/extensions/magic_value.py b/pylint/extensions/magic_value.py
index 285fb59f4..eab3eeb75 100644
--- a/pylint/extensions/magic_value.py
+++ b/pylint/extensions/magic_value.py
@@ -32,4 +32,16 @@ class MagicValueChecker(BaseChecker):
Magic values in any side of the comparison should be avoided,
Detects comparisons that `comparison-of-constants` core checker cannot detect.
"""
- pass
+ def is_magic_value(value):
+ if isinstance(value, (nodes.Const, nodes.UnaryOp)):
+ const_value = value.value if isinstance(value, nodes.Const) else value.operand.value
+ return not (isinstance(const_value, (int, float, str)) and const_value in self.valid_magic_vals)
+ return False
+
+ left = node.left
+ for op, right in node.ops:
+ if is_magic_value(left):
+ self.add_message('magic-value-comparison', node=left, args=left.as_string(), confidence=HIGH)
+ if is_magic_value(right):
+ self.add_message('magic-value-comparison', node=right, args=right.as_string(), confidence=HIGH)
+ left = right
diff --git a/pylint/extensions/mccabe.py b/pylint/extensions/mccabe.py
index 789246edf..3a121d962 100644
--- a/pylint/extensions/mccabe.py
+++ b/pylint/extensions/mccabe.py
@@ -43,12 +43,41 @@ class PathGraphingAstVisitor(Mccabe_PathGraphingAstVisitor):
def _subgraph(self, node: _SubGraphNodes, name: str, extra_blocks:
Sequence[nodes.ExceptHandler]=()) ->None:
"""Create the subgraphs representing any `if` and `for` statements."""
- pass
+ if self.graph is None:
+ return
+
+ self._bottom_counter += 1
+ subgraph_node = self.graph.new_node(f'subgraph{self._bottom_counter}')
+ self.tail = subgraph_node
+ self.dispatch_list(node.body)
+ self._subgraph_parse(node, subgraph_node, extra_blocks)
def _subgraph_parse(self, node: _SubGraphNodes, pathnode:
_SubGraphNodes, extra_blocks: Sequence[nodes.ExceptHandler]) ->None:
"""Parse the body and any `else` block of `if` and `for` statements."""
- pass
+ if self.graph is None:
+ return
+
+ bottom = self.graph.new_node(f'bottom{self._bottom_counter}')
+ self.graph.connect(self.tail, bottom)
+ self.tail = bottom
+
+ if isinstance(node, (nodes.If, nodes.Try)):
+ if node.orelse:
+ self._subgraph(node, 'else')
+ if isinstance(node, nodes.Try):
+ for handler in node.handlers:
+ self._subgraph(handler, 'except')
+ elif isinstance(node, nodes.For):
+ if node.orelse:
+ self._subgraph(node, 'else')
+
+ if extra_blocks:
+ for extra in extra_blocks:
+ self._subgraph(extra, 'except')
+
+ self.graph.connect(pathnode, bottom)
+ self.tail = bottom
class McCabeMethodChecker(checkers.BaseChecker):
@@ -68,4 +97,17 @@ class McCabeMethodChecker(checkers.BaseChecker):
"""Visit an astroid.Module node to check too complex rating and
add message if is greater than max_complexity stored from options.
"""
- pass
+ visitor = PathGraphingAstVisitor()
+ for child in node.body:
+ if isinstance(child, (nodes.FunctionDef, nodes.AsyncFunctionDef, nodes.ClassDef)):
+ visitor.graph = None
+ visitor.visit(child)
+ if visitor.graph is not None:
+ complexity = len(visitor.graph.edges) - len(visitor.graph.nodes) + 2
+ if complexity > self.linter.config.max_complexity:
+ self.add_message(
+ 'too-complex',
+ node=child,
+ args=(child.name, complexity),
+ confidence=HIGH,
+ )
diff --git a/pylint/extensions/no_self_use.py b/pylint/extensions/no_self_use.py
index 2f2372c39..41221fe0a 100644
--- a/pylint/extensions/no_self_use.py
+++ b/pylint/extensions/no_self_use.py
@@ -23,12 +23,17 @@ class NoSelfUseChecker(BaseChecker):
"""Check if the name handle an access to a class member
if so, register it.
"""
- pass
+ if isinstance(node.parent, nodes.Attribute):
+ if node.name == 'self':
+ self._first_attrs.append(node.parent.attrname)
visit_asyncfunctiondef = visit_functiondef
def _check_first_arg_for_type(self, node: nodes.FunctionDef) ->None:
"""Check the name of first argument."""
- pass
+ if node.args.args:
+ first_arg = node.args.args[0]
+ self._first_attrs = []
+ self._meth_could_be_func = first_arg.name == 'self'
def leave_functiondef(self, node: nodes.FunctionDef) ->None:
"""On method node, check if this method couldn't be a function.
@@ -36,5 +41,24 @@ class NoSelfUseChecker(BaseChecker):
ignore class, static and abstract methods, initializer,
methods overridden from a parent class.
"""
- pass
+ if not self._meth_could_be_func:
+ return
+
+ # Don't emit a warning if the method is:
+ if (node.is_method()
+ and (node.type == 'classmethod'
+ or node.type == 'staticmethod'
+ or node.name in PYMETHODS
+ or overrides_a_method(node)
+ or decorated_with_property(node)
+ or is_overload_stub(node)
+ or (isinstance(node.parent.frame(), nodes.ClassDef)
+ and is_protocol_class(node.parent.frame())))):
+ return
+
+ # Don't emit a warning if any method attribute is accessed
+ if set(node.body[0].nodes_of_class(nodes.Attribute)).intersection(self._first_attrs):
+ return
+
+ self.add_message('no-self-use', node=node)
leave_asyncfunctiondef = leave_functiondef
diff --git a/pylint/extensions/overlapping_exceptions.py b/pylint/extensions/overlapping_exceptions.py
index 518cd8c09..77d5ce5ee 100644
--- a/pylint/extensions/overlapping_exceptions.py
+++ b/pylint/extensions/overlapping_exceptions.py
@@ -23,5 +23,42 @@ class OverlappingExceptionsChecker(checkers.BaseChecker):
@utils.only_required_for_messages('overlapping-except')
def visit_try(self, node: nodes.Try) ->None:
- """Check for empty except."""
- pass
+ """Check for overlapping exceptions in except handlers."""
+ handlers = node.handlers
+ for i, handler in enumerate(handlers):
+ if handler.type is None:
+ # Skip bare except clauses
+ continue
+ exceptions = self._get_exceptions(handler.type)
+ for other_handler in handlers[i + 1:]:
+ if other_handler.type is None:
+ # Skip bare except clauses
+ continue
+ other_exceptions = self._get_exceptions(other_handler.type)
+ overlapping = self._find_overlapping(exceptions, other_exceptions)
+ if overlapping:
+ self.add_message(
+ 'overlapping-except',
+ node=handler,
+ args=', '.join(str(ex) for ex in overlapping)
+ )
+
+ def _get_exceptions(self, node: nodes.NodeNG) -> list[Any]:
+ """Get a list of exception types from an except handler type."""
+ if isinstance(node, nodes.Tuple):
+ return [
+ exception
+ for elt in node.elts
+ for exception in self._get_exceptions(elt)
+ ]
+ return list(_annotated_unpack_infer(node))
+
+ def _find_overlapping(self, exceptions1: list[Any], exceptions2: list[Any]) -> list[Any]:
+ """Find overlapping exceptions between two lists of exception types."""
+ overlapping = []
+ for ex1 in exceptions1:
+ for ex2 in exceptions2:
+ if ex1 == ex2 or util.is_subclass(ex1, ex2) or util.is_subclass(ex2, ex1):
+ overlapping.append(ex1)
+ break
+ return overlapping
diff --git a/pylint/extensions/private_import.py b/pylint/extensions/private_import.py
index 3390b4be5..8d622fca7 100644
--- a/pylint/extensions/private_import.py
+++ b/pylint/extensions/private_import.py
@@ -22,35 +22,50 @@ class PrivateImportChecker(BaseChecker):
def _get_private_imports(self, names: list[str]) ->list[str]:
"""Returns the private names from input names by a simple string check."""
- pass
+ return [name for name in names if self._name_is_private(name)]
@staticmethod
def _name_is_private(name: str) ->bool:
"""Returns true if the name exists, starts with `_`, and if len(name) > 4
it is not a dunder, i.e. it does not begin and end with two underscores.
"""
- pass
+ return bool(name) and name.startswith('_') and (len(name) <= 4 or not (name.startswith('__') and name.endswith('__')))
def _get_type_annotation_names(self, node: (nodes.Import | nodes.
ImportFrom), names: list[str]) ->list[str]:
"""Removes from names any names that are used as type annotations with no other
illegal usages.
"""
- pass
+ if not self.populated_annotations:
+ self._populate_type_annotations(node.root(), self.all_used_type_annotations)
+ self.populated_annotations = True
+
+ return [name for name in names if name not in self.all_used_type_annotations or not self.all_used_type_annotations[name]]
def _populate_type_annotations(self, node: nodes.LocalsDictNodeNG,
all_used_type_annotations: dict[str, bool]) ->None:
"""Adds to `all_used_type_annotations` all names ever used as a type annotation
in the node's (nested) scopes and whether they are only used as annotation.
"""
- pass
+ for child in node.get_children():
+ if isinstance(child, nodes.FunctionDef):
+ self._populate_type_annotations_function(child, all_used_type_annotations)
+ elif isinstance(child, nodes.AnnAssign):
+ self._populate_type_annotations_annotation(child.annotation, all_used_type_annotations)
+ elif isinstance(child, nodes.LocalsDictNodeNG):
+ self._populate_type_annotations(child, all_used_type_annotations)
def _populate_type_annotations_function(self, node: nodes.FunctionDef,
all_used_type_annotations: dict[str, bool]) ->None:
"""Adds all names used as type annotation in the arguments and return type of
the function node into the dict `all_used_type_annotations`.
"""
- pass
+ for arg in node.args.args + node.args.kwonlyargs:
+ if arg.annotation:
+ self._populate_type_annotations_annotation(arg.annotation, all_used_type_annotations)
+
+ if node.returns:
+ self._populate_type_annotations_annotation(node.returns, all_used_type_annotations)
def _populate_type_annotations_annotation(self, node: (nodes.Attribute |
nodes.Subscript | nodes.Name | None), all_used_type_annotations:
@@ -58,16 +73,32 @@ class PrivateImportChecker(BaseChecker):
"""Handles the possibility of an annotation either being a Name, i.e. just type,
or a Subscript e.g. `Optional[type]` or an Attribute, e.g. `pylint.lint.linter`.
"""
- pass
+ if isinstance(node, nodes.Name):
+ all_used_type_annotations[node.name] = all_used_type_annotations.get(node.name, True)
+ return node.name
+ elif isinstance(node, nodes.Attribute):
+ return self._populate_type_annotations_annotation(node.expr, all_used_type_annotations)
+ elif isinstance(node, nodes.Subscript):
+ return self._populate_type_annotations_annotation(node.value, all_used_type_annotations)
+ return None
@staticmethod
def _assignments_call_private_name(assignments: list[nodes.AnnAssign |
nodes.Assign], private_name: str) ->bool:
"""Returns True if no assignments involve accessing `private_name`."""
- pass
+ for assignment in assignments:
+ if isinstance(assignment, nodes.AnnAssign):
+ if private_name in assignment.target.as_string():
+ return True
+ elif isinstance(assignment, nodes.Assign):
+ if any(private_name in target.as_string() for target in assignment.targets):
+ return True
+ return False
@staticmethod
def same_root_dir(node: (nodes.Import | nodes.ImportFrom),
import_mod_name: str) ->bool:
"""Does the node's file's path contain the base name of `import_mod_name`?"""
- pass
+ node_path = Path(node.root().file)
+ import_base_name = import_mod_name.split('.')[0]
+ return import_base_name in node_path.parts
diff --git a/pylint/extensions/set_membership.py b/pylint/extensions/set_membership.py
index c38482bbd..b9227b8ae 100644
--- a/pylint/extensions/set_membership.py
+++ b/pylint/extensions/set_membership.py
@@ -18,6 +18,20 @@ class SetMembershipChecker(BaseChecker):
"""Initialize checker instance."""
super().__init__(linter=linter)
+ @only_required_for_messages('use-set-for-membership')
+ def visit_compare(self, node: nodes.Compare) -> None:
+ """Visit a comparison node."""
+ self._check_in_comparison(node)
+
def _check_in_comparison(self, comparator: nodes.NodeNG) ->None:
"""Checks for membership comparisons with in-place container objects."""
- pass
+ if isinstance(comparator, nodes.Compare):
+ if comparator.ops[0][0] in ('in', 'not in'):
+ right_side = comparator.ops[0][1]
+ if isinstance(right_side, (nodes.List, nodes.Tuple)):
+ # Check if the container has more than 5 elements
+ if len(right_side.elts) > 5:
+ self.add_message(
+ 'use-set-for-membership',
+ node=comparator,
+ )
diff --git a/pylint/extensions/typing.py b/pylint/extensions/typing.py
index 6458902ba..24c9fb522 100644
--- a/pylint/extensions/typing.py
+++ b/pylint/extensions/typing.py
@@ -115,7 +115,9 @@ class TypingChecker(BaseChecker):
def _msg_postponed_eval_hint(self, node: nodes.NodeNG) ->str:
"""Message hint if postponed evaluation isn't enabled."""
- pass
+ if not is_postponed_evaluation_enabled(node):
+ return " (Recommendation only applicable with postponed evaluation enabled)"
+ return ""
def _check_for_alternative_union_syntax(self, node: (nodes.Name | nodes
.Attribute), name: str) ->None:
@@ -126,7 +128,17 @@ class TypingChecker(BaseChecker):
- OR: Python 3.7+ with postponed evaluation in
a type annotation context
"""
- pass
+ if not self._should_check_alternative_union_syntax:
+ return
+
+ if name in UNION_NAMES and is_node_in_type_annotation_context(node):
+ hint = self._msg_postponed_eval_hint(node)
+ self.add_message(
+ "consider-alternative-union-syntax",
+ node=node,
+ args=(name, hint),
+ confidence=INFERENCE,
+ )
def _check_for_typing_alias(self, node: (nodes.Name | nodes.Attribute)
) ->None:
@@ -141,7 +153,22 @@ class TypingChecker(BaseChecker):
any name collisions, only ever used in a type annotation
context, and can safely be replaced.
"""
- pass
+ if not self._should_check_typing_alias:
+ return
+
+ qname = node.as_string()
+ if qname in DEPRECATED_TYPING_ALIASES:
+ alias = DEPRECATED_TYPING_ALIASES[qname]
+ if alias.name_collision:
+ self._alias_name_collisions.add(alias.name)
+
+ parent_subscript = isinstance(node.parent, nodes.Subscript)
+ msg = DeprecatedTypingAliasMsg(node, qname, alias.name, parent_subscript)
+
+ if is_node_in_type_annotation_context(node):
+ self._consider_using_alias_msgs.append(msg)
+ else:
+ self._deprecated_typing_alias_msgs.append(msg)
@only_required_for_messages('consider-using-alias',
'deprecated-typing-alias')
@@ -151,19 +178,55 @@ class TypingChecker(BaseChecker):
Make sure results are safe to recommend / collision free.
"""
- pass
+ for msg in self._deprecated_typing_alias_msgs:
+ self.add_message(
+ "deprecated-typing-alias",
+ node=msg.node,
+ args=(msg.qname, msg.alias),
+ confidence=HIGH,
+ )
+
+ for msg in self._consider_using_alias_msgs:
+ if msg.alias not in self._alias_name_collisions:
+ hint = self._msg_postponed_eval_hint(msg.node)
+ self.add_message(
+ "consider-using-alias",
+ node=msg.node,
+ args=(msg.qname, msg.alias, hint),
+ confidence=INFERENCE,
+ )
+
+ self._deprecated_typing_alias_msgs.clear()
+ self._consider_using_alias_msgs.clear()
+ self._alias_name_collisions.clear()
def _check_broken_noreturn(self, node: (nodes.Name | nodes.Attribute)
) ->None:
"""Check for 'NoReturn' inside compound types."""
- pass
+ if node.as_string() == TYPING_NORETURN:
+ parent = node.parent
+ if isinstance(parent, nodes.Subscript):
+ self.add_message("broken-noreturn", node=node, confidence=HIGH)
def _check_broken_callable(self, node: (nodes.Name | nodes.Attribute)
) ->None:
"""Check for 'collections.abc.Callable' inside Optional and Union."""
- pass
+ if (
+ node.as_string() == "collections.abc.Callable"
+ and self._broken_callable_location(node)
+ ):
+ self.add_message("broken-collections-callable", node=node, confidence=HIGH)
def _broken_callable_location(self, node: (nodes.Name | nodes.Attribute)
) ->bool:
"""Check if node would be a broken location for collections.abc.Callable."""
- pass
+ parent = node.parent
+ if isinstance(parent, nodes.Subscript):
+ parent = parent.parent
+ if isinstance(parent, (nodes.List, nodes.Tuple, nodes.Set)):
+ parent = parent.parent
+ if isinstance(parent, nodes.Subscript):
+ value = safe_infer(parent.value)
+ if value:
+ return value.qname() in ("typing.Union", "typing.Optional")
+ return False
diff --git a/pylint/graph.py b/pylint/graph.py
index a76f38ae0..28358679a 100644
--- a/pylint/graph.py
+++ b/pylint/graph.py
@@ -14,7 +14,9 @@ from typing import Any
def target_info_from_filename(filename: str) ->tuple[str, str, str]:
"""Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png')."""
- pass
+ directory, full_filename = os.path.split(filename)
+ name, extension = os.path.splitext(full_filename)
+ return directory, full_filename, extension[1:] # Remove the dot from extension
class DotBackend:
@@ -45,7 +47,9 @@ class DotBackend:
def get_source(self) ->str:
"""Returns self._source."""
- pass
+ if self._source is None:
+ self._source = '\n'.join(self.lines)
+ return self._source
source = property(get_source)
def generate(self, outputfile: (str | None)=None, mapfile: (str | None)
@@ -59,30 +63,58 @@ class DotBackend:
:return: a path to the generated file
:raises RuntimeError: if the executable for rendering was not found
"""
- pass
+ self.emit('}')
+ if outputfile is None:
+ outputfile = f'{self.graphname}.png'
+ outputdir, outputfile, outputext = target_info_from_filename(outputfile)
+ if outputext == 'dot':
+ with codecs.open(outputfile, 'w', encoding='utf8') as outfile:
+ outfile.write(self.source)
+ return outputfile
+
+ dotfile = tempfile.NamedTemporaryFile('w', dir=outputdir, encoding='utf8', delete=False)
+ dotfile.write(self.source)
+ dotfile.close()
+
+ if shutil.which(self.renderer) is None:
+ raise RuntimeError(f"'{self.renderer}' executable not found")
+
+ cmdline = [self.renderer, '-T', outputext, '-o', outputfile, dotfile.name]
+ if mapfile:
+ cmdline.extend(['-Tcmapx', '-o', mapfile])
+ subprocess.run(cmdline, check=True, capture_output=True, text=True)
+
+ os.unlink(dotfile.name)
+ return outputfile
def emit(self, line: str) ->None:
"""Adds <line> to final output."""
- pass
+ self.lines.append(line)
def emit_edge(self, name1: str, name2: str, **props: Any) ->None:
"""Emit an edge from <name1> to <name2>.
For edge properties: see https://www.graphviz.org/doc/info/attrs.html
"""
- pass
+ edge = f'{normalize_node_id(name1)} -> {normalize_node_id(name2)}'
+ if props:
+ edge += ' [' + ','.join(f'{key}="{value}"' for key, value in props.items()) + ']'
+ self.emit(edge + ';')
def emit_node(self, name: str, **props: Any) ->None:
"""Emit a node with given properties.
For node properties: see https://www.graphviz.org/doc/info/attrs.html
"""
- pass
+ node = normalize_node_id(name)
+ if props:
+ node += ' [' + ','.join(f'{key}="{value}"' for key, value in props.items()) + ']'
+ self.emit(node + ';')
def normalize_node_id(nid: str) ->str:
"""Returns a suitable DOT node id for `nid`."""
- pass
+ return '"%s"' % nid.replace('"', '\\"')
def get_cycles(graph_dict: dict[str, set[str]], vertices: (list[str] | None
@@ -90,10 +122,24 @@ def get_cycles(graph_dict: dict[str, set[str]], vertices: (list[str] | None
"""Return a list of detected cycles based on an ordered graph (i.e. keys are
vertices and values are lists of destination vertices representing edges).
"""
- pass
+ if vertices is None:
+ vertices = list(graph_dict.keys())
+ result: list[list[str]] = []
+ visited: set[str] = set()
+
+ for vertice in vertices:
+ if vertice not in visited:
+ _get_cycles(graph_dict, [vertice], visited, result, vertice)
+
+ return result
def _get_cycles(graph_dict: dict[str, set[str]], path: list[str], visited:
set[str], result: list[list[str]], vertice: str) ->None:
"""Recursive function doing the real work for get_cycles."""
- pass
+ visited.add(vertice)
+ for neighbor in graph_dict.get(vertice, set()):
+ if neighbor not in path:
+ _get_cycles(graph_dict, path + [neighbor], visited, result, neighbor)
+ else:
+ result.append(path[path.index(neighbor):])
diff --git a/pylint/lint/base_options.py b/pylint/lint/base_options.py
index af170fd04..394b96278 100644
--- a/pylint/lint/base_options.py
+++ b/pylint/lint/base_options.py
@@ -12,9 +12,163 @@ if TYPE_CHECKING:
def _make_linter_options(linter: PyLinter) ->Options:
"""Return the options used in a PyLinter class."""
- pass
+ return [
+ (
+ "ignore",
+ {
+ "type": "csv",
+ "metavar": "<file>[,<file>...]",
+ "dest": "black_list",
+ "default": constants.DEFAULT_IGNORE_LIST,
+ "help": "Files or directories to be skipped. They should be base names, not paths.",
+ },
+ ),
+ (
+ "ignore-patterns",
+ {
+ "type": "regexp_csv",
+ "metavar": "<pattern>[,<pattern>...]",
+ "dest": "black_list_re",
+ "default": [],
+ "help": "Files or directories matching the regex patterns are skipped. The regex matches against base names, not paths.",
+ },
+ ),
+ (
+ "persistent",
+ {"help": "Pickle collected data for later comparisons.", "type": "yn", "metavar": "<y or n>", "default": True},
+ ),
+ (
+ "load-plugins",
+ {
+ "type": "csv",
+ "metavar": "<modules>",
+ "default": [],
+ "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",
+ {"type": "yn", "metavar": "<y or n>", "default": False, "short": "r", "group": "Reports", "help": "Tells whether to display a full report or only the messages."},
+ ),
+ (
+ "evaluation",
+ {
+ "type": "string",
+ "metavar": "<python_expression>",
+ "group": "Reports",
+ "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",
+ {"type": "yn", "metavar": "<y or n>", "default": True, "group": "Reports", "help": "Activate the evaluation score."},
+ ),
+ (
+ "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 re-enable 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'.",
+ },
+ ),
+ ]
def _make_run_options(self: Run) ->Options:
"""Return the options used in a Run class."""
- pass
+ return [
+ (
+ "version",
+ {
+ "help": "show program's version number and exit",
+ "action": "version",
+ "version": f"pylint {constants.__version__}",
+ },
+ ),
+ (
+ "full-documentation",
+ {
+ "help": "generate pylint's full documentation",
+ "action": _FullDocumentationAction,
+ "group": "Commands",
+ },
+ ),
+ (
+ "generate-rcfile",
+ {
+ "help": "generate a sample configuration file according to the current configuration",
+ "action": _GenerateRCFileAction,
+ "group": "Commands",
+ },
+ ),
+ (
+ "generate-toml-config",
+ {
+ "help": "generate a configuration file in TOML format",
+ "action": _GenerateConfigFileAction,
+ "group": "Commands",
+ },
+ ),
+ (
+ "errors-only",
+ {
+ "help": "Only display errors",
+ "action": _ErrorsOnlyModeAction,
+ "group": "Messages control",
+ },
+ ),
+ (
+ "py3k",
+ {
+ "help": "Activate Python 3 compatibility checker",
+ "action": _EnableAction,
+ "group": "Commands",
+ },
+ ),
+ (
+ "verbose",
+ {
+ "help": "In verbose mode, extra non-checker-related info will be displayed",
+ "action": "store_true",
+ "group": "Miscellaneous",
+ },
+ ),
+ ]
diff --git a/pylint/lint/expand_modules.py b/pylint/lint/expand_modules.py
index e14142cd7..3eda93f33 100644
--- a/pylint/lint/expand_modules.py
+++ b/pylint/lint/expand_modules.py
@@ -10,13 +10,17 @@ from pylint.typing import ErrorDescriptionDict, ModuleDescriptionDict
def discover_package_path(modulepath: str, source_roots: Sequence[str]) ->str:
"""Discover package path from one its modules and source roots."""
- pass
+ for source_root in source_roots:
+ package_path = os.path.commonpath([source_root, modulepath])
+ if package_path == source_root:
+ return package_path
+ return os.path.dirname(modulepath)
def _is_in_ignore_list_re(element: str, ignore_list_re: list[Pattern[str]]
) ->bool:
"""Determines if the element is matched in a regex ignore-list."""
- pass
+ return any(pattern.search(element) for pattern in ignore_list_re)
def expand_modules(files_or_modules: Sequence[str], source_roots: Sequence[
@@ -26,4 +30,31 @@ def expand_modules(files_or_modules: Sequence[str], source_roots: Sequence[
"""Take a list of files/modules/packages and return the list of tuple
(file, module name) which have to be actually checked.
"""
- pass
+ result: dict[str, ModuleDescriptionDict] = {}
+ errors: list[ErrorDescriptionDict] = []
+
+ for name in files_or_modules:
+ try:
+ modname = modutils.get_module_name(name, source_roots)
+ if modname in ignore_list or _is_in_ignore_list_re(modname, ignore_list_re):
+ continue
+
+ filepath = modutils.file_from_modpath(modname.split('.'))
+ if _is_in_ignore_list_re(str(filepath), ignore_list_paths_re):
+ continue
+
+ package_path = discover_package_path(str(filepath), source_roots)
+ result[name] = {
+ 'path': str(filepath),
+ 'name': modname,
+ 'package': package_path,
+ 'basepath': None,
+ }
+ except ImportError:
+ errors.append({
+ 'key': name,
+ 'mod': modname,
+ 'ex': sys.exc_info()[1],
+ })
+
+ return result, errors
diff --git a/pylint/lint/message_state_handler.py b/pylint/lint/message_state_handler.py
index db36d7947..1a68705db 100644
--- a/pylint/lint/message_state_handler.py
+++ b/pylint/lint/message_state_handler.py
@@ -37,49 +37,82 @@ class _MessageStateHandler:
def _set_one_msg_status(self, scope: str, msg: MessageDefinition, line:
(int | None), enable: bool) ->None:
"""Set the status of an individual message."""
- pass
+ if scope == MSG_STATE_SCOPE_CONFIG:
+ self._msgs_state[msg.msgid] = enable
+ elif scope == MSG_STATE_SCOPE_MODULE:
+ self.file_state.set_msg_status(msg, line, enable)
+ else:
+ raise ValueError(f"Invalid scope: {scope}")
def _get_messages_to_set(self, msgid: str, enable: bool, ignore_unknown:
bool=False) ->list[MessageDefinition]:
"""Do some tests and find the actual messages of which the status should be set."""
- pass
+ if msgid == 'all':
+ return list(self.linter.msgs_store.messages)
+ try:
+ return [self.linter.msgs_store.get_message_definition(msgid)]
+ except exceptions.UnknownMessageError:
+ if ignore_unknown:
+ return []
+ raise
def _set_msg_status(self, msgid: str, enable: bool, scope: str=
'package', line: (int | None)=None, ignore_unknown: bool=False) ->None:
"""Do some tests and then iterate over message definitions to set state."""
- pass
+ assert scope in (MSG_STATE_SCOPE_CONFIG, MSG_STATE_SCOPE_MODULE)
+ messages = self._get_messages_to_set(msgid, enable, ignore_unknown)
+ for msg in messages:
+ self._set_one_msg_status(scope, msg, line, enable)
def _register_by_id_managed_msg(self, msgid_or_symbol: str, line: (int |
None), is_disabled: bool=True) ->None:
"""If the msgid is a numeric one, then register it to inform the user
it could furnish instead a symbolic msgid.
"""
- pass
+ if msgid_or_symbol.isdigit():
+ try:
+ symbol = self.linter.msgs_store.get_symbol(msgid_or_symbol)
+ self.file_state.handle_ignored_message(
+ ManagedMessage(msgid_or_symbol, symbol, line, is_disabled)
+ )
+ except exceptions.UnknownMessageError:
+ pass
def disable(self, msgid: str, scope: str='package', line: (int | None)=
None, ignore_unknown: bool=False) ->None:
"""Disable a message for a scope."""
- pass
+ self._set_msg_status(msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown)
def disable_next(self, msgid: str, _: str='package', line: (int | None)
=None, ignore_unknown: bool=False) ->None:
"""Disable a message for the next line."""
- pass
+ if line is None:
+ line = self.file_state.current_line
+ self._set_msg_status(msgid, enable=False, scope=MSG_STATE_SCOPE_MODULE, line=line + 1, ignore_unknown=ignore_unknown)
def enable(self, msgid: str, scope: str='package', line: (int | None)=
None, ignore_unknown: bool=False) ->None:
"""Enable a message for a scope."""
- pass
+ self._set_msg_status(msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown)
def disable_noerror_messages(self) ->None:
"""Disable message categories other than `error` and `fatal`."""
- pass
+ for msgcat, msgids in self.linter.msgs_store._msgs_by_category.items():
+ if msgcat not in ('error', 'fatal'):
+ for msgid in msgids:
+ self.disable(msgid)
def _get_message_state_scope(self, msgid: str, line: (int | None)=None,
confidence: (interfaces.Confidence | None)=None) ->(Literal[0, 1, 2
] | None):
"""Returns the scope at which a message was enabled/disabled."""
- pass
+ if self._msgs_state.get(msgid):
+ return MSG_STATE_SCOPE_CONFIG
+ if self.file_state.is_message_enabled(msgid, line):
+ return MSG_STATE_SCOPE_MODULE
+ if confidence is not None and confidence > HIGH:
+ return MSG_STATE_CONFIDENCE
+ return None
def _is_one_message_enabled(self, msgid: str, line: (int | None)) ->bool:
"""Checks state of a single message for the current file.
@@ -87,7 +120,9 @@ class _MessageStateHandler:
This function can't be cached as it depends on self.file_state which can
change.
"""
- pass
+ if msgid in self._msgs_state:
+ return self._msgs_state[msgid]
+ return self.file_state.is_message_enabled(msgid, line)
def is_message_enabled(self, msg_descr: str, line: (int | None)=None,
confidence: (interfaces.Confidence | None)=None) ->bool:
@@ -104,7 +139,16 @@ class _MessageStateHandler:
:param line: The line of the currently analysed file
:param confidence: The confidence of the message
"""
- pass
+ try:
+ msgid = self.linter.msgs_store.get_msg_id(msg_descr)
+ except exceptions.UnknownMessageError:
+ # The message doesn't exist in the store yet, so it must be enabled
+ return True
+
+ if self._get_message_state_scope(msgid, line, confidence) is None:
+ return False
+
+ return self._is_one_message_enabled(msgid, line)
def process_tokens(self, tokens: list[tokenize.TokenInfo]) ->None:
"""Process tokens from the current module to search for module/block level
@@ -112,4 +156,17 @@ class _MessageStateHandler:
See func_block_disable_msg.py test case for expected behaviour.
"""
- pass
+ for (tok_type, content, start, _, _) in tokens:
+ 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('arguments')):
+ pragma = self._parse_pragma(pragma_repr)
+ self._handle_pragma(pragma, start[0])
+ except (InvalidPragmaError, UnRecognizedOptionError):
+ pass # Ignore invalid pragmas
diff --git a/pylint/lint/parallel.py b/pylint/lint/parallel.py
index a5b179dbe..ede7a4743 100644
--- a/pylint/lint/parallel.py
+++ b/pylint/lint/parallel.py
@@ -29,13 +29,19 @@ def _worker_initialize(linter: bytes, extra_packages_paths: (Sequence[str] |
:param linter: A linter-class (PyLinter) instance pickled with dill
:param extra_packages_paths: Extra entries to be added to `sys.path`
"""
- pass
+ global _worker_linter
+ _worker_linter = dill.loads(linter)
+ if extra_packages_paths:
+ _augment_sys_path(extra_packages_paths)
def _merge_mapreduce_data(linter: PyLinter, all_mapreduce_data: defaultdict
[int, list[defaultdict[str, list[Any]]]]) ->None:
"""Merges map/reduce data across workers, invoking relevant APIs on checkers."""
- pass
+ for checker_id, mapreduce_data_list in all_mapreduce_data.items():
+ checker = linter.get_checker_by_id(checker_id)
+ if hasattr(checker, 'reduce_map_data'):
+ checker.reduce_map_data(mapreduce_data_list)
def check_parallel(linter: PyLinter, jobs: int, files: Iterable[FileItem],
@@ -45,4 +51,29 @@ def check_parallel(linter: PyLinter, jobs: int, files: Iterable[FileItem],
This splits the work filestream-by-filestream. If you need to do work across
multiple files, as in the similarity-checker, then implement the map/reduce functionality.
"""
- pass
+ if multiprocessing is None or ProcessPoolExecutor is None:
+ raise ImportError("Multiprocessing is not available.")
+
+ linter_pickle = dill.dumps(linter)
+ initializer = functools.partial(_worker_initialize, linter_pickle, extra_packages_paths)
+
+ with ProcessPoolExecutor(max_workers=jobs, initializer=initializer) as executor:
+ all_stats = []
+ all_messages = []
+ all_mapreduce_data = defaultdict(list)
+
+ for result in executor.map(lambda f: _worker_linter.check_single_file(f), files):
+ stats, messages, mapreduce_data = result
+ all_stats.append(stats)
+ all_messages.extend(messages)
+ for checker_id, data in mapreduce_data.items():
+ all_mapreduce_data[checker_id].append(data)
+
+ linter.set_current_module("")
+ linter.stats = merge_stats(all_stats)
+ linter.stats.current_module = ""
+
+ for msg in all_messages:
+ linter.reporter.handle_message(msg)
+
+ _merge_mapreduce_data(linter, all_mapreduce_data)
diff --git a/pylint/lint/pylinter.py b/pylint/lint/pylinter.py
index 3f632fa03..596c60ccc 100644
--- a/pylint/lint/pylinter.py
+++ b/pylint/lint/pylinter.py
@@ -183,7 +183,18 @@ class PyLinter(_ArgumentsManager, _MessageStateHandler, reporters.
If `force` is True (useful when multiprocessing), then the plugin is
reloaded regardless if an entry exists in self._dynamic_plugins.
"""
- pass
+ for modname in modnames:
+ if modname in self._dynamic_plugins and not force:
+ continue
+ try:
+ module = utils.load_module_from_name(modname)
+ self._dynamic_plugins[modname] = module
+ self.register_plugin(module)
+ except ModuleNotFoundError as e:
+ self._dynamic_plugins[modname] = e
+ except Exception as e:
+ self._dynamic_plugins[modname] = e
+ print(f"Failed to load plugin {modname}: {e}", file=sys.stderr)
def load_plugin_configuration(self) ->None:
"""Call the configuration hook for plugins.
@@ -201,11 +212,21 @@ class PyLinter(_ArgumentsManager, _MessageStateHandler, reporters.
in GitHub issue #7264. Making it use the stored result is more efficient, and
means that we avoid the ``init-hook`` problems from before.
"""
- pass
+ for plugin_name, plugin in self._dynamic_plugins.items():
+ if isinstance(plugin, ModuleType):
+ if hasattr(plugin, 'load_configuration'):
+ plugin.load_configuration(self)
+ elif isinstance(plugin, Exception):
+ print(f"Skipping configuration for plugin {plugin_name} due to previous load error: {plugin}", file=sys.stderr)
def _load_reporters(self, reporter_names: str) ->None:
"""Load the reporters if they are available on _reporters."""
- pass
+ for reporter_name in reporter_names.split(','):
+ reporter_name = reporter_name.strip()
+ if reporter_name in self._reporters:
+ self.set_reporter(self._reporters[reporter_name]())
+ else:
+ raise exceptions.InvalidReporterError(reporter_name)
def set_reporter(self, reporter: (reporters.BaseReporter | reporters.
MultiReporter)) ->None:
diff --git a/pylint/lint/report_functions.py b/pylint/lint/report_functions.py
index eec3528bf..ae4b2ed6d 100644
--- a/pylint/lint/report_functions.py
+++ b/pylint/lint/report_functions.py
@@ -11,16 +11,50 @@ from pylint.utils import LinterStats
def report_total_messages_stats(sect: Section, stats: LinterStats,
previous_stats: (LinterStats | None)) ->None:
"""Make total errors / warnings report."""
- pass
+ total = sum(stats.by_msg.values())
+ sect.append(Table(children=[
+ ("type", "number", "previous", "difference"),
+ ("convention", stats.convention, previous_stats.convention if previous_stats else None,
+ stats.convention - previous_stats.convention if previous_stats else None),
+ ("refactor", stats.refactor, previous_stats.refactor if previous_stats else None,
+ stats.refactor - previous_stats.refactor if previous_stats else None),
+ ("warning", stats.warning, previous_stats.warning if previous_stats else None,
+ stats.warning - previous_stats.warning if previous_stats else None),
+ ("error", stats.error, previous_stats.error if previous_stats else None,
+ stats.error - previous_stats.error if previous_stats else None),
+ ("fatal", stats.fatal, previous_stats.fatal if previous_stats else None,
+ stats.fatal - previous_stats.fatal if previous_stats else None),
+ ("total", total, sum(previous_stats.by_msg.values()) if previous_stats else None,
+ total - sum(previous_stats.by_msg.values()) if previous_stats else None),
+ ]))
def report_messages_stats(sect: Section, stats: LinterStats, _: (
LinterStats | None)) ->None:
"""Make messages type report."""
- pass
+ msgs = cast(MessageTypesFullName, collections.Counter(stats.by_msg).most_common())
+ if msgs:
+ sect.append(Table(children=[
+ ("message id", "occurrences"),
+ *((msg_id, str(count)) for msg_id, count in msgs)
+ ]))
def report_messages_by_module_stats(sect: Section, stats: LinterStats, _: (
LinterStats | None)) ->None:
"""Make errors / warnings by modules report."""
- pass
+ by_mod = defaultdict(lambda: defaultdict(int))
+ for msg_id, msg_info in stats.by_msg.items():
+ for module in msg_info['modules']:
+ by_mod[module][msg_id] += 1
+
+ if by_mod:
+ sect.append(Table(children=[
+ ("module", "error", "warning", "refactor", "convention"),
+ *((mod,
+ str(sum(1 for msg_id in msgs if msg_id[0] == 'E')),
+ str(sum(1 for msg_id in msgs if msg_id[0] == 'W')),
+ str(sum(1 for msg_id in msgs if msg_id[0] == 'R')),
+ str(sum(1 for msg_id in msgs if msg_id[0] == 'C')))
+ for mod, msgs in sorted(by_mod.items()))
+ ]))
diff --git a/pylint/lint/run.py b/pylint/lint/run.py
index 646f5ae00..f03eabb89 100644
--- a/pylint/lint/run.py
+++ b/pylint/lint/run.py
@@ -32,14 +32,38 @@ def _query_cpu() ->(int | None):
This is based on discussion and copied from suggestions in
https://bugs.python.org/issue36054.
"""
- pass
+ try:
+ with open('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') as quota_file:
+ quota = int(quota_file.read())
+ with open('/sys/fs/cgroup/cpu/cpu.cfs_period_us') as period_file:
+ period = int(period_file.read())
+ if quota > 0 and period > 0:
+ return max(1, quota // period)
+ except (FileNotFoundError, ValueError, ZeroDivisionError):
+ pass
+ return None
def _cpu_count() ->int:
"""Use sched_affinity if available for virtualized or containerized
environments.
"""
- pass
+ try:
+ import psutil
+ return len(psutil.Process().cpu_affinity())
+ except (ImportError, AttributeError):
+ pass
+
+ docker_cpu = _query_cpu()
+ if docker_cpu:
+ return docker_cpu
+
+ try:
+ return len(os.sched_getaffinity(0))
+ except AttributeError:
+ pass
+
+ return os.cpu_count() or 1
class Run:
diff --git a/pylint/lint/utils.py b/pylint/lint/utils.py
index ec27fb7a9..bc60c7af6 100644
--- a/pylint/lint/utils.py
+++ b/pylint/lint/utils.py
@@ -12,7 +12,14 @@ from pylint.constants import PYLINT_HOME, full_version
@contextlib.contextmanager
def augmented_sys_path(additional_paths: Sequence[str]) ->Iterator[None]:
"""Augment 'sys.path' by adding non-existent entries from additional_paths."""
- pass
+ original_sys_path = sys.path.copy()
+ try:
+ for path in additional_paths:
+ if path not in sys.path:
+ sys.path.insert(0, path)
+ yield
+ finally:
+ sys.path[:] = original_sys_path
def _is_relative_to(self: Path, *other: Path) ->bool:
@@ -21,4 +28,8 @@ def _is_relative_to(self: Path, *other: Path) ->bool:
Backport of pathlib.Path.is_relative_to for Python <3.9
TODO: py39: Remove this backport and use stdlib function.
"""
- pass
+ try:
+ self.relative_to(*other)
+ return True
+ except ValueError:
+ return False
diff --git a/pylint/message/_deleted_message_ids.py b/pylint/message/_deleted_message_ids.py
index dbcd3d0ab..e5c14b31c 100644
--- a/pylint/message/_deleted_message_ids.py
+++ b/pylint/message/_deleted_message_ids.py
@@ -86,22 +86,41 @@ MOVED_TO_EXTENSIONS = {
@lru_cache(maxsize=None)
def is_deleted_symbol(symbol: str) ->(str | None):
"""Return the explanation for removal if the message was removed."""
- pass
+ for explanation, messages in DELETED_MESSAGES_IDS.items():
+ for message in messages:
+ if symbol == message.symbol or any(symbol == old[1] for old in message.old_names):
+ return explanation
+ return None
@lru_cache(maxsize=None)
def is_deleted_msgid(msgid: str) ->(str | None):
"""Return the explanation for removal if the message was removed."""
- pass
+ for explanation, messages in DELETED_MESSAGES_IDS.items():
+ for message in messages:
+ if msgid == message.msgid or any(msgid == old[0] for old in message.old_names):
+ return explanation
+ for prefix in DELETED_MSGID_PREFIXES:
+ if msgid.startswith(f"{prefix:04d}"):
+ return "This message ID prefix has been deleted."
+ return None
@lru_cache(maxsize=None)
def is_moved_symbol(symbol: str) ->(str | None):
"""Return the explanation for moving if the message was moved to extensions."""
- pass
+ for explanation, messages in MOVED_TO_EXTENSIONS.items():
+ for message in messages:
+ if symbol == message.symbol or any(symbol == old[1] for old in message.old_names):
+ return explanation
+ return None
@lru_cache(maxsize=None)
def is_moved_msgid(msgid: str) ->(str | None):
"""Return the explanation for moving if the message was moved to extensions."""
- pass
+ for explanation, messages in MOVED_TO_EXTENSIONS.items():
+ for message in messages:
+ if msgid == message.msgid or any(msgid == old[0] for old in message.old_names):
+ return explanation
+ return None
diff --git a/pylint/message/message.py b/pylint/message/message.py
index f8eac91be..8b766efcc 100644
--- a/pylint/message/message.py
+++ b/pylint/message/message.py
@@ -47,4 +47,4 @@ class Message:
The template format is the one of the format method :
cf. https://docs.python.org/2/library/string.html#formatstrings
"""
- pass
+ return template.format(**asdict(self))
diff --git a/pylint/message/message_definition.py b/pylint/message/message_definition.py
index 4ae7655d2..4e406ce1d 100644
--- a/pylint/message/message_definition.py
+++ b/pylint/message/message_definition.py
@@ -46,13 +46,33 @@ class MessageDefinition:
def may_be_emitted(self, py_version: (tuple[int, ...] | sys._version_info)
) ->bool:
"""May the message be emitted using the configured py_version?"""
- pass
+ if self.minversion is not None and py_version < self.minversion:
+ return False
+ if self.maxversion is not None and py_version > self.maxversion:
+ return False
+ return True
def format_help(self, checkerref: bool=False) ->str:
"""Return the help string for the given message id."""
- pass
+ result = f'{self.msg} ({self.symbol})'
+ if checkerref:
+ result += f'\n ({self.checker_name})'
+ result += f'\n{normalize_text(self.description)}'
+ return result
def check_message_definition(self, line: (int | None), node: (nodes.
NodeNG | None)) ->None:
"""Check MessageDefinition for possible errors."""
- pass
+ if self.msgid[1] not in MSG_TYPES:
+ raise InvalidMessageError(
+ f'Invalid message type {self.msgid[1]} in {self.msgid}')
+ if self.symbol in _SCOPE_EXEMPT:
+ return
+ if self.scope == WarningScope.LINE:
+ if line is None:
+ raise InvalidMessageError(
+ f'Message {self.msgid} must provide line, got None')
+ elif self.scope == WarningScope.NODE:
+ if node is None:
+ raise InvalidMessageError(
+ f'Message {self.msgid} must provide node, got None')
diff --git a/pylint/message/message_definition_store.py b/pylint/message/message_definition_store.py
index 98137664d..6d3063705 100644
--- a/pylint/message/message_definition_store.py
+++ b/pylint/message/message_definition_store.py
@@ -27,15 +27,18 @@ class MessageDefinitionStore:
@property
def messages(self) ->ValuesView[MessageDefinition]:
"""The list of all active messages."""
- pass
+ return self._messages_definitions.values()
def register_messages_from_checker(self, checker: BaseChecker) ->None:
"""Register all messages definitions from a checker."""
- pass
+ for message in checker.messages:
+ self.register_message(message)
def register_message(self, message: MessageDefinition) ->None:
"""Register a MessageDefinition with consistency in mind."""
- pass
+ self.message_id_store.register_message_definition(message)
+ self._messages_definitions[message.symbol] = message
+ self._msgs_by_category[message.category].append(message.symbol)
@functools.lru_cache(maxsize=None)
def get_message_definitions(self, msgid_or_symbol: str) ->list[
@@ -46,21 +49,55 @@ class MessageDefinitionStore:
about 1000 characters, so even if we would have 1000 messages the cache would only
take up ~= 1 Mb.
"""
- pass
+ try:
+ return [self._messages_definitions[msgid_or_symbol]]
+ except KeyError:
+ try:
+ return [self._messages_definitions[self.message_id_store.get_symbol(msgid_or_symbol)]]
+ except UnknownMessageError:
+ return []
def get_msg_display_string(self, msgid_or_symbol: str) ->str:
"""Generates a user-consumable representation of a message."""
- pass
+ message_definitions = self.get_message_definitions(msgid_or_symbol)
+ if not message_definitions:
+ raise UnknownMessageError(msgid_or_symbol)
+ message = message_definitions[0]
+ return f"{message.symbol} ({message.msgid}): {message.msg}"
def help_message(self, msgids_or_symbols: Sequence[str]) ->None:
"""Display help messages for the given message identifiers."""
- pass
+ for msgid_or_symbol in msgids_or_symbols:
+ try:
+ for message in self.get_message_definitions(msgid_or_symbol):
+ print(self.get_msg_display_string(msgid_or_symbol))
+ print(f" {message.description}")
+ except UnknownMessageError:
+ print(f"No such message id or symbol '{msgid_or_symbol}'")
def list_messages(self) ->None:
"""Output full messages list documentation in ReST format."""
- pass
+ by_category = sorted(self._msgs_by_category.items())
+ for category, symbols in by_category:
+ print(f":{category}:")
+ print(f" Messages related to {category}")
+ print()
+ for symbol in sorted(symbols):
+ message = self._messages_definitions[symbol]
+ print(f":{symbol}: *{message.msgid}*")
+ print(f" {message.msg}")
+ print()
+ print(f" {message.description}")
+ print()
def find_emittable_messages(self) ->tuple[list[MessageDefinition], list
[MessageDefinition]]:
"""Finds all emittable and non-emittable messages."""
- pass
+ emittable = []
+ non_emittable = []
+ for message in self.messages:
+ if message.may_be_emitted():
+ emittable.append(message)
+ else:
+ non_emittable.append(message)
+ return emittable, non_emittable
diff --git a/pylint/message/message_id_store.py b/pylint/message/message_id_store.py
index 64562013d..d78d2bc4c 100644
--- a/pylint/message/message_id_store.py
+++ b/pylint/message/message_id_store.py
@@ -31,7 +31,12 @@ class MessageIdStore:
There is a little duplication with add_legacy_msgid_and_symbol to avoid a function call,
this is called a lot at initialization.
"""
- pass
+ if symbol in self.__symbol_to_msgid:
+ self._raise_duplicate_symbol(msgid, symbol, self.__symbol_to_msgid[symbol])
+ if msgid in self.__msgid_to_symbol:
+ self._raise_duplicate_msgid(symbol, msgid, self.__msgid_to_symbol[msgid])
+ self.__symbol_to_msgid[symbol] = msgid
+ self.__msgid_to_symbol[msgid] = symbol
def add_legacy_msgid_and_symbol(self, msgid: str, symbol: str,
new_msgid: str) ->None:
@@ -40,23 +45,53 @@ class MessageIdStore:
There is a little duplication with add_msgid_and_symbol to avoid a function call,
this is called a lot at initialization.
"""
- pass
+ if symbol in self.__symbol_to_msgid:
+ self._raise_duplicate_symbol(msgid, symbol, self.__symbol_to_msgid[symbol])
+ if msgid in self.__msgid_to_symbol:
+ self._raise_duplicate_msgid(symbol, msgid, self.__msgid_to_symbol[msgid])
+ self.__symbol_to_msgid[symbol] = new_msgid
+ self.__msgid_to_symbol[msgid] = symbol
+ self.__old_names.setdefault(new_msgid, []).append(msgid)
@staticmethod
def _raise_duplicate_symbol(msgid: str, symbol: str, other_symbol: str
) ->NoReturn:
"""Raise an error when a symbol is duplicated."""
- pass
+ raise InvalidMessageError(
+ f"Message symbol '{symbol}' cannot be associated to '{msgid}' because it is "
+ f"already associated to message id '{other_symbol}'"
+ )
@staticmethod
def _raise_duplicate_msgid(symbol: str, msgid: str, other_msgid: str
) ->NoReturn:
"""Raise an error when a msgid is duplicated."""
- pass
+ raise InvalidMessageError(
+ f"Message id '{msgid}' cannot be associated to '{symbol}' because it is "
+ f"already associated to message symbol '{other_msgid}'"
+ )
def get_active_msgids(self, msgid_or_symbol: str) ->list[str]:
"""Return msgids but the input can be a symbol.
self.__active_msgids is used to implement a primitive cache for this function.
"""
- pass
+ if msgid_or_symbol in self.__active_msgids:
+ return self.__active_msgids[msgid_or_symbol]
+
+ if msgid_or_symbol in self.__symbol_to_msgid:
+ msgid = self.__symbol_to_msgid[msgid_or_symbol]
+ elif msgid_or_symbol in self.__msgid_to_symbol:
+ msgid = msgid_or_symbol
+ else:
+ raise UnknownMessageError(f"No such message id or symbol '{msgid_or_symbol}'")
+
+ if is_deleted_msgid(msgid) or is_deleted_symbol(msgid_or_symbol):
+ raise DeletedMessageError(f"Message '{msgid_or_symbol}' has been deleted")
+
+ if is_moved_msgid(msgid) or is_moved_symbol(msgid_or_symbol):
+ raise MessageBecameExtensionError(f"Message '{msgid_or_symbol}' has been moved to an extension")
+
+ active_msgids = [msgid] + self.__old_names.get(msgid, [])
+ self.__active_msgids[msgid_or_symbol] = active_msgids
+ return active_msgids
diff --git a/pylint/pyreverse/diadefslib.py b/pylint/pyreverse/diadefslib.py
index 4865d5ddc..4605d82e6 100644
--- a/pylint/pyreverse/diadefslib.py
+++ b/pylint/pyreverse/diadefslib.py
@@ -24,42 +24,70 @@ class DiaDefGenerator:
def get_title(self, node: nodes.ClassDef) ->str:
"""Get title for objects."""
- pass
+ return node.name if self.module_names else node.root().name + '.' + node.name
def _set_option(self, option: (bool | None)) ->bool:
"""Activate some options if not explicitly deactivated."""
- pass
+ return bool(option) if option is not None else self.config.all_ancestors
def _set_default_options(self) ->None:
"""Set different default options with _default dictionary."""
- pass
+ self.show_ancestors = self._set_option(self.config.show_ancestors)
+ self.all_ancestors = self._set_option(self.config.all_ancestors)
+ self.show_associated = self._set_option(self.config.show_associated)
+ self.show_builtin = self._set_option(self.config.show_builtin)
+ self.module_names = self._set_option(self.config.module_names)
def _get_levels(self) ->tuple[int, int]:
"""Help function for search levels."""
- pass
+ return (self.config.show_ancestors, self.config.show_associated)
def show_node(self, node: nodes.ClassDef) ->bool:
"""Determine if node should be shown based on config."""
- pass
+ if isinstance(node, nodes.Module):
+ return True
+ if isinstance(node, nodes.ClassDef):
+ if self.show_builtin or not is_stdlib_module(node.root().name):
+ return True
+ return False
def add_class(self, node: nodes.ClassDef) ->None:
"""Visit one class and add it to diagram."""
- pass
+ if self.show_node(node):
+ self.classdiagram.add_object(self.get_title(node), node)
def get_ancestors(self, node: nodes.ClassDef, level: int) ->Generator[
nodes.ClassDef, None, None]:
"""Return ancestor nodes of a class node."""
- pass
+ if level == 0:
+ return
+ for ancestor in node.ancestors():
+ if self.show_node(ancestor):
+ yield ancestor
+ if self.all_ancestors:
+ yield from self.get_ancestors(ancestor, level - 1)
def get_associated(self, klass_node: nodes.ClassDef, level: int
) ->Generator[nodes.ClassDef, None, None]:
"""Return associated nodes of a class node."""
- pass
+ if level == 0:
+ return
+ for ass_nodes in klass_node.instance_attrs_type.values():
+ for ass_node in ass_nodes:
+ if isinstance(ass_node, nodes.ClassDef) and self.show_node(ass_node):
+ yield ass_node
+ yield from self.get_associated(ass_node, level - 1)
def extract_classes(self, klass_node: nodes.ClassDef, anc_level: int,
association_level: int) ->None:
"""Extract recursively classes related to klass_node."""
- pass
+ self.add_class(klass_node)
+ for ancestor in self.get_ancestors(klass_node, anc_level):
+ self.add_class(ancestor)
+ self.classdiagram.add_relationship(klass_node, ancestor, 'specialization')
+ for associated in self.get_associated(klass_node, association_level):
+ self.add_class(associated)
+ self.classdiagram.add_relationship(klass_node, associated, 'association')
class DefaultDiadefGenerator(LocalsVisitor, DiaDefGenerator):
@@ -78,32 +106,33 @@ class DefaultDiadefGenerator(LocalsVisitor, DiaDefGenerator):
create a diagram definition for packages
"""
- pass
+ self.pkgdiagram = PackageDiagram('packages', node)
def leave_project(self, _: Project) ->Any:
"""Leave the pyreverse.utils.Project node.
return the generated diagram definition
"""
- pass
+ return self.pkgdiagram
def visit_module(self, node: nodes.Module) ->None:
"""Visit an astroid.Module node.
add this class to the package diagram definition
"""
- pass
+ self.pkgdiagram.add_object(node.name, node)
def visit_classdef(self, node: nodes.ClassDef) ->None:
"""Visit an astroid.Class node.
add this class to the class diagram definition
"""
- pass
+ self.add_class(node)
def visit_importfrom(self, node: nodes.ImportFrom) ->None:
"""Visit astroid.ImportFrom and catch modules for package diagram."""
- pass
+ if node.level == 0 and not node.modname.startswith('.'):
+ self.pkgdiagram.add_relationship(node.root(), node.modname, 'imports')
class ClassDiadefGenerator(DiaDefGenerator):
@@ -114,7 +143,10 @@ class ClassDiadefGenerator(DiaDefGenerator):
def class_diagram(self, project: Project, klass: nodes.ClassDef
) ->ClassDiagram:
"""Return a class diagram definition for the class and related classes."""
- pass
+ self.classdiagram = ClassDiagram(klass.name, klass)
+ self.linker.project = project
+ self.extract_classes(klass, self.config.show_ancestors, self.config.show_associated)
+ return self.classdiagram
class DiadefsHandler:
@@ -135,4 +167,12 @@ class DiadefsHandler:
:returns: The list of diagram definitions
:rtype: list(:class:`pylint.pyreverse.diagrams.ClassDiagram`)
"""
- pass
+ diagrams = []
+ generator = DefaultDiadefGenerator(linker, self)
+ diagrams.append(generator.visit(project))
+
+ for klass in project.get_classes():
+ generator = ClassDiadefGenerator(linker, self)
+ diagrams.append(generator.class_diagram(project, klass))
+
+ return diagrams
diff --git a/pylint/pyreverse/diagrams.py b/pylint/pyreverse/diagrams.py
index e1f5e7682..acf1fde8f 100644
--- a/pylint/pyreverse/diagrams.py
+++ b/pylint/pyreverse/diagrams.py
@@ -70,48 +70,82 @@ class ClassDiagram(Figure, FilterMixIn):
def add_relationship(self, from_object: DiagramEntity, to_object:
DiagramEntity, relation_type: str, name: (str | None)=None) ->None:
"""Create a relationship."""
- pass
+ rel = Relationship(from_object, to_object, relation_type, name)
+ self.relationships.setdefault(relation_type, []).append(rel)
def get_relationship(self, from_object: DiagramEntity, relation_type: str
) ->Relationship:
"""Return a relationship or None."""
- pass
+ for rel in self.relationships.get(relation_type, []):
+ if rel.from_object == from_object:
+ return rel
+ return None
def get_attrs(self, node: nodes.ClassDef) ->list[str]:
"""Return visible attributes, possibly with class name."""
- pass
+ attrs = []
+ for attr in node.instance_attrs.items():
+ if self.show_attr(attr):
+ attrs.append(attr[0])
+ for attr in node.locals.items():
+ if self.show_attr(attr):
+ attrs.append(attr[0])
+ return attrs
def get_methods(self, node: nodes.ClassDef) ->list[nodes.FunctionDef]:
"""Return visible methods."""
- pass
+ methods = []
+ for method in node.mymethods():
+ if self.show_attr(method):
+ methods.append(method)
+ return methods
def add_object(self, title: str, node: nodes.ClassDef) ->None:
"""Create a diagram object."""
- pass
+ entity = ClassEntity(title, node)
+ entity.attrs = self.get_attrs(node)
+ entity.methods = self.get_methods(node)
+ self.objects.append(entity)
+ self._nodes[node] = entity
def class_names(self, nodes_lst: Iterable[nodes.NodeNG]) ->list[str]:
"""Return class names if needed in diagram."""
- pass
+ return [n.name for n in nodes_lst if isinstance(n, nodes.ClassDef) and self.has_node(n)]
def has_node(self, node: nodes.NodeNG) ->bool:
"""Return true if the given node is included in the diagram."""
- pass
+ return node in self._nodes
def object_from_node(self, node: nodes.NodeNG) ->DiagramEntity:
"""Return the diagram object mapped to node."""
- pass
+ return self._nodes.get(node)
def classes(self) ->list[ClassEntity]:
"""Return all class nodes in the diagram."""
- pass
+ return [o for o in self.objects if isinstance(o, ClassEntity)]
def classe(self, name: str) ->ClassEntity:
"""Return a class by its name, raise KeyError if not found."""
- pass
+ for cls in self.classes():
+ if cls.node.name == name:
+ return cls
+ raise KeyError(f"No class named {name}")
def extract_relationships(self) ->None:
"""Extract relationships between nodes in the diagram."""
- pass
+ for obj in self.classes():
+ node = obj.node
+ for parent in node.bases:
+ parent_node = parent.inferred()[0]
+ if self.has_node(parent_node):
+ parent_obj = self.object_from_node(parent_node)
+ self.add_relationship(obj, parent_obj, "inherits")
+ for member in node.body:
+ if isinstance(member, nodes.AnnAssign):
+ member_node = member.annotation.inferred()[0]
+ if self.has_node(member_node):
+ member_obj = self.object_from_node(member_node)
+ self.add_relationship(obj, member_obj, "association")
class PackageDiagram(ClassDiagram):
@@ -120,26 +154,59 @@ class PackageDiagram(ClassDiagram):
def modules(self) ->list[PackageEntity]:
"""Return all module nodes in the diagram."""
- pass
+ return [o for o in self.objects if isinstance(o, PackageEntity)]
def module(self, name: str) ->PackageEntity:
"""Return a module by its name, raise KeyError if not found."""
- pass
+ for mod in self.modules():
+ if mod.node.name == name:
+ return mod
+ raise KeyError(f"No module named {name}")
def add_object(self, title: str, node: nodes.Module) ->None:
"""Create a diagram object."""
- pass
+ entity = PackageEntity(title, node)
+ self.objects.append(entity)
+ self._nodes[node] = entity
def get_module(self, name: str, node: nodes.Module) ->PackageEntity:
"""Return a module by its name, looking also for relative imports;
raise KeyError if not found.
"""
- pass
+ try:
+ return self.module(name)
+ except KeyError:
+ # Try relative import
+ package = node.package()
+ if package:
+ try:
+ return self.module(f"{package}.{name}")
+ except KeyError:
+ pass
+ raise KeyError(f"No module named {name}")
def add_from_depend(self, node: nodes.ImportFrom, from_module: str) ->None:
"""Add dependencies created by from-imports."""
- pass
+ try:
+ imported_module = self.get_module(from_module, node)
+ for name, _ in node.names:
+ if name == "*":
+ self.add_relationship(self.object_from_node(node.root()), imported_module, "uses")
+ else:
+ self.add_relationship(self.object_from_node(node.root()), imported_module, "uses", name)
+ except KeyError:
+ # Module not found, ignore
+ pass
def extract_relationships(self) ->None:
"""Extract relationships between nodes in the diagram."""
- pass
+ for obj in self.modules():
+ node = obj.node
+ for dep in node.deps:
+ if isinstance(dep, nodes.Import):
+ for name, _ in dep.names:
+ if self.has_node(name):
+ imported = self.object_from_node(name)
+ self.add_relationship(obj, imported, "depends")
+ elif isinstance(dep, nodes.ImportFrom):
+ self.add_from_depend(dep, dep.modname)
diff --git a/pylint/pyreverse/dot_printer.py b/pylint/pyreverse/dot_printer.py
index 30da959a1..2ebf9741f 100644
--- a/pylint/pyreverse/dot_printer.py
+++ b/pylint/pyreverse/dot_printer.py
@@ -37,7 +37,10 @@ class DotPrinter(Printer):
def _open_graph(self) ->None:
"""Emit the header lines."""
- pass
+ print(f'digraph "{self.title}" {{')
+ print(f' charset="{self.charset}"')
+ print(f' rankdir={self.layout.value}')
+ print(' node [shape="box"]')
def emit_node(self, name: str, type_: NodeType, properties: (
NodeProperties | None)=None) ->None:
@@ -45,13 +48,26 @@ class DotPrinter(Printer):
Nodes can be classes, packages, participants etc.
"""
- pass
+ properties = properties or {}
+ shape = SHAPES.get(type_, 'box')
+ label = properties.get('label', name)
+
+ attrs = [f'shape="{shape}"', f'label="{label}"']
+ if 'color' in properties:
+ attrs.append(f'color="{properties["color"]}"')
+
+ print(f' "{name}" [{", ".join(attrs)}]')
def emit_edge(self, from_node: str, to_node: str, type_: EdgeType,
label: (str | None)=None) ->None:
"""Create an edge from one node to another to display relationships."""
- pass
+ attrs = ARROWS.get(type_, {}).copy()
+ if label:
+ attrs['label'] = f'"{label}"'
+
+ attr_str = ', '.join(f'{k}="{v}"' for k, v in attrs.items())
+ print(f' "{from_node}" -> "{to_node}" [{attr_str}]')
def _close_graph(self) ->None:
"""Emit the lines needed to properly close the graph."""
- pass
+ print('}')
diff --git a/pylint/pyreverse/inspector.py b/pylint/pyreverse/inspector.py
index 6af79d52a..cc5477caf 100644
--- a/pylint/pyreverse/inspector.py
+++ b/pylint/pyreverse/inspector.py
@@ -24,11 +24,12 @@ class IdGeneratorMixIn:
def init_counter(self, start_value: int=0) ->None:
"""Init the id counter."""
- pass
+ self.id_count = start_value
def generate_id(self) ->int:
"""Generate a new identifier."""
- pass
+ self.id_count += 1
+ return self.id_count
class Project:
@@ -91,7 +92,8 @@ class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
* optionally tag the node with a unique id
"""
- pass
+ if self.tag:
+ node.uid = self.generate_id()
def visit_module(self, node: nodes.Module) ->None:
"""Visit an astroid.Module node.
@@ -100,7 +102,10 @@ class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
* set the depends mapping
* optionally tag the node with a unique id
"""
- pass
+ node.locals_type = {}
+ node.depends = []
+ if self.tag:
+ node.uid = self.generate_id()
def visit_classdef(self, node: nodes.ClassDef) ->None:
"""Visit an astroid.Class node.
@@ -108,7 +113,10 @@ class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
* set the locals_type and instance_attrs_type mappings
* optionally tag the node with a unique id
"""
- pass
+ node.locals_type = {}
+ node.instance_attrs_type = {}
+ if self.tag:
+ node.uid = self.generate_id()
def visit_functiondef(self, node: nodes.FunctionDef) ->None:
"""Visit an astroid.Function node.
@@ -116,14 +124,18 @@ class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
* set the locals_type mapping
* optionally tag the node with a unique id
"""
- pass
+ node.locals_type = {}
+ if self.tag:
+ node.uid = self.generate_id()
def visit_assignname(self, node: nodes.AssignName) ->None:
"""Visit an astroid.AssignName node.
handle locals_type
"""
- pass
+ frame = node.frame()
+ if isinstance(frame, (nodes.FunctionDef, nodes.Module, nodes.ClassDef)):
+ frame.locals_type[node.name] = node.parent.value
@staticmethod
def handle_assignattr_type(node: nodes.AssignAttr, parent: nodes.ClassDef
@@ -132,30 +144,42 @@ class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
handle instance_attrs_type
"""
- pass
+ if isinstance(parent, nodes.ClassDef):
+ parent.instance_attrs_type[node.attrname] = node.expr
def visit_import(self, node: nodes.Import) ->None:
"""Visit an astroid.Import node.
resolve module dependencies
"""
- pass
+ for name, _ in node.names:
+ self._imported_module(node, name, False)
def visit_importfrom(self, node: nodes.ImportFrom) ->None:
"""Visit an astroid.ImportFrom node.
resolve module dependencies
"""
- pass
+ self._imported_module(node, node.modname, node.level > 0)
def compute_module(self, context_name: str, mod_path: str) ->bool:
"""Should the module be added to dependencies ?"""
- pass
+ package = self.project.name
+ if context_name == mod_path:
+ return False
+ if mod_path.startswith(package) and context_name.startswith(package):
+ return False
+ return True
def _imported_module(self, node: (nodes.Import | nodes.ImportFrom),
mod_path: str, relative: bool) ->None:
"""Notify an imported module, used to analyze dependencies."""
- pass
+ context_name = node.root().name
+ if relative:
+ pkg = context_name.rsplit(".", 1)[0]
+ mod_path = f"{pkg}.{mod_path}"
+ if self.compute_module(context_name, mod_path):
+ node.root().depends.append(mod_path)
class AssociationHandlerInterface(ABC):
@@ -175,17 +199,63 @@ class AbstractAssociationHandler(AssociationHandlerInterface):
"""
_next_handler: AssociationHandlerInterface
+ def set_next(self, handler: AssociationHandlerInterface) -> AssociationHandlerInterface:
+ self._next_handler = handler
+ return handler
+
+ def handle(self, node: nodes.NodeNG, parent: nodes.ClassDef) -> None:
+ if self._next_handler:
+ self._next_handler.handle(node, parent)
+
class AggregationsHandler(AbstractAssociationHandler):
- pass
+ def handle(self, node: nodes.NodeNG, parent: nodes.ClassDef) -> None:
+ if isinstance(node, nodes.AnnAssign) and isinstance(node.annotation, nodes.Subscript):
+ if node.annotation.value.name in ('list', 'set', 'dict'):
+ parent.aggregations_type[node.target.name] = node.annotation
+ else:
+ super().handle(node, parent)
+ else:
+ super().handle(node, parent)
class OtherAssociationsHandler(AbstractAssociationHandler):
- pass
+ def handle(self, node: nodes.NodeNG, parent: nodes.ClassDef) -> None:
+ if isinstance(node, (nodes.AnnAssign, nodes.Assign)):
+ if isinstance(node, nodes.AnnAssign):
+ target = node.target
+ value = node.annotation
+ else:
+ target = node.targets[0]
+ value = node.value
+
+ if isinstance(target, nodes.AssignName):
+ parent.associations_type[target.name] = value
def project_from_files(files: list[str], func_wrapper: _WrapperFuncT=
_astroid_wrapper, project_name: str='no name', black_list: tuple[str,
...]=constants.DEFAULT_IGNORE_LIST, verbose: bool=False) ->Project:
"""Return a Project from a list of files or modules."""
- pass
+ project = Project(project_name)
+
+ for file in files:
+ if file.endswith('.py'):
+ module_name = os.path.splitext(os.path.basename(file))[0]
+ else:
+ module_name = file
+
+ if module_name in black_list:
+ continue
+
+ try:
+ module = func_wrapper(astroid.MANAGER.ast_from_file, file, True)
+ if module:
+ project.modules.append(module)
+ project.locals[module.name] = module
+ project.path = module.file
+ except astroid.AstroidBuildingException:
+ if verbose:
+ traceback.print_exc()
+
+ return project
diff --git a/pylint/pyreverse/main.py b/pylint/pyreverse/main.py
index e8743de5e..1c3303c37 100644
--- a/pylint/pyreverse/main.py
+++ b/pylint/pyreverse/main.py
@@ -106,7 +106,28 @@ class Run(_ArgumentsManager, _ArgumentsProvider):
def run(self, args: list[str]) ->int:
"""Checking arguments and run project."""
- pass
+ if not args:
+ print("No packages to analyze.", file=sys.stderr)
+ return 1
+
+ with augmented_sys_path(self.config.source_roots):
+ project = project_from_files(
+ args,
+ project_name=self.config.project,
+ black_list=self.config.ignore_list,
+ verbose=self.config.verbose,
+ )
+
+ linker = Linker(project, tag=True)
+ handler = DiadefsHandler(self.config)
+ diadefs = handler.get_diadefs(project, linker)
+
+ if self.config.output_format.lower() == "plantuml":
+ self.config.output_format = "puml"
+
+ wrt = writer.get_writer(self.config.output_format, self.config)
+ wrt.write(diadefs)
+ return 0
if __name__ == '__main__':
diff --git a/pylint/pyreverse/mermaidjs_printer.py b/pylint/pyreverse/mermaidjs_printer.py
index 5c9dac6c4..39f6ba3bd 100644
--- a/pylint/pyreverse/mermaidjs_printer.py
+++ b/pylint/pyreverse/mermaidjs_printer.py
@@ -15,7 +15,7 @@ class MermaidJSPrinter(Printer):
def _open_graph(self) ->None:
"""Emit the header lines."""
- pass
+ self.emit("classDiagram")
def emit_node(self, name: str, type_: NodeType, properties: (
NodeProperties | None)=None) ->None:
@@ -23,15 +23,26 @@ class MermaidJSPrinter(Printer):
Nodes can be classes, packages, participants etc.
"""
- pass
+ node_type = self.NODES.get(type_, "class")
+ self.emit(f"{node_type} {name}")
+ if properties:
+ for prop in properties.attrs:
+ self.emit(f" {name} : {get_annotation_label(prop)}")
+ for method in properties.methods:
+ self.emit(f" {name} : {method}()")
def emit_edge(self, from_node: str, to_node: str, type_: EdgeType,
label: (str | None)=None) ->None:
"""Create an edge from one node to another to display relationships."""
- pass
+ arrow = self.ARROWS.get(type_, "--")
+ edge = f"{from_node} {arrow} {to_node}"
+ if label:
+ edge += f" : {label}"
+ self.emit(edge)
def _close_graph(self) ->None:
"""Emit the lines needed to properly close the graph."""
+ # MermaidJS doesn't require any closing statements
pass
@@ -44,3 +55,17 @@ class HTMLMermaidJSPrinter(MermaidJSPrinter):
"""
HTML_CLOSE_BOILERPLATE = '\n </div>\n </body>\n</html>\n'
GRAPH_INDENT_LEVEL = 4
+
+ def __init__(self):
+ super().__init__()
+ self.content = []
+
+ def emit(self, line: str) -> None:
+ """Emit a line of MermaidJS content."""
+ indent = ' ' * self.GRAPH_INDENT_LEVEL
+ self.content.append(f"{indent}{line}")
+
+ def generate(self) -> str:
+ """Generate the complete HTML output."""
+ mermaid_content = '\n'.join(self.content)
+ return f"{self.HTML_OPEN_BOILERPLATE}{mermaid_content}{self.HTML_CLOSE_BOILERPLATE}"
diff --git a/pylint/pyreverse/plantuml_printer.py b/pylint/pyreverse/plantuml_printer.py
index ed05f0b13..34bf755c0 100644
--- a/pylint/pyreverse/plantuml_printer.py
+++ b/pylint/pyreverse/plantuml_printer.py
@@ -15,7 +15,7 @@ class PlantUmlPrinter(Printer):
def _open_graph(self) ->None:
"""Emit the header lines."""
- pass
+ print("@startuml")
def emit_node(self, name: str, type_: NodeType, properties: (
NodeProperties | None)=None) ->None:
@@ -23,13 +23,23 @@ class PlantUmlPrinter(Printer):
Nodes can be classes, packages, participants etc.
"""
- pass
+ node_type = self.NODES.get(type_, "object")
+ properties_str = ""
+ if properties:
+ if properties.attrs:
+ properties_str += "\n ".join(properties.attrs)
+ if properties.methods:
+ properties_str += "\n " + "\n ".join(properties.methods)
+
+ print(f"{node_type} {name} {{{properties_str}}}")
def emit_edge(self, from_node: str, to_node: str, type_: EdgeType,
label: (str | None)=None) ->None:
"""Create an edge from one node to another to display relationships."""
- pass
+ arrow = self.ARROWS.get(type_, "--")
+ label_str = f" : {label}" if label else ""
+ print(f"{from_node} {arrow} {to_node}{label_str}")
def _close_graph(self) ->None:
"""Emit the lines needed to properly close the graph."""
- pass
+ print("@enduml")
diff --git a/pylint/pyreverse/printer.py b/pylint/pyreverse/printer.py
index 289b213ad..36d1fc268 100644
--- a/pylint/pyreverse/printer.py
+++ b/pylint/pyreverse/printer.py
@@ -49,11 +49,11 @@ class Printer(ABC):
def _inc_indent(self) ->None:
"""Increment indentation."""
- pass
+ self._indent += ' '
def _dec_indent(self) ->None:
"""Decrement indentation."""
- pass
+ self._indent = self._indent[:-4]
@abstractmethod
def _open_graph(self) ->None:
@@ -79,7 +79,9 @@ class Printer(ABC):
def generate(self, outputfile: str) ->None:
"""Generate and save the final outputfile."""
- pass
+ self._close_graph()
+ with open(outputfile, 'w', encoding='utf-8') as f:
+ f.write('\n'.join(self.lines))
@abstractmethod
def _close_graph(self) ->None:
diff --git a/pylint/pyreverse/utils.py b/pylint/pyreverse/utils.py
index 4d75d3e1a..11d604572 100644
--- a/pylint/pyreverse/utils.py
+++ b/pylint/pyreverse/utils.py
@@ -19,12 +19,17 @@ RCFILE = '.pyreverserc'
def get_default_options() ->list[str]:
"""Read config file and return list of options."""
- pass
+ options = []
+ if os.path.exists(RCFILE):
+ with open(RCFILE, 'r') as rcfile:
+ options = [line.strip() for line in rcfile if line.strip() and not line.startswith('#')]
+ return options
def insert_default_options() ->None:
"""Insert default options to sys.argv."""
- pass
+ options = get_default_options()
+ sys.argv[1:1] = options
SPECIAL = re.compile('^__([^\\W_]_*)+__$')
@@ -34,7 +39,13 @@ PROTECTED = re.compile('^_\\w*$')
def get_visibility(name: str) ->str:
"""Return the visibility from a name: public, protected, private or special."""
- pass
+ if SPECIAL.match(name):
+ return 'special'
+ if PRIVATE.match(name):
+ return 'private'
+ if PROTECTED.match(name):
+ return 'protected'
+ return 'public'
_SPECIAL = 2
@@ -61,7 +72,8 @@ class FilterMixIn:
def show_attr(self, node: (nodes.NodeNG | str)) ->bool:
"""Return true if the node should be treated."""
- pass
+ visibility = get_visibility(node.name if isinstance(node, nodes.NodeNG) else node)
+ return not (self.__mode & VIS_MOD[visibility])
class LocalsVisitor:
@@ -80,17 +92,39 @@ class LocalsVisitor:
def get_callbacks(self, node: nodes.NodeNG) ->_CallbackTupleT:
"""Get callbacks from handler for the visited node."""
- pass
+ klass = node.__class__
+ if klass not in self._cache:
+ visit = getattr(self, f'visit_{klass.__name__.lower()}', None)
+ leave = getattr(self, f'leave_{klass.__name__.lower()}', None)
+ self._cache[klass] = (visit, leave)
+ return self._cache[klass]
def visit(self, node: nodes.NodeNG) ->Any:
"""Launch the visit starting from the given node."""
- pass
+ if node in self._visited:
+ return
+
+ self._visited.add(node)
+ visit, leave = self.get_callbacks(node)
+
+ if visit:
+ visit(node)
+
+ for child_node in node.get_children():
+ self.visit(child_node)
+
+ if leave:
+ leave(node)
def get_annotation(node: (nodes.AssignAttr | nodes.AssignName)) ->(nodes.
Name | nodes.Subscript | None):
"""Return the annotation for `node`."""
- pass
+ if isinstance(node, nodes.AssignName):
+ return node.parent.annotation
+ elif isinstance(node, nodes.AssignAttr):
+ return node.annotation
+ return None
def infer_node(node: (nodes.AssignAttr | nodes.AssignName)) ->set[
@@ -98,7 +132,10 @@ def infer_node(node: (nodes.AssignAttr | nodes.AssignName)) ->set[
"""Return a set containing the node annotation if it exists
otherwise return a set of the inferred types using the NodeNG.infer method.
"""
- pass
+ annotation = get_annotation(node)
+ if annotation:
+ return {annotation}
+ return set(node.infer())
def check_graphviz_availability() ->None:
@@ -107,7 +144,12 @@ def check_graphviz_availability() ->None:
This is needed if image output is desired and ``dot`` is used to convert
from *.dot or *.gv into the final output format.
"""
- pass
+ if shutil.which("dot") is None:
+ raise RuntimeError(
+ "The 'dot' command from Graphviz is required for image output. "
+ "Please install Graphviz (https://graphviz.org/) and ensure the 'dot' "
+ "command is available in your system's PATH."
+ )
def check_if_graphviz_supports_format(output_format: str) ->None:
@@ -116,4 +158,17 @@ def check_if_graphviz_supports_format(output_format: str) ->None:
This is needed if image output is desired and ``dot`` is used to convert
from *.gv into the final output format.
"""
- pass
+ check_graphviz_availability()
+ try:
+ subprocess.run(
+ ["dot", f"-T{output_format}", "-o", os.devnull],
+ input="digraph { a -> b }",
+ text=True,
+ capture_output=True,
+ check=True,
+ )
+ except subprocess.CalledProcessError as e:
+ raise RuntimeError(
+ f"The 'dot' command does not support the '{output_format}' output format. "
+ f"Error: {e.stderr.strip()}"
+ ) from e
diff --git a/pylint/pyreverse/writer.py b/pylint/pyreverse/writer.py
index 55d8714f1..2a685e24e 100644
--- a/pylint/pyreverse/writer.py
+++ b/pylint/pyreverse/writer.py
@@ -27,32 +27,72 @@ class DiagramWriter:
def write(self, diadefs: Iterable[ClassDiagram | PackageDiagram]) ->None:
"""Write files for <project> according to <diadefs>."""
- pass
+ for diagram in diadefs:
+ if isinstance(diagram, PackageDiagram):
+ self.write_packages(diagram)
+ elif isinstance(diagram, ClassDiagram):
+ self.write_classes(diagram)
def write_packages(self, diagram: PackageDiagram) ->None:
"""Write a package diagram."""
- pass
+ self.set_printer(diagram.name, "packages")
+ for obj in diagram.modules():
+ properties = self.get_package_properties(obj)
+ self.printer.emit_node(obj.fig_id, properties)
+ for rel in diagram.relationships:
+ self.printer.emit_edge(rel.from_object.fig_id, rel.to_object.fig_id, EdgeType.USES)
+ self.save()
def write_classes(self, diagram: ClassDiagram) ->None:
"""Write a class diagram."""
- pass
+ self.set_printer(diagram.name, "classes")
+ for obj in diagram.objects:
+ properties = self.get_class_properties(obj)
+ self.printer.emit_node(obj.fig_id, properties)
+ for rel in diagram.relationships:
+ self.printer.emit_edge(rel.from_object.fig_id, rel.to_object.fig_id, rel.type)
+ self.save()
def set_printer(self, file_name: str, basename: str) ->None:
"""Set printer."""
- pass
+ self.file_name = f"{basename}_{file_name}"
+ self.printer = self.printer_class(self.file_name)
def get_package_properties(self, obj: PackageEntity) ->NodeProperties:
"""Get label and shape for packages."""
- pass
+ return NodeProperties(
+ label=obj.title,
+ shape="box",
+ style="filled",
+ color=self.get_shape_color(obj),
+ fontcolor="black",
+ fontname="Helvetica",
+ fontsize=10,
+ )
def get_class_properties(self, obj: ClassEntity) ->NodeProperties:
"""Get label and shape for classes."""
- pass
+ label = f"{obj.title}|{obj.attrs}|{obj.methods}" if obj.attrs or obj.methods else obj.title
+ return NodeProperties(
+ label=label,
+ shape="record",
+ style="filled",
+ color=self.get_shape_color(obj),
+ fontcolor="black",
+ fontname="Helvetica",
+ fontsize=10,
+ )
def get_shape_color(self, obj: DiagramEntity) ->str:
"""Get shape color."""
- pass
+ if obj.node_type == NodeType.PACKAGE:
+ return "#ADD8E6" # Light blue for packages
+ elif obj.node_type == NodeType.CLASS:
+ if is_exception(obj):
+ return "#FFA07A" # Light salmon for exceptions
+ return "#98FB98" # Pale green for regular classes
+ return "#FFFFFF" # White for unknown types
def save(self) ->None:
"""Write to disk."""
- pass
+ self.printer.generate(self.file_name)
diff --git a/pylint/reporters/base_reporter.py b/pylint/reporters/base_reporter.py
index 2a79b16e1..3f96222f8 100644
--- a/pylint/reporters/base_reporter.py
+++ b/pylint/reporters/base_reporter.py
@@ -28,19 +28,23 @@ class BaseReporter:
def handle_message(self, msg: Message) ->None:
"""Handle a new message triggered on the current file."""
- pass
+ self.messages.append(msg)
def writeln(self, string: str='') ->None:
"""Write a line in the output buffer."""
- pass
+ print(string, file=self.out)
def display_reports(self, layout: Section) ->None:
"""Display results encapsulated in the layout tree."""
- pass
+ self._display(layout)
def _display(self, layout: Section) ->None:
"""Display the layout."""
- pass
+ for child in layout.children:
+ if isinstance(child, Text):
+ self.writeln(child.data)
+ elif isinstance(child, Section):
+ self._display(child)
def display_messages(self, layout: (Section | None)) ->None:
"""Hook for displaying the messages of the reporter.
@@ -52,14 +56,21 @@ class BaseReporter:
This method can be implemented to display them after they've
been aggregated.
"""
- pass
+ for msg in self.messages:
+ self.writeln(f"{msg.path}:{msg.line}: {msg.symbol} {msg.msg}")
def on_set_current_module(self, module: str, filepath: (str | None)
) ->None:
"""Hook called when a module starts to be analysed."""
- pass
+ self.writeln(f"Analyzing module: {module}")
+ if filepath:
+ self.writeln(f"File path: {filepath}")
def on_close(self, stats: LinterStats, previous_stats: (LinterStats | None)
) ->None:
"""Hook called when a module finished analyzing."""
- pass
+ self.writeln("Analysis completed")
+ self.writeln(f"Total messages: {stats.total_errors}")
+ if previous_stats:
+ diff = stats.total_errors - previous_stats.total_errors
+ self.writeln(f"Difference from previous run: {diff}")
diff --git a/pylint/reporters/json_reporter.py b/pylint/reporters/json_reporter.py
index ddf8abc09..546beedd5 100644
--- a/pylint/reporters/json_reporter.py
+++ b/pylint/reporters/json_reporter.py
@@ -26,15 +26,32 @@ class JSONReporter(BaseReporter):
def display_messages(self, layout: (Section | None)) ->None:
"""Launch layouts display."""
- pass
+ messages = [self._export_message(msg) for msg in self.messages]
+ print(json.dumps(messages, indent=4))
def display_reports(self, layout: Section) ->None:
"""Don't do anything in this reporter."""
- pass
+ # This method intentionally does nothing as per the docstring
def _display(self, layout: Section) ->None:
"""Do nothing."""
- pass
+ # This method intentionally does nothing as per the docstring
+
+ def _export_message(self, msg: Message) -> OldJsonExport:
+ """Export a message to the old JSON format."""
+ return {
+ "type": msg.category,
+ "module": msg.module,
+ "obj": msg.obj,
+ "line": msg.line,
+ "column": msg.column,
+ "endLine": msg.end_line,
+ "endColumn": msg.end_column,
+ "path": msg.path,
+ "symbol": msg.symbol,
+ "message": msg.msg or "",
+ "message-id": msg.msg_id,
+ }
class JSONMessage(TypedDict):
@@ -59,16 +76,51 @@ class JSON2Reporter(BaseReporter):
def display_reports(self, layout: Section) ->None:
"""Don't do anything in this reporter."""
- pass
+ # This method intentionally does nothing as per the docstring
def _display(self, layout: Section) ->None:
"""Do nothing."""
- pass
+ # This method intentionally does nothing as per the docstring
def display_messages(self, layout: (Section | None)) ->None:
"""Launch layouts display."""
- pass
+ messages = [self._format_message(msg) for msg in self.messages]
+ result = {
+ "messages": messages,
+ "statistics": self.serialize_stats(),
+ }
+ print(json.dumps(result, indent=2))
def serialize_stats(self) ->dict[str, str | int | dict[str, int]]:
"""Serialize the linter stats into something JSON dumpable."""
- pass
+ stats = self.linter.stats
+ return {
+ "by_module": stats.by_module,
+ "message_count": stats.message_count,
+ "module_count": stats.module_count,
+ "statement_count": stats.statement_count,
+ "error": stats.error,
+ "warning": stats.warning,
+ "refactor": stats.refactor,
+ "convention": stats.convention,
+ "info": stats.info,
+ "fatal": stats.fatal,
+ }
+
+ def _format_message(self, msg: Message) -> JSONMessage:
+ """Format a message for JSON output."""
+ return {
+ "type": msg.category,
+ "message": msg.msg or "",
+ "messageId": msg.msg_id,
+ "symbol": msg.symbol,
+ "confidence": CONFIDENCE_MAP[msg.confidence] if msg.confidence != UNDEFINED else "undefined",
+ "module": msg.module,
+ "path": msg.path,
+ "absolutePath": str(msg.abspath),
+ "line": msg.line,
+ "endLine": msg.end_line,
+ "column": msg.column,
+ "endColumn": msg.end_column,
+ "obj": msg.obj,
+ }
diff --git a/pylint/reporters/multi_reporter.py b/pylint/reporters/multi_reporter.py
index 933044920..fdca72aa5 100644
--- a/pylint/reporters/multi_reporter.py
+++ b/pylint/reporters/multi_reporter.py
@@ -39,26 +39,33 @@ class MultiReporter:
def handle_message(self, msg: Message) ->None:
"""Handle a new message triggered on the current file."""
- pass
+ for reporter in self._sub_reporters:
+ reporter.handle_message(msg)
+ self.messages.append(msg)
def writeln(self, string: str='') ->None:
"""Write a line in the output buffer."""
- pass
+ for reporter in self._sub_reporters:
+ reporter.writeln(string)
def display_reports(self, layout: Section) ->None:
"""Display results encapsulated in the layout tree."""
- pass
+ for reporter in self._sub_reporters:
+ reporter.display_reports(layout)
def display_messages(self, layout: (Section | None)) ->None:
"""Hook for displaying the messages of the reporter."""
- pass
+ for reporter in self._sub_reporters:
+ reporter.display_messages(layout)
def on_set_current_module(self, module: str, filepath: (str | None)
) ->None:
"""Hook called when a module starts to be analysed."""
- pass
+ for reporter in self._sub_reporters:
+ reporter.on_set_current_module(module, filepath)
def on_close(self, stats: LinterStats, previous_stats: (LinterStats | None)
) ->None:
"""Hook called when a module finished analyzing."""
- pass
+ for reporter in self._sub_reporters:
+ reporter.on_close(stats, previous_stats)
diff --git a/pylint/reporters/reports_handler_mix_in.py b/pylint/reporters/reports_handler_mix_in.py
index c68428765..3f74f82a6 100644
--- a/pylint/reporters/reports_handler_mix_in.py
+++ b/pylint/reporters/reports_handler_mix_in.py
@@ -24,7 +24,9 @@ class ReportsHandlerMixIn:
def report_order(self) ->MutableSequence[BaseChecker]:
"""Return a list of reporters."""
- pass
+ return [checker for checker, _ in sorted(
+ self._reports.items(), key=lambda x: x[0].name.lower()
+ )]
def register_report(self, reportid: str, r_title: str, r_cb:
ReportsCallable, checker: BaseChecker) ->None:
@@ -35,21 +37,32 @@ class ReportsHandlerMixIn:
:param r_cb: The method to call to make the report
:param checker: The checker defining the report
"""
- pass
+ self._reports[checker].append((reportid, r_title, r_cb))
def enable_report(self, reportid: str) ->None:
"""Enable the report of the given id."""
- pass
+ self._reports_state[reportid] = True
def disable_report(self, reportid: str) ->None:
"""Disable the report of the given id."""
- pass
+ self._reports_state[reportid] = False
def report_is_enabled(self, reportid: str) ->bool:
"""Is the report associated to the given identifier enabled ?"""
- pass
+ return self._reports_state.get(reportid, True)
def make_reports(self: PyLinter, stats: LinterStats, old_stats: (
LinterStats | None)) ->Section:
"""Render registered reports."""
- pass
+ sect = Section("Report")
+ for checker in self.report_order():
+ for reportid, r_title, r_cb in self._reports[checker]:
+ if not self.report_is_enabled(reportid):
+ continue
+ report_sect = Section(r_title)
+ try:
+ r_cb(report_sect, stats, old_stats)
+ except EmptyReportError:
+ continue
+ sect.append(report_sect)
+ return sect
diff --git a/pylint/reporters/text.py b/pylint/reporters/text.py
index 913080584..99d4b8dfc 100644
--- a/pylint/reporters/text.py
+++ b/pylint/reporters/text.py
@@ -34,7 +34,15 @@ class MessageStyle(NamedTuple):
:return: the built escape code
"""
- pass
+ code = []
+ if self.color:
+ if self.color.isdigit():
+ code.append(f"38;5;{self.color}")
+ else:
+ code.append(ANSI_COLORS[self.color])
+ for style in self.style:
+ code.append(ANSI_STYLES[style])
+ return ANSI_PREFIX + ';'.join(code) + ANSI_END
ColorMappingDict = Dict[str, MessageStyle]
@@ -52,7 +60,9 @@ MESSAGE_FIELDS = {i.name for i in fields(Message)}
def colorize_ansi(msg: str, msg_style: MessageStyle) ->str:
"""Colorize message by wrapping it with ANSI escape codes."""
- pass
+ if not msg_style.color and not msg_style.style:
+ return msg
+ return f"{msg_style.__get_ansi_code()}{msg}{ANSI_RESET}"
class TextReporter(BaseReporter):
@@ -71,21 +81,34 @@ class TextReporter(BaseReporter):
def on_set_current_module(self, module: str, filepath: (str | None)
) ->None:
"""Set the format template to be used and check for unrecognized arguments."""
- pass
+ self._modules.add(module)
+ self._template = self.line_format
+ if filepath is None:
+ filepath = module
+ self._fixed_template = self._template.format(
+ path=filepath,
+ module=module,
+ **{name: '{' + name + '}' for name in MESSAGE_FIELDS}
+ )
def write_message(self, msg: Message) ->None:
"""Convenience method to write a formatted message with class default
template.
"""
- pass
+ self.writeln(self._fixed_template.format(**asdict(msg)))
def handle_message(self, msg: Message) ->None:
"""Manage message of different type and in the context of path."""
- pass
+ if msg.module not in self._modules:
+ if msg.module and msg.module != "global":
+ self.writeln(f"************* Module {msg.module}")
+ self._modules.add(msg.module)
+ self.write_message(msg)
def _display(self, layout: Section) ->None:
"""Launch layouts display."""
- pass
+ writer = TextWriter(self.out)
+ writer.format_section(layout)
class NoHeaderReporter(TextReporter):
@@ -94,7 +117,7 @@ class NoHeaderReporter(TextReporter):
def handle_message(self, msg: Message) ->None:
"""Write message(s) without module header."""
- pass
+ self.write_message(msg)
class ParseableTextReporter(TextReporter):
@@ -141,13 +164,17 @@ class ColorizedTextReporter(TextReporter):
def _get_decoration(self, msg_id: str) ->MessageStyle:
"""Returns the message style as defined in self.color_mapping."""
- pass
+ return self.color_mapping.get(msg_id[0], MessageStyle(None))
def handle_message(self, msg: Message) ->None:
"""Manage message of different types, and colorize output
using ANSI escape codes.
"""
- pass
+ if msg.module not in self._modules:
+ if msg.module and msg.module != "global":
+ self.writeln(colorize_ansi(f"************* Module {msg.module}", MessageStyle("green", ("bold",))))
+ self._modules.add(msg.module)
+ self.write_message(colorize_ansi(self._fixed_template.format(**asdict(msg)), self._get_decoration(msg.C)))
class GithubReporter(TextReporter):
diff --git a/pylint/reporters/ureports/base_writer.py b/pylint/reporters/ureports/base_writer.py
index 8b1244c33..2d66c3cf3 100644
--- a/pylint/reporters/ureports/base_writer.py
+++ b/pylint/reporters/ureports/base_writer.py
@@ -23,37 +23,57 @@ class BaseWriter:
try to call 'stream.write' with it, but give it back encoded using
the given encoding if it fails
"""
- pass
+ self.encoding = encoding
+ self.out = stream
+ self.begin_format()
+ layout.accept(self)
+ self.end_format()
def format_children(self, layout: (EvaluationSection | Paragraph | Section)
) ->None:
"""Recurse on the layout children and call their accept method
(see the Visitor pattern).
"""
- pass
+ for child in layout.children:
+ child.accept(self)
def writeln(self, string: str='') ->None:
"""Write a line in the output buffer."""
- pass
+ self.write(string + '\n')
def write(self, string: str) ->None:
"""Write a string in the output buffer."""
- pass
+ if isinstance(string, str):
+ self.out.write(string)
+ else:
+ self.out.write(string.encode(self.encoding or 'utf-8'))
def begin_format(self) ->None:
"""Begin to format a layout."""
- pass
+ self.section = 0
def end_format(self) ->None:
"""Finished formatting a layout."""
- pass
+ if self.out is not sys.stdout:
+ self.out.flush()
def get_table_content(self, table: Table) ->list[list[str]]:
"""Trick to get table content without actually writing it.
return an aligned list of lists containing table cells values as string
"""
- pass
+ result = []
+ for row in table.data:
+ result_row = []
+ for cell in row:
+ if isinstance(cell, BaseLayout):
+ stream = StringIO()
+ self.format(cell, stream)
+ result_row.append(stream.getvalue().strip())
+ else:
+ result_row.append(str(cell).strip())
+ result.append(result_row)
+ return result
def compute_content(self, layout: BaseLayout) ->Iterator[str]:
"""Trick to compute the formatting of children layout before actually
@@ -61,4 +81,9 @@ class BaseWriter:
return an iterator on strings (one for each child element)
"""
- pass
+ stream = StringIO()
+ for child in layout.children:
+ child.accept(self)
+ yield stream.getvalue()
+ stream.seek(0)
+ stream.truncate()
diff --git a/pylint/reporters/ureports/nodes.py b/pylint/reporters/ureports/nodes.py
index 9787ce5b8..09099f672 100644
--- a/pylint/reporters/ureports/nodes.py
+++ b/pylint/reporters/ureports/nodes.py
@@ -39,19 +39,26 @@ class BaseLayout(VNode):
def append(self, child: VNode) ->None:
"""Add a node to children."""
- pass
+ self.children.append(child)
+ child.parent = self
def insert(self, index: int, child: VNode) ->None:
"""Insert a child node."""
- pass
+ self.children.insert(index, child)
+ child.parent = self
def parents(self) ->list[BaseLayout]:
"""Return the ancestor nodes."""
- pass
+ ancestors = []
+ parent = self.parent
+ while parent:
+ ancestors.append(parent)
+ parent = parent.parent
+ return ancestors
def add_text(self, text: str) ->None:
"""Shortcut to add text data."""
- pass
+ self.append(Text(text))
class Text(VNode):
diff --git a/pylint/reporters/ureports/text_writer.py b/pylint/reporters/ureports/text_writer.py
index a827d6c5f..96f2e7b04 100644
--- a/pylint/reporters/ureports/text_writer.py
+++ b/pylint/reporters/ureports/text_writer.py
@@ -19,29 +19,49 @@ class TextWriter(BaseWriter):
def visit_section(self, layout: Section) ->None:
"""Display a section as text."""
- pass
+ self.section += 1
+ if self.section > 1:
+ self.writeln()
+ self.format_children(layout)
+ self.section -= 1
def visit_evaluationsection(self, layout: EvaluationSection) ->None:
"""Display an evaluation section as a text."""
- pass
+ self.visit_section(layout)
def visit_paragraph(self, layout: Paragraph) ->None:
"""Enter a paragraph."""
- pass
+ self.format_children(layout)
+ self.writeln()
def visit_table(self, layout: Table) ->None:
"""Display a table as text."""
- pass
+ table_content = self.get_table_content(layout)
+ cols_width = self.get_table_cols_width(table_content)
+ self.default_table(layout, table_content, cols_width)
def default_table(self, layout: Table, table_content: list[list[str]],
cols_width: list[int]) ->None:
"""Format a table."""
- pass
+ cols_width = [max(width, 4) for width in cols_width]
+ table_width = sum(cols_width) + len(cols_width) * 3 + 1
+ self.writeln('=' * table_width)
+ for row in table_content:
+ self.write('| ')
+ for width, cell in zip(cols_width, row):
+ self.write(cell.ljust(width))
+ self.write(' | ')
+ self.writeln()
+ self.writeln('=' * table_width)
def visit_verbatimtext(self, layout: VerbatimText) ->None:
"""Display a verbatim layout as text (so difficult ;)."""
- pass
+ self.writeln('::')
+ self.writeln()
+ for line in layout.data.splitlines():
+ self.writeln(' ' + line)
+ self.writeln()
def visit_text(self, layout: Text) ->None:
"""Add some text."""
- pass
+ self.write(layout.data)
diff --git a/pylint/testutils/_primer/package_to_lint.py b/pylint/testutils/_primer/package_to_lint.py
index ff547e409..4dfa9e7f3 100644
--- a/pylint/testutils/_primer/package_to_lint.py
+++ b/pylint/testutils/_primer/package_to_lint.py
@@ -56,12 +56,12 @@ class PackageToLint:
@property
def clone_directory(self) ->Path:
"""Directory to clone repository into."""
- pass
+ return PRIMER_DIRECTORY_PATH / self.url.split('/')[-1].replace('.git', '')
@property
def paths_to_lint(self) ->list[str]:
"""The paths we need to lint."""
- pass
+ return [str(self.clone_directory / directory) for directory in self.directories]
def lazy_clone(self) ->str:
"""Concatenates the target directory and clones the file.
@@ -72,4 +72,19 @@ class PackageToLint:
we'll probably notice because we'll have a fatal when launching the
primer locally.
"""
- pass
+ if not self.clone_directory.exists():
+ logging.info("Cloning %s", self.url)
+ Repo.clone_from(self.url, self.clone_directory, branch=self.branch)
+ else:
+ logging.info("Repository already exists, pulling latest changes")
+ repo = Repo(self.clone_directory)
+ try:
+ repo.remotes.origin.pull()
+ except GitCommandError:
+ raise DirtyPrimerDirectoryException(self.clone_directory)
+
+ if self.commit:
+ repo = Repo(self.clone_directory)
+ repo.git.checkout(self.commit)
+
+ return str(self.clone_directory)
diff --git a/pylint/testutils/_primer/primer_compare_command.py b/pylint/testutils/_primer/primer_compare_command.py
index f71c9c3a6..4537c051f 100644
--- a/pylint/testutils/_primer/primer_compare_command.py
+++ b/pylint/testutils/_primer/primer_compare_command.py
@@ -10,4 +10,7 @@ class CompareCommand(PrimerCommand):
def _truncate_comment(self, comment: str) ->str:
"""GitHub allows only a set number of characters in a comment."""
- pass
+ if len(comment) <= MAX_GITHUB_COMMENT_LENGTH:
+ return comment
+ truncated = comment[:MAX_GITHUB_COMMENT_LENGTH - 3] + "..."
+ return truncated
diff --git a/pylint/testutils/_primer/primer_prepare_command.py b/pylint/testutils/_primer/primer_prepare_command.py
index 6ceb3a886..043fed10e 100644
--- a/pylint/testutils/_primer/primer_prepare_command.py
+++ b/pylint/testutils/_primer/primer_prepare_command.py
@@ -1,9 +1,48 @@
from __future__ import annotations
import sys
+import os
from git.cmd import Git
from git.repo import Repo
from pylint.testutils._primer.primer_command import PrimerCommand
class PrepareCommand(PrimerCommand):
- pass
+ def __init__(self, repo_path: str, branch: str):
+ super().__init__()
+ self.repo_path = repo_path
+ self.branch = branch
+ self.repo = None
+
+ def run(self) -> int:
+ try:
+ self.repo = Repo(self.repo_path)
+ self._prepare_repository()
+ return 0
+ except Exception as e:
+ print(f"Error: {e}", file=sys.stderr)
+ return 1
+
+ def _prepare_repository(self) -> None:
+ self._ensure_clean_working_tree()
+ self._checkout_branch()
+ self._pull_latest_changes()
+
+ def _ensure_clean_working_tree(self) -> None:
+ if self.repo.is_dirty():
+ raise ValueError("Working tree is not clean. Please commit or stash your changes.")
+
+ def _checkout_branch(self) -> None:
+ try:
+ self.repo.git.checkout(self.branch)
+ except Git.GitCommandError:
+ print(f"Branch '{self.branch}' not found. Creating a new branch.", file=sys.stderr)
+ self.repo.git.checkout('-b', self.branch)
+
+ def _pull_latest_changes(self) -> None:
+ try:
+ self.repo.git.pull('origin', self.branch)
+ except Git.GitCommandError as e:
+ if "There is no tracking information for the current branch" in str(e):
+ print(f"No upstream branch set for '{self.branch}'. Skipping pull.", file=sys.stderr)
+ else:
+ raise
diff --git a/pylint/testutils/_primer/primer_run_command.py b/pylint/testutils/_primer/primer_run_command.py
index 9a5876619..61f683b41 100644
--- a/pylint/testutils/_primer/primer_run_command.py
+++ b/pylint/testutils/_primer/primer_run_command.py
@@ -18,4 +18,8 @@ class RunCommand(PrimerCommand):
@staticmethod
def _filter_fatal_errors(messages: list[OldJsonExport]) ->list[Message]:
"""Separate fatal errors so we can report them independently."""
- pass
+ return [
+ Message(**msg)
+ for msg in messages
+ if msg.get('type') == 'fatal'
+ ]
diff --git a/pylint/testutils/_run.py b/pylint/testutils/_run.py
index 8752caca2..ed1b71a6e 100644
--- a/pylint/testutils/_run.py
+++ b/pylint/testutils/_run.py
@@ -11,7 +11,9 @@ from pylint.testutils.lint_module_test import PYLINTRC
def _add_rcfile_default_pylintrc(args: list[str]) ->list[str]:
"""Add a default pylintrc with the rcfile option in a list of pylint args."""
- pass
+ if "--rcfile" not in args:
+ args.extend(["--rcfile", PYLINTRC])
+ return args
class _Run(LintRun):
diff --git a/pylint/testutils/checker_test_case.py b/pylint/testutils/checker_test_case.py
index fa4a782ae..b192c073d 100644
--- a/pylint/testutils/checker_test_case.py
+++ b/pylint/testutils/checker_test_case.py
@@ -18,7 +18,12 @@ class CheckerTestCase:
@contextlib.contextmanager
def assertNoMessages(self) ->Iterator[None]:
"""Assert that no messages are added by the given method."""
- pass
+ old_messages = linter.reporter.messages[:]
+ yield
+ new_messages = linter.reporter.messages[:]
+ added_messages = new_messages[len(old_messages):]
+ if added_messages:
+ raise AssertionError(f"Unexpected message(s) added: {added_messages}")
@contextlib.contextmanager
def assertAddsMessages(self, *messages: MessageTest, ignore_position:
@@ -33,8 +38,26 @@ class CheckerTestCase:
arguments (line, col_offset, ...) will be skipped. This can be used to
just test messages for the correct node.
"""
- pass
+ old_messages = linter.reporter.messages[:]
+ yield
+ new_messages = linter.reporter.messages[:]
+ added_messages = new_messages[len(old_messages):]
+
+ if len(added_messages) != len(messages):
+ raise AssertionError(
+ f"Expected {len(messages)} message(s), got {len(added_messages)}"
+ )
+
+ for expected, actual in zip(messages, added_messages):
+ if not ignore_position:
+ assert expected.line == actual.line, f"Line mismatch: expected {expected.line}, got {actual.line}"
+ assert expected.column == actual.column, f"Column mismatch: expected {expected.column}, got {actual.column}"
+
+ assert expected.msg_id == actual.msg_id, f"Message ID mismatch: expected {expected.msg_id}, got {actual.msg_id}"
+ assert expected.symbol == actual.symbol, f"Symbol mismatch: expected {expected.symbol}, got {actual.symbol}"
+ assert expected.msg == actual.msg, f"Message mismatch: expected {expected.msg}, got {actual.msg}"
def walk(self, node: nodes.NodeNG) ->None:
"""Recursive walk on the given node."""
- pass
+ walker = ASTWalker(linter)
+ walker.walk(node)
diff --git a/pylint/testutils/configuration_test.py b/pylint/testutils/configuration_test.py
index 3c00e103a..3d131fed2 100644
--- a/pylint/testutils/configuration_test.py
+++ b/pylint/testutils/configuration_test.py
@@ -15,7 +15,11 @@ PylintConfiguration = Dict[str, ConfigurationValue]
def get_expected_or_default(tested_configuration_file: (str | Path), suffix:
str, default: str) ->str:
"""Return the expected value from the file if it exists, or the given default."""
- pass
+ expected_file = Path(tested_configuration_file).with_suffix(suffix)
+ if expected_file.exists():
+ with expected_file.open("r") as f:
+ return f.read().strip()
+ return default
EXPECTED_CONF_APPEND_KEY = 'functional_append'
@@ -25,22 +29,62 @@ EXPECTED_CONF_REMOVE_KEY = 'functional_remove'
def get_expected_configuration(configuration_path: str,
default_configuration: PylintConfiguration) ->PylintConfiguration:
"""Get the expected parsed configuration of a configuration functional test."""
- pass
+ expected_configuration = copy.deepcopy(default_configuration)
+ expected_file = Path(configuration_path).with_suffix('.json')
+
+ if expected_file.exists():
+ with expected_file.open("r") as f:
+ expected_json = json.load(f)
+
+ for key, value in expected_json.get(EXPECTED_CONF_APPEND_KEY, {}).items():
+ if key in expected_configuration:
+ expected_configuration[key].extend(value)
+ else:
+ expected_configuration[key] = value
+
+ for key, value in expected_json.get(EXPECTED_CONF_REMOVE_KEY, {}).items():
+ if key in expected_configuration:
+ for item in value:
+ if item in expected_configuration[key]:
+ expected_configuration[key].remove(item)
+
+ return expected_configuration
def get_related_files(tested_configuration_file: (str | Path),
suffix_filter: str) ->list[Path]:
"""Return all the file related to a test conf file ending with a suffix."""
- pass
+ base_path = Path(tested_configuration_file).with_suffix('')
+ return list(base_path.parent.glob(f"{base_path.name}*{suffix_filter}"))
def get_expected_output(configuration_path: (str | Path),
user_specific_path: Path) ->tuple[int, str]:
"""Get the expected output of a functional test."""
- pass
+ expected_output_file = Path(configuration_path).with_suffix('.out')
+ if expected_output_file.exists():
+ with expected_output_file.open("r") as f:
+ content = f.read().strip()
+ lines = content.splitlines()
+ return_code = int(lines[0])
+ output = "\n".join(lines[1:])
+ return return_code, output
+ else:
+ return 0, ""
def run_using_a_configuration_file(configuration_path: (Path | str),
file_to_lint: str=__file__) ->tuple[Mock, Mock, Run]:
"""Simulate a run with a configuration without really launching the checks."""
- pass
+ args = ["--rcfile", str(configuration_path), file_to_lint]
+
+ reporter = Mock()
+ linter = Mock()
+ linter.config = Mock()
+ linter.reporter = reporter
+
+ with unittest.mock.patch("pylint.lint.pylinter.PyLinter", return_value=linter):
+ with unittest.mock.patch("pylint.lint.run._do_run"):
+ run = Run(args)
+
+ return reporter, linter, run
diff --git a/pylint/testutils/decorator.py b/pylint/testutils/decorator.py
index 50a300f10..bd145ef2d 100644
--- a/pylint/testutils/decorator.py
+++ b/pylint/testutils/decorator.py
@@ -12,4 +12,22 @@ def set_config(**kwargs: Any) ->Callable[[Callable[..., None]], Callable[
Passing the args and kwargs back to the test function itself
allows this decorator to be used on parameterized test cases.
"""
- pass
+ def decorator(test):
+ @functools.wraps(test)
+ def wrapper(self, *args, **test_kwargs):
+ if not isinstance(self, CheckerTestCase):
+ raise TypeError("set_config can only be used with CheckerTestCase")
+
+ original_config = {}
+ for key, value in kwargs.items():
+ original_config[key] = getattr(self.checker, key)
+ setattr(self.checker, key, value)
+
+ try:
+ return test(self, *args, **test_kwargs)
+ finally:
+ for key, value in original_config.items():
+ setattr(self.checker, key, value)
+
+ return wrapper
+ return decorator
diff --git a/pylint/testutils/functional/find_functional_tests.py b/pylint/testutils/functional/find_functional_tests.py
index 79a06c358..e804e602d 100644
--- a/pylint/testutils/functional/find_functional_tests.py
+++ b/pylint/testutils/functional/find_functional_tests.py
@@ -19,7 +19,21 @@ def get_functional_test_files_from_directory(input_dir: (Path | str),
max_file_per_directory: int=REASONABLY_DISPLAYABLE_VERTICALLY) ->list[
FunctionalTestFile]:
"""Get all functional tests in the input_dir."""
- pass
+ input_path = Path(input_dir)
+ _check_functional_tests_structure(input_path, max_file_per_directory)
+
+ functional_test_files = []
+ for root, _, files in os.walk(input_path):
+ root_path = Path(root)
+ if root_path.name.startswith('_') or root_path.name in IGNORED_PARENT_DIRS or root_path.parent.name in IGNORED_PARENT_PARENT_DIRS:
+ continue
+
+ for file in files:
+ if file.endswith('.py') and not file.startswith('_'):
+ file_path = root_path / file
+ functional_test_files.append(FunctionalTestFile(file_path))
+
+ return functional_test_files
def _check_functional_tests_structure(directory: Path,
@@ -28,4 +42,20 @@ def _check_functional_tests_structure(directory: Path,
Ignore underscored directories or files.
"""
- pass
+ for root, dirs, files in os.walk(directory):
+ root_path = Path(root)
+ if root_path.name.startswith('_'):
+ continue
+
+ py_files = [f for f in files if f.endswith('.py') and not f.startswith('_')]
+
+ if len(py_files) > max_file_per_directory:
+ raise ValueError(f"Directory {root} contains {len(py_files)} Python files, "
+ f"which exceeds the maximum of {max_file_per_directory}.")
+
+ for dir_name in dirs:
+ if not dir_name.startswith('_'):
+ subdir = root_path / dir_name
+ if any(f.endswith('.py') for f in os.listdir(subdir) if not f.startswith('_')):
+ raise ValueError(f"Subdirectory {subdir} contains Python files. "
+ f"All Python files should be in the top-level directory.")
diff --git a/pylint/testutils/functional/lint_module_output_update.py b/pylint/testutils/functional/lint_module_output_update.py
index d8e3eb6ac..1eacee6e2 100644
--- a/pylint/testutils/functional/lint_module_output_update.py
+++ b/pylint/testutils/functional/lint_module_output_update.py
@@ -20,4 +20,14 @@ class LintModuleOutputUpdate(LintModuleTest):
def _check_output_text(self, _: MessageCounter, expected_output: list[
OutputLine], actual_output: list[OutputLine]) ->None:
"""Overwrite or remove the expected output file based on actual output."""
- pass
+ expected_output_file = self._test_file.expected_output
+ if actual_output:
+ # If there's actual output, overwrite the expected output file
+ with open(expected_output_file, 'w', encoding='utf-8', newline='') as f:
+ writer = csv.writer(f, dialect='test')
+ for line in actual_output:
+ writer.writerow([str(line.symbol), line.msg, line.line, line.column, line.path, line.module, line.obj])
+ else:
+ # If there's no actual output, remove the expected output file if it exists
+ if os.path.exists(expected_output_file):
+ os.remove(expected_output_file)
diff --git a/pylint/testutils/functional/test_file.py b/pylint/testutils/functional/test_file.py
index 6fe0e17be..1f8cb2bfb 100644
--- a/pylint/testutils/functional/test_file.py
+++ b/pylint/testutils/functional/test_file.py
@@ -7,11 +7,14 @@ from typing import TypedDict
def parse_python_version(ver_str: str) ->tuple[int, ...]:
"""Convert python version to a tuple of integers for easy comparison."""
- pass
+ return tuple(int(v) for v in ver_str.split('.'))
class NoFileError(Exception):
- pass
+ """Exception raised when a file is not found."""
+ def __init__(self, filename: str) -> None:
+ super().__init__(f"File not found: {filename}")
+ self.filename = filename
class TestFileOptions(TypedDict):
diff --git a/pylint/testutils/get_test_info.py b/pylint/testutils/get_test_info.py
index 4d1b573f1..9b0a54e6b 100644
--- a/pylint/testutils/get_test_info.py
+++ b/pylint/testutils/get_test_info.py
@@ -16,4 +16,25 @@ def _get_tests_info(input_dir: str, msg_dir: str, prefix: str, suffix: str
message for python >= x.y -> message = <name>_pyxy.txt
lower versions -> message with highest num
"""
- pass
+ result = []
+ for input_file in glob(join(input_dir, prefix + '*' + suffix)):
+ base_name = splitext(basename(input_file))[0]
+ msg_file = _get_message_file(msg_dir, base_name)
+ if msg_file:
+ result.append((input_file, msg_file))
+ return result
+
+def _get_message_file(msg_dir: str, base_name: str) -> str:
+ """Get the message file with the highest version number for the given base name."""
+ candidates = glob(join(msg_dir, base_name + '*.txt'))
+ if not candidates:
+ return ''
+
+ # Sort candidates by version number
+ sorted_candidates = sorted(
+ candidates,
+ key=lambda x: tuple(map(int, splitext(basename(x))[0].split('_')[-1][2:]))
+ )
+
+ # Return the candidate with the highest version number
+ return sorted_candidates[-1]
diff --git a/pylint/testutils/lint_module_test.py b/pylint/testutils/lint_module_test.py
index 646c8986f..d9877e617 100644
--- a/pylint/testutils/lint_module_test.py
+++ b/pylint/testutils/lint_module_test.py
@@ -90,7 +90,18 @@ class LintModuleTest:
:returns: A dict mapping line,msg-symbol tuples to the count on this line.
:rtype: dict
"""
- pass
+ messages = Counter()
+ for lineno, line in enumerate(stream, start=1):
+ match = _EXPECTED_RE.search(line)
+ if match:
+ line = match.group('line')
+ if line is None:
+ line = lineno
+ else:
+ line = int(line)
+ msg_id = match.group('msg_id')
+ messages[(line, msg_id)] += 1
+ return messages
@staticmethod
def multiset_difference(expected_entries: MessageCounter,
@@ -100,11 +111,29 @@ class LintModuleTest:
A multiset is a dict with the cardinality of the key as the value.
"""
- pass
+ missing = Counter()
+ unexpected = {}
+ for key, count in expected_entries.items():
+ if actual_entries[key] < count:
+ missing[key] = count - actual_entries[key]
+ for key, count in actual_entries.items():
+ if expected_entries[key] < count:
+ unexpected[key] = count - expected_entries[key]
+ return missing, unexpected
def _check_output_text(self, _: MessageCounter, expected_output: list[
OutputLine], actual_output: list[OutputLine]) ->None:
"""This is a function because we want to be able to update the text in
LintModuleOutputUpdate.
"""
- pass
+ if expected_output != actual_output:
+ diff = '\n'.join(
+ difflib.unified_diff(
+ [str(l) for l in expected_output],
+ [str(l) for l in actual_output],
+ fromfile='expected',
+ tofile='actual',
+ n=0,
+ )
+ )
+ pytest.fail(f'\n{diff}')
diff --git a/pylint/testutils/output_line.py b/pylint/testutils/output_line.py
index 50d52257c..3e7a319a7 100644
--- a/pylint/testutils/output_line.py
+++ b/pylint/testutils/output_line.py
@@ -35,19 +35,32 @@ class OutputLine(NamedTuple):
@classmethod
def from_msg(cls, msg: Message, check_endline: bool=True) ->OutputLine:
"""Create an OutputLine from a Pylint Message."""
- pass
+ return cls(
+ symbol=msg.symbol,
+ lineno=msg.line,
+ column=cls._get_column(msg.column),
+ end_lineno=cls._get_py38_none_value(msg.end_line, check_endline),
+ end_column=cls._get_py38_none_value(msg.end_column, check_endline),
+ object=msg.obj or "",
+ msg=msg.msg or "",
+ confidence=msg.confidence.name
+ )
@staticmethod
def _get_column(column: (str | int)) ->int:
"""Handle column numbers."""
- pass
+ if isinstance(column, str):
+ return int(column)
+ return column or 0
@staticmethod
def _get_py38_none_value(value: _T, check_endline: bool) ->(_T | None):
"""Used to make end_line and end_column None as indicated by our version
compared to `min_pyver_end_position`.
"""
- pass
+ if check_endline:
+ return value
+ return None
@classmethod
def from_csv(cls, row: (Sequence[str] | str), check_endline: bool=True
@@ -55,15 +68,38 @@ class OutputLine(NamedTuple):
"""Create an OutputLine from a comma separated list (the functional tests
expected output .txt files).
"""
- pass
+ if isinstance(row, str):
+ row = row.split(',')
+
+ return cls(
+ symbol=row[0],
+ lineno=int(row[1]),
+ column=cls._get_column(row[2]),
+ end_lineno=cls._get_py38_none_value(cls._value_to_optional_int(row[3]), check_endline),
+ end_column=cls._get_py38_none_value(cls._value_to_optional_int(row[4]), check_endline),
+ object=row[5],
+ msg=row[6],
+ confidence=row[7]
+ )
def to_csv(self) ->tuple[str, str, str, str, str, str, str, str]:
"""Convert an OutputLine to a tuple of string to be written by a
csv-writer.
"""
- pass
+ return (
+ self.symbol,
+ str(self.lineno),
+ str(self.column),
+ str(self.end_lineno) if self.end_lineno is not None else '',
+ str(self.end_column) if self.end_column is not None else '',
+ self.object,
+ self.msg,
+ self.confidence
+ )
@staticmethod
def _value_to_optional_int(value: (str | None)) ->(int | None):
"""Checks if a (stringified) value should be None or a Python integer."""
- pass
+ if value is None or value == '':
+ return None
+ return int(value)
diff --git a/pylint/testutils/pyreverse.py b/pylint/testutils/pyreverse.py
index f9eeb3f8c..96e2fb655 100644
--- a/pylint/testutils/pyreverse.py
+++ b/pylint/testutils/pyreverse.py
@@ -58,7 +58,22 @@ class FunctionalPyreverseTestfile(NamedTuple):
options: TestFileOptions
-def get_functional_test_files(root_directory: Path) ->list[
- FunctionalPyreverseTestfile]:
+def get_functional_test_files(root_directory: Path) -> list[FunctionalPyreverseTestfile]:
"""Get all functional test files from the given directory."""
- pass
+ functional_test_files = []
+ for source_file in root_directory.rglob('*.py'):
+ if source_file.name.startswith('func_'):
+ config_file = source_file.with_suffix('.rc')
+ if config_file.exists():
+ config = configparser.ConfigParser()
+ config.read(config_file)
+
+ options = TestFileOptions(
+ source_roots=config.get('testoptions', 'source_roots', fallback='').split(','),
+ output_formats=config.get('testoptions', 'output_formats', fallback='').split(','),
+ command_line_args=shlex.split(config.get('testoptions', 'command_line_args', fallback=''))
+ )
+
+ functional_test_files.append(FunctionalPyreverseTestfile(source=source_file, options=options))
+
+ return functional_test_files
diff --git a/pylint/testutils/reporter_for_tests.py b/pylint/testutils/reporter_for_tests.py
index 194c5b93e..60564b4c6 100644
--- a/pylint/testutils/reporter_for_tests.py
+++ b/pylint/testutils/reporter_for_tests.py
@@ -18,11 +18,11 @@ class GenericTestReporter(BaseReporter):
def handle_message(self, msg: Message) ->None:
"""Append messages to the list of messages of the reporter."""
- pass
+ self.out.write(f"{msg.path[len(self.path_strip_prefix):]}:{msg.line}: {msg.symbol} {msg.msg}\n")
def finalize(self) ->str:
"""Format and print messages in the context of the path."""
- pass
+ return self.out.getvalue()
def display_reports(self, layout: Section) ->None:
"""Ignore layouts."""
@@ -30,7 +30,15 @@ class GenericTestReporter(BaseReporter):
class MinimalTestReporter(BaseReporter):
- pass
+ def __init__(self) ->None:
+ super().__init__()
+ self.messages: list[Message] = []
+
+ def handle_message(self, msg: Message) ->None:
+ self.messages.append(msg)
+
+ def finalize(self) ->None:
+ pass
class FunctionalTestReporter(BaseReporter):
diff --git a/pylint/testutils/unittest_linter.py b/pylint/testutils/unittest_linter.py
index e3aec6085..fe685a61d 100644
--- a/pylint/testutils/unittest_linter.py
+++ b/pylint/testutils/unittest_linter.py
@@ -18,4 +18,14 @@ class UnittestLinter(PyLinter):
None)=None, col_offset: (int | None)=None, end_lineno: (int | None)
=None, end_col_offset: (int | None)=None) ->None:
"""Add a MessageTest to the _messages attribute of the linter class."""
- pass
+ message = MessageTest(
+ msg_id=msgid,
+ line=line,
+ node=node,
+ args=args,
+ confidence=confidence or UNDEFINED,
+ col=col_offset,
+ end_line=end_lineno,
+ end_col=end_col_offset,
+ )
+ self._messages.append(message)
diff --git a/pylint/testutils/utils.py b/pylint/testutils/utils.py
index 8ca619cfa..230a68b58 100644
--- a/pylint/testutils/utils.py
+++ b/pylint/testutils/utils.py
@@ -11,7 +11,15 @@ from typing import TextIO
@contextlib.contextmanager
def _patch_streams(out: TextIO) ->Iterator[None]:
"""Patch and subsequently reset a text stream."""
- pass
+ old_stdout = sys.stdout
+ old_stderr = sys.stderr
+ sys.stdout = out
+ sys.stderr = out
+ try:
+ yield
+ finally:
+ sys.stdout = old_stdout
+ sys.stderr = old_stderr
def create_files(paths: list[str], chroot: str='.') ->None:
@@ -33,4 +41,10 @@ def create_files(paths: list[str], chroot: str='.') ->None:
>>> isfile('/tmp/a/b/foo.py')
True
"""
- pass
+ for path in paths:
+ full_path = Path(chroot) / path
+ if path.endswith('/'):
+ full_path.mkdir(parents=True, exist_ok=True)
+ else:
+ full_path.parent.mkdir(parents=True, exist_ok=True)
+ full_path.touch()
diff --git a/pylint/utils/ast_walker.py b/pylint/utils/ast_walker.py
index 8872be9e0..5f4e2c841 100644
--- a/pylint/utils/ast_walker.py
+++ b/pylint/utils/ast_walker.py
@@ -24,10 +24,30 @@ class ASTWalker:
def add_checker(self, checker: BaseChecker) ->None:
"""Walk to the checker's dir and collect visit and leave methods."""
- pass
+ for member in dir(checker):
+ if member.startswith('visit_'):
+ self.visit_events[member[6:]].append(getattr(checker, member))
+ elif member.startswith('leave_'):
+ self.leave_events[member[6:]].append(getattr(checker, member))
def walk(self, astroid: nodes.NodeNG) ->None:
"""Call visit events of astroid checkers for the given node, recurse on
its children, then leave events.
"""
- pass
+ try:
+ callbacks = self.visit_events[astroid.__class__.__name__]
+ for cb in callbacks:
+ cb(astroid)
+
+ for child in astroid.get_children():
+ self.walk(child)
+
+ callbacks = self.leave_events[astroid.__class__.__name__]
+ for cb in callbacks:
+ cb(astroid)
+ except Exception:
+ if not self.exception_msg:
+ self.exception_msg = True
+ exc_info = sys.exc_info()
+ traceback.print_exception(*exc_info)
+ self.linter.add_message('astroid-error', args=str(exc_info[1]))
diff --git a/pylint/utils/docs.py b/pylint/utils/docs.py
index 69b539e48..baebab595 100644
--- a/pylint/utils/docs.py
+++ b/pylint/utils/docs.py
@@ -10,21 +10,63 @@ if TYPE_CHECKING:
def _get_checkers_infos(linter: PyLinter) ->dict[str, dict[str, Any]]:
"""Get info from a checker and handle KeyError."""
- pass
+ checkers_infos = {}
+ for checker in linter.get_checkers():
+ name = checker.name
+ try:
+ checkers_infos[name] = {
+ "name": name,
+ "options": list(checker.options),
+ "msgs": dict(checker.msgs),
+ "reports": list(checker.reports),
+ }
+ except KeyError:
+ # Ignore checkers without options or messages
+ continue
+ return checkers_infos
def _get_global_options_documentation(linter: PyLinter) ->str:
"""Get documentation for the main checker."""
- pass
+ result = []
+ for checker in linter.get_checkers():
+ if checker.name == MAIN_CHECKER_NAME:
+ result.append(get_rst_title("Global options", "-"))
+ result.extend(checker.options_and_values())
+ break
+ return "\n".join(result)
def _get_checkers_documentation(linter: PyLinter, show_options: bool=True
) ->str:
"""Get documentation for individual checkers."""
- pass
+ result = []
+ for checker in sorted(linter.get_checkers(), key=lambda x: x.name):
+ if checker.name == MAIN_CHECKER_NAME:
+ continue
+ result.append(get_rst_title(checker.name.capitalize(), "~"))
+ if checker.options and show_options:
+ result.append("Options:")
+ result.append("--------")
+ result.extend(checker.options_and_values())
+ result.append("")
+ if checker.msgs:
+ result.append("Messages:")
+ result.append("---------")
+ for message in sorted(checker.msgs.values(), key=lambda x: x.msgid):
+ result.append(f"{message.msgid} ({message.symbol}): {message.msg}")
+ result.append("")
+ return "\n".join(result)
def print_full_documentation(linter: PyLinter, stream: TextIO=sys.stdout,
show_options: bool=True) ->None:
"""Output a full documentation in ReST format."""
- pass
+ stream.write(get_rst_title("Pylint Global Options and Switches", "="))
+ stream.write("\n")
+ stream.write(_get_global_options_documentation(linter))
+ stream.write("\n\n")
+ stream.write(get_rst_title("Pylint checkers' options and switches", "="))
+ stream.write("\n")
+ stream.write(_get_checkers_documentation(linter, show_options))
+ stream.write("\n")
diff --git a/pylint/utils/file_state.py b/pylint/utils/file_state.py
index 91b309b26..4bfa2cb0f 100644
--- a/pylint/utils/file_state.py
+++ b/pylint/utils/file_state.py
@@ -39,22 +39,49 @@ class FileState:
"""Recursively walk (depth first) AST to collect block level options
line numbers and set the state correctly.
"""
- pass
+ first_child = None
+ if isinstance(node, nodes.Module):
+ first_child = node.body[0] if node.body else None
+ elif isinstance(node, nodes.FunctionDef):
+ first_child = node.body[0] if node.body else None
+ elif isinstance(node, nodes.ClassDef):
+ first_child = node.body[0] if node.body else None
+
+ if first_child:
+ self._set_message_state_in_block(msg, msg_state, node, first_child.lineno)
+
+ for child in node.get_children():
+ self._set_state_on_block_lines(msgs_store, child, msg, msg_state)
def _set_message_state_in_block(self, msg: MessageDefinition, lines:
dict[int, bool], node: nodes.NodeNG, firstchildlineno: int) ->None:
"""Set the state of a message in a block of lines."""
- pass
+ start = node.fromlineno
+ end = node.tolineno
+ for line in range(start, firstchildlineno):
+ self._set_message_state_on_line(msg, line, lines.get(start, True), start)
+ for line in range(firstchildlineno, end + 1):
+ self._set_message_state_on_line(msg, line, lines.get(line, True), line)
def _set_message_state_on_line(self, msg: MessageDefinition, line: int,
state: bool, original_lineno: int) ->None:
"""Set the state of a message on a line."""
- pass
+ msg_id = msg.msgid
+ if msg_id not in self._module_msgs_state:
+ self._module_msgs_state[msg_id] = {}
+ self._module_msgs_state[msg_id][line] = state
+ self._raw_module_msgs_state[msg_id][original_lineno] = state
def set_msg_status(self, msg: MessageDefinition, line: int, status:
bool, scope: str='package') ->None:
"""Set status (enabled/disable) for a given message at a given line."""
- pass
+ assert line > 0
+
+ if scope != 'package':
+ self._set_message_state_on_line(msg, line, status, line)
+
+ if self._module and not self._is_base_filestate:
+ self._set_state_on_block_lines(self._msgs_store, self._module, msg, {line: status})
def handle_ignored_message(self, state_scope: (Literal[0, 1, 2] | None),
msgid: str, line: (int | None)) ->None:
@@ -64,4 +91,12 @@ class FileState:
depending on whether the message was disabled locally in the module,
or globally.
"""
- pass
+ if state_scope == MSG_STATE_SCOPE_MODULE:
+ if line in self._suppression_mapping:
+ self._suppression_mapping[(msgid, line)] = self._suppression_mapping.pop(line)
+ else:
+ self._suppression_mapping[(msgid, line)] = line
+
+ if line is None:
+ line = 0
+ self._ignored_msgs[(msgid, line)].add(state_scope)
diff --git a/pylint/utils/linterstats.py b/pylint/utils/linterstats.py
index 3950c7b35..c87f2a5c9 100644
--- a/pylint/utils/linterstats.py
+++ b/pylint/utils/linterstats.py
@@ -122,81 +122,131 @@ class LinterStats:
"""Use through PyLinter.set_current_module so PyLinter.current_name is
consistent.
"""
- pass
+ self.by_module[module_name] = ModuleStats(convention=0, error=0, fatal=0, info=0, refactor=0, statement=0, warning=0)
def get_bad_names(self, node_name: Literal['argument', 'attr', 'class',
'class_attribute', 'class_const', 'const', 'inlinevar', 'function',
'method', 'module', 'variable', 'typevar', 'typealias']) ->int:
"""Get a bad names node count."""
- pass
+ return self.bad_names[node_name]
def increase_bad_name(self, node_name: str, increase: int) ->None:
"""Increase a bad names node count."""
- pass
+ self.bad_names[node_name] += increase
def reset_bad_names(self) ->None:
"""Resets the bad_names attribute."""
- pass
+ self.bad_names = BadNames(argument=0, attr=0, klass=0, class_attribute=0, class_const=0, const=0, inlinevar=0,
+ function=0, method=0, module=0, variable=0, typevar=0, typealias=0)
def get_code_count(self, type_name: Literal['code', 'comment',
'docstring', 'empty', 'total']) ->int:
"""Get a code type count."""
- pass
+ return self.code_type_count[type_name]
def reset_code_count(self) ->None:
"""Resets the code_type_count attribute."""
- pass
+ self.code_type_count = CodeTypeCount(code=0, comment=0, docstring=0, empty=0, total=0)
def reset_duplicated_lines(self) ->None:
"""Resets the duplicated_lines attribute."""
- pass
+ self.duplicated_lines = DuplicatedLines(nb_duplicated_lines=0, percent_duplicated_lines=0.0)
def get_node_count(self, node_name: Literal['function', 'class',
'method', 'module']) ->int:
"""Get a node count while handling some extra conditions."""
- pass
+ return self.node_count[node_name]
def reset_node_count(self) ->None:
"""Resets the node count attribute."""
- pass
+ self.node_count = NodeCount(function=0, klass=0, method=0, module=0)
def get_undocumented(self, node_name: Literal['function', 'class',
'method', 'module']) ->float:
"""Get a undocumented node count."""
- pass
+ return self.undocumented[node_name]
def reset_undocumented(self) ->None:
"""Resets the undocumented attribute."""
- pass
+ self.undocumented = UndocumentedNodes(function=0, klass=0, method=0, module=0)
def get_global_message_count(self, type_name: str) ->int:
"""Get a global message count."""
- pass
+ return getattr(self, type_name)
def get_module_message_count(self, modname: str, type_name:
MessageTypesFullName) ->int:
"""Get a module message count."""
- pass
+ return self.by_module.get(modname, {}).get(type_name, 0)
def increase_single_message_count(self, type_name: str, increase: int
) ->None:
"""Increase the message type count of an individual message type."""
- pass
+ setattr(self, type_name, getattr(self, type_name) + increase)
def increase_single_module_message_count(self, modname: str, type_name:
MessageTypesFullName, increase: int) ->None:
"""Increase the message type count of an individual message type of a
module.
"""
- pass
+ if modname not in self.by_module:
+ self.init_single_module(modname)
+ self.by_module[modname][type_name] += increase
def reset_message_count(self) ->None:
"""Resets the message type count of the stats object."""
- pass
+ self.convention = 0
+ self.error = 0
+ self.fatal = 0
+ self.info = 0
+ self.refactor = 0
+ self.warning = 0
+ self.by_module.clear()
def merge_stats(stats: list[LinterStats]) ->LinterStats:
"""Used to merge multiple stats objects into a new one when pylint is run in
parallel mode.
"""
- pass
+ merged = LinterStats()
+ for stat in stats:
+ for attr, value in stat.bad_names.items():
+ merged.bad_names[attr] += value
+ for modname, mod_stats in stat.by_module.items():
+ if modname not in merged.by_module:
+ merged.by_module[modname] = ModuleStats(**mod_stats)
+ else:
+ for key, value in mod_stats.items():
+ merged.by_module[modname][key] += value
+ for msg, count in stat.by_msg.items():
+ merged.by_msg[msg] = merged.by_msg.get(msg, 0) + count
+ for key, value in stat.code_type_count.items():
+ merged.code_type_count[key] += value
+ for dep, deps in stat.dependencies.items():
+ if dep not in merged.dependencies:
+ merged.dependencies[dep] = deps.copy()
+ else:
+ merged.dependencies[dep].update(deps)
+ merged.duplicated_lines['nb_duplicated_lines'] += stat.duplicated_lines['nb_duplicated_lines']
+ merged.duplicated_lines['percent_duplicated_lines'] += stat.duplicated_lines['percent_duplicated_lines']
+ for key, value in stat.node_count.items():
+ merged.node_count[key] += value
+ for key, value in stat.undocumented.items():
+ merged.undocumented[key] += value
+ merged.convention += stat.convention
+ merged.error += stat.error
+ merged.fatal += stat.fatal
+ merged.info += stat.info
+ merged.refactor += stat.refactor
+ merged.statement += stat.statement
+ merged.warning += stat.warning
+ merged.global_note += stat.global_note
+ merged.nb_duplicated_lines += stat.nb_duplicated_lines
+ merged.percent_duplicated_lines += stat.percent_duplicated_lines
+
+ # Calculate average for percent_duplicated_lines
+ if stats:
+ merged.percent_duplicated_lines /= len(stats)
+ merged.duplicated_lines['percent_duplicated_lines'] /= len(stats)
+
+ return merged
diff --git a/pylint/utils/utils.py b/pylint/utils/utils.py
index 12fbd9948..f20171c1a 100644
--- a/pylint/utils/utils.py
+++ b/pylint/utils/utils.py
@@ -43,7 +43,8 @@ T_GlobalOptionReturnTypes = TypeVar('T_GlobalOptionReturnTypes', bool, int,
def normalize_text(text: str, line_len: int=DEFAULT_LINE_LENGTH, indent: str=''
) ->str:
"""Wrap the text on the given line length."""
- pass
+ lines = textwrap.wrap(text, width=line_len)
+ return '\n'.join(indent + line for line in lines)
CMPS = ['=', '-', '+']
@@ -51,32 +52,68 @@ CMPS = ['=', '-', '+']
def diff_string(old: float, new: float) ->str:
"""Given an old and new value, return a string representing the difference."""
- pass
+ diff = new - old
+ if diff == 0:
+ return '='
+ sign = '+' if diff > 0 else '-'
+ return f"{sign}{abs(diff):.2f}"
def get_module_and_frameid(node: nodes.NodeNG) ->tuple[str, str]:
"""Return the module name and the frame id in the module."""
- pass
+ frame = node.frame()
+ module = node.root()
+ name = module.name
+ if isinstance(frame, Module):
+ return name, '0'
+ return name, f"{frame.lineno}.{frame.col_offset}"
def get_rst_title(title: str, character: str) ->str:
"""Permit to get a title formatted as ReStructuredText test (underlined with a
chosen character).
"""
- pass
+ return f"{title}\n{character * len(title)}"
def get_rst_section(section: (str | None), options: list[tuple[str,
OptionDict, Any]], doc: (str | None)=None) ->str:
"""Format an option's section using as a ReStructuredText formatted output."""
- pass
+ result = []
+ if section:
+ result.append(get_rst_title(section, "="))
+ if doc:
+ result.append(normalize_text(doc))
+ result.append("\n")
+ for optname, optdict, value in options:
+ help_text = optdict.get("help")
+ result.append(f":{optname}:")
+ if help_text:
+ result.append(normalize_text(help_text, indent=" "))
+ if value:
+ result.append(f" Default: ``{value}``")
+ result.append("")
+ return "\n".join(result)
def register_plugins(linter: PyLinter, directory: str) ->None:
"""Load all module and package in the given directory, looking for a
'register' function in each one, used to register pylint checkers.
"""
- pass
+ imported_modules = []
+ for filename in os.listdir(directory):
+ name, ext = os.path.splitext(filename)
+ if ext in PY_EXTS and name != '__init__':
+ module_path = os.path.join(directory, filename)
+ spec = modutils.file_from_modpath([module_path])
+ if spec is None:
+ continue
+ module = modutils.load_module_from_file(spec.loader.get_filename())
+ imported_modules.append(module)
+
+ for module in imported_modules:
+ if hasattr(module, 'register'):
+ module.register(linter)
def _splitstrip(string: str, sep: str=',') ->list[str]:
@@ -99,7 +136,7 @@ def _splitstrip(string: str, sep: str=',') ->list[str]:
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
- pass
+ return [s.strip() for s in string.split(sep) if s.strip()]
def _unquote(string: str) ->str:
@@ -108,14 +145,18 @@ def _unquote(string: str) ->str:
:param string: an optionally quoted string
:return: the unquoted string (or the input string if it wasn't quoted)
"""
- pass
+ if len(string) > 2 and string[0] == string[-1] and string[0] in '"\'':
+ return string[1:-1]
+ return string
def _check_regexp_csv(value: (list[str] | tuple[str] | str)) ->Iterable[str]:
"""Split a comma-separated list of regexps, taking care to avoid splitting
a regex employing a comma as quantifier, as in `\\d{1,2}`.
"""
- pass
+ if isinstance(value, str):
+ value = _splitstrip(value)
+ return [_unquote(v) for v in value]
def _comment(string: str) ->str: