Add function that pretty prints a dictionary (#13)

* Add function that pretty prints a dictionary

* Test with rich

Author: gahjelle

examples/validate/config.py

@@ -9,7 +9,7 @@
 
 from pydantic import BaseModel, ConfigDict, HttpUrl, SecretStr
 
-from configaroo import Configuration
+from configaroo import Configuration, print_configuration
 
 
 class ExactBaseModel(BaseModel):
@@ -42,7 +42,7 @@ class ConfigModel(ExactBaseModel):
     server: ServerConfig
 
 
-def get_configuration():
+def get_configuration() -> ConfigModel:
     """Read and validate the configuration."""
     return Configuration.from_file(
         Path(__file__).parent / "settings.toml",
@@ -51,4 +51,4 @@ def get_configuration():
 
 
 if __name__ == "__main__":
-    print(get_configuration())
+    print_configuration(get_configuration())

pyproject.toml

@@ -42,6 +42,7 @@ dev = [
     "mypy>=1.17.1",
     "pre-commit>=4.2.0",
     "pytest>=8.3.5",
+    "rich>=14.1.0",
     "ruff>=0.11.11",
     "tomli-w>=1.2.0",
 ]

src/configaroo/__init__.py

@@ -1,16 +1,17 @@
 """Bouncy configuration handling"""
 
-from configaroo.configuration import Configuration
+from configaroo.configuration import Configuration, print_configuration
 from configaroo.exceptions import (
     ConfigarooException,
     MissingEnvironmentVariableError,
     UnsupportedLoaderError,
 )
 
 __all__ = [
-    "Configuration",
     "ConfigarooException",
+    "Configuration",
     "MissingEnvironmentVariableError",
+    "print_configuration",
     "UnsupportedLoaderError",
 ]
 

src/configaroo/configuration.py

@@ -5,7 +5,7 @@
 import re
 from collections import UserDict
 from pathlib import Path
-from typing import Any, Self, Type, TypeVar
+from typing import Any, Callable, Self, Type, TypeVar
 
 from pydantic import BaseModel
 
@@ -15,7 +15,7 @@
 ModelT = TypeVar("ModelT", bound=BaseModel)
 
 
-class Configuration(UserDict):
+class Configuration(UserDict[str, Any]):
     """A Configuration is a dict-like structure with some conveniences"""
 
     @classmethod
@@ -183,6 +183,50 @@ def to_flat_dict(self, _prefix: str = "") -> dict[str, Any]:
         }
 
 
+def print_configuration(config: Configuration | BaseModel, indent: int = 4) -> None:
+    """Pretty print a configuration.
+
+    If rich is installed, then a rich console is used for the printing.
+    """
+    return _print_dict_as_tree(
+        config.model_dump() if isinstance(config, BaseModel) else config,
+        indent=indent,
+        print=_get_rich_print(),
+    )
+
+
+def _get_rich_print() -> Callable[[str], None]:
+    """Initialize a Rich console if Rich is installed, otherwise use built-in print."""
+    try:
+        from rich.console import Console
+
+        return Console().print
+    except ImportError:
+        import builtins
+
+        return builtins.print
+
+
+def _print_dict_as_tree(
+    data: dict[str, Any] | UserDict[str, Any] | Configuration,
+    indent: int = 4,
+    current_indent: int = 0,
+    print: Callable[[str], None] = print,
+) -> None:
+    """Print a nested dictionary as a tree."""
+    for key, value in data.items():
+        if isinstance(value, dict | UserDict | Configuration):
+            print(" " * current_indent + f"- {key}")
+            _print_dict_as_tree(
+                value,
+                indent=indent,
+                current_indent=current_indent + indent,
+                print=print,
+            )
+        else:
+            print(" " * current_indent + f"- {key}: {value!r}")
+
+
 def _find_pyproject_toml(
     path: Path | None = None, _file_name: str = "pyproject.toml"
 ) -> Path:

tests/conftest.py

@@ -3,60 +3,16 @@
 import json
 from pathlib import Path
 from types import ModuleType
-from typing import Type
 
-import pydantic
 import pytest
 import tomli_w
 
 from configaroo import Configuration
-
-
-# Configuration schema
-class StrictSchema(pydantic.BaseModel):
-    model_config = pydantic.ConfigDict(extra="forbid")
-
-
-class DeeplyNestedSchema(StrictSchema):
-    sea: str
-
-
-class NestedSchema(StrictSchema):
-    pie: float
-    seven: int
-    deep: DeeplyNestedSchema
-
-
-class LogSchema(StrictSchema):
-    level: str
-    format: str
-
-
-class WithDotSchema(StrictSchema):
-    org_num: int = pydantic.Field(alias="org.num")
-
-
-class PathsSchema(StrictSchema):
-    relative: Path
-    dynamic: Path
-    absolute: Path
-    directory: Path
-    nested: Path
-
-
-class ConfigSchema(StrictSchema):
-    number: int
-    word: str
-    phrase: str
-    things: list[str]
-    nested: NestedSchema
-    log: LogSchema
-    with_dot: WithDotSchema
-    paths: PathsSchema
+from tests.schema import ConfigSchema
 
 
 @pytest.fixture
-def model() -> Type[ConfigSchema]:
+def model() -> type[ConfigSchema]:
     """A schema for the test configuration"""
     return ConfigSchema
 
@@ -89,30 +45,32 @@ def base_path() -> Path:
 
 
 @pytest.fixture
-def toml_path(base_path, config) -> Path:
+def toml_path(base_path: Path, config: Configuration) -> Path:
     """A path to a TOML file representing the configuration"""
     return write_file(base_path / "files" / "config.toml", tomli_w, config)
 
 
 @pytest.fixture
-def other_toml_path(base_path, config) -> Path:
+def other_toml_path(base_path: Path, config: Configuration) -> Path:
     """An alternative path to a TOML file representing the configuration"""
     return write_file(base_path / "files" / "tomlfile", tomli_w, config)
 
 
 @pytest.fixture
-def json_path(base_path, config) -> Path:
+def json_path(base_path: Path, config: Configuration) -> Path:
     """A path to a JSON file representing the configuration"""
     return write_file(base_path / "files" / "config.json", json, config, indent=4)
 
 
 @pytest.fixture
-def other_json_path(base_path, config) -> Path:
+def other_json_path(base_path: Path, config: Configuration) -> Path:
     """A path to a JSON file representing the configuration"""
     return write_file(base_path / "files" / "jsonfile", json, config, indent=4)
 
 
-def write_file(path: Path, lib: ModuleType, config: Configuration, **kwargs) -> Path:
+def write_file(
+    path: Path, lib: ModuleType, config: Configuration, **kwargs: str | int
+) -> Path:
     """Write a configuration to file. Return path for convenience"""
     path.write_text(lib.dumps(config.to_dict(), **kwargs), encoding="utf-8")
     return path

tests/schema.py

@@ -0,0 +1,48 @@
+"""Configuration schema used in tests."""
+
+from pathlib import Path
+
+import pydantic
+
+
+# Configuration schema
+class StrictSchema(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DeeplyNestedSchema(StrictSchema):
+    sea: str
+
+
+class NestedSchema(StrictSchema):
+    pie: float
+    seven: int
+    deep: DeeplyNestedSchema
+
+
+class LogSchema(StrictSchema):
+    level: str
+    format: str
+
+
+class WithDotSchema(StrictSchema):
+    org_num: int = pydantic.Field(alias="org.num")
+
+
+class PathsSchema(StrictSchema):
+    relative: Path
+    dynamic: Path
+    absolute: Path
+    directory: Path
+    nested: Path
+
+
+class ConfigSchema(StrictSchema):
+    number: int
+    word: str
+    phrase: str
+    things: list[str]
+    nested: NestedSchema
+    log: LogSchema
+    with_dot: WithDotSchema
+    paths: PathsSchema

tests/test_configuration.py

@@ -142,4 +142,6 @@ def test_incomplete_formatter():
 def test_public_classes_are_exposed():
     """Test that the __all__ attribute exposes all public classes"""
     public_classes = [attr for attr in dir(configaroo) if "A" <= attr[:1] <= "Z"]
-    assert sorted(public_classes) == sorted(configaroo.__all__)
+    assert sorted(public_classes) == sorted(
+        cls for cls in configaroo.__all__ if "A" <= cls[:1] <= "Z"
+    )

tests/test_print.py

@@ -0,0 +1,50 @@
+"""Test pretty printing of configurations."""
+
+from configaroo import Configuration, print_configuration
+from tests.schema import ConfigSchema
+
+
+def test_printing_of_config(capsys, config: Configuration) -> None:
+    """Test that a configuration can be printed."""
+    print_configuration(config, indent=4)
+    stdout = capsys.readouterr().out
+    lines = stdout.splitlines()
+
+    assert "- number: 42" in lines
+    assert "- word: 'platypus'" in lines
+    assert "- nested" in lines
+    assert "    - pie: 3.14" in lines
+
+
+def test_indentation(capsys, config: Configuration) -> None:
+    """Test that indentation can be controlled."""
+    print_configuration(config, indent=7)
+    stdout = capsys.readouterr().out
+    lines = stdout.splitlines()
+
+    assert "       - pie: 3.14" in lines
+
+
+def test_printing_of_basemodel(
+    capsys, config: Configuration, model: type[ConfigSchema]
+) -> None:
+    """Test that a configuration converted into a BaseModel can be printed."""
+    print_configuration(config.with_model(model))
+    stdout = capsys.readouterr().out
+    lines = stdout.splitlines()
+
+    assert "- number: 42" in lines
+    assert "- word: 'platypus'" in lines
+    assert "- nested" in lines
+    assert "    - pie: 3.14" in lines
+
+
+def test_printing_of_dynamic_values(capsys, config: Configuration) -> None:
+    """Test that interpolated values are printed correctly."""
+    print_configuration(config.parse_dynamic({"message": "testing configaroo"}))
+    stdout = capsys.readouterr().out
+    lines = stdout.splitlines()
+
+    assert "- number: 42" in lines
+    assert "- phrase: 'The meaning of life is 42'" in lines
+    assert "    - format: '<level>{level:<8} testing configaroo</level>'" in lines