docker-tidy 4.2.0__tar.gz → 4.2.2__tar.gz

{docker_tidy-4.2.0 → docker_tidy-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-tidy
-Version: 4.2.0
+Version: 4.2.2
 Summary: Keep docker hosts tidy.
 License: Apache-2.0
 License-File: LICENSE
@@ -24,24 +24,24 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development
 Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Utilities
-Requires-Dist: anyconfig (==0.15.1)
+Requires-Dist: anyconfig (==0.16.0)
 Requires-Dist: appdirs (==1.4.4)
 Requires-Dist: certifi (==2026.7.22)
 Requires-Dist: colorama (==0.4.6)
-Requires-Dist: dateparser (==1.4.2)
+Requires-Dist: dateparser (==1.4.3)
 Requires-Dist: docker (==7.2.0)
 Requires-Dist: docker-pycreds (==0.4.0)
-Requires-Dist: environs (==15.1.0)
-Requires-Dist: idna (==3.18)
+Requires-Dist: environs (==15.2.0)
+Requires-Dist: idna (==3.19)
 Requires-Dist: ipaddress (==1.0.23)
 Requires-Dist: jsonschema (==4.26.0)
 Requires-Dist: nested-lookup (==0.2.25)
 Requires-Dist: pathspec (==1.1.1)
 Requires-Dist: python-dateutil (==2.9.0.post0)
-Requires-Dist: python-json-logger (==4.1.0)
+Requires-Dist: python-json-logger (==4.2.0)
 Requires-Dist: requests (==2.34.2)
 Requires-Dist: ruamel.yaml (==0.19.1)
-Requires-Dist: websocket_client (==1.9.0)
+Requires-Dist: websocket_client (==1.9.2)
 Requires-Dist: zipp (==4.1.0)
 Project-URL: Documentation, https://docker-tidy.geekdocs.de/
 Project-URL: Homepage, https://docker-tidy.geekdocs.de/

docker_tidy-4.2.2/dockertidy/__init__.py

@@ -0,0 +1,8 @@
+"""Default package."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("docker-tidy")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

{docker_tidy-4.2.0 → docker_tidy-4.2.2}/dockertidy/config.py

@@ -9,7 +9,7 @@ import environs
 import jsonschema.exceptions
 import ruamel.yaml
 from appdirs import AppDirs
-from jsonschema._utils import format_as_index
+from environs.exceptions import EnvError, EnvNotSetError
 
 import dockertidy.exception
 import dockertidy.parser
@@ -167,20 +167,23 @@ class Config:
 
     def _get_envs(self) -> dict[str, Any]:
         normalized: dict[str, Any] = {}
+        prefix = "TIDY_"
         for key, item in self.SETTINGS.items():
-            if item.get("env"):
-                prefix = "TIDY_"
-                env_name = prefix + item["env"]
-                try:
-                    value = item["type"](env_name)
-                    normalized = self._add_dict_branch(normalized, key.split("."), value)
-                except environs.EnvError as e:
-                    if f'"{env_name}" not set' in str(e):
-                        pass
-                    else:
-                        raise dockertidy.exception.ConfigError(
-                            "Unable to read environment variable", str(e)
-                        ) from e
+            env = item.get("env")
+            if not env:
+                continue
+
+            env_name = prefix + env
+            try:
+                value = item["type"](env_name)
+            except EnvNotSetError:
+                continue
+            except EnvError as e:
+                raise dockertidy.exception.ConfigError(
+                    "Unable to read environment variable", str(e)
+                ) from e
+
+            normalized = self._add_dict_branch(normalized, key.split("."), value)
 
         return normalized
 
@@ -249,8 +252,9 @@ class Config:
         try:
             anyconfig.validate(config, self.schema, ac_schema_safe=False)
         except jsonschema.exceptions.ValidationError as e:
-            schema = format_as_index("config", list(e.relative_schema_path)[1:-1])
-            schema_error = f"Failed validating '{e.validator}' in schema {schema}\n{e.message}"
+            schema_error = (
+                f"Failed validating '{e.validator}' in schema {e.json_path}\n{e.message}"
+            )
             raise dockertidy.exception.ConfigError("Configuration error", schema_error) from e
 
         return True

docker_tidy-4.2.2/dockertidy/logger.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Global utility methods and classes."""
+
+import copy
+import logging
+import os
+import sys
+from typing import Any, NoReturn
+
+import colorama
+from pythonjsonlogger.json import JsonFormatter
+
+from dockertidy.utils import Singleton
+
+JSON_FORMAT = "%(asctime)s %(levelname)s %(message)s"
+
+_LEVEL_COLORS: dict[int, tuple[str, str]] = {
+    logging.DEBUG: (colorama.Fore.BLUE, colorama.Style.BRIGHT),
+    logging.INFO: (colorama.Fore.CYAN, colorama.Style.BRIGHT),
+    logging.WARNING: (colorama.Fore.YELLOW, colorama.Style.BRIGHT),
+    logging.ERROR: (colorama.Fore.RED, colorama.Style.BRIGHT),
+    logging.CRITICAL: (colorama.Fore.RED, colorama.Style.BRIGHT),
+}
+
+_STDOUT_LEVELS = {logging.INFO, logging.WARNING}
+_STDERR_LEVELS = {logging.DEBUG, logging.ERROR, logging.CRITICAL}
+
+
+def _should_do_markup() -> bool:
+    py_colors = os.environ.get("PY_COLORS")
+    if py_colors is not None:
+        return py_colors.strip().lower() in {"1", "true", "yes", "on", "y", "t"}
+
+    return sys.stdout.isatty() and os.environ.get("TERM") != "dumb"
+
+
+colorama.init(autoreset=True, strip=not _should_do_markup())
+
+
+class LevelFilter(logging.Filter):
+    """Keep only records whose level belongs to the configured level set."""
+
+    def __init__(self, levels: set[int]) -> None:
+        super().__init__()
+        self._levels = levels
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.levelno in self._levels
+
+
+class ConsoleFormatter(logging.Formatter):
+    """Colorize the level prefix and reset the color after line breaks."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        color, style = _LEVEL_COLORS.get(record.levelno, (colorama.Fore.WHITE, ""))
+        reset = colorama.Style.RESET_ALL
+        message = record.getMessage().replace("\n", f"\n{reset}... ")
+        output = f"{color}{style}[{record.levelname}]{reset} {message}"
+
+        if record.exc_info and not record.exc_text:
+            record.exc_text = self.formatException(record.exc_info)
+        if record.exc_text:
+            if output[-1:] != "\n":
+                output += "\n"
+            output += record.exc_text
+
+        return output
+
+
+class MultilineJsonFormatter(JsonFormatter):
+    """JSON formatter that replaces line breaks in messages with spaces."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        record = copy.copy(record)
+        record.msg = record.msg.replace("\n", " ")
+        return JsonFormatter.format(self, record)
+
+
+class Log:
+    """Base logging object."""
+
+    def __init__(
+        self, level: int = logging.WARNING, name: str = "dockertidy", json: bool = False
+    ) -> None:
+        self.logger = logging.getLogger(name)
+        self.logger.propagate = False
+        self.logger.setLevel(level)
+        self._configure(json)
+
+    def _configure(self, json: bool = False) -> None:
+        for handler in self.logger.handlers[:]:
+            self.logger.removeHandler(handler)
+
+        self.logger.addHandler(self._get_handler(sys.stdout, _STDOUT_LEVELS, json))
+        self.logger.addHandler(self._get_handler(sys.stderr, _STDERR_LEVELS, json))
+
+    def _get_handler(self, stream: Any, levels: set[int], json: bool = False) -> logging.Handler:
+        handler = logging.StreamHandler(stream)
+        handler.setLevel(logging.DEBUG)
+        handler.addFilter(LevelFilter(levels))
+        handler.setFormatter(self._get_formatter(json))
+        return handler
+
+    def _get_formatter(self, json: bool = False) -> logging.Formatter:
+        if json:
+            return MultilineJsonFormatter(JSON_FORMAT)
+        return ConsoleFormatter()
+
+    def set_level(self, s: str | int) -> None:
+        """Set log level."""
+        self.logger.setLevel(s)
+
+    def sysexit(self, code: int = 1) -> NoReturn:
+        """Exit running program with given exit code."""
+        sys.exit(code)
+
+    def sysexit_with_message(self, msg: Any, code: int = 1) -> NoReturn:
+        """Exit running program with given exit code and message."""
+        self.logger.critical(str(msg))
+        self.sysexit(code)
+
+
+class SingleLog(Log, metaclass=Singleton):
+    """Singleton logger object."""
+
+    pass

docker_tidy-4.2.2/dockertidy/utils.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Global utility methods and classes."""
+
+import threading
+from typing import Any
+
+
+def dict_intersect(d1: dict[str, Any], d2: dict[str, Any]) -> dict[str, Any]:
+    return {
+        k: dict_intersect(d1[k], d2[k]) if isinstance(d1[k], dict) else d1[k]
+        for k in d1.keys() & d2.keys()
+    }
+
+
+class Singleton(type):
+    """Thread-safe singleton metaclass."""
+
+    _instances: dict[Any, Any] = {}
+    _lock = threading.Lock()
+
+    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
+        if cls not in cls._instances:
+            with cls._lock:
+                if cls not in cls._instances:
+                    cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]

{docker_tidy-4.2.0 → docker_tidy-4.2.2}/pyproject.toml

@@ -28,44 +28,44 @@ name = "docker-tidy"
 packages = [{ include = "dockertidy", format = ["sdist", "wheel"] }]
 readme = "README.md"
 repository = "https://github.com/thegeeklab/docker-tidy/"
-version = "4.2.0"
+version = "4.2.2"
 
 [tool.poetry.dependencies]
-anyconfig = "0.15.1"
+anyconfig = "0.16.0"
 appdirs = "1.4.4"
 certifi = "2026.7.22"
 colorama = "0.4.6"
-dateparser = "1.4.2"
+dateparser = "1.4.3"
 docker = "7.2.0"
 docker-pycreds = "0.4.0"
-environs = "15.1.0"
-idna = "3.18"
+environs = "15.2.0"
+idna = "3.19"
 ipaddress = "1.0.23"
 jsonschema = "4.26.0"
 nested-lookup = "0.2.25"
 pathspec = "1.1.1"
 python = "^3.11.0"
 python-dateutil = "2.9.0.post0"
-python-json-logger = "4.1.0"
+python-json-logger = "4.2.0"
 requests = "2.34.2"
 "ruamel.yaml" = "0.19.1"
-websocket_client = "1.9.0"
+websocket_client = "1.9.2"
 zipp = "4.1.0"
 
 [tool.poetry.scripts]
 docker-tidy = "dockertidy.cli:main"
 
 [tool.poetry.group.dev.dependencies]
-ruff = "0.16.2"
+ruff = "0.16.7"
 pytest = "9.1.1"
 pytest-mock = "3.15.1"
 pytest-cov = "7.1.0"
 toml = "0.10.2"
 types-appdirs = "1.4.3.5"
-types-docker = "7.2.0.20260806"
-mypy = "2.3.0"
+types-docker = "7.2.0.20260827"
+mypy = "2.3.1"
 types-python-dateutil = "2.9.0.20260807"
-types-dateparser = "1.4.1.20260806"
+types-dateparser = "1.4.3.20260907"
 types-jsonschema = "4.26.0.20260518"
 types-colorama = "0.4.15.20260508"
 

docker_tidy-4.2.0/dockertidy/__init__.py

@@ -1,3 +0,0 @@
-"""Default package."""
-
-__version__ = "4.2.0"

docker_tidy-4.2.0/dockertidy/logger.py

@@ -1,201 +0,0 @@
-#!/usr/bin/env python3
-"""Global utility methods and classes."""
-
-import logging
-import os
-import sys
-from typing import Any, NoReturn
-
-import colorama
-from pythonjsonlogger.json import JsonFormatter
-
-from dockertidy.utils import Singleton, to_bool
-
-CONSOLE_FORMAT = "{}[%(levelname)s]{} %(message)s"
-JSON_FORMAT = "%(asctime)s %(levelname)s %(message)s"
-
-
-def _should_do_markup() -> bool:
-    py_colors = os.environ.get("PY_COLORS", None)
-    if py_colors is not None:
-        return to_bool(py_colors)
-
-    return sys.stdout.isatty() and os.environ.get("TERM") != "dumb"
-
-
-colorama.init(autoreset=True, strip=not _should_do_markup())
-
-
-class LogFilter:
-    """A custom log filter which excludes log messages above the logged level."""
-
-    def __init__(self, level: int) -> None:
-        """
-        Initialize a new custom log filter.
-
-        :param level: Log level limit
-        :returns: None
-
-        """
-        self.__level = level
-
-    def filter(self, logRecord: logging.LogRecord) -> bool:  # noqa
-        # https://docs.python.org/3/library/logging.html#logrecord-attributes
-        return logRecord.levelno <= self.__level
-
-
-class MultilineFormatter(logging.Formatter):
-    """Logging Formatter to reset color after newline characters."""
-
-    def format(self, record: logging.LogRecord) -> str:
-        record.msg = record.msg.replace("\n", f"\n{colorama.Style.RESET_ALL}... ")
-        return logging.Formatter.format(self, record)
-
-
-class MultilineJsonFormatter(JsonFormatter):
-    """Logging Formatter to remove newline characters."""
-
-    def format(self, record: logging.LogRecord) -> str:
-        record.msg = record.msg.replace("\n", " ")
-        return JsonFormatter.format(self, record)
-
-
-class Log:
-    """Base logging object."""
-
-    def __init__(
-        self, level: int = logging.WARNING, name: str = "dockertidy", json: bool = False
-    ) -> None:
-        self.logger = logging.getLogger(name)
-        self.logger.setLevel(level)
-        self.logger.addHandler(self._get_error_handler(json=json))
-        self.logger.addHandler(self._get_warning_handler(json=json))
-        self.logger.addHandler(self._get_info_handler(json=json))
-        self.logger.addHandler(self._get_critical_handler(json=json))
-        self.logger.addHandler(self._get_debug_handler(json=json))
-        self.logger.propagate = False
-
-    def _get_error_handler(self, json: bool = False) -> logging.Handler:
-        handler = logging.StreamHandler(sys.stderr)
-        handler.setLevel(logging.ERROR)
-        handler.addFilter(LogFilter(logging.ERROR))
-        handler.setFormatter(
-            MultilineFormatter(
-                self.error(CONSOLE_FORMAT.format(colorama.Fore.RED, colorama.Style.RESET_ALL))
-            )
-        )
-
-        if json:
-            handler.setFormatter(MultilineJsonFormatter(JSON_FORMAT))
-
-        return handler
-
-    def _get_warning_handler(self, json: bool = False) -> logging.Handler:
-        handler = logging.StreamHandler(sys.stdout)
-        handler.setLevel(logging.WARNING)
-        handler.addFilter(LogFilter(logging.WARNING))
-        handler.setFormatter(
-            MultilineFormatter(
-                self.warning(CONSOLE_FORMAT.format(colorama.Fore.YELLOW, colorama.Style.RESET_ALL))
-            )
-        )
-
-        if json:
-            handler.setFormatter(MultilineJsonFormatter(JSON_FORMAT))
-
-        return handler
-
-    def _get_info_handler(self, json: bool = False) -> logging.Handler:
-        handler = logging.StreamHandler(sys.stdout)
-        handler.setLevel(logging.INFO)
-        handler.addFilter(LogFilter(logging.INFO))
-        handler.setFormatter(
-            MultilineFormatter(
-                self.info(CONSOLE_FORMAT.format(colorama.Fore.CYAN, colorama.Style.RESET_ALL))
-            )
-        )
-
-        if json:
-            handler.setFormatter(MultilineJsonFormatter(JSON_FORMAT))
-
-        return handler
-
-    def _get_critical_handler(self, json: bool = False) -> logging.Handler:
-        handler = logging.StreamHandler(sys.stderr)
-        handler.setLevel(logging.CRITICAL)
-        handler.addFilter(LogFilter(logging.CRITICAL))
-        handler.setFormatter(
-            MultilineFormatter(
-                self.critical(CONSOLE_FORMAT.format(colorama.Fore.RED, colorama.Style.RESET_ALL))
-            )
-        )
-
-        if json:
-            handler.setFormatter(MultilineJsonFormatter(JSON_FORMAT))
-
-        return handler
-
-    def _get_debug_handler(self, json: bool = False) -> logging.Handler:
-        handler = logging.StreamHandler(sys.stderr)
-        handler.setLevel(logging.DEBUG)
-        handler.addFilter(LogFilter(logging.DEBUG))
-        handler.setFormatter(
-            MultilineFormatter(
-                self.critical(CONSOLE_FORMAT.format(colorama.Fore.BLUE, colorama.Style.RESET_ALL))
-            )
-        )
-
-        if json:
-            handler.setFormatter(MultilineJsonFormatter(JSON_FORMAT))
-
-        return handler
-
-    def set_level(self, s: str | int) -> None:
-        """Set log level."""
-        self.logger.setLevel(s)
-
-    def debug(self, msg: str) -> str:
-        """Format info messages and return string."""
-        return msg
-
-    def critical(self, msg: str) -> str:
-        """Format critical messages and return string."""
-        return msg
-
-    def error(self, msg: str) -> str:
-        """Format error messages and return string."""
-        return msg
-
-    def warning(self, msg: str) -> str:
-        """Format warning messages and return string."""
-        return msg
-
-    def info(self, msg: str) -> str:
-        """Format info messages and return string."""
-        return msg
-
-    def _color_text(self, color: str, msg: str) -> str:
-        """
-        Colorize strings.
-
-        :param color: colorama color settings
-        :param msg: string to colorize
-        :returns: string
-
-        """
-        return f"{color}{msg}{colorama.Style.RESET_ALL}"
-
-    def sysexit(self, code: int = 1) -> NoReturn:
-        """Exit running program with given exit code."""
-        sys.exit(code)
-
-    def sysexit_with_message(self, msg: Any, code: int = 1) -> NoReturn:
-        """Exit running program with given exit code and message."""
-        self.logger.critical(str(msg))
-        self.sysexit(code)
-
-
-class SingleLog(Log, metaclass=Singleton):
-    """Singleton logger object."""
-
-    pass

docker_tidy-4.2.0/dockertidy/utils.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""Global utility methods and classes."""
-
-from typing import Any
-
-
-def strtobool(value: str) -> bool:
-    """Convert a string representation of truth to true or false."""
-
-    _map = {
-        "y": True,
-        "yes": True,
-        "t": True,
-        "true": True,
-        "on": True,
-        "1": True,
-        "n": False,
-        "no": False,
-        "f": False,
-        "false": False,
-        "off": False,
-        "0": False,
-    }
-
-    try:
-        return _map[str(value).lower()]
-    except KeyError as err:
-        raise ValueError(f'"{value}" is not a valid bool value') from err
-
-
-def to_bool(string: str | bool) -> bool:
-    return bool(strtobool(str(string)))
-
-
-def dict_intersect(d1: dict[str, Any], d2: dict[str, Any]) -> dict[str, Any]:
-    return {
-        k: dict_intersect(d1[k], d2[k]) if isinstance(d1[k], dict) else d1[k]
-        for k in d1.keys() & d2.keys()
-    }
-
-
-class Singleton(type):
-    """Singleton metaclass."""
-
-    _instances: dict[Any, Any] = {}
-
-    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
-        if cls not in cls._instances:
-            cls._instances[cls] = super().__call__(*args, **kwargs)
-        return cls._instances[cls]