1. import logging
  2. import os
  3. import json
  4. from typing import Dict, Any
  6. # Configure logging
  7. logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
  9. def log_config_operation(filepath: str, operation: str, data: Dict[str, Any] = None):
  10. """Logs the operation performed on a configuration file."""
  11. try:
  12. logging.info(f"Operation: {operation} on file: {filepath}")
  13. if data:
  14. logging.debug(f"Data: {data}")
  15. except Exception as e:
  16. logging.error(f"Error logging operation: {e}")
  18. def load_config(filepath: str) -> Dict[str, Any]:
  19. """Loads configuration data from a file with error handling."""
  20. try:
  21. if not os.path.exists(filepath):
  22. raise FileNotFoundError(f"File not found: {filepath}")
  23. try:
  24. with open(filepath, 'r') as f:
  25. config = json.load(f)
  26. return config
  27. except json.JSONDecodeError as e:
  28. raise ValueError(f"Invalid JSON format in {filepath}: {e}")
  29. except Exception as e:
  30. logging.error(f"Error loading config from {filepath}: {e}")
  31. raise
  33. def save_config(filepath: str, data: Dict[str, Any]):
  34. """Saves configuration data to a file with defensive checks."""
  35. try:
  36. if not isinstance(data, dict):
  37. raise TypeError("Data must be a dictionary.")
  38. with open(filepath, 'w') as f:
  39. json.dump(data, f, indent=4)
  40. logging.info(f"Successfully saved configuration to {filepath}")
  41. except Exception as e:
  42. logging.error(f"Error saving configuration to {filepath}: {e}")
  43. raise
  45. def validate_config(config: Dict[str, Any]) -> bool:
  46. """Validates the configuration data (example validation)."""
  47. # Add your validation logic here. This is just an example.
  48. if not isinstance(config, dict):
  49. logging.warning("Configuration is not a dictionary.")
  50. return False
  51. if 'required_key' not in config:
  52. logging.warning("Missing required key 'required_key'.")
  53. return False
  54. if not isinstance(config['required_key'], str):
  55. logging.warning("Value of 'required_key' is not a string.")
  56. return False
  57. return True
  59. def apply_config(filepath: str, config: Dict[str, Any]):
  60. """Applies the configuration data."""
  61. try:
  62. # Placeholder for applying the configuration.
  63. # Replace with your actual application logic.
  64. logging.info(f"Applying configuration from {filepath}: {config}")
  65. validate_config(config) # Validate before applying
  66. except Exception as e:
  67. logging.error(f"Error applying configuration from {filepath}: {e}")
  68. raise
  70. if __name__ == '__main__':
  71. # Example Usage
  72. config_file = "config.json"
  74. # Load configuration
  75. try:
  76. config = load_config(config_file)
  77. log_config_operation(config_file, "load", config)
  79. # Apply configuration
  80. apply_config(config_file, config)
  81. log_config_operation(config_file, "apply")
  83. # Save configuration
  84. config['new_key'] = 'new_value'
  85. save_config(config_file, config)
  86. log_config_operation(config_file, "save", config)
  88. except Exception as e:
  89. print(f"An error occurred: {e}")

Add your comment