file-groups 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

file_groups/__init__.py

@@ -1,4 +1,6 @@
-from importlib.metadata import version  # type: ignore
+"""Set __version__ property."""
+
+from importlib.metadata import version
 
 
 __version__ = version("file_groups")

file_groups/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,31 +22,56 @@ 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) -> dict[str, Any]:
+        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):
+    def is_protected(self, ff: FsPath) -> re.Pattern|None:
         """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("re.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):
+    def __json__(self) -> dict[str, Any]:
         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,47 +157,43 @@ 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,
+            ignore_config_dirs_config_files: bool = False, ignore_per_directory_config_files: bool =False, remember_configs: bool =True,
             app_dirs: Sequence[AppDirs]|None = None,
             *,
             config_file: Path|None = None,
         ):
         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/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
 
@@ -35,14 +35,14 @@ class _Group():
     num_directories: int = 0
     num_directory_symlinks: int = 0
 
-    def add_entry_match(self, entry: DirEntry):
+    def add_entry_match(self, entry: DirEntry) -> None:
         """Abstract, but abstract and dataclass does not work with mypy. https://github.com/python/mypy/issues/500"""
 
 @dataclass
 class _IncludeMatchGroup(_Group):
     include: re.Pattern|None = None
 
-    def add_entry_match(self, entry: DirEntry):
+    def add_entry_match(self, entry: DirEntry) -> None:
         if not self.include:
             self.files[entry.path] = entry
             return
@@ -58,7 +58,7 @@ class _IncludeMatchGroup(_Group):
 class _ExcludeMatchGroup(_Group):
     exclude: re.Pattern|None = None
 
-    def add_entry_match(self, entry: DirEntry):
+    def add_entry_match(self, entry: DirEntry) -> None:
         if not self.exclude:
             self.files[entry.path] = entry
             return
@@ -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 find_group(abs_dir_path: str, group: _Group, other_group: _Group, parent_conf: DirConfig|None):
-            """Find all files belonging to 'group'"""
+        def handle_entry(abs_dir_path: str, group: _Group, other_group: _Group, dir_config: DirConfig, entry: DirEntry) -> None:
+            """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) -> 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")
@@ -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
 
@@ -234,7 +238,7 @@ class FileGroups():
             else:
                 find_group(any_dir, self.may_work_on, self.must_protect, parent_conf)
 
-    def dump(self):
+    def dump(self) -> None:
         """Log collected files. This may be A LOT of output for large directories."""
 
         log = _LOG.getChild("dump")
@@ -276,7 +280,7 @@ class FileGroups():
 
         log.log(lvl, "")
 
-    def stats(self):
+    def stats(self) -> None:
         """Log collection numbers."""
         log = _LOG.getChild("stats")
         lvl = logging.INFO

file_groups/handler.py

@@ -2,13 +2,12 @@ import os
 from pathlib import Path
 import shutil
 import re
-from contextlib import contextmanager
 import logging
 from typing import Sequence
 
 from .groups import FileGroups
 from .config_files import ConfigFiles
-
+from .types import FsPath
 
 _LOG = logging.getLogger(__name__)
 
@@ -28,14 +27,14 @@ 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],
             *,
             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):
+            delete_symlinks_instead_of_relinking: bool =False):
         super().__init__(
             protect_dirs_seq=protect_dirs_seq, work_dirs_seq=work_dirs_seq,
             protect_exclude=protect_exclude, work_include=work_include,
@@ -55,7 +54,7 @@ class FileHandler(FileGroups):
         self.num_moved = 0
         self.num_relinked = 0
 
-    def reset(self):
+    def reset(self) -> None:
         """Reset internal housekeeping of deleted/renamed/moved files.
 
         This makes it possible to do a 'dry_run' and an actual run without collecting files again.
@@ -69,7 +68,7 @@ class FileHandler(FileGroups):
         self.num_moved = 0
         self.num_relinked = 0
 
-    def _no_symlink_check_registered_delete(self, delete_path: str):
+    def _no_symlink_check_registered_delete(self, delete_path: str) -> None:
         """Does a registered delete without checking for symlinks, so that we can use this in the symlink handling."""
         assert isinstance(delete_path, str)
         assert os.path.isabs(delete_path), f"Expected absolute path, got '{delete_path}'"
@@ -84,7 +83,7 @@ class FileHandler(FileGroups):
         if delete_path in self.may_work_on.symlinks:
             self.deleted_symlinks.add(delete_path)
 
-    def _handle_single_symlink_chain(self, symlnk_path: str, keep_path):
+    def _handle_single_symlink_chain(self, symlnk_path: str, keep_path: str|FsPath|None) -> None:
         """TODO doc - Symlink will only be deleted if it is in self.may_work_on.files."""
 
         assert os.path.isabs(symlnk_path), f"Expected an absolute path, got '{symlnk_path}'"
@@ -141,8 +140,12 @@ class FileHandler(FileGroups):
 
         self.num_relinked += 1
 
-    def _fix_symlinks_to_deleted_or_moved_files(self, from_path: str, to_path):
-        """Any symlinks pointing to 'from_path' will be change to point to 'to_path'"""
+    def _fix_symlinks_to_deleted_or_moved_files(self, from_path: str, to_path: str|FsPath|None) -> None:
+        """Any symlinks pointing to 'from_path' will be change to point to 'to_path' or deleted.
+
+        If 'to_path' is None then delete full chains of symlinks in 'may_work_on' dirs.
+        """
+
         _LOG.debug("_fix_symlinks_to_deleted_or_moved_files(self, %s, %s)", from_path, to_path)
 
         for symlnk in self.must_protect.symlinks_by_abs_points_to.get(from_path, ()):
@@ -153,13 +156,13 @@ class FileHandler(FileGroups):
             _LOG.debug("_fix_symlinks_to_deleted_or_moved_files, may_work_on symlink: '%s'.", symlnk)
             self._handle_single_symlink_chain(os.fspath(symlnk), to_path)
 
-    def registered_delete(self, delete_path: str, corresponding_keep_path) -> Path|None:
+    def registered_delete(self, delete_path: str, corresponding_keep_path: str|FsPath|None) -> Path|None:
         """Return `corresponding_keep_path` as absolute Path"""
         self._no_symlink_check_registered_delete(delete_path)
         self._fix_symlinks_to_deleted_or_moved_files(delete_path, corresponding_keep_path)
         return Path(corresponding_keep_path).absolute() if corresponding_keep_path else None
 
-    def _registered_move_or_rename(self, from_path: str, to_path, *, is_move) -> Path:
+    def _registered_move_or_rename(self, from_path: str, to_path: str|FsPath, *, is_move: bool) -> Path:
         """Return `to_path` as absolute Path"""
         assert isinstance(from_path, str)
         assert os.path.isabs(from_path), f"Expected absolute path, got '{from_path}'"
@@ -189,20 +192,18 @@ class FileHandler(FileGroups):
         self._fix_symlinks_to_deleted_or_moved_files(from_path, to_path)
         return res
 
-    def registered_move(self, from_path: str, to_path) -> Path:
+    def registered_move(self, from_path: str, to_path: str|FsPath) -> Path:
         """Return `to_path` as absolute Path"""
         return self._registered_move_or_rename(from_path, to_path, is_move=True)
 
-    def registered_rename(self, from_path: str, to_path) -> Path:
+    def registered_rename(self, from_path: str, to_path: str|FsPath) -> Path:
         """Return `to_path` as absolute Path"""
         return self._registered_move_or_rename(from_path, to_path, is_move=False)
 
-    @contextmanager
-    def stats(self):
+    def stats(self) -> None:
         log = _LOG.getChild("stats")
         lvl = logging.INFO
         if not log.isEnabledFor(lvl):
-            yield
             return
 
         prefix = ''
@@ -218,10 +219,3 @@ class FileHandler(FileGroups):
         log.log(lvl, "%srenamed: %s", prefix, self.num_renamed)
         log.log(lvl, "%smoved: %s", prefix, self.num_moved)
         log.log(lvl, "%srelinked: %s", prefix, self.num_relinked)
-
-        try:
-            yield
-
-        finally:
-            if self.dry_run:
-                log.log(lvl, "*** DRY RUN ***")

file_groups/handler_compare.py

@@ -22,14 +22,14 @@ 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,
             *,
             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):
+            delete_symlinks_instead_of_relinking: bool = False):
         super().__init__(
             protect_dirs_seq=protect_dirs_seq, work_dirs_seq=work_dirs_seq,
             protect_exclude=protect_exclude, work_include=work_include,

file_groups/types.py

@@ -1,6 +1,5 @@
 from os import DirEntry
 from pathlib import Path
-from typing import Union
 
 
-FsPath = Union[DirEntry, Path]
+FsPath = DirEntry|Path

{file_groups-0.3.0.dist-info → file_groups-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: file-groups
-Version: 0.3.0
+Metadata-Version: 2.2
+Name: file_groups
+Version: 0.4.0
 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,16 @@ 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: Topic :: Software Development :: Libraries
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 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.4.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+file_groups/__init__.py,sha256=FAl1D2-Fm2nQgXdM1rttTymLby24pN3ogmbS5dri770,111
+file_groups/compare_files.py,sha256=38EfZzpEpj0wH7SUruPxgyF_W8eqCbIjG6yUOx8hcFA,434
+file_groups/config_files.py,sha256=-sEyPkcds9gZEVvIJVnhWqXk9H4X20w_TT8BQg3_xzM,14101
+file_groups/groups.py,sha256=fMn85U2QPF39sgYzma806XgtUOozOsA-CUNRjB2mC5I,11433
+file_groups/handler.py,sha256=QerrcMtLEzl5NUOpwX2QbbngBUl8ssfYemcbGbaV208,10156
+file_groups/handler_compare.py,sha256=zVRHdqP-2Z7u3D2jQ_6_HLF3SOUk0mSyJ7xiS5Y0Hig,2182
+file_groups/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+file_groups/types.py,sha256=IEDtGNxhQhQaWn8sTHn5-jbpM-dbba7wiIfaud1XSXc,74
+file_groups-0.4.0.dist-info/LICENSE.txt,sha256=NZc9ictLEwfoL4ywpAbLbd-n02KETGHLYQU820TJD_Q,1494
+file_groups-0.4.0.dist-info/METADATA,sha256=hCMNdysRiHy14tnW7TKa4vxO0BKBRO_RlMHdISRDJe4,1510
+file_groups-0.4.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+file_groups-0.4.0.dist-info/top_level.txt,sha256=mAdRf0R2TA8tpH7ftHzXP7VMRhw07p7B2mI8QKpDnjU,12
+file_groups-0.4.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+file_groups-0.4.0.dist-info/RECORD,,

{file_groups-0.3.0.dist-info → file_groups-0.4.0.dist-info}/WHEEL

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

file_groups-0.3.0.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=kU1wTANXjk5H95x1TpxIBFZrobJFjTMbQ_mjpnewh-U,13011
-file_groups/groups.py,sha256=R3wF8DV3rhMckjgz6wuycxJ9UxAB2p56zzYcdbh72M0,11072
-file_groups/handler.py,sha256=X_uFNAMtuiBro_8WG6XFEq_Ys4L8175tSP_gajA01fo,10045
-file_groups/handler_compare.py,sha256=J6Jev9ev9oECzYCD9M6FUlkKMMMkaP2YlygG11lKqPI,2136
-file_groups/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-file_groups/types.py,sha256=giq3H58RuKpS6b7sjxnzP-sN1Xr4VTQ-rG4brLP5qMI,107
-file_groups-0.3.0.dist-info/LICENSE.txt,sha256=NZc9ictLEwfoL4ywpAbLbd-n02KETGHLYQU820TJD_Q,1494
-file_groups-0.3.0.dist-info/METADATA,sha256=BseS9ayqXIwuDBBUb95mPQUcLmrHbmHLO7mSGOr9IEQ,1512
-file_groups-0.3.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-file_groups-0.3.0.dist-info/top_level.txt,sha256=mAdRf0R2TA8tpH7ftHzXP7VMRhw07p7B2mI8QKpDnjU,12
-file_groups-0.3.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-file_groups-0.3.0.dist-info/RECORD,,