add readable config printing

Author: marcorudolphflex

tests/config/test_legacy.py

@@ -18,3 +18,11 @@ def test_env_switch(config_manager):
     assert get_manager().profile == "dev"
     config_module.Env.set_current(config_module.Env.prod)
     assert get_manager().profile == "prod"
+
+
+def test_legacy_wrapper_str(config_manager):
+    from tidy3d.config import config
+
+    text = str(config)
+    assert text.startswith("Config(profile='default')")
+    assert '"https://tidy3d-api.simulation.cloud"' in text

tests/config/test_manager.py

@@ -97,3 +97,24 @@ def test_autograd_update_section(config_manager):
 
     assert autograd.gradient_dtype_float is np.float64
     assert autograd.gradient_dtype_complex is np.complex128
+
+
+def test_config_str_formatting(config_manager):
+    text = str(config_manager)
+    lines = text.splitlines()
+    assert lines[0] == "Config(profile='default')"
+    assert lines[1] == ""
+    assert lines[2] == "web:"
+    assert '  api_endpoint: "https://tidy3d-api.simulation.cloud"' in lines
+    assert '  s3_region: "us-gov-west-1"' in lines
+
+
+def test_section_accessor_str_formatting(config_manager):
+    text = str(config_manager.autograd)
+    lines = text.splitlines()
+    assert lines[0] == "autograd:"
+    assert '  gradient_precision: "single"' in lines
+    idx = lines.index("  monitor_interval_poly:")
+    assert lines[idx + 1] == "    - 1"
+    assert lines[idx + 2] == "    - 1"
+    assert lines[idx + 3] == "    - 1"

tidy3d/config/legacy.py

@@ -96,6 +96,9 @@ def __setattr__(self, name: str, value: Any) -> None:
         else:
             setattr(self._manager, name, value)
 
+    def __str__(self) -> str:  # pragma: no cover - presentation helper
+        return self._manager.format()
+
 
 class LegacyEnvironmentConfig:
     """Backward compatible environment config wrapper."""

tidy3d/config/manager.py

@@ -7,6 +7,7 @@
 from collections import defaultdict
 from collections.abc import Iterable
 from copy import deepcopy
+from enum import Enum
 from pathlib import Path
 from typing import Any, Optional, get_args, get_origin
 
@@ -63,6 +64,9 @@ def dict(self, *args, **kwargs):  # type: ignore[override]
             return {}
         return model.model_dump(*args, **kwargs)
 
+    def __str__(self) -> str:  # pragma: no cover - presentation helper
+        return self._manager.format_section(self._path)
+
 
 class PluginsAccessor:
     """Provides access to registered plugin configurations."""
@@ -236,6 +240,21 @@ def as_dict(self, include_env: bool = True) -> dict[str, Any]:
             return deepcopy(self._effective_tree)
         return self._compose_without_env()
 
+    def format(self, *, include_env: bool = True) -> str:
+        """Return a human-friendly representation of the full configuration."""
+
+        tree = self.as_dict(include_env=include_env)
+        return _render_config_tree(tree, profile=self._profile)
+
+    def format_section(self, name: str) -> str:
+        """Return a string representation for an individual section."""
+
+        model = self._get_model(name)
+        if model is None:
+            raise AttributeError(f"Section '{name}' is not available")
+        data = model.model_dump(exclude_unset=False)
+        return _render_config_tree(data, root=name)
+
     # ------------------------------------------------------------------
     # Registry callbacks
     # ------------------------------------------------------------------
@@ -387,6 +406,9 @@ def __setattr__(self, name: str, value: Any) -> None:
             return
         object.__setattr__(self, name, value)
 
+    def __str__(self) -> str:  # pragma: no cover - presentation helper
+        return self.format()
+
 
 # ----------------------------------------------------------------------
 # Helpers
@@ -429,6 +451,139 @@ def _serialize_value(value: Any) -> Any:
     return value
 
 
+def _render_config_tree(
+    data: Any,
+    *,
+    profile: Optional[str] = None,
+    root: Optional[str] = None,
+) -> str:
+    processed = _prepare_for_display(data)
+    lines: list[str] = []
+
+    if profile is not None and root is None:
+        lines.append(f"Config(profile={profile!r})")
+        if processed:
+            lines.append("")
+
+    if root is not None:
+        header = f"{root}:"
+        if isinstance(processed, dict) and processed:
+            lines.append(header)
+            lines.extend(_format_mapping(processed, indent=2))
+        elif isinstance(processed, dict):
+            lines.append(f"{header} {{}}")
+        else:
+            inline = _format_inline(processed)
+            lines.append(f"{header} {inline}")
+        return "\n".join(lines)
+
+    if isinstance(processed, dict) and processed:
+        lines.extend(_format_mapping(processed, indent=0))
+    elif isinstance(processed, dict):
+        lines.append("<empty>")
+    else:
+        lines.extend(_format_value(processed, indent=0))
+    return "\n".join(lines)
+
+
+def _prepare_for_display(value: Any) -> Any:
+    if isinstance(value, BaseModel):
+        return {
+            k: _prepare_for_display(v) for k, v in value.model_dump(exclude_unset=False).items()
+        }
+    if isinstance(value, dict):
+        return {str(k): _prepare_for_display(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_prepare_for_display(v) for v in value]
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Enum):
+        return value.value
+    if hasattr(value, "get_secret_value"):
+        displayed = getattr(value, "display", None)
+        if callable(displayed):
+            return displayed()
+        return str(value)
+    return value
+
+
+def _format_mapping(data: dict[str, Any], *, indent: int) -> list[str]:
+    lines: list[str] = []
+    for key in sorted(data.keys()):
+        value = data[key]
+        prefix = " " * indent + f"{key}:"
+        if isinstance(value, dict):
+            if value:
+                lines.append(prefix)
+                lines.extend(_format_mapping(value, indent=indent + 2))
+            else:
+                lines.append(f"{prefix} {{}}")
+            continue
+        if isinstance(value, list):
+            if value:
+                lines.append(prefix)
+                lines.extend(_format_sequence(value, indent=indent + 2))
+            else:
+                lines.append(f"{prefix} []")
+            continue
+        inline = _format_inline(value)
+        lines.append(f"{prefix} {inline}")
+    return lines
+
+
+def _format_sequence(items: list[Any], *, indent: int) -> list[str]:
+    lines: list[str] = []
+    if not items:
+        lines.append(" " * indent + "[]")
+        return lines
+    for item in items:
+        bullet = " " * indent + "-"
+        if isinstance(item, dict):
+            if item:
+                lines.append(bullet)
+                lines.extend(_format_mapping(item, indent=indent + 2))
+            else:
+                lines.append(f"{bullet} {{}}")
+            continue
+        if isinstance(item, list):
+            lines.append(bullet)
+            lines.extend(_format_sequence(item, indent=indent + 2))
+            continue
+        inline = _format_inline(item)
+        lines.append(f"{bullet} {inline}")
+    return lines
+
+
+def _format_value(value: Any, indent: int) -> list[str]:
+    if isinstance(value, dict):
+        return _format_mapping(value, indent=indent)
+    if isinstance(value, list):
+        return _format_sequence(value, indent=indent)
+    return [" " * indent + _format_inline(value)]
+
+
+def _format_inline(value: Any) -> str:
+    if isinstance(value, str):
+        return _quote_string(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return "null"
+    if isinstance(value, float):
+        return repr(value)
+    return str(value)
+
+
+def _quote_string(value: str) -> str:
+    if value == "":
+        return '""'
+    if any(ch in value for ch in '\n\r\t"'):
+        import json
+
+        return json.dumps(value)
+    return f'"{value}"'
+
+
 def _model_dict(model: BaseModel) -> dict[str, Any]:
     data = model.model_dump(exclude_unset=False)
     for key, value in list(data.items()):