bitranox-template-py-cli 2.1.0__tar.gz → 2.1.1__tar.gz

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/CHANGELOG.md

@@ -6,6 +6,27 @@ the [Keep a Changelog](https://keepachangelog.com/) format.
 
 ## [Unreleased]
 
+## [2.1.1] 2026-10-06 18:13:05
+
+### Fixed
+- **A refused `LOG_*` variable no longer disables every command (exit code change).** A value
+  lib_log_rich refuses in a `LOG_*` variable, set in the environment or in the `.env` logging
+  reads (`LOG_CONSOLE_LEVEL=bogus` in the `--env-file`), made every command, `info` and
+  `config-deploy` included, exit 1 with `InvalidLoggingConfigError: lib_log_rich: Unknown log
+  level: 'bogus'`: the fallback restarted logging with an empty configuration, but lib_log_rich
+  reads the `LOG_*` variables on every start and refused the same variable again. Logging now
+  falls back to its defaults with every `LOG_*` variable hidden for that start (and put back
+  afterwards), so only the commands that read the configuration (`config`, `send-email`,
+  `send-notification`) exit 78, and the others run with exit 0. The 78 carries lib_log_rich's
+  own message, `Error: lib_log_rich: Unknown log level: 'bogus'`, which may name neither the
+  variable nor where it was set. A refused `[lib_log_rich]` value still leaves every valid
+  `LOG_*` variable in force for the fallback, as in 2.1.0: only a refused variable hides them.
+- **The testing composition ignores the developer's `LOG_*` variables.** `build_testing()`'s
+  logging runtime (`init_logging_in_memory`) now starts with every `LOG_*` variable hidden and
+  puts them back afterwards. A `LOG_CONSOLE_LEVEL=bogus` in the shell running the tests made
+  every command under `build_testing()` fail with `ValueError: Unknown log level: 'bogus'`, and a
+  valid one changed the quiet test runtime. Production logging is unaffected.
+
 ## [2.1.0] 2026-10-06 15:37:27
 
 ### Added

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bitranox_template_py_cli
-Version: 2.1.0
+Version: 2.1.1
 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

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/docs/systemdesign/module_reference.md

@@ -26,7 +26,7 @@ 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
+- `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)
 - `src/bitranox_template_py_cli/adapters/cli/`  -  CLI adapter package:
   - `__init__.py`  -  Public facade
   - `constants.py`  -  Shared constants
@@ -92,6 +92,7 @@ moves or removes a module, a CLI option or a public name.
 - `tests/test_enums.py`  -  Domain enum tests
 - `tests/test_errors.py`  -  Domain error types
 - `tests/test_logging.py`  -  Logging configuration model
+- `tests/test_logging_dotenv_isolation.py`  -  Only `LOG_*` lines of a `.env` reach the environment; an invalid `[lib_log_rich]` section or `LOG_*` variable is a configuration failure that leaves logging running
 - `tests/test_mail.py`  -  Email configuration and sending tests (the `integration` ones send real mail)
 - `tests/test_memory_logging.py`  -  Testing-composition logging runtime and the per-test logging reset
 - `tests/test_metadata.py`  -  Package metadata and PEP 561 marker tests
@@ -322,9 +323,9 @@ Raises `ValueError` with descriptive message on invalid input.
 `EmailConfig` (`adapters/email/config.py`, re-exported by `adapters/email/sender.py`) subclasses
 btx_lib_mail's `ConfMail`: frozen, a name that is not a field is refused, the password is a
 `SecretStr`, and a validation error never shows the password or a host. It adds `from_address` and
-`recipients`, and checks every SMTP host's syntax (port range, IPv6 brackets) when it loads. In
-Python the fields use the library's names; the configuration file keeps its own keys (third
-column).
+`recipients`. ConfMail checks every SMTP host's syntax (port range, IPv6 brackets, host name
+labels) when it loads, so `EmailConfig` has no host check of its own. In Python the fields use
+the library's names; the configuration file keeps its own keys (fourth column).
 
 | Field                          | Type                | Default | File key (`[email]`)           | Description                                                      |
 |--------------------------------|---------------------|---------|--------------------------------|------------------------------------------------------------------|
@@ -362,7 +363,7 @@ lib_layered_config is the only reader of configuration: it merges every layer (t
 defaults, the app, host and user files, `.env`, the environment, `--set`) into one mapping.
 `load_email_config_from_dict()` turns that mapping's `[email]` section into an `EmailConfig`:
 
-- the six keys in the third column that differ from the field names are mapped;
+- the six keys in the fourth column that differ from the field names are mapped;
 - `[email.attachments]` keys become `attachment_<key>`;
 - a key that is not listed is refused (exit 78, `email.<key>: unknown key`), whatever layer it came from;
 - blank text means "not configured"; a single host or address string is a one-entry list;
@@ -379,7 +380,7 @@ problem, never with the refused value.
 |---------------------|------------------------------------------------------------------------------|
 | `SECTION_KEYS`      | Every key `[email]` accepts (the `attachments` table included)               |
 | `ATTACHMENT_KEYS`   | Every key `[email.attachments]` accepts; each names field `attachment_<key>` |
-| `FILE_KEY_TO_FIELD` | File key -> `EmailConfig` field, for the five keys whose names differ        |
+| `FILE_KEY_TO_FIELD` | File key -> `EmailConfig` field, for the six keys whose names differ         |
 
 ---
 

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bitranox_template_py_cli"
-version = "2.1.0"
+version = "2.1.1"
 description = "Template CLI application with configuration management and structured logging"
 readme = "README.md"
 requires-python = ">=3.10"

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/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.1.0"
+version = "2.1.1"
 #: 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.1.0 → bitranox_template_py_cli-2.1.1}/src/bitranox_template_py_cli/adapters/cli/commands/email/_common.py

@@ -84,8 +84,8 @@ def smtp_config_options(func: Callable[..., Any]) -> Callable[..., Any]:
 
     Adds CLI flags for the SMTP connection and delivery settings (hosts, credentials,
     STARTTLS, timeout, the two raise_on_* switches). ``starttls_verify``,
-    ``local_hostname`` and the attachment settings have no flag; set them with
-    ``--set email.<key>=...``.
+    ``local_hostname``, ``delivery_deadline``, ``recipient_max_count`` and the attachment
+    settings have no flag; set them with ``--set email.<key>=...``.
     """
     options = [
         option(

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/src/bitranox_template_py_cli/adapters/cli/config_load.py

@@ -14,7 +14,8 @@ configuration.
 
 Contents:
     * :func:`load_config` - load with profile, ``.env`` and ``--set``, or say why not.
-    * :func:`start_logging` - start logging; an invalid ``[lib_log_rich]`` is a load failure.
+    * :func:`start_logging` - start logging; an invalid ``[lib_log_rich]`` value or ``LOG_*``
+      variable is a load failure.
     * :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.
@@ -97,9 +98,13 @@ def start_logging(
 ) -> tuple[Config, Exception | None]:
     """Start logging with ``config``; a logging section it refuses is recorded like a load failure.
 
-    An invalid ``[lib_log_rich]`` value would otherwise stop every command, ``config-deploy``
-    (which replaces the file holding it) included. Logging then starts with its defaults, and
-    the commands that read the configuration refuse with exit 78 naming the key.
+    An invalid ``[lib_log_rich]`` value or ``LOG_*`` variable would otherwise stop every
+    command, ``config-deploy`` (which replaces the file holding it) included. ``init_logging``
+    then starts logging with its defaults (and no ``LOG_*`` variable, if one of them is the
+    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'``).
 
     Args:
         services: The composition's services; only ``init_logging`` is used.
@@ -114,7 +119,6 @@ def start_logging(
     try:
         services.init_logging(config, dotenv_path=env_file)
     except InvalidLoggingConfigError as exc:
-        services.init_logging(Config({}, {}), dotenv_path=env_file)
         return Config({}, {}), config_error or exc
     return config, config_error
 

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/src/bitranox_template_py_cli/adapters/email/transport.py

@@ -122,10 +122,12 @@ def send_email(
 
     Raises:
         ValueError: No from_address configured and no override provided,
-            or no recipients configured and no override provided.
+            or no recipients configured and no override provided, or more
+            recipients or attachments than config.recipient_max_count or
+            config.attachment_max_count allow (refused before any delivery).
         ConfigurationError: No SMTP hosts configured.
-        FileNotFoundError: Required attachment missing and config.raise_on_missing_attachments
-            is True.
+        FileNotFoundError: Required attachment missing or unreadable and
+            config.raise_on_missing_attachments is True.
         DeliveryError: All SMTP hosts failed for a recipient.
 
     Side Effects:

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/src/bitranox_template_py_cli/adapters/logging/setup.py

@@ -5,8 +5,10 @@ eliminating duplication between module entry (__main__.py) and console script
 (cli.py) while ensuring initialization happens exactly once.
 
 Contents:
-    * :func:`init_logging` - idempotent logging initialization with layered config.
-    * :class:`InvalidLoggingConfigError` - the ``[lib_log_rich]`` section cannot configure logging.
+    * :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``).
+    * :class:`InvalidLoggingConfigError` - the ``[lib_log_rich]`` section or a ``LOG_*`` variable
+      cannot configure logging.
     * :func:`_build_runtime_config` - constructs RuntimeConfig from layered sources.
 
 System Role:
@@ -18,18 +20,20 @@ System Role:
 from __future__ import annotations
 
 import os
+from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 
 import lib_log_rich.runtime
 from dotenv import dotenv_values
+from lib_layered_config import Config
 from pydantic import BaseModel, ConfigDict, ValidationError
 
 from bitranox_template_py_cli import __init__conf__
 from bitranox_template_py_cli.domain.errors import ConfigurationError
 
 if TYPE_CHECKING:
-    from lib_layered_config import Config
+    from collections.abc import Generator
 
 
 class LoggingConfigModel(BaseModel):
@@ -94,18 +98,20 @@ def _build_runtime_config(config: Config) -> lib_log_rich.runtime.RuntimeConfig:
 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 names
-    the key and never repeats the refused value.
+    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.
 
     Attributes:
         problems: One line per refused setting.
 
     Example:
-        >>> from lib_layered_config import Config
         >>> try:
-        ...     init_logging(Config({"lib_log_rich": {"rate_limit": "100:60"}}, {}))
-        ... except InvalidLoggingConfigError as exc:
-        ...     print(exc)
+        ...     _build_runtime_config(Config({"lib_log_rich": {"rate_limit": "100:60"}}, {}))
+        ... except ValidationError as exc:
+        ...     print(InvalidLoggingConfigError(_problems(exc)))
         lib_log_rich.rate_limit: Input should be a valid tuple
     """
 
@@ -126,8 +132,8 @@ def _problems(error: BaseException) -> list[str]:
     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): its own first line, which names
-        # the setting.
+        # 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.
         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()]
 
@@ -182,6 +188,41 @@ def _load_log_variables(dotenv_path: str | None) -> None:
             os.environ.setdefault(name, value)
 
 
+@contextmanager
+def log_variables_hidden() -> Generator[None]:
+    """Remove every ``LOG_*`` variable from the environment for the block, then put each back.
+
+    Example:
+        >>> os.environ["LOG_HIDDEN_PROBE"] = "x"
+        >>> with log_variables_hidden():
+        ...     "LOG_HIDDEN_PROBE" in os.environ
+        False
+        >>> os.environ.pop("LOG_HIDDEN_PROBE")
+        'x'
+    """
+    names = [name for name in os.environ if name.startswith(_LOG_VARIABLE_PREFIX)]
+    hidden = {name: os.environ.pop(name) for name in names}
+    try:
+        yield
+    finally:
+        os.environ.update(hidden)
+
+
+def _start_default_logging() -> None:
+    """Start lib_log_rich with the package defaults; without the ``LOG_*`` variables only if needed.
+
+    lib_log_rich reads the ``LOG_*`` variables from the environment on every init. When the
+    refused setting came from the ``[lib_log_rich]`` section, the defaults start with them and
+    a valid ``LOG_CONSOLE_LEVEL`` still applies. When one of them is the refused setting, that
+    start is refused again, and only then do the defaults start with every ``LOG_*`` hidden.
+    """
+    try:
+        lib_log_rich.runtime.init(_build_runtime_config(Config({}, {})))
+    except ValueError:  # pydantic's ValidationError is a ValueError
+        with log_variables_hidden():
+            lib_log_rich.runtime.init(_build_runtime_config(Config({}, {})))
+
+
 def init_logging(config: Config, *, dotenv_path: str | None = None) -> None:
     """Initialize lib_log_rich runtime with the provided configuration.
 
@@ -199,8 +240,12 @@ def init_logging(config: Config, *, dotenv_path: str | None = None) -> None:
             to use the nearest ``.env`` from the working directory up to the project root.
 
     Raises:
-        InvalidLoggingConfigError: The ``[lib_log_rich]`` section holds a value lib_log_rich
-            refuses; logging is not started.
+        InvalidLoggingConfigError: The ``[lib_log_rich]`` section or a ``LOG_*`` variable holds
+            a value lib_log_rich refuses. Logging is started anyway, with the package defaults
+            and the ``LOG_*`` variables (every one of them ignored if the defaults are refused
+            with them too), so the caller can record the failure and run the commands that do
+            not read the configuration. Only the first call can raise: logging is running after
+            it, so a later call returns at once, also with the same refused configuration.
 
     Side Effects:
         Copies the ``LOG_*`` lines of that ``.env`` into the process environment on first
@@ -226,9 +271,11 @@ def init_logging(config: Config, *, dotenv_path: str | None = None) -> None:
     _load_log_variables(dotenv_path)
     try:
         lib_log_rich.runtime.init(_build_runtime_config(config))
-    except (ValidationError, ValueError) as exc:
+    except ValueError as exc:  # pydantic's ValidationError is a ValueError
         # The type check of the section and lib_log_rich's own range checks (which also see the
         # LOG_* variables) both refuse here; neither has started the runtime.
+        _start_default_logging()
+        lib_log_rich.runtime.attach_std_logging()
         raise InvalidLoggingConfigError(_problems(exc)) from exc
     lib_log_rich.runtime.attach_std_logging()
 
@@ -237,4 +284,5 @@ __all__ = [
     "InvalidLoggingConfigError",
     "LoggingConfigModel",
     "init_logging",
+    "log_variables_hidden",
 ]

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/src/bitranox_template_py_cli/adapters/memory/logging.py

@@ -12,6 +12,7 @@ import lib_log_rich.runtime
 from lib_log_rich.domain import LogLevel
 
 from bitranox_template_py_cli import __init__conf__
+from bitranox_template_py_cli.adapters.logging.setup import log_variables_hidden
 
 if TYPE_CHECKING:
     from lib_layered_config import Config
@@ -29,7 +30,10 @@ def init_logging_in_memory(config: Config, *, dotenv_path: str | None = None) ->
     double has no business writing to a system log, and a queue is a background thread the
     test run would have to reap. The console level is ERROR so ordinary INFO logging cannot
     land in the output a test asserts on. Unlike the production initializer this never loads
-    a ``.env`` file, so a test run does not pick up the developer's own environment.
+    a ``.env`` file, and it starts with every ``LOG_*`` variable hidden (each is put back
+    afterwards): lib_log_rich reads them on every init, so a developer's own
+    ``LOG_CONSOLE_LEVEL`` would otherwise change the test runtime, and a value lib_log_rich
+    refuses would fail every command run under ``build_testing()``.
 
     Args:
         config: Layered configuration object. Unused: the test runtime is fixed, and the
@@ -45,17 +49,18 @@ def init_logging_in_memory(config: Config, *, dotenv_path: str | None = None) ->
     """
     if lib_log_rich.runtime.is_initialised():
         return
-    lib_log_rich.runtime.init(
-        lib_log_rich.runtime.RuntimeConfig(
-            service=f"{__init__conf__.name}-test",
-            environment="test",
-            console_level=LogLevel.ERROR,
-            enable_journald=False,
-            enable_eventlog=False,
-            enable_graylog=False,
-            queue_enabled=False,
+    with log_variables_hidden():
+        lib_log_rich.runtime.init(
+            lib_log_rich.runtime.RuntimeConfig(
+                service=f"{__init__conf__.name}-test",
+                environment="test",
+                console_level=LogLevel.ERROR,
+                enable_journald=False,
+                enable_eventlog=False,
+                enable_graylog=False,
+                queue_enabled=False,
+            )
         )
-    )
 
 
 __all__ = ["init_logging_in_memory"]

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/src/bitranox_template_py_cli/application/ports.py

@@ -102,6 +102,8 @@ class InitLogging(Protocol):
     """Initialize lib_log_rich runtime with the provided configuration.
 
     ``dotenv_path`` is the ``.env`` the configuration was loaded with, or None for the nearest one.
+    A refused logging setting raises ``InvalidLoggingConfigError`` only after logging has been
+    started with its defaults, so the caller never has to start it a second time.
     """
 
     def __call__(self, config: Config, *, dotenv_path: str | None = None) -> None: ...

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/tests/test_email_config_translation.py

@@ -1,7 +1,7 @@
 """The merged [email] section becomes an EmailConfig: file keys kept, unknown keys refused.
 
 lib_layered_config merges every layer into one mapping; load_email_config_from_dict reads its
-[email] section. Five file keys differ from ConfMail's field names, values that mean "not
+[email] section. Six file keys differ from ConfMail's field names, values that mean "not
 configured" are dropped so the library default applies, and a key that is not a file key is
 refused, whatever layer it came from.
 """
@@ -33,7 +33,7 @@ def _problems(email: object) -> list[str]:
 
 
 @pytest.mark.os_agnostic
-def test_the_five_renamed_file_keys_reach_their_fields() -> None:
+def test_the_six_renamed_file_keys_reach_their_fields() -> None:
     config = _load(
         {
             "smtp_hosts": ["smtp.example.com:587"],
@@ -41,6 +41,7 @@ def test_the_five_renamed_file_keys_reach_their_fields() -> None:
             "timeout": 12.5,
             "starttls_verify": False,
             "local_hostname": "mail.example.com",
+            "delivery_deadline": 120,
         }
     )
 
@@ -49,6 +50,7 @@ def test_the_five_renamed_file_keys_reach_their_fields() -> None:
     assert config.smtp_timeout == 12.5
     assert config.smtp_starttls_verify is False
     assert config.smtp_local_hostname == "mail.example.com"
+    assert config.smtp_delivery_deadline == 120.0
 
 
 @pytest.mark.os_agnostic
@@ -223,7 +225,7 @@ def test_a_directory_list_becomes_paths() -> None:
     "host", ["smtp.example.com:99999", "smtp.example.com:abc", "[::1"], ids=["port-range", "port-text", "bracket"]
 )
 def test_a_malformed_host_is_refused_at_load(host: str) -> None:
-    """ConfMail refuses only userinfo, paths and control characters; the port and brackets are checked here."""
+    """A port or bracket typo surfaces when the configuration loads, not at the first delivery."""
     problems = _problems({"smtp_hosts": [host]})
 
     assert len(problems) == 1, problems
@@ -231,6 +233,21 @@ def test_a_malformed_host_is_refused_at_load(host: str) -> None:
     assert "Value error" not in problems[0], problems
 
 
+@pytest.mark.os_agnostic
+@pytest.mark.parametrize(
+    "host",
+    ["smtp.example.com:99999", "smtp.example.com:abc", "[::1", "smtp.example.com:+25", "a..example.com", "[zz]"],
+    ids=["port-range", "port-text", "bracket", "port-sign", "empty-label", "bracket-not-ip"],
+)
+def test_conf_mail_itself_refuses_a_malformed_host(host: str) -> None:
+    """EmailConfig has no host check of its own: ConfMail runs validate_smtp_host on every entry.
+
+    If a btx_lib_mail release stops doing so, this fails, and the check belongs back in EmailConfig.
+    """
+    with pytest.raises(ValidationError):
+        ConfMail(smtphosts=[host])
+
+
 @pytest.mark.os_agnostic
 def test_a_host_list_of_the_wrong_type_reads_as_the_file_key_without_a_prefix() -> None:
     """btx_lib_mail drops ctx for a credential field, so pydantic's prefix is still on the message."""

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/tests/test_logging_dotenv_isolation.py

@@ -5,7 +5,9 @@ reach the process environment: a later configuration load (``config --profile``,
 permission read) would take an app-prefixed line for the environment layer. With ``--env-file``,
 that file is the only ``.env`` read. An invalid ``[lib_log_rich]`` section is a configuration
 failure like a broken file: the commands that read the configuration refuse with exit 78, the
-others still run.
+others still run, logging with its defaults and every valid ``LOG_*`` variable. A refused ``LOG_*``
+variable, from the environment or the ``.env``, is the same failure: logging still starts, with its
+defaults and without any ``LOG_*`` variable.
 
 The end-to-end tests run the real CLI in a subprocess with every configuration location under
 ``tmp_path``.
@@ -23,7 +25,7 @@ import pytest
 from lib_layered_config import Config
 
 from bitranox_template_py_cli import __init__conf__
-from bitranox_template_py_cli.adapters.logging.setup import init_logging
+from bitranox_template_py_cli.adapters.logging.setup import InvalidLoggingConfigError, init_logging
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -202,3 +204,128 @@ def test_an_invalid_logging_section_does_not_block_the_deploy_that_replaces_it(t
     )
 
     assert result.returncode == 0, result.stderr
+
+
+# ------------------------------------------------------------------ a refused setting still leaves logging running
+
+
+@pytest.mark.os_agnostic
+def test_a_refused_logging_section_still_leaves_logging_running() -> None:
+    with pytest.raises(InvalidLoggingConfigError):
+        init_logging(Config({"lib_log_rich": {"rate_limit": "100:60"}}, {}))
+
+    assert lib_log_rich.runtime.is_initialised()
+
+
+@pytest.mark.os_agnostic
+def test_only_the_first_call_raises_for_a_refused_logging_section() -> None:
+    """The fallback leaves logging running, so a later call returns before it checks anything."""
+    refused = Config({"lib_log_rich": {"rate_limit": "100:60"}}, {})
+    with pytest.raises(InvalidLoggingConfigError):
+        init_logging(refused)
+
+    init_logging(refused)
+
+    assert lib_log_rich.runtime.is_initialised()
+
+
+@pytest.mark.os_agnostic
+def test_a_refused_log_variable_still_leaves_logging_running(monkeypatch: pytest.MonkeyPatch) -> None:
+    """lib_log_rich reads every ``LOG_*`` variable on each init, so the fallback must start without them."""
+    monkeypatch.setenv("LOG_CONSOLE_LEVEL", "bogus")
+
+    with pytest.raises(InvalidLoggingConfigError):
+        init_logging(Config({}, {}))
+
+    assert lib_log_rich.runtime.is_initialised()
+    assert os.environ["LOG_CONSOLE_LEVEL"] == "bogus"
+
+
+@pytest.mark.os_agnostic
+@pytest.mark.parametrize(
+    "command", [("info",), ("config-deploy", "--target", "user", "--force")], ids=["info", "deploy"]
+)
+def test_a_refused_log_variable_in_the_env_file_leaves_commands_that_do_not_read_the_config_running(
+    tmp_path: Path, command: tuple[str, ...]
+) -> None:
+    env_file = tmp_path / "service.env"
+    env_file.write_text("LOG_CONSOLE_LEVEL=bogus\n", encoding="utf-8")
+
+    result = _run(tmp_path, "--env-file", str(env_file), *command)
+
+    assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.os_agnostic
+def test_a_refused_log_variable_in_the_env_file_is_a_configuration_error(tmp_path: Path) -> None:
+    env_file = tmp_path / "service.env"
+    env_file.write_text("LOG_CONSOLE_LEVEL=bogus\n", encoding="utf-8")
+
+    result = _run(tmp_path, "--env-file", str(env_file), "config")
+
+    assert result.returncode == 78, result.stderr
+    errors = [line for line in result.stderr.splitlines() if line.startswith("Error:")]
+    assert len(errors) == 1, result.stderr
+    assert errors[0].startswith("Error: lib_log_rich")
+
+
+@pytest.mark.os_agnostic
+def test_a_refused_log_variable_in_the_environment_leaves_info_running(tmp_path: Path) -> None:
+    result = _run(tmp_path, "info", env={"LOG_CONSOLE_LEVEL": "bogus"})
+
+    assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.os_agnostic
+def test_every_log_variable_comes_back_even_when_the_default_start_fails(monkeypatch: pytest.MonkeyPatch) -> None:
+    """The fallback start hides the ``LOG_*`` variables; a failure there must not lose them.
+
+    ``lib_log_rich.runtime.init`` is the third-party edge: the first call refuses like a bad
+    level, the second (the defaults) fails for a reason of its own.
+    """
+    monkeypatch.setenv("LOG_CONSOLE_LEVEL", "bogus")
+    variable_seen: list[bool] = []
+
+    def refuse(_config: object) -> None:
+        variable_seen.append("LOG_CONSOLE_LEVEL" in os.environ)
+        if "LOG_CONSOLE_LEVEL" in os.environ:
+            raise ValueError("Unknown log level: 'bogus'")
+        raise RuntimeError("the default start failed too")
+
+    monkeypatch.setattr(lib_log_rich.runtime, "init", refuse)
+
+    with pytest.raises(RuntimeError, match="the default start failed too"):
+        init_logging(Config({}, {}))
+
+    # The configuration, then the defaults with the variables, then the defaults without them.
+    assert variable_seen == [True, True, False]
+    assert os.environ["LOG_CONSOLE_LEVEL"] == "bogus"
+
+
+# ------------------------------------------------------------------ which LOG_* variables the fallback keeps
+
+_INFO_LINE = "Displaying package information"
+_REFUSED_SECTION = ("--set", "lib_log_rich.rate_limit=100:60")
+
+
+@pytest.mark.os_agnostic
+def test_a_valid_log_variable_is_still_honoured_when_the_logging_section_is_refused(tmp_path: Path) -> None:
+    """Only a refused ``LOG_*`` variable is a reason to start without them; a refused section is not."""
+    shown = _run(tmp_path, *_REFUSED_SECTION, "info")
+    quieted = _run(tmp_path, *_REFUSED_SECTION, "info", env={"LOG_CONSOLE_LEVEL": "error"})
+
+    # Premise: at the default console level the fallback shows info's INFO line.
+    assert shown.returncode == 0, shown.stderr
+    assert _INFO_LINE in shown.stderr, shown.stderr
+    assert quieted.returncode == 0, quieted.stderr
+    assert _INFO_LINE not in quieted.stderr, quieted.stderr
+
+
+@pytest.mark.os_agnostic
+@pytest.mark.parametrize("section", [(), _REFUSED_SECTION], ids=["variable-alone", "with-refused-section"])
+def test_a_refused_log_variable_is_hidden_and_the_fallback_still_logs(tmp_path: Path, section: tuple[str, ...]) -> None:
+    """The defaults start without every ``LOG_*`` variable, and std logging still reaches the console."""
+    result = _run(tmp_path, *section, "info", env={"LOG_CONSOLE_LEVEL": "bogus"})
+
+    assert result.returncode == 0, result.stderr
+    assert _INFO_LINE in result.stderr, result.stderr

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/tests/test_mail.py

@@ -15,6 +15,7 @@ from unittest.mock import patch
 
 import pytest
 import rtoml
+from btx_lib_mail import ConfMail
 from pydantic import SecretStr
 from pydantic import ValidationError as PydanticValidationError
 
@@ -46,6 +47,7 @@ class _Delivery:
     credentials: tuple[str, str] | None
     local_hostname: str | None
     starttls_verify: bool
+    deadline: float | None
 
 
 class RecordingTransport:
@@ -87,6 +89,7 @@ class RecordingTransport:
                 credentials=delivery.credentials,
                 local_hostname=delivery.local_hostname,
                 starttls_verify=delivery.starttls_verify,
+                deadline=delivery.deadline,
             )
         )
 
@@ -1346,6 +1349,55 @@ def test_starttls_verify_and_local_hostname_from_the_file_reach_the_transport()
     assert transport.deliveries[0].starttls_verify is False
 
 
+@pytest.mark.os_agnostic
+def test_delivery_deadline_from_the_file_reaches_the_transport() -> None:
+    config = load_email_config_from_dict(
+        {"email": {"smtp_hosts": ["smtp.test.com:587"], "from_address": "app@example.com", "delivery_deadline": 90}}
+    )
+    transport = RecordingTransport()
+
+    send_email(config=config, recipients="ops@example.com", subject="s", transport=transport)
+
+    assert transport.deliveries[0].deadline == 90.0
+
+
+@pytest.mark.os_agnostic
+def test_recipient_max_count_from_the_file_refuses_a_larger_send_before_any_delivery() -> None:
+    config = load_email_config_from_dict(
+        {"email": {"smtp_hosts": ["smtp.test.com:587"], "from_address": "app@example.com", "recipient_max_count": 1}}
+    )
+    transport = RecordingTransport()
+
+    with pytest.raises(ValueError, match=r"2 recipients, more than recipient_max_count \(1\)"):
+        send_email(config=config, recipients=["a@example.com", "b@example.com"], subject="s", transport=transport)
+
+    assert transport.attempted_hosts == []
+
+
+@pytest.mark.os_agnostic
+def test_attachments_max_count_from_the_file_refuses_a_larger_send_before_any_delivery(tmp_path: Path) -> None:
+    first, second = tmp_path / "a.txt", tmp_path / "b.txt"
+    first.write_text("a", encoding="utf-8")
+    second.write_text("b", encoding="utf-8")
+    config = load_email_config_from_dict(
+        {
+            "email": {
+                "smtp_hosts": ["smtp.test.com:587"],
+                "from_address": "app@example.com",
+                "attachments": {"max_count": 1},
+            }
+        }
+    )
+    transport = RecordingTransport()
+
+    with pytest.raises(ValueError, match=r"2 attachments, more than attachment_max_count \(1\)"):
+        send_email(
+            config=config, recipients="ops@example.com", subject="s", attachments=[first, second], transport=transport
+        )
+
+    assert transport.attempted_hosts == []
+
+
 _SHIPPED_MAIL = (
     Path(__file__).parent.parent / "src" / "bitranox_template_py_cli" / "adapters" / "config" / "defaultconfig.d"
 ) / "50-mail.toml"
@@ -1356,3 +1408,18 @@ def test_the_shipped_defaults_verify_the_certificate_and_name_no_ehlo_host() ->
     shipped = rtoml.load(_SHIPPED_MAIL)["email"]
     assert shipped["starttls_verify"] is True
     assert shipped["local_hostname"] == ""
+
+
+@pytest.mark.os_agnostic
+def test_the_shipped_count_limits_and_deadline_load_as_the_library_defaults() -> None:
+    shipped = rtoml.load(_SHIPPED_MAIL)
+    # The keys are written out, so a reader of the shipped file sees them: the premise.
+    assert "recipient_max_count" in shipped["email"]
+    assert "delivery_deadline" in shipped["email"]
+    assert "max_count" in shipped["email"]["attachments"]
+    loaded = load_email_config_from_dict(shipped)
+    library = ConfMail()
+
+    assert loaded.recipient_max_count == library.recipient_max_count
+    assert loaded.attachment_max_count == library.attachment_max_count
+    assert loaded.smtp_delivery_deadline is library.smtp_delivery_deadline is None

{bitranox_template_py_cli-2.1.0 → bitranox_template_py_cli-2.1.1}/tests/test_memory_logging.py

@@ -11,6 +11,7 @@ reset within one test instead of relying on test order.
 from __future__ import annotations
 
 import logging
+import os
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -71,6 +72,30 @@ def test_the_reset_restores_the_root_logger_a_production_init_changed(
     assert (list(root.handlers), root.level, root.propagate) == before
 
 
+@pytest.mark.os_agnostic
+def test_a_refused_log_variable_in_the_shell_does_not_break_build_testing(
+    cli_runner: CliRunner, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """lib_log_rich reads the ``LOG_*`` variables on every init, so a developer's own
+    ``LOG_CONSOLE_LEVEL=bogus`` would refuse the test runtime and fail every command."""
+    monkeypatch.setenv("LOG_CONSOLE_LEVEL", "bogus")
+
+    result = cli_runner.invoke(cli_mod.cli, ["info"], obj=build_testing)
+
+    assert result.exception is None, result.exception
+    assert result.exit_code == 0, result.output
+
+
+@pytest.mark.os_agnostic
+def test_the_testing_runtime_puts_the_log_variables_back(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("LOG_CONSOLE_LEVEL", "bogus")
+
+    build_testing().init_logging(Config({}, {}))
+
+    assert lib_log_rich.runtime.is_initialised() is True
+    assert os.environ.get("LOG_CONSOLE_LEVEL") == "bogus"
+
+
 def _deploy_nothing(**_kwargs: Any) -> list[Path]:
     return []