bitranox-template-py-cli 2.2.0__tar.gz → 2.3.0__tar.gz

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/CHANGELOG.md

@@ -6,6 +6,23 @@ the [Keep a Changelog](https://keepachangelog.com/) format.
 
 ## [Unreleased]
 
+## [2.3.0] 2026-10-08 16:14:12
+
+### Changed
+- **`config --profile NAME` checks the profile's logging settings instead of restarting logging.**
+  The check now runs through lib_log_rich's `validate_config`, which refuses exactly what starting
+  logging refuses, with the same `Error:` lines and exit 78, so nothing changes for an invalid
+  setting. What changes: the running logging runtime is no longer shut down and started again, so
+  the rest of the command keeps logging with the settings logging started with (not the profile's),
+  and a `main()` call from a worker thread no longer replaces the logging every other thread uses.
+  The `RestartLogging` port is now `CheckLoggingConfig` (`AppServices.check_logging_config`; the
+  testing composition's double refuses nothing). Requires `lib_log_rich>=6.4.2`.
+
+### Fixed
+- **A logging refusal no single setting owns reads `lib_log_rich: <reason>`.** Such a problem (for
+  example TLS together with UDP for Graylog, which lib_log_rich 6.4.2 now refuses up front) has no
+  key, and its `Error:` line came out as `lib_log_rich.: <reason>` with a dangling dot.
+
 ## [2.2.0] 2026-10-08 13:56:49
 
 ### Removed

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bitranox_template_py_cli
-Version: 2.2.0
+Version: 2.3.0
 Summary: Template CLI application with configuration management and structured logging
 Project-URL: Homepage, https://github.com/bitranox/bitranox_template_py_cli
 Project-URL: Repository, https://github.com/bitranox/bitranox_template_py_cli.git
@@ -25,7 +25,7 @@ Requires-Dist: btx-lib-mail>=4.0.0
 Requires-Dist: click>=8.5.0
 Requires-Dist: lib-cli-exit-tools>=2.4.0
 Requires-Dist: lib-layered-config>=7.0.1
-Requires-Dist: lib-log-rich>=6.3.9
+Requires-Dist: lib-log-rich>=6.4.2
 Requires-Dist: orjson>=3.13.0
 Requires-Dist: pydantic>=2.13.5
 Requires-Dist: python-dotenv>=1.2.4

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/docs/systemdesign/module_reference.md

@@ -26,14 +26,14 @@ moves or removes a module, a CLI option or a public name.
 - `src/bitranox_template_py_cli/adapters/email/transport.py`  -  `send_email` / `send_notification` over btx_lib_mail
 - `src/bitranox_template_py_cli/adapters/email/sender.py`  -  Re-exports of `config.py` and `transport.py`
 - `src/bitranox_template_py_cli/adapters/email/validation.py`  -  Email recipient validation
-- `src/bitranox_template_py_cli/adapters/logging/setup.py`  -  lib_log_rich initialization; takes only the `LOG_*` lines of a `.env`, and raises `InvalidLoggingConfigError` for a refused `[lib_log_rich]` value or `LOG_*` variable, after starting logging with its defaults (and without the `LOG_*` variables only when one of them is refused); `restart_logging` shuts the running runtime down and starts it again with another configuration
+- `src/bitranox_template_py_cli/adapters/logging/setup.py`  -  lib_log_rich initialization; takes only the `LOG_*` lines of a `.env`, and raises `InvalidLoggingConfigError` for a refused `[lib_log_rich]` value or `LOG_*` variable, after starting logging with its defaults (and without the `LOG_*` variables only when one of them is refused); `check_logging_config` refuses another configuration's logging settings through lib_log_rich's `validate_config`, without touching the running runtime
 - `src/bitranox_template_py_cli/adapters/cli/`  -  CLI adapter package:
   - `__init__.py`  -  Public facade
   - `constants.py`  -  Shared constants
   - `safe_console.py`  -  Encode-safe terminal output; use `safe_console.echo` instead of `click.echo`
   - `exit_codes.py`  -  POSIX exit codes (ExitCode IntEnum)
   - `context.py`  -  Click context helpers
-  - `config_load.py`  -  Configuration load for the CLI; records a load failure, `require_config` refuses with exit 78, `restart_logging` restarts logging with a configuration reloaded by `config --profile`, refusing its logging settings as the root does
+  - `config_load.py`  -  Configuration load for the CLI; records a load failure, `require_config` refuses with exit 78, `check_logging` checks the logging settings of a configuration reloaded by `config --profile`, refusing them as the root does
   - `root.py`  -  Root command group
   - `main.py`  -  Entry point
   - `typed_click.py`  -  Strictly typed wrappers for rich_click's `option`, `version_option` and `get_current_context`
@@ -409,7 +409,7 @@ The `adapters/memory/` package provides lightweight implementations for testing:
 |---------------------|-----------------------------------------------------------------------------|
 | `memory/config.py`  | `GetConfig`, `GetDefaultConfigPath`, `DeployConfiguration`, `DisplayConfig` |
 | `memory/email.py`   | `SendEmail`, `SendNotification`                                             |
-| `memory/logging.py` | `InitLogging`, `RestartLogging`                                             |
+| `memory/logging.py` | `InitLogging`, `CheckLoggingConfig`                                         |
 
 `adapters/memory` exports `EmailSpy` (from `memory/email.py`): its `send_email` and
 `send_notification` methods satisfy the email ports and record each call as a `CapturedEmail` /

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bitranox_template_py_cli"
-version = "2.2.0"
+version = "2.3.0"
 description = "Template CLI application with configuration management and structured logging"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -9,7 +9,8 @@ dependencies = [
     # Imported directly (adapters/cli/main.py, commands/config.py), not only through rich-click.
     "click>=8.5.0",
     "lib_cli_exit_tools>=2.4.0",
-    "lib_log_rich>=6.3.9",
+    # 6.4.2: validate_config, the check config --profile runs, refuses exactly what init() refuses.
+    "lib_log_rich>=6.4.2",
     "python-dotenv>=1.2.4",
     "lib_layered_config>=7.0.1",
     "btx_lib_mail>=4.0.0",

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/__init__conf__.py

@@ -40,7 +40,7 @@ name = "bitranox_template_py_cli"
 #: Human-readable summary shown in CLI help output.
 title = "Template CLI application with configuration management and structured logging"
 #: Current release version pulled from ``pyproject.toml`` by automation.
-version = "2.2.0"
+version = "2.3.0"
 #: Repository homepage presented to users.
 homepage = "https://github.com/bitranox/bitranox_template_py_cli"
 #: Author attribution surfaced in CLI output.

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/adapters/cli/commands/config.py

@@ -32,7 +32,7 @@ from bitranox_template_py_cli.adapters.config.overrides import nest_overrides
 from bitranox_template_py_cli.domain.enums import DeployTarget, OutputFormat
 
 from .. import safe_console
-from ..config_load import load_config, report_load_failure, require_config, restart_logging
+from ..config_load import check_logging, load_config, report_load_failure, require_config
 from ..constants import CLICK_CONTEXT_SETTINGS
 from ..context import CLIContext, get_cli_context
 from ..exit_codes import ExitCode
@@ -110,8 +110,8 @@ def _resolve_config(ctx: click.Context, cli_ctx: CLIContext, profile: str | None
 
     When a subcommand-level profile override is specified, reloads config
     with that profile, the root's ``--env-file`` and any root-level ``--set``
-    overrides stored in the CLI context, and restarts logging with it, which
-    refuses its logging settings the way the root refuses its own.
+    overrides stored in the CLI context, and checks its logging settings, which
+    are refused the way the root refuses its own; logging itself keeps running unchanged.
 
     Args:
         ctx: The running command's click context, exited with 78 when loading failed.
@@ -128,7 +128,7 @@ def _resolve_config(ctx: click.Context, cli_ctx: CLIContext, profile: str | None
         cli_ctx.services, profile=profile, env_file=cli_ctx.env_file, set_overrides=cli_ctx.set_overrides
     )
     if error is None:
-        error = restart_logging(cli_ctx.services, config, env_file=cli_ctx.env_file)
+        error = check_logging(cli_ctx.services, config)
     if error is not None:
         report_load_failure(error, show_traceback=cli_ctx.traceback)
         ctx.exit(ExitCode.CONFIG_ERROR)

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/adapters/cli/config_load.py

@@ -16,7 +16,7 @@ Contents:
     * :func:`load_config` - load with profile, ``.env`` and ``--set``, or say why not.
     * :func:`start_logging` - start logging; an invalid ``[lib_log_rich]`` value or ``LOG_*``
       variable is a load failure.
-    * :func:`restart_logging` - the same refusal for a configuration loaded after logging started.
+    * :func:`check_logging` - the same refusal for a configuration loaded after logging started.
     * :func:`require_config` - the configuration, or exit 78 naming the failure.
     * :func:`report_load_failure` - the one-line report, after the traceback on request.
     * :func:`echo_load_traceback` - the loader's traceback alone, for a caller with its own line.
@@ -105,7 +105,8 @@ def start_logging(
     refused setting) before it raises, and the commands that read the configuration refuse with
     exit 78 and the refusal: ``lib_log_rich.<key>: <reason>`` for a problem the section's type
     check finds, lib_log_rich's own message for a value only lib_log_rich refuses, whether it
-    came from the section or a ``LOG_*`` variable (``lib_log_rich: Unknown log level: 'bogus'``).
+    came from the section or a ``LOG_*`` variable (``lib_log_rich: Invalid runtime settings:
+    console_level: Unknown log level: 'bogus'``).
 
     Args:
         services: The composition's services; only ``init_logging`` is used.
@@ -124,25 +125,24 @@ def start_logging(
     return config, config_error
 
 
-def restart_logging(services: AppServices, config: Config, *, env_file: str | None) -> Exception | None:
-    """Restart logging with a configuration loaded after it started; a refused setting is returned.
+def check_logging(services: AppServices, config: Config) -> Exception | None:
+    """Judge the logging settings of a configuration loaded after logging started; a refusal is returned.
 
     ``config --profile`` reloads the configuration once logging is running, so
     :func:`start_logging` never sees the reloaded ``[lib_log_rich]`` section; without this an
-    invalid value there would display with exit 0 while plain ``config`` exits 78. Restarting
-    runs the very start :func:`start_logging` ran, so it refuses the same settings in the same
-    words, and the rest of the command logs with the reloaded settings.
+    invalid value there would display with exit 0 while plain ``config`` exits 78. The check
+    refuses what :func:`start_logging` refuses, in the same words, and never touches the
+    running runtime: the command keeps logging with the settings logging started with.
 
     Args:
-        services: The composition's services; only ``restart_logging`` is used.
+        services: The composition's services; only ``check_logging_config`` is used.
         config: The configuration :func:`load_config` returned.
-        env_file: The ``--env-file`` path, or None; logging reads its ``LOG_*`` lines from it.
 
     Returns:
-        None, or the refusal; logging then runs with its defaults.
+        None, or the refusal.
     """
     try:
-        services.restart_logging(config, dotenv_path=env_file)
+        services.check_logging_config(config)
     except InvalidLoggingConfigError as exc:
         return exc
     return None
@@ -196,10 +196,10 @@ def require_config(ctx: click.Context, cli_ctx: CLIContext) -> Config:
 
 
 __all__ = [
+    "check_logging",
     "echo_load_traceback",
     "load_config",
     "report_load_failure",
     "require_config",
-    "restart_logging",
     "start_logging",
 ]

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/adapters/logging/setup.py

@@ -7,7 +7,7 @@ eliminating duplication between module entry (__main__.py) and console script
 Contents:
     * :func:`init_logging` - idempotent logging initialization from the ``[lib_log_rich]``
       section and the ``LOG_*`` variables (the environment, plus the ``LOG_*`` lines of a ``.env``).
-    * :func:`restart_logging` - stop the running runtime and start it again with another configuration.
+    * :func:`check_logging_config` - refuse another configuration's logging settings without touching the runtime.
     * :class:`InvalidLoggingConfigError` - the ``[lib_log_rich]`` section or a ``LOG_*`` variable
       cannot configure logging.
     * :func:`_build_runtime_config` - constructs RuntimeConfig from layered sources.
@@ -100,10 +100,12 @@ class InvalidLoggingConfigError(ConfigurationError):
     """lib_log_rich refuses its settings: one ``<key>: <reason>`` in :attr:`problems` per problem.
 
     The settings are the ``[lib_log_rich]`` section plus any ``LOG_*`` variable. A problem the
-    type check of the section finds names the key and never repeats the refused value. A value
-    only lib_log_rich itself refuses, such as an unknown level in ``LOG_CONSOLE_LEVEL`` or in the
-    section's ``console_level``, is reported in lib_log_rich's own words (``lib_log_rich: Unknown
-    log level: 'bogus'``), which may name neither the setting nor where it was set.
+    type check of the section finds names the key and never repeats the refused value; one no
+    single key owns (TLS over UDP for Graylog) reads ``lib_log_rich: <reason>``. A value only
+    lib_log_rich itself refuses, such as an unknown level in ``LOG_CONSOLE_LEVEL`` or in the
+    section's ``console_level``, is reported in lib_log_rich's own words, which name the setting
+    and repeat the value (``lib_log_rich: Invalid runtime settings: console_level: Unknown log
+    level: 'bogus'``).
 
     Attributes:
         problems: One line per refused setting.
@@ -128,15 +130,33 @@ _PROJECT_MARKERS = ("pyproject.toml", ".git")
 
 
 def _problems(error: BaseException) -> list[str]:
-    """One line per problem, from the first pydantic error in ``error``'s chain; never the value."""
+    """One line per problem: key and reason from the first pydantic error in ``error``'s chain.
+
+    A pydantic problem never repeats the refused value; one no single key owns (a model-wide
+    check) has no key and reads ``lib_log_rich: <reason>``. Without a pydantic error in the chain,
+    the line is lib_log_rich's own first line, which may repeat the value
+    (``Invalid runtime settings: console_level: Unknown log level: 'bogus'``).
+    """
     cause: BaseException | None = error
     while cause is not None and not isinstance(cause, ValidationError):
         cause = cause.__cause__ or cause.__context__
     if cause is None:
         # Not a pydantic error (e.g. an unknown level name in a LOG_* variable): lib_log_rich's
-        # own first line, which may name neither the variable nor where it was set.
+        # own first line.
         return [f"lib_log_rich: {str(error).splitlines()[0]}"]
-    return [f"lib_log_rich.{'.'.join(str(part) for part in item['loc'])}: {item['msg']}" for item in cause.errors()]
+    return [f"{_problem_key(item['loc'])}: {item['msg']}" for item in cause.errors()]
+
+
+def _problem_key(loc: tuple[int | str, ...]) -> str:
+    """``lib_log_rich.<key>`` for a problem located at a key, bare ``lib_log_rich`` for a model-wide one.
+
+    Example:
+        >>> _problem_key(("rate_limit",))
+        'lib_log_rich.rate_limit'
+        >>> _problem_key(())
+        'lib_log_rich'
+    """
+    return ".".join(["lib_log_rich", *(str(part) for part in loc)])
 
 
 def _nearest_dotenv() -> Path | None:
@@ -281,35 +301,39 @@ def init_logging(config: Config, *, dotenv_path: str | None = None) -> None:
     lib_log_rich.runtime.attach_std_logging()
 
 
-def restart_logging(config: Config, *, dotenv_path: str | None = None) -> None:
-    """Stop the running lib_log_rich runtime, then start it again with ``config``.
+def check_logging_config(config: Config) -> None:
+    """Refuse ``config``'s logging settings as :func:`init_logging` would, without touching the runtime.
 
     :func:`init_logging` returns at once while a runtime is running, so a configuration loaded
     after logging started (``config --profile``'s reload) would never have its logging settings
-    judged. This runs that same start again: a setting lib_log_rich refuses raises exactly as it
-    does there, and logging is left running with the defaults. lib_log_rich has no public call
-    that checks settings without starting the runtime.
+    judged. lib_log_rich's ``validate_config`` refuses exactly what its ``init`` refuses, with the
+    same message and the same ``LOG_*`` overrides, and neither reads nor replaces the running
+    runtime, so logging keeps running with the settings it started with, on every thread.
 
     Args:
         config: Already-loaded layered configuration object.
-        dotenv_path: As for :func:`init_logging`.
 
     Raises:
-        InvalidLoggingConfigError: As for :func:`init_logging`.
+        InvalidLoggingConfigError: As for :func:`init_logging`, with the same problem lines.
 
-    Side Effects:
-        Flushes and shuts down the running runtime first (its queue, Graylog and journald
-        adapters included); the new one carries ``config``'s logging settings.
+    Example:
+        >>> check_logging_config(Config({"lib_log_rich": {"console_level": "info"}}, {}))
+        >>> try:
+        ...     check_logging_config(Config({"lib_log_rich": {"rate_limit": "100:60"}}, {}))
+        ... except InvalidLoggingConfigError as exc:
+        ...     print(exc)
+        lib_log_rich.rate_limit: Input should be a valid tuple
     """
-    if lib_log_rich.runtime.is_initialised():
-        lib_log_rich.runtime.shutdown()
-    init_logging(config, dotenv_path=dotenv_path)
+    try:
+        lib_log_rich.runtime.validate_config(_build_runtime_config(config))
+    except ValueError as exc:  # pydantic's ValidationError is a ValueError
+        raise InvalidLoggingConfigError(_problems(exc)) from exc
 
 
 __all__ = [
     "InvalidLoggingConfigError",
     "LoggingConfigModel",
+    "check_logging_config",
     "init_logging",
     "log_variables_hidden",
-    "restart_logging",
 ]

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/adapters/memory/__init__.py

@@ -20,28 +20,28 @@ from .config import (
     get_default_config_path_in_memory,
 )
 from .email import EmailSpy
-from .logging import init_logging_in_memory, restart_logging_in_memory
+from .logging import check_logging_config_in_memory, init_logging_in_memory
 
 # Static conformance assertions
 if TYPE_CHECKING:
     from bitranox_template_py_cli.application.ports import (
+        CheckLoggingConfig,
         GetConfig,
         GetDefaultConfigPath,
         InitLogging,
-        RestartLogging,
     )
 
     _assert_get_config: GetConfig = get_config_in_memory
     _assert_get_default_config_path: GetDefaultConfigPath = get_default_config_path_in_memory
     _assert_init_logging: InitLogging = init_logging_in_memory
-    _assert_restart_logging: RestartLogging = restart_logging_in_memory
+    _assert_check_logging_config: CheckLoggingConfig = check_logging_config_in_memory
 
 __all__ = [
     "EmailSpy",
+    "check_logging_config_in_memory",
     "deploy_configuration_in_memory",
     "display_config_in_memory",
     "get_config_in_memory",
     "get_default_config_path_in_memory",
     "init_logging_in_memory",
-    "restart_logging_in_memory",
 ]

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/adapters/memory/logging.py

@@ -63,17 +63,18 @@ def init_logging_in_memory(config: Config, *, dotenv_path: str | None = None) ->
         )
 
 
-def restart_logging_in_memory(config: Config, *, dotenv_path: str | None = None) -> None:
-    """Keep the test runtime: :func:`init_logging_in_memory` ignores the configuration, so a restart changes nothing.
+def check_logging_config_in_memory(config: Config) -> None:
+    """Refuse nothing: the test runtime ignores the configuration, so no setting in it can break it.
+
+    :func:`init_logging_in_memory` starts a fixed runtime whatever the configuration holds.
 
     Args:
-        config: Unused; the parameter exists to satisfy the ``RestartLogging`` protocol.
-        dotenv_path: Unused for the same reason.
+        config: Unused; the parameter exists to satisfy the ``CheckLoggingConfig`` protocol.
 
     Example:
         >>> from lib_layered_config import Config
-        >>> restart_logging_in_memory(Config({"lib_log_rich": {"rate_limit": "100:60"}}, {}))
+        >>> check_logging_config_in_memory(Config({"lib_log_rich": {"rate_limit": "100:60"}}, {}))
     """
 
 
-__all__ = ["init_logging_in_memory", "restart_logging_in_memory"]
+__all__ = ["check_logging_config_in_memory", "init_logging_in_memory"]

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/application/ports.py

@@ -109,24 +109,24 @@ class InitLogging(Protocol):
     def __call__(self, config: Config, *, dotenv_path: str | None = None) -> None: ...
 
 
-class RestartLogging(Protocol):
-    """Stop the running logging runtime and start it again with ``config``, as ``InitLogging`` does.
+class CheckLoggingConfig(Protocol):
+    """Refuse ``config``'s logging settings as ``InitLogging`` would, leaving the running runtime alone.
 
     For a configuration loaded after logging is running; a refused setting raises
-    ``InvalidLoggingConfigError`` after logging has been started with its defaults.
+    ``InvalidLoggingConfigError`` and logging keeps running with the settings it started with.
     """
 
-    def __call__(self, config: Config, *, dotenv_path: str | None = None) -> None: ...
+    def __call__(self, config: Config) -> None: ...
 
 
 __all__ = [
+    "CheckLoggingConfig",
     "DeployConfiguration",
     "DisplayConfig",
     "GetConfig",
     "GetDefaultConfigPath",
     "InitLogging",
     "LoadEmailConfigFromDict",
-    "RestartLogging",
     "SendEmail",
     "SendNotification",
 ]

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/src/bitranox_template_py_cli/composition/__init__.py

@@ -19,20 +19,20 @@ from ..adapters.email.sender import (
 )
 
 # Logging services
-from ..adapters.logging.setup import init_logging, restart_logging
+from ..adapters.logging.setup import check_logging_config, init_logging
 
 # Static conformance assertions — pyright verifies that each adapter function
 # structurally satisfies its corresponding Protocol at type-check time.
 if TYPE_CHECKING:
     from ..adapters.memory.email import EmailSpy
     from ..application.ports import (
+        CheckLoggingConfig,
         DeployConfiguration,
         DisplayConfig,
         GetConfig,
         GetDefaultConfigPath,
         InitLogging,
         LoadEmailConfigFromDict,
-        RestartLogging,
         SendEmail,
         SendNotification,
     )
@@ -45,7 +45,7 @@ if TYPE_CHECKING:
     _assert_send_notification: SendNotification = send_notification
     _assert_load_email_config_from_dict: LoadEmailConfigFromDict = load_email_config_from_dict
     _assert_init_logging: InitLogging = init_logging
-    _assert_restart_logging: RestartLogging = restart_logging
+    _assert_check_logging_config: CheckLoggingConfig = check_logging_config
 
 
 @dataclass(frozen=True, slots=True)
@@ -60,7 +60,7 @@ class AppServices:
     send_notification: SendNotification
     load_email_config_from_dict: LoadEmailConfigFromDict
     init_logging: InitLogging
-    restart_logging: RestartLogging
+    check_logging_config: CheckLoggingConfig
 
 
 def build_production() -> AppServices:
@@ -74,7 +74,7 @@ def build_production() -> AppServices:
         send_notification=send_notification,
         load_email_config_from_dict=load_email_config_from_dict,
         init_logging=init_logging,
-        restart_logging=restart_logging,
+        check_logging_config=check_logging_config,
     )
 
 
@@ -91,12 +91,12 @@ def build_testing(*, spy: EmailSpy | None = None) -> AppServices:
     """
     from ..adapters.memory import (  # noqa: PLC0415 - deferred: keeps in-memory test doubles out of the production import path
         EmailSpy,
+        check_logging_config_in_memory,
         deploy_configuration_in_memory,
         display_config_in_memory,
         get_config_in_memory,
         get_default_config_path_in_memory,
         init_logging_in_memory,
-        restart_logging_in_memory,
     )
 
     email_spy = spy if spy is not None else EmailSpy()
@@ -111,7 +111,7 @@ def build_testing(*, spy: EmailSpy | None = None) -> AppServices:
         # The real translation: an in-memory one would let every CLI test skip it.
         load_email_config_from_dict=load_email_config_from_dict,
         init_logging=init_logging_in_memory,
-        restart_logging=restart_logging_in_memory,
+        check_logging_config=check_logging_config_in_memory,
     )
 
 
@@ -119,13 +119,13 @@ __all__ = [
     "AppServices",
     "build_production",
     "build_testing",
+    "check_logging_config",
     "deploy_configuration",
     "display_config",
     "get_config",
     "get_default_config_path",
     "init_logging",
     "load_email_config_from_dict",
-    "restart_logging",
     "send_email",
     "send_notification",
 ]

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/tests/conftest.py

@@ -396,7 +396,7 @@ def inject_config(
             result = cli_runner.invoke(cli, ["config"], obj=factory)
             assert "key" in result.output
     """
-    from bitranox_template_py_cli.adapters.memory import init_logging_in_memory, restart_logging_in_memory
+    from bitranox_template_py_cli.adapters.memory import check_logging_config_in_memory, init_logging_in_memory
     from bitranox_template_py_cli.composition import AppServices, build_production
 
     def _inject(config: Config) -> Callable[[], AppServices]:
@@ -415,7 +415,7 @@ def inject_config(
             # The quiet runtime: production init_logging queues INFO lines that race into
             # CliRunner's stderr, so a stderr assertion would depend on timing.
             init_logging=init_logging_in_memory,
-            restart_logging=restart_logging_in_memory,
+            check_logging_config=check_logging_config_in_memory,
         )
         return lambda: test_services
 
@@ -451,7 +451,7 @@ def inject_config_with_profile_capture(
             cli_runner.invoke(cli, ["--profile", "staging", "config"], obj=factory)
             assert captured == ["staging"]
     """
-    from bitranox_template_py_cli.adapters.memory import init_logging_in_memory, restart_logging_in_memory
+    from bitranox_template_py_cli.adapters.memory import check_logging_config_in_memory, init_logging_in_memory
     from bitranox_template_py_cli.composition import AppServices, build_production
 
     def _inject(config: Config, captured_profiles: list[str | None]) -> Callable[[], AppServices]:
@@ -471,7 +471,7 @@ def inject_config_with_profile_capture(
             # The quiet runtime: production init_logging queues INFO lines that race into
             # CliRunner's stderr, so a stderr assertion would depend on timing.
             init_logging=init_logging_in_memory,
-            restart_logging=restart_logging_in_memory,
+            check_logging_config=check_logging_config_in_memory,
         )
         return lambda: test_services
 
@@ -507,7 +507,7 @@ def inject_deploy_with_profile_capture(
             cli_runner.invoke(cli, ["--profile", "prod", "config-deploy", ...], obj=factory)
             assert captured == ["prod"]
     """
-    from bitranox_template_py_cli.adapters.memory import init_logging_in_memory, restart_logging_in_memory
+    from bitranox_template_py_cli.adapters.memory import check_logging_config_in_memory, init_logging_in_memory
     from bitranox_template_py_cli.composition import AppServices, build_production
 
     def _inject(deployed_path: Path, captured_profiles: list[str | None]) -> Callable[[], AppServices]:
@@ -536,7 +536,7 @@ def inject_deploy_with_profile_capture(
             # The quiet runtime: production init_logging queues INFO lines that race into
             # CliRunner's stderr, so a stderr assertion would depend on timing.
             init_logging=init_logging_in_memory,
-            restart_logging=restart_logging_in_memory,
+            check_logging_config=check_logging_config_in_memory,
         )
         return lambda: test_services
 
@@ -568,7 +568,7 @@ def inject_deploy_configuration() -> Callable[[Callable[..., list[Path]]], Calla
             cli_runner.invoke(cli, ["config-deploy", "--target", "user"], obj=factory)
             assert len(calls) == 1
     """
-    from bitranox_template_py_cli.adapters.memory import init_logging_in_memory, restart_logging_in_memory
+    from bitranox_template_py_cli.adapters.memory import check_logging_config_in_memory, init_logging_in_memory
     from bitranox_template_py_cli.composition import AppServices, build_production
 
     def _inject(deploy_fn: Callable[..., list[Path]]) -> Callable[[], AppServices]:
@@ -584,7 +584,7 @@ def inject_deploy_configuration() -> Callable[[Callable[..., list[Path]]], Calla
             # The quiet runtime: production init_logging queues INFO lines that race into
             # CliRunner's stderr, so a stderr assertion would depend on timing.
             init_logging=init_logging_in_memory,
-            restart_logging=restart_logging_in_memory,
+            check_logging_config=check_logging_config_in_memory,
         )
         return lambda: test_services
 
@@ -670,7 +670,7 @@ def email_cli_context(
             assert ctx.spy.sent_notifications[0].subject == "Hi"
     """
     from bitranox_template_py_cli.adapters.email.config import load_email_config_from_dict
-    from bitranox_template_py_cli.adapters.memory import init_logging_in_memory, restart_logging_in_memory
+    from bitranox_template_py_cli.adapters.memory import check_logging_config_in_memory, init_logging_in_memory
     from bitranox_template_py_cli.adapters.memory.email import EmailSpy as EmailSpyImpl
     from bitranox_template_py_cli.composition import AppServices, build_production
 
@@ -693,7 +693,7 @@ def email_cli_context(
             # The quiet runtime: production init_logging queues INFO lines that race into
             # CliRunner's stderr, so a stderr assertion would depend on timing.
             init_logging=init_logging_in_memory,
-            restart_logging=restart_logging_in_memory,
+            check_logging_config=check_logging_config_in_memory,
         )
         return EmailCliContext(factory=lambda: test_services, spy=spy)
 
@@ -725,7 +725,7 @@ def config_cli_context(
             result = cli_runner.invoke(cli, ["config"], obj=factory)
             assert "key" in result.output
     """
-    from bitranox_template_py_cli.adapters.memory import init_logging_in_memory, restart_logging_in_memory
+    from bitranox_template_py_cli.adapters.memory import check_logging_config_in_memory, init_logging_in_memory
     from bitranox_template_py_cli.composition import AppServices, build_production
 
     def _create(config_data: dict[str, Any]) -> Callable[[], AppServices]:
@@ -746,7 +746,7 @@ def config_cli_context(
             # The quiet runtime: production init_logging queues INFO lines that race into
             # CliRunner's stderr, so a stderr assertion would depend on timing.
             init_logging=init_logging_in_memory,
-            restart_logging=restart_logging_in_memory,
+            check_logging_config=check_logging_config_in_memory,
         )
         return lambda: test_services
 

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/tests/test_cli_env_file.py

@@ -52,7 +52,7 @@ def inject_config_with_dotenv_capture(
             send_notification=prod.send_notification,
             load_email_config_from_dict=prod.load_email_config_from_dict,
             init_logging=prod.init_logging,
-            restart_logging=prod.restart_logging,
+            check_logging_config=prod.check_logging_config,
         )
         return lambda: test_services
 

{bitranox_template_py_cli-2.2.0 → bitranox_template_py_cli-2.3.0}/tests/test_deploy_permissions.py

@@ -77,7 +77,7 @@ def inject_deploy_with_permission_capture(
             send_notification=prod.send_notification,
             load_email_config_from_dict=prod.load_email_config_from_dict,
             init_logging=prod.init_logging,
-            restart_logging=prod.restart_logging,
+            check_logging_config=prod.check_logging_config,
         )
         return lambda: test_services