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

{file_groups-0.3.0 → 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.3.0 → 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.3.0 → file_groups-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: file_groups
-Version: 0.3.0
+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.3.0 → file_groups-0.3.1}/file_groups.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: file-groups
-Version: 0.3.0
+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.3.0 → file_groups-0.3.1}/file_groups.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ 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.3.0 → 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.3.0 → 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.3.0 → 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.3.0 → 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.0 → file_groups-0.3.1}/src/config_files.py

@@ -7,7 +7,7 @@ import itertools
 from pprint import pformat
 import logging
 from dataclasses import dataclass
-from typing import Tuple, Sequence, cast
+from typing import Tuple, Sequence, Any
 
 from appdirs import AppDirs # type: ignore
 
@@ -22,22 +22,47 @@ class ConfigException(Exception):
 
 
 @dataclass
-class DirConfig():
-    """Hold protect config for a directory, or global (site or user) config."""
-    protect: dict[str, set[re.Pattern]]
+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: Sequence[str]
+    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."""
 
-        for pattern in itertools.chain(self.protect["local"], self.protect["recursive"]):
+        # _LOG.debug("ff '%s'", ff)
+        for pattern in itertools.chain(self.protect_local, self.protect_recursive):
             if os.sep in str(pattern):
-                # Match against full path
+                # _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
 
@@ -45,8 +70,8 @@ class DirConfig():
 
     def __json__(self):
         return {
-            "DirConfig": {
-                "protect": {key: list(str(pat) for pat in val) for key, val in self.protect.items()},
+            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,
             }
@@ -113,15 +138,16 @@ class ConfigFiles():
         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 `dir_configs` member variable.
+        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:
-       remember_configs: Whether per directory resolved/merged configs are stored in `dir_configs`.
-       dir_configs: dict[str: dict] Mapping from dir name to directory specific config dict. Only if remember_configs is True.
+       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")
@@ -131,7 +157,7 @@ class ConfigFiles():
     _valid_dir_protect_scopes = ("local", "recursive")
     _valid_config_dir_protect_scopes = ("local", "recursive", "global")
 
-    def __init__(
+    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,
@@ -140,38 +166,34 @@ class ConfigFiles():
         ):
         super().__init__()
 
-        self._global_config = DirConfig({
-            "local": set(),
-            "recursive": set(protect),
-        }, None, ())
-
+        self._global_config = ProtectConfig(set(protect))
         self.remember_configs = remember_configs
-        self.per_dir_configs: dict[str, DirConfig] = {}  # key is abs_dir_path
+        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_names = tuple((apd.appname + ".conf", "." + apd.appname + ".conf") for apd in app_dirs)
-        _LOG.debug("Conf file names: %s", self.conf_file_names)
+        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 = []
-        if not ignore_config_dirs_config_files:
-            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)
+        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_validate_config_file_for_one_appname(  # pylint: disable=too-many-locals
-            self, conf_dir: Path, conf_file_name_pair: Sequence[str], parent_conf: DirConfig, valid_protect_scopes: Tuple[str, ...], ignore_config_files: bool
-    ) -> Tuple[dict[str, set[re.Pattern]], str|None]:
-        """Read config file, validate keys and compile regexes and merge with parent.
+    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.
-        Merge parent conf into conf_dir conf (if any) and return the merged dict. The parent conf is not modified.
-
-        Return: merged config dict with compiled regexes, config file name. If no config files is found, then return inherited parent conf and None.
+        Return: Config dict, config file name, or if no config files is found, None, None.
         """
 
         assert conf_dir.is_absolute()
@@ -180,27 +202,41 @@ class ConfigFiles():
         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)
-                no_conf_file: dict[str, set[re.Pattern]] = {
-                    "local": set(),
-                    "recursive": parent_conf.protect["recursive"]
-                }
-                return no_conf_file, None
+                return {}, None
 
             case [conf_file]:
                 if ignore_config_files:
                     _LOG.debug("Ignoring config file: %s", conf_file)
-                    return self._global_config.protect, None
+                    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:
@@ -213,8 +249,6 @@ class ConfigFiles():
                 raise ConfigException(msg)
 
             protect_conf[key] = set(re.compile(pattern) for pattern in val)
-            if key == "recursive":
-                protect_conf[key].update(parent_conf.protect[key])
 
         for key in self._valid_dir_protect_scopes:  # Do NOT use the 'valid_protect_scopes' argument here
             protect_conf.setdefault(key, set())
@@ -223,55 +257,34 @@ class ConfigFiles():
         if _LOG.isEnabledFor(lvl):
             _LOG.log(lvl, "Merged directory config:\n%s", pformat(new_config))
 
-        return protect_conf, conf_file.name
-
-    def _read_and_validate_config_files(
-            self, conf_dir: Path, parent_conf: DirConfig, valid_protect_scopes: Tuple[str, ...], ignore_config_files: bool) -> DirConfig:
-        cfg_merge: dict[str, set[re.Pattern]] = {}
-        cfg_files: list[str] = []
-        for conf_file_name_pair in self.conf_file_names:
-            cfg, cfg_file = self._read_and_validate_config_file_for_one_appname(
-                conf_dir, conf_file_name_pair, parent_conf, valid_protect_scopes, ignore_config_files)
-            for key, val in cfg.items():
-                cfg_merge.setdefault(key, set()).update(val)
-            if cfg_file:
-                cfg_files.append(cfg_file)
-
-        return DirConfig(cfg_merge, conf_dir, cfg_files)
+        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."""
 
-        def merge_one_config_to_global(conf_dir, new_config):
-            if self.remember_configs:
-                self.per_dir_configs[str(conf_dir)] = new_config
+        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
 
-            self._global_config.protect["recursive"].update(new_config.protect.get("global", set()))
-            _LOG.debug("Merged global config:\n %s", new_config)
-
-            try:
-                del new_config.protect['global']
-            except KeyError:
-                pass
-
-        _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
-
-            new_config = self._read_and_validate_config_files(conf_dir, self._global_config, self._valid_config_dir_protect_scopes, False)
-            merge_one_config_to_global(conf_dir, new_config)
+                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, filename = self._read_and_validate_config_file_for_one_appname(
-                conf_dir, (conf_name,), self._global_config, self._valid_config_dir_protect_scopes, ignore_config_files=False)
-            if not filename:
+            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())
 
-            merge_one_config_to_global(conf_dir, DirConfig(cfg, conf_dir, (cast(str, filename),)))
+        _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'.
@@ -279,12 +292,24 @@ class ConfigFiles():
         If directory has no parent in the file_groups included dirs, then None should be supplied as parent_conf.
         """
 
-        new_config = self._read_and_validate_config_files(
-            conf_dir, parent_conf or self._global_config, self._valid_dir_protect_scopes, self.ignore_per_directory_config_files)
+        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[str(conf_dir)] = new_config
+            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.3.0 → file_groups-0.3.1}/src/groups.py

@@ -7,7 +7,7 @@ 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 DirConfig, ConfigFiles
 
@@ -89,7 +89,7 @@ class FileGroups():
             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.
 
-        config_files: Load config files. See config_files.ConfigFiles.
+        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__(
@@ -169,8 +169,46 @@ class FileGroups():
 
         checked_dirs: set[str] = set()
 
+        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):
-            """Find all files belonging to 'group'"""
+            """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")
@@ -180,48 +218,14 @@ class FileGroups():
             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 entry.name in dir_config.config_files:
-                    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 = 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)
-                        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
 

{file_groups-0.3.0 → file_groups-0.3.1}/src/handler.py

@@ -28,7 +28,7 @@ class FileHandler(FileGroups):
            they could have logically been made to point to a file in a protect dir.
     """
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments
             self,
             protect_dirs_seq: Sequence[Path], work_dirs_seq: Sequence[Path],
             *,

{file_groups-0.3.0 → file_groups-0.3.1}/src/handler_compare.py

@@ -22,7 +22,7 @@ class FileHandlerCompare(FileHandler):
         fcmp: Object providing compare function.
     """
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments
             self,
             protect_dirs_seq: Sequence[Path], work_dirs_seq: Sequence[Path], fcmp: CompareFiles,
             *,

{file_groups-0.3.0 → file_groups-0.3.1}/test/.coveragerc

@@ -24,6 +24,8 @@ partial_branches =
     pragma: no branch
 
 omit =
+    .nox/*
     test/*
     experiments
-    .nox/*
+    *_flymake.py
+    flycheck_*.py