84 lines
3 KiB
Python
84 lines
3 KiB
Python
"""Configuration utilities for loading YAML configs and merging with CLI args."""
|
|
|
|
import os
|
|
import sys
|
|
from typing import Dict, Any, Type, TypeVar
|
|
import yaml
|
|
from dataclasses import fields, is_dataclass
|
|
|
|
from experiment_logger.unified_logger import get_logger
|
|
|
|
T = TypeVar("T")
|
|
|
|
|
|
def load_yaml_config(config_path: str) -> Dict[str, Any]:
|
|
"""Load configuration from YAML file."""
|
|
if not os.path.exists(config_path):
|
|
raise FileNotFoundError(f"Config file not found: {config_path}")
|
|
|
|
with open(config_path, "r") as f:
|
|
config = yaml.safe_load(f)
|
|
|
|
if config is None:
|
|
return {}
|
|
|
|
get_logger().info(f"Loaded configuration from: {config_path}")
|
|
return config
|
|
|
|
|
|
def save_yaml_config(config: Dict[str, Any], config_path: str):
|
|
"""Save configuration to YAML file."""
|
|
os.makedirs(os.path.dirname(config_path), exist_ok=True)
|
|
|
|
with open(config_path, "w") as f:
|
|
yaml.dump(config, f, default_flow_style=False, indent=2, sort_keys=False)
|
|
|
|
get_logger().info(f"Saved configuration to: {config_path}")
|
|
|
|
|
|
def dataclass_from_dict(cls: Type[T], config_dict: Dict[str, Any]) -> T:
|
|
"""Create dataclass instance from dictionary, handling type conversions."""
|
|
if not is_dataclass(cls):
|
|
raise ValueError(f"{cls} is not a dataclass")
|
|
|
|
# Get field names and types
|
|
field_map = {f.name: f for f in fields(cls)} # type: ignore
|
|
|
|
# Filter config to only include valid fields
|
|
filtered_config: Dict[str, Any] = {}
|
|
for key, value in config_dict.items():
|
|
if key in field_map:
|
|
field = field_map[key]
|
|
# Handle type conversion if needed
|
|
try:
|
|
# Handle None values and optional types
|
|
if value is None:
|
|
filtered_config[key] = None
|
|
elif hasattr(field.type, "__origin__") and field.type.__origin__ is type(None):
|
|
# Optional type (Union[X, None])
|
|
filtered_config[key] = value
|
|
else:
|
|
# Try to convert to the expected type
|
|
if field.type is bool and isinstance(value, str):
|
|
filtered_config[key] = value.lower() in ("true", "1", "yes", "on")
|
|
else:
|
|
filtered_config[key] = field.type(value) if value is not None else None # type: ignore
|
|
except (ValueError, TypeError) as e:
|
|
get_logger().warning(f"Could not convert {key}={value} to {field.type}: {e}")
|
|
filtered_config[key] = value
|
|
else:
|
|
get_logger().warning(f"Unknown configuration parameter: {key}")
|
|
|
|
return cls(**filtered_config)
|
|
|
|
|
|
def print_config(config: Any, title: str = "Configuration"):
|
|
"""Pretty print configuration."""
|
|
get_logger().info(f"{title}:")
|
|
if is_dataclass(config):
|
|
for field in fields(config):
|
|
value = getattr(config, field.name)
|
|
get_logger().info(f" {field.name}: {value}")
|
|
else:
|
|
for key, value in vars(config).items():
|
|
get_logger().info(f" {key}: {value}")
|