command_watcher 0.6.0__tar.gz → 0.7.0__tar.gz

{command_watcher-0.6.0 → command_watcher-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: command_watcher
-Version: 0.6.0
+Version: 0.7.0
 Summary: Module to watch the execution of shell scripts. Both streams (`stdout` and `stderr`) are captured.
 Author: Josef Friedrich
 Author-email: Josef Friedrich <josef@friedrich.rocks>
@@ -37,6 +37,10 @@ command_watcher
 Module to watch the execution of shell scripts. Both streams (`stdout`
 and `stderr`) are captured.
 
+The watcher's loggers print each message once and do not propagate it to
+Python's root logger. Command output is also stored on the command executor
+and, unless ``log=False`` is passed to ``watch.run()``, on the watcher.
+
 .. code:: python
 
     watch = Watch()

{command_watcher-0.6.0 → command_watcher-0.7.0}/README.rst

@@ -12,6 +12,10 @@ command_watcher
 Module to watch the execution of shell scripts. Both streams (`stdout`
 and `stderr`) are captured.
 
+The watcher's loggers print each message once and do not propagate it to
+Python's root logger. Command output is also stored on the command executor
+and, unless ``log=False`` is passed to ``watch.run()``, on the watcher.
+
 .. code:: python
 
     watch = Watch()

command_watcher-0.7.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "command_watcher"
+version = "0.7.0"
+description = "Module to watch the execution of shell scripts. Both streams (`stdout` and `stderr`) are captured."
+requires-python = ">=3.12,<4"
+readme = "README.rst"
+license = "MIT"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "pretiac>=0.6.0",
+    "pydantic>=2.12.5",
+    "pyyaml>=6.0.3",
+    "termcolor>=3.3.0",
+    "types-pyyaml>=6.0.12.20250915",
+    "types-requests>=2.32.4.20260107",
+    "types-termcolor>=1.1.6.2",
+]
+
+[[project.authors]]
+name = "Josef Friedrich"
+email = "josef@friedrich.rocks"
+
+[project.urls]
+Repository = "https://github.com/Josef-Friedrich/command-watcher"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.0",
+    "pytest>=9.0.2",
+    "stdout-stderr-capturing>=0.2.1",
+]
+
+[tool.uv.sources.pretiac]
+git = "https://github.com/Josef-Friedrich/PREtty-Typed-Icinga2-Api-Client_py.git"
+
+[tool.pytest.ini_options]
+verbosity_assertions = 2
+truncation_limit_lines = 999999
+truncation_limit_chars = 999999
+
+[build-system]
+requires = ["uv_build>=0.13.7,<0.14.0"]
+build-backend = "uv_build"

command_watcher-0.6.0/pyproject.toml → command_watcher-0.7.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "command_watcher"
-version = "0.6.0"
+version = "0.7.0"
 description = "Module to watch the execution of shell scripts. Both streams (`stdout` and `stderr`) are captured."
 authors = [{ name = "Josef Friedrich", email = "josef@friedrich.rocks" }]
 requires-python = ">=3.12,<4"
@@ -30,6 +30,7 @@ Repository = "https://github.com/Josef-Friedrich/command-watcher"
 
 [dependency-groups]
 dev = [
+    "mypy>=1.0",
     "pytest>=9.0.2",
     "stdout-stderr-capturing>=0.2.1",
 ]
@@ -40,7 +41,7 @@ dev = [
 pretiac = { git = "https://github.com/Josef-Friedrich/PREtty-Typed-Icinga2-Api-Client_py.git" }
 
 [build-system]
-requires = ["uv_build>=0.11.1,<0.12.0"]
+requires = ["uv_build>=0.13.7,<0.14.0"]
 build-backend = "uv_build"
 
 [tool.pytest.ini_options]

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/__init__.py

@@ -17,14 +17,10 @@ from typing import (
     IO,
     Any,
     Literal,
-    Optional,
-    Tuple,
     TypedDict,
-    Union,
+    Unpack,
 )
 
-from typing_extensions import Unpack
-
 from command_watcher.channels.base_channel import BaseChannel
 from command_watcher.channels.beep import BeepChannel
 from command_watcher.channels.email import EmailChannel
@@ -64,10 +60,10 @@ class Timer:
     """Measure the execution time of a command run."""
 
     stop: float
-    """"The time when the timer stops. (UNIX timestamp)"""
+    """The time when the timer stops. (UNIX timestamp)"""
 
     start: float
-    """"The start time. (UNIX timestamp)"""
+    """The start time. (UNIX timestamp)"""
 
     interval: float
     """The time interval between start and stop."""
@@ -84,15 +80,15 @@ class Timer:
         :return: A formatted string displaying the result."""
         self.stop = time.time()
         self.interval = self.stop - self.start
-        return "{:.3f}s".format(self.interval)
+        return f"{self.interval:.3f}s"
 
 
 # Main code ###################################################################
 
-Arg = Union[str, Path]
+Arg = str | Path
 """Command line argument"""
 
-Args = Union[Arg, list[Arg], tuple[Arg]]
+Args = Arg | list[Arg] | tuple[Arg]
 """Command line arguments"""
 
 
@@ -123,7 +119,7 @@ class CommandExecutor:
     args: Args
     """Process arguments in various types."""
 
-    _queue: "queue.Queue[Optional[Tuple[bytes, Stream]]]"
+    _queue: queue.Queue[tuple[bytes, Stream] | None]
 
     log: ExtendedLogger
     """A ready to go and configured logger."""
@@ -135,7 +131,7 @@ class CommandExecutor:
     def __init__(
         self,
         args: Args,
-        master_logger: Optional[ExtendedLogger] = None,
+        master_logger: ExtendedLogger | None = None,
         **kwargs: Unpack[ProcessArgs],
     ) -> None:
         # self.args: typing.Union[str, list, tuple] = args
@@ -217,12 +213,10 @@ class CommandExecutor:
             with pipe:
                 for line in iter(pipe.readline, b""):
                     self._queue.put((line, stream))
-        except Exception:
-            pass
         finally:
             self._queue.put(None)
 
-    def _start_thread(self, pipe: Optional[IO[bytes]], stream: Stream) -> None:
+    def _start_thread(self, pipe: IO[bytes] | None, stream: Stream) -> None:
         """
         :param object pipe: ``process.stdout`` or ``process.stdout``
         """
@@ -249,7 +243,7 @@ class Watch:
     _service_name: str
     """A name of the watched service."""
 
-    _service_display_name: Optional[str]
+    _service_display_name: str | None
     """A human readable form of the *service name*."""
 
     log: ExtendedLogger
@@ -262,7 +256,7 @@ class Watch:
     :py:class:`Process`. Everytime you use the method
     `run()` the process object is appened in the list."""
 
-    _config: Optional[Config]
+    _config: Config | None
 
     _raise_exceptions: bool
     """Raise exceptions"""
@@ -271,12 +265,12 @@ class Watch:
 
     def __init__(
         self,
-        config_file: Optional[Union[str, Path]] = None,
+        config_file: str | Path | None = None,
         service_name: str = "command_watcher",
-        service_display_name: Optional[str] = None,
+        service_display_name: str | None = None,
         raise_exceptions: bool = True,
-        config: Optional[Config] = None,
-        report_channels: Optional[list[BaseChannel]] = None,
+        config: Config | None = None,
+        report_channels: list[BaseChannel] | None = None,
     ) -> None:
         self._hostname = HOSTNAME
 
@@ -330,7 +324,7 @@ class Watch:
                 self.log.debug(beep_reporter)
 
         else:
-            reporter.channels = []
+            reporter.channels = list(report_channels)
 
         self.processes = []
 
@@ -352,7 +346,7 @@ class Watch:
         self,
         args: Args,
         log: bool = True,
-        ignore_exceptions: list[int] = [],
+        ignore_exceptions: list[int] | None = None,
         **kwargs: Unpack[ProcessArgs],
     ) -> CommandExecutor:
         """
@@ -366,6 +360,8 @@ class Watch:
         :param ignore_exceptions: A list of none-zero exit codes, which is
             ignored by this method.
         """
+        if ignore_exceptions is None:
+            ignore_exceptions = []
         if log:
             master_logger = self.log
         else:
@@ -406,6 +402,5 @@ class Watch:
         if "performance_data" not in data_dict:
             data_dict["performance_data"] = {}
         data_dict["performance_data"]["execution_time"] = timer_result
-        if "status" in data_dict:
-            del data_dict["status"]
+        data_dict.pop("status", None)
         return self.report(status=status, **data_dict)

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/channels/beep.py

@@ -1,6 +1,5 @@
 import shutil
 import subprocess
-from typing import Union
 
 from command_watcher.channels.base_channel import BaseChannel
 from command_watcher.message import Message
@@ -9,7 +8,7 @@ from command_watcher.message import Message
 class BeepChannel(BaseChannel):
     """Send beep sounds."""
 
-    cmd: Union[str, None]
+    cmd: str | None
 
     def __init__(self) -> None:
         self.cmd = shutil.which("beep")
@@ -29,7 +28,9 @@ class BeepChannel(BaseChannel):
         :param length: Length in milliseconds.
         """
         # TODO: Use self.cmd -> Fix tests
-        subprocess.run(["beep", "-f", str(float(frequency)), "-l", str(float(length))])
+        subprocess.run(
+            ["beep", "-f", str(float(frequency)), "-l", str(float(length))], check=False
+        )
 
     def report(self, message: Message) -> None:
         """Send a beep sounds.

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/channels/icinga.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pretiac.client import Client
 from pretiac.config import Config
 
@@ -11,22 +9,22 @@ from command_watcher.utils import HOSTNAME
 class IcingaChannel(BaseChannel):
     service_name: str
 
-    service_display_name: Optional[str]
+    service_display_name: str | None
 
     __client: Client
 
-    api_endpoint_host: Optional[str]
-    api_endpoint_port: Optional[int]
-    http_basic_username: Optional[str]
-    client_certificate: Optional[str]
-    client_private_key: Optional[str]
-    ca_certificate: Optional[str]
+    api_endpoint_host: str | None
+    api_endpoint_port: int | None
+    http_basic_username: str | None
+    client_certificate: str | None
+    client_private_key: str | None
+    ca_certificate: str | None
 
     def __init__(
         self,
         service_name: str,
         config: Config,
-        service_display_name: Optional[str] = None,
+        service_display_name: str | None = None,
     ) -> None:
         self.service_name = service_name
         self.service_display_name = service_display_name

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/config.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import Optional, Union
 
 import yaml
 from pretiac.config import Config as IcingaConfig
@@ -36,17 +35,17 @@ class BeepConfig:
 
 @dataclass
 class Config:
-    email: Optional[EmailConfig] = None
+    email: EmailConfig | None = None
 
-    icinga: Optional[IcingaConfig] = None
+    icinga: IcingaConfig | None = None
 
-    beep: Optional[BeepConfig] = None
+    beep: BeepConfig | None = None
 
 
-_config: Optional[Config] = None
+_config: Config | None = None
 
 
-def load_config(config_file: Optional[Union[str, Path]] = None) -> Config:
+def load_config(config_file: str | Path | None = None) -> Config:
     if config_file is None:
         config_file = "/etc/command-watcher.yml"
     global _config

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/log.py

@@ -3,7 +3,7 @@ import sys
 import time
 import uuid
 from logging.handlers import BufferingHandler
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import termcolor
 
@@ -29,9 +29,9 @@ DATEFMT = "%Y%m%d_%H%M%S"
 class LoggingHandler(BufferingHandler):
     """Store of all logging records in the memory. Print all records on emit."""
 
-    _master_logger: Optional[logging.Logger]
+    _master_logger: logging.Logger | None
 
-    def __init__(self, master_logger: Optional[logging.Logger] = None):
+    def __init__(self, master_logger: logging.Logger | None = None):
         BufferingHandler.__init__(self, capacity=1000000)
         self._master_logger = master_logger
 
@@ -84,15 +84,12 @@ class LoggingHandler(BufferingHandler):
         else:
             stream = sys.stdout
 
-        created = "{}_{:03d}".format(
-            time.strftime(DATEFMT, time.localtime(record.created)),
-            int(record.msecs),
-        )
+        created = f"{time.strftime(DATEFMT, time.localtime(record.created))}_{int(record.msecs):03d}"
 
         print(
             "{} {} {}".format(
                 created,
-                termcolor.colored(" {:<8} ".format(level), color, attrs=reverse),
+                termcolor.colored(f" {level:<8} ", color, attrs=reverse),
                 termcolor.colored(record.msg, color, attrs=normal),
             ),
             file=stream,
@@ -161,7 +158,7 @@ logging.Logger.stderr = _log_stderr  # type: ignore
 
 
 def setup_logging(
-    master_logger: Optional[logging.Logger] = None,
+    master_logger: logging.Logger | None = None,
 ) -> tuple[ExtendedLogger, LoggingHandler]:
     """Setup a fresh logger for each watch action.
 
@@ -178,4 +175,5 @@ def setup_logging(
     # the root logger is created with level WARNING.
     logger.setLevel(1)
     logger.addHandler(handler)
+    logger.propagate = False
     return (cast(ExtendedLogger, logger), handler)

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/message.py

@@ -2,9 +2,7 @@ import os
 import pwd
 import socket
 import textwrap
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, TypedDict
-
-from typing_extensions import Unpack
+from typing import TYPE_CHECKING, Any, Literal, TypedDict, Unpack
 
 if TYPE_CHECKING:
     from . import CommandExecutor
@@ -25,7 +23,7 @@ class MinimalMessageParams(TypedDict, total=False):
     body: str
     """ A longer report text."""
 
-    performance_data: Dict[str, Any]
+    performance_data: dict[str, Any]
     """ A dictionary like
           `{'perf_1': 1, 'perf_2': 'test'}`"""
 
@@ -44,14 +42,16 @@ class MessageParams(MinimalMessageParams, total=False):
     log_records: str
     """Log records separated by new lines"""
 
-    processes: List["CommandExecutor"]
+    processes: list["CommandExecutor"]
 
 
 class BaseClass:
-    def _obj_to_str(self, attributes: List[str] = []) -> str:
+    def _obj_to_str(self, attributes: list[str] | None = None) -> str:
+        if attributes is None:
+            attributes = []
         if not attributes:
             attributes = dir(self)
-        output: List[str] = []
+        output: list[str] = []
         for attribute in attributes:
             if not attribute.startswith("_") and not callable(getattr(self, attribute)):
                 value = getattr(self, attribute)
@@ -109,11 +109,11 @@ class Message(BaseClass):
         """
         performance_data = self._data.get("performance_data")
         if performance_data:
-            pairs: List[str] = []
+            pairs: list[str] = []
             key: str
             value: Any
             for key, value in performance_data.items():
-                pairs.append("{!s}={!s}".format(key, value))
+                pairs.append(f"{key!s}={value!s}")
             return " ".join(pairs)
         return ""
 
@@ -135,7 +135,7 @@ class Message(BaseClass):
         output.append(self.service_name.upper())
         output.append(self.status_text)
         if self.custom_message:
-            output.append("- {}".format(self.custom_message))
+            output.append(f"- {self.custom_message}")
         return " ".join(output)
 
     @property
@@ -146,13 +146,13 @@ class Message(BaseClass):
             output.append(self.service_name.upper())
         output.append(self.status_text)
         if self.custom_message:
-            output.append("- {}".format(self.custom_message))
+            output.append(f"- {self.custom_message}")
         return " ".join(output)
 
     @property
     def message_monitoring(self) -> str:
         """plugin_output + performance_data"""
-        output: List[str] = []
+        output: list[str] = []
         output.append(self.plugin_output)
         if self.performance_data:
             output.append("|")
@@ -162,7 +162,7 @@ class Message(BaseClass):
     @property
     def body(self) -> str:
         """Text body for the e-mail message."""
-        output: List[str] = []
+        output: list[str] = []
         output.append(f"Host: {HOSTNAME}")
         output.append(f"User: {USERNAME}")
         output.append(f"Service name: {self.service_name}")
@@ -185,8 +185,8 @@ class Message(BaseClass):
         return "\n".join(output)
 
     @property
-    def processes(self) -> Optional[str]:
-        output: List[str] = []
+    def processes(self) -> str | None:
+        output: list[str] = []
         processes = self._data.get("processes")
         if processes:
             for process in processes:
@@ -197,4 +197,4 @@ class Message(BaseClass):
 
     @property
     def user(self) -> str:
-        return "[user:{}]".format(USERNAME)
+        return f"[user:{USERNAME}]"

{command_watcher-0.6.0 → command_watcher-0.7.0}/src/command_watcher/report.py

@@ -1,6 +1,4 @@
-from typing import List, Literal
-
-from typing_extensions import Unpack
+from typing import Literal, Unpack
 
 from command_watcher.channels.base_channel import BaseChannel
 from command_watcher.message import Message, MessageParams
@@ -11,7 +9,7 @@ Status = Literal[0, 1, 2, 3]
 class Reporter:
     """Collect all channels."""
 
-    channels: List[BaseChannel]
+    channels: list[BaseChannel]
 
     def __init__(self) -> None:
         self.channels = []