file-groups 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

file_groups/__init__.py

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

file_groups/config_files.py

@@ -1,11 +1,13 @@
 import ast
 import os
+import errno
 import re
 from pathlib import Path
 import itertools
 from pprint import pformat
 import logging
-from typing import Mapping, Tuple, Sequence, cast
+from dataclasses import dataclass
+from typing import Tuple, Sequence, Any
 
 from appdirs import AppDirs # type: ignore
 
@@ -19,11 +21,74 @@ 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.
-    Config files in config directories must be named 'file_groups.conf' and in collected directories '.file_groups.conf' or 'file_groups.conf'.
+
+    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.
 
@@ -56,14 +121,14 @@ class ConfigFiles():
             }
         }
 
-    The level one keys (e.g. 'file_groups') are the application (library) names.
-    Applications are free to add entries at this level.
+    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 filename (i.e. not the full path) unless they contain at least one path separator (os.sep), in
+    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.
 
@@ -73,126 +138,107 @@ 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.
-        app_dirs: AppDirs("file_groups", "Hupfeldt_IT"), Provide your own instance to change congig file names and path.
+        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:
-       global_config: dict
-       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.
     """
 
-    conf_file_names = [".file_groups.conf", "file_groups.conf"]
+    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__(
+    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=False,
-            app_dirs=None):
+            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
 
-        self.per_dir_configs: dict[str, dict] = {}  # key is abs_dir_path, value is config dict
-        self.global_config = {
-            "file_groups": {
-                "protect": {
-                    "local": set(),
-                    "recursive": set(protect),
-                }
-            }
-        }
+        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_per_directory_config_files = ignore_per_directory_config_files
+        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
 
-        if not ignore_config_dirs_config_files:
-            self._load_config_dir_files(app_dirs or AppDirs("file_groups", "Hupfeldt_IT"))
-
-    def _load_config_dir_files(self, app_dirs):
-        config_dirs = app_dirs.site_config_dir.split(':') + [app_dirs.user_config_dir]
-        _LOG.debug("config_dirs: %s", config_dirs)
-        gfpt = self.global_config["file_groups"]["protect"]
-        for conf_dir in config_dirs:
-            conf_dir = Path(conf_dir)
-            if not conf_dir.exists():
-                continue
-
-            new_config, _ = self._read_and_validate_config_file(conf_dir, self.global_config, self._valid_config_dir_protect_scopes, False)
-            if self.remember_configs:
-                self.per_dir_configs[str(conf_dir)] = new_config
-
-            fpt = new_config["file_groups"]["protect"]
-            cast(set, gfpt["recursive"]).update(fpt.get("global", ()))
-            _LOG.debug("Merged global config:\n %s", pformat(new_config))
-
-            try:
-                del fpt['global']
-            except KeyError:
-                pass
-
-    # self.default_config_file_example = self.default_config_file.with_suffix('.example.py')
-
-    def _get_single_conf_file(self, conf_dir: Path, ignore_config_files: bool) -> Tuple[dict|None, Path|None]:
-        """Return the config file content and path if any config file is found in conf_dir. Error if two are found."""
-        _LOG.debug("Checking for config file in directory: %s", conf_dir)
-
-        num_files = 0
-        for cfn in self.conf_file_names:
-            tmp_conf_file = conf_dir/cfn
-            if tmp_conf_file.exists():
-                conf_file = tmp_conf_file
-                num_files += 1
-
-        if num_files == 1:
-            if ignore_config_files:
-                _LOG.debug("Ignoring config file: %s", conf_file)
-                return None, 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
-
-        if num_files == 0:
-            _LOG.debug("No config file in directory %s", conf_dir)
-            return None, None
-
-        msg = f"More than one config file in dir '{conf_dir}': {self.conf_file_names}."
-        _LOG.debug("%s", msg)
-        raise ConfigException(msg)
-
-    def _read_and_validate_config_file(
-            self, conf_dir: Path, parent_conf: dict, valid_protect_scopes: Tuple[str, ...], ignore_config_files: bool
-    ) -> Tuple[dict, Path|None]:
-        """Read config file, validate keys and compile regexes and merge with parent.
-
-        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.
+        # 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)
 
-        no_conf_file = {
-            "file_groups": {
-                "protect": {
-                    "local": set(),
-                    "recursive": parent_conf[self._fg_key][self._protect_key]["recursive"]
-                }
-            }
-        }
+    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._get_single_conf_file(conf_dir, ignore_config_files)
-        if not new_config or ignore_config_files:
-            return no_conf_file, 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 = new_config[self._fg_key][self._protect_key]
+            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
 
@@ -203,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[self._fg_key][self._protect_key][key])
 
         for key in self._valid_dir_protect_scopes:  # Do NOT use the 'valid_protect_scopes' argument here
             protect_conf.setdefault(key, set())
@@ -213,32 +257,59 @@ class ConfigFiles():
         if _LOG.isEnabledFor(lvl):
             _LOG.log(lvl, "Merged directory config:\n%s", pformat(new_config))
 
-        return new_config, conf_file
+        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())
 
-    def dir_config(self, conf_dir: Path, parent_conf: dict) -> Tuple[dict, Path|None]:
+        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 self.global_config must be supplied as parent_conf.
+        If directory has no parent in the file_groups included dirs, then None should be supplied as parent_conf.
         """
 
-        new_config, conf_file = self._read_and_validate_config_file(
-            conf_dir, parent_conf, self._valid_dir_protect_scopes, self.ignore_per_directory_config_files)
-        if self.remember_configs:
-            self.per_dir_configs[str(conf_dir)] = new_config
-        return new_config, conf_file
+        cfg_merge_local: set[re.Pattern] = set()
+        cfg_merge_recursive: set[re.Pattern] = set()
+        cfg_files: list[str] = []
 
-    def is_protected(self, ff: FsPath, dir_config: Mapping):
-        """If ff id protected by a regex patterm then return the pattern, otherwise return None."""
+        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)
 
-        cfg_protected = dir_config[self._fg_key][self._protect_key]
-        for pattern in itertools.chain(cfg_protected["local"], cfg_protected["recursive"]):
-            if os.sep in str(pattern):
-                # Match against full path
-                assert os.path.isabs(ff), f"Expected absolute path, got '{ff}'"
-                if pattern.search(os.fspath(ff)):
-                    return pattern
+        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)
 
-            elif pattern.search(ff.name):
-                return pattern
+        if self.remember_configs:
+            self.per_dir_configs[conf_dir] = new_config
+            # _LOG.debug("per_dir_configs:\n %s", self.per_dir_configs)
 
-        return None
+        return new_config

file_groups/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)

file_groups/handler.py

@@ -7,6 +7,7 @@ import logging
 from typing import Sequence
 
 from .groups import FileGroups
+from .config_files import ConfigFiles
 
 
 _LOG = logging.getLogger(__name__)
@@ -20,26 +21,25 @@ class FileHandler(FileGroups):
     Re-link symlinks when a file being deleted has a corresponding file.
 
     Arguments:
-        protect_dirs_seq, work_dirs_seq, protect_exclude, work_include: See `FileGroups` class.
-        dry_run: Don't actually do anything.
-        protected_regexes: Protect files matching this from being deleted or moved.
+        protect_dirs_seq, work_dirs_seq, protect_exclude, work_include, config_files: See `FileGroups` class.
+        dry_run: Don't change any files.
         delete_symlinks_instead_of_relinking: Normal operation is to re-link to a 'corresponding' or renamed file when renaming or deleting a file.
            If delete_symlinks_instead_of_relinking is true, then symlinks in work_on dirs pointing to renamed/deletes files will be deleted even if
            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],
             *,
-            dry_run: bool,
-            protected_regexes: Sequence[re.Pattern],
             protect_exclude: re.Pattern|None = None, work_include: re.Pattern|None = None,
+            config_files: ConfigFiles|None = None,
+            dry_run: bool,
             delete_symlinks_instead_of_relinking=False):
         super().__init__(
-            protect=protected_regexes,
             protect_dirs_seq=protect_dirs_seq, work_dirs_seq=work_dirs_seq,
-            protect_exclude=protect_exclude, work_include=work_include)
+            protect_exclude=protect_exclude, work_include=work_include,
+            config_files=config_files)
 
         self.dry_run = dry_run
         self.delete_symlinks_instead_of_relinking = delete_symlinks_instead_of_relinking

file_groups/handler_compare.py

@@ -7,6 +7,7 @@ from typing import Sequence
 from .compare_files import CompareFiles
 from .types import FsPath
 from .handler import FileHandler
+from .config_files import ConfigFiles
 
 
 _LOG = logging.getLogger(__name__)
@@ -16,26 +17,24 @@ class FileHandlerCompare(FileHandler):
     """Extend `FileHandler` with a compare method
 
     Arguments:
-        protect_dirs_seq, work_dirs_seq, protect_exclude, work_include: See `FileGroups` class.
+        protect_dirs_seq, work_dirs_seq, protect_exclude, work_include, config_files: See `FileGroups` class.
         dry_run, protected_regexes, delete_symlinks_instead_of_relinking: See `FileHandler` class.
         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,
             *,
-            dry_run: bool,
-            protected_regexes: Sequence[re.Pattern],
             protect_exclude: re.Pattern|None = None, work_include: re.Pattern|None = None,
+            config_files: ConfigFiles|None = None,
+            dry_run: bool,
             delete_symlinks_instead_of_relinking=False):
         super().__init__(
-            protect_dirs_seq=protect_dirs_seq,
-            work_dirs_seq=work_dirs_seq,
+            protect_dirs_seq=protect_dirs_seq, work_dirs_seq=work_dirs_seq,
+            protect_exclude=protect_exclude, work_include=work_include,
+            config_files=config_files,
             dry_run=dry_run,
-            protected_regexes=protected_regexes,
-            protect_exclude=protect_exclude,
-            work_include=work_include,
             delete_symlinks_instead_of_relinking=delete_symlinks_instead_of_relinking)
 
         self._fcmp = fcmp

{file_groups-0.2.1.dist-info → file_groups-0.3.1.dist-info}/METADATA

@@ -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,16 +11,17 @@ 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
 License-File: LICENSE.txt
-Requires-Dist: appdirs >=1.4.4
+Requires-Dist: appdirs>=1.4.4
 Provides-Extra: dev
-Requires-Dist: nox ; extra == 'dev'
+Requires-Dist: nox; extra == "dev"
 
 Library for grouping files into sets of 'work-on' and 'protect' based on arbitrarily nested directories.
 

file_groups-0.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+file_groups/__init__.py,sha256=XBp5563xhTer1vQY-DpKRvViAvlHaZqx9GrINiGqbeI,127
+file_groups/compare_files.py,sha256=38EfZzpEpj0wH7SUruPxgyF_W8eqCbIjG6yUOx8hcFA,434
+file_groups/config_files.py,sha256=VwRmZYEemKQawYI43qV9XhvPyI7ouaDjjadhc74wqNs,14021
+file_groups/groups.py,sha256=Lt8QlAET8032t9OXcq9cmzLy27tZsYTnLAaGilzEtcM,11377
+file_groups/handler.py,sha256=NmYfmPLGXgPsGxM9uR2r8aS3cI-8S7D5-8884EoGA1M,10083
+file_groups/handler_compare.py,sha256=qbGHwT0FSvfnWtAnjYi4px6V5xIM2cStm0soflwYAi4,2174
+file_groups/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+file_groups/types.py,sha256=giq3H58RuKpS6b7sjxnzP-sN1Xr4VTQ-rG4brLP5qMI,107
+file_groups-0.3.1.dist-info/LICENSE.txt,sha256=NZc9ictLEwfoL4ywpAbLbd-n02KETGHLYQU820TJD_Q,1494
+file_groups-0.3.1.dist-info/METADATA,sha256=wSlWiFxs8yMgFvY6jN3pWIBGBVbbneRhyMQM5tNcoPw,1561
+file_groups-0.3.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+file_groups-0.3.1.dist-info/top_level.txt,sha256=mAdRf0R2TA8tpH7ftHzXP7VMRhw07p7B2mI8QKpDnjU,12
+file_groups-0.3.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+file_groups-0.3.1.dist-info/RECORD,,

{file_groups-0.2.1.dist-info → file_groups-0.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

file_groups-0.2.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-file_groups/__init__.py,sha256=1OO3tLnRnIe51VfZSQz0sqUaUP-xS7oHxiSexnKwpEY,94
-file_groups/compare_files.py,sha256=38EfZzpEpj0wH7SUruPxgyF_W8eqCbIjG6yUOx8hcFA,434
-file_groups/config_files.py,sha256=IDwhznEM8wpMBp0Fl69r1CbPxfgYCu82iE3b_mxkk6g,10211
-file_groups/groups.py,sha256=6tVIYBC5nCVPI4Ig1EuijT12accw2DZ08TEIMSJecLo,11531
-file_groups/handler.py,sha256=06_8_fBEaHndrfUdxMsFw6KZw8PRcRj4MsH4FY3I4sU,10083
-file_groups/handler_compare.py,sha256=78TXl9QFMIL5gZQhiLYvbzF5OidS7kcaRz6zCCNVG6I,2120
-file_groups/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-file_groups/types.py,sha256=giq3H58RuKpS6b7sjxnzP-sN1Xr4VTQ-rG4brLP5qMI,107
-file_groups-0.2.1.dist-info/LICENSE.txt,sha256=NZc9ictLEwfoL4ywpAbLbd-n02KETGHLYQU820TJD_Q,1494
-file_groups-0.2.1.dist-info/METADATA,sha256=hnoCAPIfqQ_bjodGN2qVzLhGWCBdg1-PCmYpf5G0I1U,1512
-file_groups-0.2.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-file_groups-0.2.1.dist-info/top_level.txt,sha256=mAdRf0R2TA8tpH7ftHzXP7VMRhw07p7B2mI8QKpDnjU,12
-file_groups-0.2.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-file_groups-0.2.1.dist-info/RECORD,,