file-groups 0.2.1__tar.gz → 0.3.1__tar.gz

{file_groups-0.2.1 → file_groups-0.3.1}/.copier-answers.yml

@@ -1,5 +1,5 @@
 # Changes here will be overwritten by Copier
-_commit: bbb7699
+_commit: 1ddef8a
 _src_path: git@github.com:lhupfeldt/copier_python_package_template.git
 author_email: lhn@hupfeldtit.dk
 author_name: Lars Hupfeldt Nielsen
@@ -11,5 +11,6 @@ description: Group files into 'protect' and 'work_on' and provide operations for
 git_repo_url: https://github.com/lhupfeldt/file_groups.git
 github_organization: lhupfeldt
 legal_entity: ApS
+local_devel_dependency: ''
 module_name: file_groups
 package_name: file_groups

{file_groups-0.2.1 → file_groups-0.3.1}/.gitignore

@@ -1,5 +1,5 @@
 *~
-*.pyc
+*.py[cod]
 __pycache__
 .cache
 .coverage
@@ -13,8 +13,10 @@ dist
 .tox
 .nox
 .mypy_cache
+*_flymake.py
+flycheck_*.py
 build
 test/out
 
 # Sphinx
-doc/_build/*
+docs/_build/*

{file_groups-0.2.1 → file_groups-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: file_groups
-Version: 0.2.1
+Version: 0.3.1
 Summary: Group files into 'protect' and 'work_on' and provide operations for safe delete/move and symlink handling.
 Home-page: https://github.com/lhupfeldt/file_groups.git
 Author: Lars Hupfeldt Nielsen
@@ -11,9 +11,10 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst

{file_groups-0.2.1 → file_groups-0.3.1}/file_groups.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: file-groups
-Version: 0.2.1
+Name: file_groups
+Version: 0.3.1
 Summary: Group files into 'protect' and 'work_on' and provide operations for safe delete/move and symlink handling.
 Home-page: https://github.com/lhupfeldt/file_groups.git
 Author: Lars Hupfeldt Nielsen
@@ -11,9 +11,10 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst

{file_groups-0.2.1 → file_groups-0.3.1}/file_groups.egg-info/SOURCES.txt

@@ -47,16 +47,22 @@ test/in/configs/config_files_inherit_global_recursive_ignore_other
 test/in/configs/config_files_inherit_global_recursive_no_other
 test/in/configs/config_files_inherit_ignore_global_recursive
 test/in/configs/config_files_sys_user_and_and_other_dir_config_files_no_global_no_other_recursive
+test/in/configs/config_files_sys_user_config_files_replaced_appdirs
 test/in/configs/file_groups_sys_user_config_files_no_global
 test/in/configs/config_files_inherit_global_recursive/home/file_groups.conf
 test/in/configs/config_files_inherit_global_recursive/sys/file_groups.conf
+test/in/configs/config_files_specified/direct.conf
 test/in/configs/config_files_sys_config_file_no_global/sys/file_groups.conf
+test/in/configs/config_files_sys_user_config_files_additional_appdirs/home/an_app.conf
+test/in/configs/config_files_sys_user_config_files_additional_appdirs/home/file_groups.conf
+test/in/configs/config_files_sys_user_config_files_additional_appdirs/sys/file_groups.conf
 test/in/configs/config_files_sys_user_config_files_no_global/home/file_groups.conf
 test/in/configs/config_files_sys_user_config_files_no_global/sys/file_groups.conf
 test/in/configs/config_files_two_in_same_config_dir/home/.file_groups.conf
 test/in/configs/config_files_two_in_same_config_dir/home/file_groups.conf
 test/in/configs/config_files_unknown_protect_sub_key_config_dir/sys/file_groups.conf
 test/in/configs/config_files_user_config_file_no_global/home/file_groups.conf
+test/in/configs/file_groups_group_dirs_by_config_file_protect/home/file_groups.conf
 test/in/configs/file_groups_group_files_by_config_protect/home/file_groups.conf
 test/in/configs/file_groups_group_files_by_config_protect/sys/file_groups.conf
 test/perf/protect_home_work_on_pictures.py

{file_groups-0.2.1 → file_groups-0.3.1}/noxfile.py

@@ -2,14 +2,16 @@
 
 # Use nox >= 2023.4.22
 
+import os
 from pathlib import Path
+import shutil
 
 import nox
 
 
 _HERE = Path(__file__).absolute().parent
 _TEST_DIR = _HERE/"test"
-_PY_VERSIONS = ["3.12", "3.11", "3.10"]
+_PY_VERSIONS = ['3.13', '3.12', '3.11', '3.10']
 
 nox.options.error_on_missing_interpreters = True
 
@@ -17,17 +19,17 @@ nox.options.error_on_missing_interpreters = True
 @nox.session(python=_PY_VERSIONS, reuse_venv=True)
 def typecheck(session):
     session.install("-e", ".", "mypy>=1.5.1")
-    session.run("mypy", "-v", str(_HERE/"src"))
+    session.run("mypy", str(_HERE/"src"))
 
 
-# TODO: pylint-pytest does not support 3.12
-@nox.session(python="3.11", reuse_venv=True)
+@nox.session(python=_PY_VERSIONS[0], reuse_venv=True)
 def pylint(session):
-    session.install(".", "pylint>=2.16.1,<3.0.0", "pylint-pytest>=1.1.2")
+    session.install(".", "pylint>=3.3.1", "pylint-pytest>=1.1.8")
 
     print("\nPylint src")
     disable_checks = "missing-module-docstring"
     session.run("pylint", "--fail-under", "10", "--disable", disable_checks, str(_HERE/"src"))
+
     print("\nPylint test sources")
     disable_checks += ",missing-class-docstring,missing-function-docstring,multiple-imports,invalid-name,duplicate-code"
     session.run("pylint", "--fail-under", "9.94", "--variable-rgx", r"[a-z_][a-z0-9_]{1,30}$", "--disable", disable_checks, str(_HERE/"test"))
@@ -37,3 +39,12 @@ def pylint(session):
 def unit(session):
     session.install(".", "pytest>=7.4.1", "coverage>=7.3.1", "pytest-cov>=4.1.0")
     session.run("pytest", "--import-mode=append", "--cov", "--cov-report=term-missing", f"--cov-config={_TEST_DIR}/.coveragerc", *session.posargs)
+
+
+@nox.session(python=_PY_VERSIONS[0], reuse_venv=True)
+def build(session):
+    if Path("dist").is_dir():
+        shutil.rmtree("dist")
+    session.install("build>=1.0.3", "twine>=4.0.2")
+    session.run("python", "-m", "build")
+    session.run("python", "-m", "twine", "check", "dist/*")

{file_groups-0.2.1 → file_groups-0.3.1}/pytest.ini

@@ -3,4 +3,4 @@
 [pytest]
 minversion = 7.4.1
 testpaths = test
-norecursedirs = __pycache__ utils perf
+norecursedirs = __pycache__ utils perf docs dist

{file_groups-0.2.1 → file_groups-0.3.1}/setup.cfg

@@ -13,9 +13,10 @@ classifiers =
 	License :: OSI Approved :: BSD License
 	Natural Language :: English
 	Operating System :: OS Independent
-	Programming Language :: Python :: 3.10
-	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.13
 	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.10
 	Topic :: Software Development :: Libraries
 
 [options]

{file_groups-0.2.1 → file_groups-0.3.1}/src/__init__.py

@@ -1,3 +1,5 @@
+"""Set __version__ property."""
+
 from importlib.metadata import version  # type: ignore
 
 

file_groups-0.3.1/src/config_files.py

@@ -0,0 +1,315 @@
+import ast
+import os
+import errno
+import re
+from pathlib import Path
+import itertools
+from pprint import pformat
+import logging
+from dataclasses import dataclass
+from typing import Tuple, Sequence, Any
+
+from appdirs import AppDirs # type: ignore
+
+from .types import FsPath
+
+
+_LOG = logging.getLogger(__name__)
+
+
+class ConfigException(Exception):
+    """Invalid configuration"""
+
+
+@dataclass
+class ProtectConfig():
+    """Hold global (site or user) protect config."""
+    protect_recursive: set[re.Pattern]
+
+    def __json__(self):
+        return {
+            ProtectConfig.__name__: {
+                "protect_recursive": [str(pat) for pat in self.protect_recursive],
+            }
+        }
+
+
+@dataclass
+class DirConfig(ProtectConfig):
+    """Hold directory specific protect config."""
+    protect_local: set[re.Pattern]
+    config_dir: Path|None
+    config_files: list[str]
+
+    def is_protected(self, ff: FsPath):
+        """If ff id protected by a regex pattern then return the pattern, otherwise return None."""
+
+        # _LOG.debug("ff '%s'", ff)
+        for pattern in itertools.chain(self.protect_local, self.protect_recursive):
+            if os.sep in str(pattern):
+                # _LOG.debug("Pattern '%s' has path sep", pattern)
+                assert os.path.isabs(ff), f"Expected absolute path, got '{ff}'"
+
+                # Search against full path
+                if pattern.search(os.fspath(ff)):
+                    return pattern
+
+                # Attempt exact match against path relative to , i.e. if pattern starts with '^'.
+                # This makes sense for patterns specified on commandline
+                cwd = os.getcwd()
+                ff_relative = str(Path(ff).relative_to(cwd))
+                # _LOG.debug("ff '%s' relative to start dir'%s'", ff_relative, cwd)
+
+                if pattern.match(ff_relative):
+                    return pattern
+
+            elif pattern.search(ff.name):
+                return pattern
+
+        return None
+
+    def __json__(self):
+        return {
+            DirConfig.__name__: super().__json__()[ProtectConfig.__name__] | {
+                "protect_local": [str(pat) for pat in self.protect_local],
+                "config_dir": str(self.config_dir),
+                "config_files": self.config_files,
+            }
+        }
+
+
+class ConfigFiles():
+    r"""Handle config files.
+
+    Config files are searched for in the standard config directories on the platform AND in any collected directory.
+
+    The 'app_dirs' default sets default config dirs and config-file names.
+    It is also possible to specify additional or alternative config files specific to the application using this library.
+    Config files must be named after the AppDirs.appname (first argument) as <appname>.conf or .<appname>.conf.
+    The defaults are 'file_groups.conf' and '.file_groups.conf'.
+    You should consider carefully before disabling loading of the default files, as an end user likely wants the protection rules to apply for any
+    application using this library.
+
+    The content of a conf file is a Python dict with the following structure.
+
+        {
+            "file_groups": {  # Required
+                "protect": {  # Optional
+                    "local": [  # Optional
+                        ...  # Regex patterns
+                    ],
+                    "recursive": [  # Optional, merged with parent config dir property
+                        ... # Regex patterns
+                    ]
+                    "global": [  # Optional. Only allowed in config directory files. Merged into collect dir configs 'recursive' property.
+                        ...  # Regex patterns
+                    ],
+                },
+            }
+            ...
+        }
+
+    E.g.:
+
+        {
+            "file_groups": {
+                "protect": {
+                    "recursive": [
+                        r"PP.*\.jpg",  # Don't mess with JPEG files starting with 'PP'.
+                    ]
+                }
+            }
+        }
+
+    The level one key is 'file_groups'.
+    Applications are free to add entries at this level, but not underneath. This is protect against ignored misspelled keys.
+
+    The 'file_groups' entry is a dict with a single 'protect' entry.
+    The 'protect' entry is a dict with at most three entries: 'local', 'recursive' and 'global'. These specify whether a directory specific
+    configuration will inherit and extend the parent (and global) config, or whether it is local to current directory only.
+    The 'local', 'recursive' and 'global' entries are lists of regex patterns to match against collected 'work_on' files.
+    Regexes are checked against the simple file name (i.e. not the full path) unless they contain at least one path separator (os.sep), in
+    which case they are checked against the absolute path.
+    All checks are done as regex *search* (better to protect too much than too little). Write the regex to match the full name or path if needed.
+
+    Note that for security ast.literal_eval is used to interpret the config, so no code is allowed.
+
+    Arguments:
+        protect: An optional sequence of regexes to be added to protect[recursive] for all directories.
+        ignore_config_dirs_config_files: Ignore config files in standard config directories.
+        ignore_per_directory_config_files: Ignore config files in collected directories.
+        remember_configs: Store loaded and merged configs in `per_dir_configs` member variable.
+        app_dirs: Provide your own instance of AppDirs in addition to or as a replacement of the default to add config file names and path.
+            Configuration from later entries have higher precedence.
+            Note that if no AppDirs are specified, no config files will be loaded, neither from config dirs, nor from collected directories.
+            See: https://pypi.org/project/appdirs/
+
+    Members:
+       conf_file_names: File names which are config files.
+       remember_configs: Whether per directory resolved/merged configs are stored in `per_dir_configs`.
+       per_dir_configs: Mapping from dir name to directory specific config dict. Only if remember_configs is True.
+    """
+
+    default_appdirs: AppDirs = AppDirs("file_groups", "Hupfeldt_IT")
+
+    _fg_key = "file_groups"
+    _protect_key = "protect"
+    _valid_dir_protect_scopes = ("local", "recursive")
+    _valid_config_dir_protect_scopes = ("local", "recursive", "global")
+
+    def __init__(  # pylint: disable=too-many-positional-arguments,too-many-arguments
+            self, protect: Sequence[re.Pattern] = (),
+            ignore_config_dirs_config_files=False, ignore_per_directory_config_files=False, remember_configs=True,
+            app_dirs: Sequence[AppDirs]|None = None,
+            *,
+            config_file: Path|None = None,
+        ):
+        super().__init__()
+
+        self._global_config = ProtectConfig(set(protect))
+        self.remember_configs = remember_configs
+        self.per_dir_configs: dict[Path, DirConfig] = {}  # key is abs_dir_path
+        self.ignore_per_directory_config_files = ignore_per_directory_config_files
+
+        app_dirs = app_dirs or (ConfigFiles.default_appdirs,)
+        self.conf_file_name_pairs = tuple((apd.appname + ".conf", "." + apd.appname + ".conf") for apd in app_dirs)
+        _LOG.debug("Conf file names: %s", self.conf_file_name_pairs)
+        self.conf_file_names = list(itertools.chain.from_iterable(self.conf_file_name_pairs))
+
+        self.ignore_config_dirs_config_files = ignore_config_dirs_config_files
+        self.config_dirs = []
+        for appd in app_dirs:
+            self.config_dirs.extend(appd.site_config_dir.split(':'))
+        for appd in app_dirs:
+            self.config_dirs.append(appd.user_config_dir)
+
+        self.config_file = config_file
+
+        # self.default_config_file_example = self.default_config_file.with_suffix('.example.py')
+
+    def _read_and_eval_config_file_for_one_appname(
+            self, conf_dir: Path, conf_file_name_pair: Sequence[str], ignore_config_files: bool
+    ) -> Tuple[dict[str, Any], Path|None]:
+        """Read config file.
+
+        Error if config files are found both with and withput '.' prefix.
+        Return: Config dict, config file name, or if no config files is found, None, None.
+        """
+
+        assert conf_dir.is_absolute()
+        _LOG.debug("Checking for config files %s in directory: %s", conf_file_name_pair, conf_dir)
+
+        match [conf_dir/cfn for cfn in conf_file_name_pair if (conf_dir/cfn).exists()]:
+            case []:
+                _LOG.debug("No config file in directory %s", conf_dir)
+                return {}, None
+
+            case [conf_file]:
+                if ignore_config_files:
+                    _LOG.debug("Ignoring config file: %s", conf_file)
+                    return {}, None
+
+                _LOG.debug("Read config file: %s", conf_file)
+                with open(conf_file, encoding="utf-8") as fh:
+                    new_config = ast.literal_eval(fh.read())
+                _LOG.debug("%s", pformat(new_config))
+                return new_config, conf_file
+
+            case config_files:
+                msg = f"More than one config file in dir '{conf_dir}': {[cf.name for cf in config_files]}."
+                _LOG.debug("%s", msg)
+                raise ConfigException(msg)
+
+    def _read_and_validate_config_file_for_one_appname(
+            self, conf_dir: Path, conf_file_name_pair: Sequence[str], valid_protect_scopes: Tuple[str, ...], ignore_config_files: bool
+    ) -> Tuple[dict[str, set[re.Pattern]], Path|None]:
+        """Read config file, validate keys and compile regexes.
+
+        Error if config files are found both with and withput '.' prefix.
+
+        Return: merged config dict with compiled regexes, config file name. If no config files is found, then return empty sets and None.
+        """
+
+        new_config, conf_file = self._read_and_eval_config_file_for_one_appname(conf_dir, conf_file_name_pair, ignore_config_files)
+        if not new_config:
+            return {
+                "local": set(),
+                "recursive": set(),
+            }, None
+
+        try:
+            protect_conf: dict[str, set[re.Pattern]] = new_config[self._fg_key][self._protect_key]
+        except KeyError as ex:
+            raise ConfigException(f"Config file '{conf_file}' is missing mandatory configuration '{self._fg_key}[{self._protect_key}]'.") from ex
+
+        for key, val in protect_conf.items():
+            if key not in valid_protect_scopes:
+                msg = f"The only keys allowed in '{self._fg_key}[{self._protect_key}]' section in the config file '{conf_file}' are: {valid_protect_scopes}. Got: '{key}'."
+                _LOG.debug("%s", msg)
+                raise ConfigException(msg)
+
+            protect_conf[key] = set(re.compile(pattern) for pattern in val)
+
+        for key in self._valid_dir_protect_scopes:  # Do NOT use the 'valid_protect_scopes' argument here
+            protect_conf.setdefault(key, set())
+
+        lvl = logging.DEBUG
+        if _LOG.isEnabledFor(lvl):
+            _LOG.log(lvl, "Merged directory config:\n%s", pformat(new_config))
+
+        return protect_conf, conf_file
+
+    def load_config_dir_files(self) -> None:
+        """Load config files from platform standard directories and specified config file, if any."""
+
+        if not self.ignore_config_dirs_config_files:
+            _LOG.debug("config_dirs: %s", self.config_dirs)
+            for conf_dir in self.config_dirs:
+                conf_dir = Path(conf_dir)
+                if not conf_dir.exists():
+                    continue
+
+                for conf_file_name_pair in self.conf_file_name_pairs:
+                    cfg, _ = self._read_and_validate_config_file_for_one_appname(
+                        conf_dir, conf_file_name_pair, self._valid_config_dir_protect_scopes, self.ignore_config_dirs_config_files)
+                    self._global_config.protect_recursive |= cfg.get("global", set())
+
+        if self.config_file:
+            _LOG.debug("specified config_file: %s", self.config_file)
+            conf_dir = self.config_file.parent.absolute()
+            conf_name = self.config_file.name
+            cfg, fpath = self._read_and_validate_config_file_for_one_appname(
+                conf_dir, (conf_name,), self._valid_config_dir_protect_scopes, self.ignore_config_dirs_config_files)
+            if not fpath:
+                raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), str(self.config_file))
+            self._global_config.protect_recursive |= cfg.get("global", set())
+
+        _LOG.debug("Merged global config:\n %s", self._global_config)
+
+    def dir_config(self, conf_dir: Path, parent_conf: DirConfig|None) -> DirConfig:
+        """Read and merge config file from directory 'conf_dir' with 'parent_conf'.
+
+        If directory has no parent in the file_groups included dirs, then None should be supplied as parent_conf.
+        """
+
+        cfg_merge_local: set[re.Pattern] = set()
+        cfg_merge_recursive: set[re.Pattern] = set()
+        cfg_files: list[str] = []
+
+        for conf_file_name_pair in self.conf_file_name_pairs:
+            cfg, cfg_file = self._read_and_validate_config_file_for_one_appname(
+                conf_dir, conf_file_name_pair, self._valid_dir_protect_scopes, self.ignore_per_directory_config_files)
+            cfg_merge_local.update(cfg.get("local", set()))
+            cfg_merge_recursive.update(cfg.get("recursive", set()))
+            if cfg_file:
+                cfg_files.append(cfg_file.name)
+
+        parent_protect_recursive = parent_conf.protect_recursive if parent_conf else self._global_config.protect_recursive
+        new_config = DirConfig(cfg_merge_recursive | parent_protect_recursive, cfg_merge_local, conf_dir, cfg_files)
+        _LOG.debug("new_config:\n %s", new_config)
+
+        if self.remember_configs:
+            self.per_dir_configs[conf_dir] = new_config
+            # _LOG.debug("per_dir_configs:\n %s", self.per_dir_configs)
+
+        return new_config

{file_groups-0.2.1 → file_groups-0.3.1}/src/groups.py

@@ -7,9 +7,9 @@ from dataclasses import dataclass
 from itertools import chain
 from enum import Enum
 import logging
-from typing import Sequence
+from typing import Sequence, cast
 
-from .config_files import ConfigFiles
+from .config_files import DirConfig, ConfigFiles
 
 
 _LOG = logging.getLogger(__name__)
@@ -87,27 +87,21 @@ class FileGroups():
 
         protect_exclude: Exclude files matching regex in the protected files (does not apply to symlinks). Default: Include ALL.
             Note: Since these files are excluded from protection, it means they er NOT protected!
-        work_include: Only include files matching regex in the may_work_on files (does not apply to symlinks). Default: Include ALL.
+        work_include: ONLY include files matching regex in the may_work_on files (does not apply to symlinks). Default: Include ALL.
 
-        ignore_config_dirs_config_files: Ignore config files in standard config directories.
-        ignore_per_directory_config_files: Ignore config files in collected directories.
+        config_files: Load config files. See config_files.ConfigFiles. Note that the default 'None' means use the `config_files.ConfigFiles` class with default arguments.
     """
 
     def __init__(
             self,
             protect_dirs_seq: Sequence[Path], work_dirs_seq: Sequence[Path],
             *,
-            protect: Sequence[re.Pattern] = (),
             protect_exclude: re.Pattern|None = None, work_include: re.Pattern|None = None,
-            ignore_config_dirs_config_files=False, ignore_per_directory_config_files=False,
-            remember_configs=True):
+            config_files: ConfigFiles|None = None):
         super().__init__()
 
-        self.config_files = ConfigFiles(
-            protect=protect,
-            ignore_config_dirs_config_files=ignore_config_dirs_config_files,
-            ignore_per_directory_config_files=ignore_per_directory_config_files,
-            remember_configs=remember_configs)
+        self.config_files = config_files or ConfigFiles()
+        self.config_files.load_config_dir_files()
 
         # Turn all paths into absolute paths with symlinks resolved, keep referrence to original argument for messages
         protect_dirs: dict[str, Path] = {os.path.abspath(os.path.realpath(kp)): kp for kp in protect_dirs_seq}
@@ -153,8 +147,8 @@ class FileGroups():
             top/d2/d1
             top/d2/d1/f1.jpg
 
-            When: self.work_dirs_seq is [top, top/d1/d1]
-            And: self.protect_dirs_seq is [top/d1]
+            When: work_dirs_seq is [top, top/d1/d1]
+            And: protect_dirs_seq is [top/d1]
 
             Then:
 
@@ -175,65 +169,69 @@ class FileGroups():
 
         checked_dirs: set[str] = set()
 
-        def find_group(abs_dir_path: str, group: _Group, other_group: _Group, parent_conf: dict):
-            """Find all files belonging to 'group'"""
+        def handle_entry(abs_dir_path: str, group: _Group, other_group: _Group, dir_config: DirConfig, entry: DirEntry):
+            """Put entry in  the correct group. Call 'find_group' if entry is a directory."""
+            if group.typ is GroupType.MAY_WORK_ON:
+                # Check for match against configured protect patterns, if match, then the file must got to protect group instead
+                pattern = dir_config.is_protected(entry)
+                if pattern:
+                    _LOG.debug("find %s - '%s' is protected by regex %s, assigning to group %s instead.", group.typ.name, entry.path, pattern, other_group.typ.name)
+                    group, other_group = other_group, group
+
+            if entry.is_dir(follow_symlinks=False):
+                if entry.path in other_group.dirs:
+                    _LOG.debug("find %s - '%s' is in '%s' dir list and not in '%s' dir list", group.typ.name, entry.path, other_group.typ.name, group.typ.name)
+                    find_group(entry.path, other_group, group, dir_config)
+                    return
+
+                find_group(entry.path, group, other_group, dir_config)
+                return
+
+            if entry.name in self.config_files.conf_file_names:
+                return
+
+            if entry.is_symlink():
+                # cast: https://github.com/python/mypy/issues/11964
+                points_to = os.readlink(cast(str, entry))
+                abs_points_to = os.path.normpath(os.path.join(abs_dir_path, points_to))
+
+                if entry.is_dir(follow_symlinks=True):
+                    _LOG.debug("find %s - '%s' -> '%s' is a symlink to a directory - ignoring", group.typ.name, entry.path, points_to)
+                    group.num_directory_symlinks += 1
+                    return
+
+                group.symlinks[entry.path] = entry
+                group.symlinks_by_abs_points_to[abs_points_to].append(entry)
+                return
+
+            _LOG.debug("find %s - entry name: %s", group.typ.name, entry.name)
+            group.add_entry_match(entry)
+
+        def find_group(abs_dir_path: str, group: _Group, other_group: _Group, parent_conf: DirConfig|None):
+            """Recursively find all files belonging to 'group'"""
             _LOG.debug("find %s: %s", group.typ.name, abs_dir_path)
             if abs_dir_path in checked_dirs:
                 _LOG.debug("directory already checked")
                 return
 
             group.num_directories += 1
-            dir_config, config_file = self.config_files.dir_config(Path(abs_dir_path), parent_conf)
+            dir_config = self.config_files.dir_config(Path(abs_dir_path), parent_conf)
 
             for entry in os.scandir(abs_dir_path):
-                if entry.is_dir(follow_symlinks=False):
-                    if entry.path in other_group.dirs:
-                        _LOG.debug("find %s - '%s' is in '%s' dir list and not in '%s' dir list", group.typ.name, entry.path, other_group.typ.name, group.typ.name)
-                        find_group(entry.path, other_group, group, dir_config)
-                        continue
-
-                    find_group(entry.path, group, other_group, dir_config)
-                    continue
-
-                if config_file and entry.name == config_file.name:
-                    continue
-
-                current_group = group
-                if group.typ is GroupType.MAY_WORK_ON:
-                    # We need to check for match against configured protect patterns, if match, then the file must got to protect group instead
-                    pattern = self.config_files.is_protected(entry, dir_config)
-                    if pattern:
-                        _LOG.debug("find %s - '%s' is protected by regex %s, assigning to group %s instead.", group.typ.name, entry.path, pattern, other_group.typ.name)
-                        current_group = other_group
-
-                if entry.is_symlink():
-                    points_to = os.readlink(entry)
-                    abs_points_to = os.path.normpath(os.path.join(abs_dir_path, points_to))
-
-                    if entry.is_dir(follow_symlinks=True):
-                        _LOG.debug("find %s - '%s' -> '%s' is a symlink to a directory - ignoring", current_group.typ.name, entry.path, points_to)
-                        current_group.num_directory_symlinks += 1
-                        continue
-
-                    current_group.symlinks[entry.path] = entry
-                    current_group.symlinks_by_abs_points_to[abs_points_to].append(entry)
-                    continue
-
-                _LOG.debug("find %s - entry name: %s", current_group.typ.name, entry.name)
-                current_group.add_entry_match(entry)
+                handle_entry(abs_dir_path, group, other_group, dir_config, entry)
 
             checked_dirs.add(abs_dir_path)
 
         for any_dir in sorted(chain(self.must_protect.dirs, self.may_work_on.dirs), key=lambda dd: len(Path(dd).parts)):
             parent_dir = Path(any_dir)
             while len(parent_dir.parts) > 1:
-                parent_conf = self.config_files.per_dir_configs.get(any_dir)
+                parent_conf = self.config_files.per_dir_configs.get(parent_dir)
                 if parent_conf:
                     break
 
                 parent_dir = parent_dir.parent
             else:
-                parent_conf = self.config_files.global_config
+                parent_conf = None
 
             if any_dir in self.must_protect.dirs:
                 find_group(any_dir, self.must_protect, self.may_work_on, parent_conf)