Add support for per-directory configuration files

- Create additional Namespaces for subdirectories with configuration files
- Open checkers per-file, so they use values from local config during opening

Author: Aleksey Petryankin

pylint/config/arguments_manager.py

@@ -81,6 +81,9 @@ def __init__(
         self._directory_namespaces: DirectoryNamespaceDict = {}
         """Mapping of directories and their respective namespace objects."""
 
+        self._cli_args: list[str] = []
+        """Options that were passed as command line arguments and have highest priority."""
+
     @property
     def config(self) -> argparse.Namespace:
         """Namespace for all options."""
@@ -226,6 +229,8 @@ def _parse_command_line_configuration(
     ) -> list[str]:
         """Parse the arguments found on the command line into the namespace."""
         arguments = sys.argv[1:] if arguments is None else arguments
+        if not self._cli_args:
+            self._cli_args = list(arguments)
 
         self.config, parsed_args = self._arg_parser.parse_known_args(
             arguments, self.config

pylint/config/config_initialization.py

@@ -23,6 +23,7 @@
     from pylint.lint import PyLinter
 
 
+# pylint: disable = too-many-statements
 def _config_initialization(
     linter: PyLinter,
     args_list: list[str],
@@ -141,7 +142,8 @@ def _config_initialization(
     linter._parse_error_mode()
 
     # Link the base Namespace object on the current directory
-    linter._directory_namespaces[Path(".").resolve()] = (linter.config, {})
+    if Path(".").resolve() not in linter._directory_namespaces:
+        linter._directory_namespaces[Path(".").resolve()] = (linter.config, {})
 
     # parsed_args_list should now only be a list of inputs to lint.
     # All other options have been removed from the list.

pylint/config/find_default_config_files.py

@@ -64,17 +64,19 @@ def _cfg_has_config(path: Path | str) -> bool:
     return any(section.startswith("pylint.") for section in parser.sections())
 
 
-def _yield_default_files() -> Iterator[Path]:
+def _yield_default_files(basedir: Path | str = ".") -> Iterator[Path]:
     """Iterate over the default config file names and see if they exist."""
+    basedir = Path(basedir)
     for config_name in CONFIG_NAMES:
+        config_file = basedir / config_name
         try:
-            if config_name.is_file():
-                if config_name.suffix == ".toml" and not _toml_has_config(config_name):
+            if config_file.is_file():
+                if config_file.suffix == ".toml" and not _toml_has_config(config_file):
                     continue
-                if config_name.suffix == ".cfg" and not _cfg_has_config(config_name):
+                if config_file.suffix == ".cfg" and not _cfg_has_config(config_file):
                     continue
 
-                yield config_name.resolve()
+                yield config_file.resolve()
         except OSError:
             pass
 
@@ -142,3 +144,8 @@ def find_default_config_files() -> Iterator[Path]:
             yield Path("/etc/pylintrc").resolve()
     except OSError:
         pass
+
+
+def find_subdirectory_config_files(basedir: Path | str) -> Iterator[Path]:
+    """Find config file in arbitrary subdirectory."""
+    yield from _yield_default_files(basedir)

pylint/lint/base_options.py

@@ -414,6 +414,25 @@ def _make_linter_options(linter: PyLinter) -> Options:
                 "Useful if running pylint in a server-like mode.",
             },
         ),
+        (
+            "use-local-configs",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "When some of the linted files or modules have pylint config in the same directory, "
+                "use their local configs for checking these files.",
+            },
+        ),
+        (
+            "use-parent-configs",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Search for local pylint configs up until current working directory or root.",
+            },
+        ),
     )
 
 

pylint/lint/pylinter.py

@@ -7,6 +7,7 @@
 import argparse
 import collections
 import contextlib
+import copy
 import functools
 import os
 import sys
@@ -26,6 +27,8 @@
 from pylint import checkers, exceptions, interfaces, reporters
 from pylint.checkers.base_checker import BaseChecker
 from pylint.config.arguments_manager import _ArgumentsManager
+from pylint.config.config_initialization import _config_initialization
+from pylint.config.find_default_config_files import find_subdirectory_config_files
 from pylint.constants import (
     MAIN_CHECKER_NAME,
     MSG_TYPES,
@@ -615,6 +618,43 @@ def initialize(self) -> None:
             if not msg.may_be_emitted(self.config.py_version):
                 self._msgs_state[msg.msgid] = False
 
+    def register_local_config(self, file_or_dir: str) -> None:
+        if os.path.isdir(file_or_dir):
+            basedir = Path(file_or_dir)
+        else:
+            basedir = Path(os.path.dirname(file_or_dir))
+
+        if self.config.use_parent_configs is False:
+            # exit loop after first iteration
+            scan_root_dir = basedir
+        elif _is_relative_to(basedir, Path(os.getcwd())):
+            scan_root_dir = Path(os.getcwd())
+        else:
+            scan_root_dir = Path("/")
+
+        while basedir.resolve() not in self._directory_namespaces and _is_relative_to(
+            basedir, scan_root_dir
+        ):
+            local_conf = next(find_subdirectory_config_files(basedir), None)
+            if local_conf is not None:
+                # in order to avoid creating new PyLinter objects, _config_initialization modifies
+                # existing self.config, so we need to save original self.config to restore it later
+                original_config_ref = self.config
+                self.config = copy.deepcopy(self.config)
+                _config_initialization(self, self._cli_args, config_file=local_conf)
+                self._directory_namespaces[basedir.resolve()] = (self.config, {})
+                # keep dict keys reverse-sorted so that
+                # iteration over keys in _get_namespace_for_file gets the most nested path first
+                self._directory_namespaces = dict(
+                    sorted(self._directory_namespaces.items(), reverse=True)
+                )
+                self.config = original_config_ref
+                break
+            if basedir.parent != basedir:
+                basedir = basedir.parent
+            else:
+                break
+
     def _discover_files(self, files_or_modules: Sequence[str]) -> Iterator[str]:
         """Discover python modules and packages in sub-directory.
 
@@ -665,12 +705,12 @@ def check(self, files_or_modules: Sequence[str]) -> None:
                     "Missing filename required for --from-stdin"
                 )
 
-        extra_packages_paths = list(
-            {
+        extra_packages_paths_set = set()
+        for file_or_module in files_or_modules:
+            extra_packages_paths_set.add(
                 discover_package_path(file_or_module, self.config.source_roots)
-                for file_or_module in files_or_modules
-            }
-        )
+            )
+        extra_packages_paths = list(extra_packages_paths_set)
 
         # TODO: Move the parallel invocation into step 3 of the checking process
         if not self.config.from_stdin and self.config.jobs > 1:
@@ -693,14 +733,16 @@ def check(self, files_or_modules: Sequence[str]) -> None:
                 fileitems = self._iterate_file_descrs(files_or_modules)
                 data = None
 
-        # The contextmanager also opens all checkers and sets up the PyLinter class
         with augmented_sys_path(extra_packages_paths):
-            with self._astroid_module_checker() as check_astroid_module:
-                # 2) Get the AST for each FileItem
-                ast_per_fileitem = self._get_asts(fileitems, data)
-
-                # 3) Lint each ast
-                self._lint_files(ast_per_fileitem, check_astroid_module)
+            # 2) Get the AST for each FileItem
+            ast_per_fileitem = self._get_asts(fileitems, data)
+            # 3) Lint each ast
+            if self.config.use_local_configs is False:
+                # The contextmanager also opens all checkers and sets up the PyLinter class
+                with self._astroid_module_checker() as check_astroid_module:
+                    self._lint_files(ast_per_fileitem, check_astroid_module)
+            else:
+                self._lint_files(ast_per_fileitem, None)
 
     def _get_asts(
         self, fileitems: Iterator[FileItem], data: str | None
@@ -710,6 +752,7 @@ def _get_asts(
 
         for fileitem in fileitems:
             self.set_current_module(fileitem.name, fileitem.filepath)
+            self._set_astroid_options()
 
             try:
                 ast_per_fileitem[fileitem] = self.get_ast(
@@ -741,7 +784,7 @@ def check_single_file_item(self, file: FileItem) -> None:
     def _lint_files(
         self,
         ast_mapping: dict[FileItem, nodes.Module | None],
-        check_astroid_module: Callable[[nodes.Module], bool | None],
+        check_astroid_module: Callable[[nodes.Module], bool | None] | None,
     ) -> None:
         """Lint all AST modules from a mapping.."""
         for fileitem, module in ast_mapping.items():
@@ -765,7 +808,7 @@ def _lint_file(
         self,
         file: FileItem,
         module: nodes.Module,
-        check_astroid_module: Callable[[nodes.Module], bool | None],
+        check_astroid_module: Callable[[nodes.Module], bool | None] | None,
     ) -> None:
         """Lint a file using the passed utility function check_astroid_module).
 
@@ -784,7 +827,13 @@ def _lint_file(
         self.current_file = module.file
 
         try:
-            check_astroid_module(module)
+            # call _astroid_module_checker after set_current_module, when
+            # self.config is the right config for current module
+            if check_astroid_module is None:
+                with self._astroid_module_checker() as local_check_astroid_module:
+                    local_check_astroid_module(module)
+            else:
+                check_astroid_module(module)
         except Exception as e:
             raise astroid.AstroidError from e
 
@@ -907,7 +956,8 @@ def set_current_module(self, modname: str, filepath: str | None = None) -> None:
         self.stats.init_single_module(modname or "")
 
         # If there is an actual filepath we might need to update the config attribute
-        if filepath:
+        if filepath and self.config.use_local_configs:
+            self.register_local_config(filepath)
             namespace = self._get_namespace_for_file(
                 Path(filepath), self._directory_namespaces
             )
@@ -917,6 +967,7 @@ def set_current_module(self, modname: str, filepath: str | None = None) -> None:
     def _get_namespace_for_file(
         self, filepath: Path, namespaces: DirectoryNamespaceDict
     ) -> argparse.Namespace | None:
+        filepath = filepath.resolve()
         for directory in namespaces:
             if _is_relative_to(filepath, directory):
                 namespace = self._get_namespace_for_file(
@@ -1068,16 +1119,19 @@ def _check_astroid_module(
         walker.walk(node)
         return True
 
-    def open(self) -> None:
-        """Initialize counters."""
+    def _set_astroid_options(self) -> None:
+        """Pass some config values to astroid.MANAGER object."""
         MANAGER.always_load_extensions = self.config.unsafe_load_any_extension
         MANAGER.max_inferable_values = self.config.limit_inference_results
         MANAGER.extension_package_whitelist.update(self.config.extension_pkg_allow_list)
         if self.config.extension_pkg_whitelist:
             MANAGER.extension_package_whitelist.update(
                 self.config.extension_pkg_whitelist
             )
-        self.stats.reset_message_count()
+
+    def open(self) -> None:
+        """Initialize self as main checker for one or more modules."""
+        self._set_astroid_options()
 
     def generate_reports(self, verbose: bool = False) -> int | None:
         """Close the whole package /module, it's time to make reports !