chore(log): remove dead code

src/experiment_logger/__init__.py

@@ -4,7 +4,6 @@ This package provides a unified interface for logging to multiple backends
 (WandB, disk, stdout) simultaneously, ensuring no data loss.
 """
 
-from experiment_logger.config_utils import load_yaml_config
 from experiment_logger.unified_logger import UnifiedLogger, get_logger, init_logger
 from experiment_logger.simple_logger import SimpleLogger
 from experiment_logger.wandb_utils import finish_wandb, init_wandb
@@ -16,6 +15,5 @@ __all__ = [
     "init_logger",
     "init_wandb",
     "finish_wandb",
-    "load_yaml_config",
 ]
 __version__ = "0.1.0"

src/experiment_logger/config_utils.py

@@ -1,83 +0,0 @@
-"""Configuration utilities for loading YAML configs and merging with CLI args."""
-
-import os
-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}")