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

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, cast
 
 from appdirs import AppDirs # type: ignore
 
@@ -19,11 +21,49 @@ class ConfigException(Exception):
     """Invalid configuration"""
 
 
+@dataclass
+class DirConfig():
+    """Hold protect config for a directory, or global (site or user) config."""
+    protect: dict[str, set[re.Pattern]]
+    config_dir: Path|None
+    config_files: Sequence[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"]):
+            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
+
+            elif pattern.search(ff.name):
+                return pattern
+
+        return None
+
+    def __json__(self):
+        return {
+            "DirConfig": {
+                "protect": {key: list(str(pat) for pat in val) for key, val in self.protect.items()},
+                "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 +96,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.
 
@@ -74,14 +114,18 @@ class ConfigFiles():
         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: 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_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")
@@ -89,104 +133,76 @@ class ConfigFiles():
 
     def __init__(
             self, protect: Sequence[re.Pattern] = (),
-            ignore_config_dirs_config_files=False, ignore_per_directory_config_files=False, remember_configs=False):
+            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.remember_configs = remember_configs
 
-        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),
-                }
-            }
-        }
+        self._global_config = DirConfig({
+            "local": set(),
+            "recursive": set(protect),
+        }, None, ())
 
+        self.remember_configs = remember_configs
+        self.per_dir_configs: dict[str, 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.config_dirs = []
         if not ignore_config_dirs_config_files:
-            app_dirs = AppDirs("file_groups", "Hupfeldt_IT")
-            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
+            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 _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]:
+    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.
 
+        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.
+        Return: merged config dict with compiled regexes, config file name. If no config files is found, then return inherited parent conf and None.
         """
 
         assert conf_dir.is_absolute()
+        _LOG.debug("Checking for config files %s in directory: %s", conf_file_name_pair, conf_dir)
 
-        no_conf_file = {
-            "file_groups": {
-                "protect": {
+        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[self._fg_key][self._protect_key]["recursive"]
+                    "recursive": parent_conf.protect["recursive"]
                 }
-            }
-        }
+                return no_conf_file, None
+
+            case [conf_file]:
+                if ignore_config_files:
+                    _LOG.debug("Ignoring config file: %s", conf_file)
+                    return self._global_config.protect, 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))
 
-        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
+            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)
 
         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
 
@@ -198,7 +214,7 @@ class ConfigFiles():
 
             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])
+                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())
@@ -207,32 +223,68 @@ class ConfigFiles():
         if _LOG.isEnabledFor(lvl):
             _LOG.log(lvl, "Merged directory config:\n%s", pformat(new_config))
 
-        return new_config, conf_file
-
-    def dir_config(self, conf_dir: Path, parent_conf: dict) -> Tuple[dict, Path|None]:
+        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)
+
+    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
+
+            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)
+
+        if 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:
+                raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), str(self.config_file))
+
+            merge_one_config_to_global(conf_dir, DirConfig(cfg, conf_dir, (cast(str, filename),)))
+
+    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)
+        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)
+        _LOG.debug("new_config:\n %s", new_config)
+
         if self.remember_configs:
             self.per_dir_configs[str(conf_dir)] = new_config
-        return new_config, conf_file
-
-    def is_protected(self, ff: FsPath, dir_config: Mapping):
-        """If ff id protected by a regex patterm then return the pattern, otherwise return None."""
-
-        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
-
-            elif pattern.search(ff.name):
-                return pattern
+            # _LOG.debug("per_dir_configs:\n %s", self.per_dir_configs)
 
-        return None
+        return new_config

file_groups/groups.py

@@ -9,7 +9,7 @@ from enum import Enum
 import logging
 from typing import Sequence
 
-from .config_files import ConfigFiles
+from .config_files import DirConfig, ConfigFiles
 
 
 _LOG = logging.getLogger(__name__)
@@ -35,14 +35,14 @@ class _Group():
     num_directories: int = 0
     num_directory_symlinks: int = 0
 
-    def add_entry_match(self, entry):
+    def add_entry_match(self, entry: DirEntry):
         """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):
+    def add_entry_match(self, entry: DirEntry):
         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):
+    def add_entry_match(self, entry: DirEntry):
         if not self.exclude:
             self.files[entry.path] = entry
             return
@@ -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.
     """
 
     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,7 +169,7 @@ class FileGroups():
 
         checked_dirs: set[str] = set()
 
-        def find_group(abs_dir_path: str, group: _Group, other_group: _Group, parent_conf: dict):
+        def find_group(abs_dir_path: str, group: _Group, other_group: _Group, parent_conf: DirConfig|None):
             """Find all files belonging to 'group'"""
             _LOG.debug("find %s: %s", group.typ.name, abs_dir_path)
             if abs_dir_path in checked_dirs:
@@ -183,7 +177,7 @@ class FileGroups():
                 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):
@@ -195,13 +189,13 @@ class FileGroups():
                     find_group(entry.path, group, other_group, dir_config)
                     continue
 
-                if config_file and entry.name == config_file.name:
+                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 = self.config_files.is_protected(entry, dir_config)
+                    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
@@ -233,7 +227,7 @@ class FileGroups():
 
                 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,9 +21,8 @@ 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.
@@ -32,14 +32,14 @@ class FileHandler(FileGroups):
             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,7 +17,7 @@ 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.
     """
@@ -25,17 +26,15 @@ class FileHandlerCompare(FileHandler):
             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.0.dist-info → file_groups-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: file-groups
-Version: 0.2.0
+Version: 0.3.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

file_groups-0.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+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,,

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

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

file_groups-0.2.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=pb1HXk-wUbD9R5iztuiYqsLewD_oS7rEFPDJt49Y_Ww,10007
-file_groups/groups.py,sha256=6v2LpzJqBHBWEToMI2RwqVy3ktIdWm2XIpS_tX6u94E,11501
-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.0.dist-info/LICENSE.txt,sha256=NZc9ictLEwfoL4ywpAbLbd-n02KETGHLYQU820TJD_Q,1494
-file_groups-0.2.0.dist-info/METADATA,sha256=fsDleiP5-XzNVRXiMK1xLx-NPbKOK3Qym18dkXA8iKQ,1512
-file_groups-0.2.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-file_groups-0.2.0.dist-info/top_level.txt,sha256=mAdRf0R2TA8tpH7ftHzXP7VMRhw07p7B2mI8QKpDnjU,12
-file_groups-0.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-file_groups-0.2.0.dist-info/RECORD,,