fb-tools 3.2.1__tar.gz → 3.3.0__tar.gz

{fb_tools-3.2.1 → fb_tools-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fb_tools
-Version: 3.2.1
+Version: 3.3.0
 Summary: @summary: A module for common used objects, error classes and functions.
 Author-email: Frank Brehm <frank@brehm-online.com>
 Requires-Python: >=3.8

{fb_tools-3.2.1 → fb_tools-3.3.0}/src/fb_tools/__init__.py

@@ -27,11 +27,13 @@ MIN_INDENT = 2
 # Maximal indention of configuration files
 MAX_INDENT = 12
 
+PROJECT_NAME = "fb-tools"
+
 # Own modules
 
 from .mailaddress import MailAddress, MailAddressList, QualifiedMailAddress  # noqa: F401
 from .multi_config import BaseMultiConfig  # noqa: F401
 
-__version__ = "3.2.1"
+__version__ = "3.3.0"
 
 # vim: ts=4 et list

{fb_tools-3.2.1 → fb_tools-3.3.0}/src/fb_tools/application/get_file_rm.py

@@ -29,7 +29,7 @@ from ..common import get_monday, pp
 from ..errors import FbAppError
 from ..xlate import XLATOR
 
-__version__ = "2.2.1"
+__version__ = "2.2.2"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -171,8 +171,10 @@ class GetFileRmApplication(BaseApplication):
         if v >= self.min_keep_days:
             self._keep_days = v
         else:
-            msg = _("Wrong value {v!r} for {n}, must be >= {m}").format(
-                v=value, n="keep_days", m=self.min_keep_days
+            msg = _("Wrong value {v} for {n}, must be >= {m}").format(
+                v=self.colored(repr(value), "red"),
+                n="keep_days",
+                m=self.colored(str(self.min_keep_days), "yellow"),
             )
             raise ValueError(msg)
 
@@ -188,8 +190,10 @@ class GetFileRmApplication(BaseApplication):
         if v >= self.min_keep_weeks:
             self._keep_weeks = v
         else:
-            msg = _("Wrong value {v!r} for {n}, must be >= {m}").format(
-                v=value, n="keep_weeks", m=self.min_keep_weeks
+            msg = _("Wrong value {v} for {n}, must be >= {m}").format(
+                v=self.colored(repr(value), "red"),
+                n="keep_weeks",
+                m=self.colored(str(self.min_keep_weeks), "yellow"),
             )
             raise ValueError(msg)
 
@@ -205,8 +209,10 @@ class GetFileRmApplication(BaseApplication):
         if v >= self.min_keep_months:
             self._keep_months = v
         else:
-            msg = _("Wrong value {v!r} for {n}, must be >= {m}").format(
-                v=value, n="keep_months", m=self.min_keep_months
+            msg = _("Wrong value {v} for {n}, must be >= {m}").format(
+                v=self.colored(repr(value), "red"),
+                n="keep_months",
+                m=self.colored(str(self.min_keep_months), "yellow"),
             )
             raise ValueError(msg)
 
@@ -222,8 +228,10 @@ class GetFileRmApplication(BaseApplication):
         if v >= self.min_keep_years:
             self._keep_years = v
         else:
-            msg = _("Wrong value {v!r} for {n}, must be >= {m}").format(
-                v=value, n="keep_years", m=self.min_keep_years
+            msg = _("Wrong value {v} for {n}, must be >= {m}").format(
+                v=self.colored(repr(value), "red"),
+                n="keep_years",
+                m=self.colored(str(self.min_keep_years), "yellow"),
             )
             raise ValueError(msg)
 
@@ -239,8 +247,10 @@ class GetFileRmApplication(BaseApplication):
         if v >= self.min_keep_last:
             self._keep_last = v
         else:
-            msg = _("Wrong value {v!r} for {n}, must be >= {m}").format(
-                v=value, n="keep_last", m=self.min_keep_last
+            msg = _("Wrong value {v} for {n}, must be >= {m}").format(
+                v=self.colored(repr(value), "red"),
+                n="keep_last",
+                m=self.colored(str(self.min_keep_last), "yellow"),
             )
             raise ValueError(msg)
 
@@ -368,7 +378,7 @@ class GetFileRmApplication(BaseApplication):
         if not check_date_pattern(pat):
             raise WrongDatePattern(self.date_pattern)
         if self.verbose > 1:
-            LOG.debug(_("Resolving date pattern {!r}.").format(pat))
+            LOG.debug(_("Resolving date pattern {}.").format(self.colored(pat, "cyan")))
 
         self._pattern = (
             pat.replace("%Y", r"(?P<year>\d{4})")
@@ -395,7 +405,7 @@ class GetFileRmApplication(BaseApplication):
         for fname in self.args.files:
 
             if self.verbose > 2:
-                LOG.debug(_("Checking given file {!r} ...").format(fname))
+                LOG.debug(_("Checking given file {} ...").format(self.colored(fname, "cyan")))
 
             given_paths = []
             single_fpath = Path(fname)
@@ -429,8 +439,9 @@ class GetFileRmApplication(BaseApplication):
                 match = self.re_date.search(str(fpath))
                 if not match:
                     LOG.warning(
-                        _("File {fi!r} does not match pattern {pa!r}.").format(
-                            fi=str(fpath), pa=self.date_pattern
+                        _("File {fi} does not match pattern {pa}.").format(
+                            fi=self.colored(str(fpath), "yellow"),
+                            pa=self.colord(repr(self.date_pattern), "yellow"),
                         )
                     )
                     continue

{fb_tools-3.2.1 → fb_tools-3.3.0}/src/fb_tools/handling_obj.py

@@ -24,17 +24,13 @@ import shutil
 import signal
 import socket
 import sys
+from pathlib import Path
 from shlex import quote
 from subprocess import PIPE, Popen
 
 # from codecs import BOM_BE, BOM_LE, BOM_UTF32_BE, BOM_UTF32_LE, BOM_UTF8
 # from collections import OrderedDict
 
-try:
-    import pathlib
-except ImportError:
-    import pathlib2 as pathlib
-
 if sys.version_info[0] >= 3:
     from subprocess import SubprocessError, TimeoutExpired
 else:
@@ -57,6 +53,7 @@ import six
 
 # Own modules
 from . import DEFAULT_TERMINAL_HEIGHT, DEFAULT_TERMINAL_WIDTH
+from . import PROJECT_NAME
 from .common import caller_search_path, encode_or_bust, pp, to_bool, to_str
 from .common import indent, is_sequence
 from .errors import AbortAppError
@@ -69,7 +66,7 @@ from .errors import WriteTimeoutError
 from .obj import FbBaseObject
 from .xlate import XLATOR, format_list
 
-__version__ = "2.4.9"
+__version__ = "2.6.0"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -182,19 +179,23 @@ class HandlingObject(FbBaseObject):
     * appname             (str          - rw) (inherited from FbBaseObject)
     * assumed_answer      (None or bool - rw)
     * base_dir            (pathlib.Path - rw) (inherited from FbBaseObject)
+    * cache_dir           (pathlib.Path - rw)
+    * data_dir            (pathlib.Path - rw)
     * force               (bool         - rw)
     * initialized         (bool         - rw) (inherited from FbBaseObject)
     * interrupted         (bool         - rw)
     * is_venv             (bool         - ro)
+    * project_name        (str)         - rw)
     * prompt_timeout      (int          - rw)
     * quiet               (bool         - rw)
     * simulate            (bool         - rw)
+    * state_dir           (pathlib.Path - rw)
     * terminal_has_colors (bool         - rw)
     * verbose             (int          - rw) (inherited from FbBaseObject)
     * version             (str          - ro) (inherited from FbBaseObject)
 
     Public attributes:
-    * add_search_paths       Array of pathlib.Path
+    * add_search_paths       Array of Path
     * signals_dont_interrupt Array of int
     """
 
@@ -221,6 +222,12 @@ class HandlingObject(FbBaseObject):
         "6",
     )
 
+    # Project name, used for the subdirectory name of different default directories
+    # e.g. log directory, data directory, cache dir, runtime dir a.s.o.
+    default_project_name = PROJECT_NAME
+
+    re_project_name = re.compile(r"^[a-z0-9]([a-z0-9+\-_\.]*[a-z0-9])?$", re.IGNORECASE)
+
     # -------------------------------------------------------------------------
     def __init__(
         self,
@@ -230,6 +237,11 @@ class HandlingObject(FbBaseObject):
         simulate=None,
         force=None,
         assumed_answer=None,
+        project_name=None,
+        data_dir=None,
+        cache_dir=None,
+        state_dir=None,
+        runtime_dir=None,
         *args,
         **kwargs,
     ):
@@ -248,11 +260,22 @@ class HandlingObject(FbBaseObject):
         @type: bool
         @param assumed_answer: The assumed answer to all yes/no questions.
         @type: bool or None
+        @param project_name: Project name used for subdirectories in default directories
+        @type: str
+        @param data_dir: directory to which user-specific data files should be stored.
+        @type: Path or None
+        @param cache_dir: directory to which user-specific non-essential data files
+                          should be stored.
+        @type: Path or None
+        @param state_dir: directory to which user-specific state files should be stored.
+        @type: Path or None
+        @param runtime_dir: directory to which non-essential runtime files should be stored.
+        @type: Path or None
 
         @param appname: name of the current running application
         @type: str
         @param base_dir: base directory used for different purposes
-        @type: str or pathlib.Path
+        @type: str or Path
         @param initialized: initialisation of this object is complete after init
         @type: bool
         @param verbose: verbosity level (0 - 9)
@@ -266,10 +289,19 @@ class HandlingObject(FbBaseObject):
         self._assumed_answer = None
         self._address_family = self.default_address_family
 
+        self._project_name = self.default_project_name
+        if project_name:
+            self.project_name = project_name
+
+        self._data_dir = self.get_default_data_dir() / self.project_name
+        self._cache_dir = self.get_default_cache_dir() / self.project_name
+        self._state_dir = self.get_default_state_dir() / self.project_name
+        self._runtime_dir = self.get_default_runtime_dir() / self.project_name
+
         self.add_search_paths = []
         """
         @ivar: Additional search paths of executing external commands
-        @type: Array of pathlib.Path
+        @type: Array of Path
         """
 
         self._prompt_timeout = self.default_prompt_timeout
@@ -292,6 +324,14 @@ class HandlingObject(FbBaseObject):
             version=version,
             **kwargs,
         )
+        if data_dir:
+            self._data_dir = data_dir
+        if cache_dir:
+            self.cache_dir = cache_dir
+        if state_dir:
+            self.state_dir = state_dir
+        if runtime_dir:
+            self.runtime_dir = runtime_dir
 
         if simulate is not None:
             self.simulate = simulate
@@ -427,6 +467,102 @@ class HandlingObject(FbBaseObject):
             family = socket.AF_INET6
         self._address_family = family
 
+    # -----------------------------------------------------------
+    @property
+    def project_name(self):
+        """Return the project name used for subdirectories in default directories."""
+        return self._project_name
+
+    @project_name.setter
+    def project_name(self, value):
+        if value is None:
+            self._project_name = self.default_project_name
+            return
+
+        val = str(value)
+        if val == "":
+            raise ValueError(_("A project name must not be empty."))
+
+        if not self.re_project_name.match(val):
+            msg = _("Invalid project name {} given.").format(self.colored(val, "red"))
+            raise ValueError(msg)
+
+    # -----------------------------------------------------------
+    @property
+    def data_dir(self):
+        """Return the directory to which user-specific data files should be stored."""
+        return self._data_dir
+
+    @data_dir.setter
+    def data_dir(self, value):
+        if value is None:
+            self._data_dir = self.get_default_data_dir() / self.project_name
+            return
+
+        path = Path(value)
+        if path.is_absolute():
+            self._data_dir = path
+            return
+
+        self._data_dir = path.resolve()
+
+    # -----------------------------------------------------------
+    @property
+    def cache_dir(self):
+        """Return the dir to which user-specific non-essential data files should be stored."""
+        return self._cache_dir
+
+    @cache_dir.setter
+    def cache_dir(self, value):
+        if value is None:
+            self._cache_dir = self.get_default_cache_dir() / self.project_name
+            return
+
+        path = Path(value)
+        if path.is_absolute():
+            self._cache_dir = path
+            return
+
+        self._cache_dir = path.resolve()
+
+    # -----------------------------------------------------------
+    @property
+    def state_dir(self):
+        """Return the directory to which user-specific state files should be stored."""
+        return self._state_dir
+
+    @state_dir.setter
+    def state_dir(self, value):
+        if value is None:
+            self._state_dir = self.get_default_state_dir() / self.project_name
+            return
+
+        path = Path(value)
+        if path.is_absolute():
+            self._state_dir = path
+            return
+
+        self._state_dir = path.resolve()
+
+    # -----------------------------------------------------------
+    @property
+    def runtime_dir(self):
+        """Return the directory to which user-specific runtime files should be stored."""
+        return self._runtime_dir
+
+    @runtime_dir.setter
+    def runtime_dir(self, value):
+        if value is None:
+            self._runtime_dir = self.get_default_runtime_dir() / self.project_name
+            return
+
+        path = Path(value)
+        if path.is_absolute():
+            self._runtime_dir = path
+            return
+
+        self._runtime_dir = path.resolve()
+
     # -------------------------------------------------------------------------
     @classmethod
     def init_yes_no_lists(cls):
@@ -450,6 +586,80 @@ class HandlingObject(FbBaseObject):
         )
         cls.re_yes_no = re.compile(cls.pattern_yes_no, re.IGNORECASE)
 
+    # -------------------------------------------------------------------------
+    @classmethod
+    def get_default_data_dir(cls):
+        """Return the default base path to the data directory."""
+        xdg_dir = os.environ.get("XDG_DATA_HOME", None)
+        xdg_dirs = os.environ.get("XDG_DATA_DIRS", None)
+
+        if xdg_dirs:
+            xdg_dirs = [Path(x) for x in xdg_dirs.split(os.pathsep)]
+        else:
+            xdg_dirs = []
+
+        # If $XDG_DATA_HOME was given, then use it, no matter whether it exists
+        if xdg_dir:
+            # LOG.debug(f"Using data_dir {xdg_dir!r}.")
+            return Path(xdg_dir)
+
+        # Search for the first existing dir in XDG_DATA_DIRS. If not existing,
+        # use the first one, no matter whether it exists
+        if xdg_dirs:
+            for ddir in xdg_dirs:
+                # LOG.debug(f"Checking data_dir {str(ddir)!r}.")
+                if ddir.exists and ddir.is_dir() and os.access(str(ddir), os.W_OK):
+                    # LOG.debug(f"Using data_dir {str(ddir)!r}.")
+                    return ddir
+            if not os.geteuid():
+                return xdg_dirs[0]
+
+        # Init as root user
+        if not os.geteuid():
+            return Path("/var/lib")
+
+        # Init as non root user
+        return Path("~/.local/share").expanduser()
+
+    # -------------------------------------------------------------------------
+    @classmethod
+    def get_default_cache_dir(cls):
+        """Get the default base path to the cache directory."""
+        xdg_dir = os.environ.get("XDG_CACHE_HOME", None)
+
+        if xdg_dir:
+            return Path(xdg_dir)
+
+        if not os.geteuid():
+            return Path("/var/cache")
+
+        return Path("~/.cache").expanduser()
+
+    # -------------------------------------------------------------------------
+    @classmethod
+    def get_default_state_dir(cls):
+        """Get the default base path to the state directory."""
+        xdg_dir = os.environ.get("XDG_STATE_HOME", None)
+
+        if xdg_dir:
+            return Path(xdg_dir)
+
+        if not os.geteuid():
+            return Path("/var/lib")
+
+        return Path("~/.local/state").expanduser()
+
+    # -------------------------------------------------------------------------
+    @classmethod
+    def get_default_runtime_dir(cls):
+        """Get the default base path to the runtime directory."""
+        xdg_dir = os.environ.get("XDG_RUNTIME_DIR", None)
+
+        if xdg_dir:
+            return Path(xdg_dir)
+
+        return Path("/run")
+
     # -------------------------------------------------------------------------
     def as_dict(self, short=True):
         """
@@ -464,15 +674,20 @@ class HandlingObject(FbBaseObject):
         res = super(HandlingObject, self).as_dict(short=short)
         res["address_family"] = self.address_family
         res["assumed_answer"] = self.assumed_answer
+        res["cache_dir"] = self.cache_dir
+        res["data_dir"] = self.data_dir
         res["fileio_timeout"] = self.fileio_timeout
         res["force"] = self.force
         res["interrupted"] = self.interrupted
         res["is_venv"] = self.is_venv
         res["no_list"] = self.no_list
         res["pattern_yes_no"] = self.pattern_yes_no
+        res["project_name"] = self.project_name
         res["prompt_timeout"] = self.prompt_timeout
         res["quiet"] = self.quiet
+        res["runtime_dir"] = self.runtime_dir
         res["simulate"] = self.simulate
+        res["state_dir"] = self.state_dir
         res["terminal_has_colors"] = self.terminal_has_colors
         res["yes_list"] = self.yes_list
 
@@ -637,7 +852,7 @@ class HandlingObject(FbBaseObject):
         @rtype: str or None
 
         """
-        cmd = pathlib.Path(cmd)
+        cmd = Path(cmd)
 
         if self.verbose > 2:
             LOG.debug(_("Searching for command {!r} ...").format(str(cmd)))

{fb_tools-3.2.1 → fb_tools-3.3.0}/src/fb_tools/multi_config/inits.py

@@ -25,7 +25,7 @@ import six
 from ..common import is_sequence, to_str
 from ..xlate import XLATOR
 
-__version__ = "0.2.1"
+__version__ = "0.4.0"
 
 LOG = logging.getLogger(__name__)
 
@@ -43,54 +43,74 @@ class MultiCfgInitMixin:
 
     # -------------------------------------------------------------------------
     def _init_config_dirs(self, additional_cfgdirs=None):
-
+        """Create the list of possible configuration directories."""
         self.config_dirs = []
 
-        self.config_dirs.append(Path("/etc") / self.config_dir)
+        # Insert in this list possible paths in decreasing priority
 
-        path = Path(os.path.expanduser("~")) / ".config" / self.config_dir
-        if path in self.config_dirs:
-            self.config_dirs.remove(path)
+        # Exceptionally given additional config directory or directories
+        if additional_cfgdirs:
+            if is_sequence(additional_cfgdirs):
+                for item in additional_cfgdirs:
+                    path = Path(item)
+                    if path not in self.config_dirs:
+                        self.config_dirs.append(path)
+            else:
+                path = Path(additional_cfgdirs)
+                self.config_dirs.append(Path(additional_cfgdirs))
 
-        self.config_dirs.append(path)
-        if self.is_venv():
-            path = Path(sys.prefix) / "etc"
-            if path in self.config_dirs:
-                self.config_dirs.remove(path)
+        # Current working directory
+        path = Path.cwd()
+        if path not in self.config_dirs:
             self.config_dirs.append(path)
 
-        path = Path.cwd() / "etc"
-        if path in self.config_dirs:
-            self.config_dirs.remove(path)
-        self.config_dirs.append(path)
+        # The base directory itselv (whatever it is)
+        path = self.base_dir
+        if path not in self.config_dirs:
+            self.config_dirs.append(path)
 
+        # ${base_dir}/etc
         path = self.base_dir / "etc"
-        if path in self.config_dirs:
-            self.config_dirs.remove(path)
-        self.config_dirs.append(path)
+        if path not in self.config_dirs:
+            self.config_dirs.append(path)
 
-        path = self.base_dir
-        if path in self.config_dirs:
-            self.config_dirs.remove(path)
-        self.config_dirs.append(path)
+        # ${current_working_directory}/etc
+        path = Path.cwd() / "etc"
+        if path not in self.config_dirs:
+            self.config_dirs.append(path)
 
-        path = Path.cwd()
-        if path in self.config_dirs:
-            self.config_dirs.remove(path)
-        self.config_dirs.append(path)
+        # ${virtual_env_directory}/etc
+        if self.is_venv():
+            path = Path(sys.prefix) / "etc"
+            if path not in self.config_dirs:
+                self.config_dirs.append(path)
 
-        if additional_cfgdirs:
-            if is_sequence(additional_cfgdirs):
-                for item in additional_cfgdirs:
-                    path = Path(item)
-                    if path in self.config_dirs:
-                        self.config_dirs.remove(path)
+        # ${XDG_CONFIG_HOME}/${config_dir}
+        xdg_dir = os.environ.get("XDG_CONFIG_HOME", None)
+        if xdg_dir:
+            path = Path(xdg_dir) / self.config_dir
+        else:
+            path = Path("~/.config").expanduser() / self.config_dir
+        if path not in self.config_dirs:
+            self.config_dirs.append(path)
+
+        # All directories in $XDG_CONFIG_DIRS, appended by ${config_dir}
+        xdg_dirs = os.environ.get("XDG_CONFIG_DIRS", None)
+        if xdg_dirs:
+            xdg_dirs = [Path(x) for x in xdg_dirs.split(os.pathsep)]
+            for path in xdg_dirs:
+                path = path / self.config_dir
+                if path not in self.config_dirs:
                     self.config_dirs.append(path)
-            else:
-                path = Path(additional_cfgdirs)
-                if path in self.config_dirs:
-                    self.config_dirs.remove(path)
-                self.config_dirs.append(path)
+
+        # last, but not least /etc/${config_dir}
+        path = Path("/etc") / self.config_dir
+        if path not in self.config_dirs:
+            self.config_dirs.append(path)
+
+        # And now revert the list, so the lowest prioritized dirs come first,
+        # and the highest prioritized dir comes at last
+        self.config_dirs.reverse()
 
     # -------------------------------------------------------------------------
     def _init_stems(self, append_appname_to_stems, additional_stems=None):

{fb_tools-3.2.1 → fb_tools-3.3.0}/src/fb_tools/socket_obj/__init__.py

@@ -34,7 +34,7 @@ from ..errors import GenericSocketError
 from ..handling_obj import HandlingObject
 from ..xlate import XLATOR
 
-__version__ = "0.8.0"
+__version__ = "0.8.1"
 
 LOG = logging.getLogger(__name__)
 
@@ -689,14 +689,18 @@ class GenericSocket(HandlingObject):
     def __enter__(self):
         """Execute this action, when this socket will be opened by the with-block."""
         LOG.debug(
-            _("Opened the {cls} {name!r} ...").format(cls=self.__class__.__name__, name=self.name)
+            _("Opened the {cls} {name} ...").format(
+                cls=self.__class__.__name__, name=self.colored(self.name, "cyan")
+            )
         )
 
     # -------------------------------------------------------------------------
     def __exit__(self, exc_type, exc_val, exc_traceback):
         """Exit action at the end of the with-block - closing socket."""
         LOG.debug(
-            _("Closing the {cls} {name!r} ...").format(cls=self.__class__.__name__, name=self.name)
+            _("Closing the {cls} {name} ...").format(
+                cls=self.__class__.__name__, name=self.colored(self.name, "cyan")
+            )
         )
 
         self.close()