Spaces:
Sleeping
Sleeping
| #!/usr/bin/env python3 | |
| import yaml | |
| import os | |
| from typing import Dict, Any, List | |
| from pathlib import Path | |
| class ConfigManager: | |
| """Manages configuration loading and access for the chatbot application.""" | |
| def __init__(self, config_path: str = None): | |
| """ | |
| Initialize the configuration manager. | |
| Args: | |
| config_path: Path to the configuration file. Defaults to config.yaml in project root. | |
| """ | |
| if config_path is None: | |
| # Default to config.yaml in the project root | |
| project_root = Path(__file__).parent.parent | |
| config_path = project_root / "config.yaml" | |
| self.config_path = Path(config_path) | |
| self._config = self._load_config() | |
| def _load_config(self) -> Dict[str, Any]: | |
| """Load configuration from YAML file.""" | |
| try: | |
| with open(self.config_path, 'r', encoding='utf-8') as file: | |
| config = yaml.safe_load(file) | |
| return config or {} | |
| except FileNotFoundError: | |
| raise FileNotFoundError(f"Configuration file not found: {self.config_path}") | |
| except yaml.YAMLError as e: | |
| raise ValueError(f"Error parsing configuration file: {e}") | |
| def get(self, key_path: str, default: Any = None) -> Any: | |
| """ | |
| Get a configuration value using dot notation. | |
| Args: | |
| key_path: Dot-separated path to the configuration value (e.g., 'database.path') | |
| default: Default value to return if key is not found | |
| Returns: | |
| The configuration value or default if not found | |
| """ | |
| keys = key_path.split('.') | |
| value = self._config | |
| try: | |
| for key in keys: | |
| value = value[key] | |
| return value | |
| except (KeyError, TypeError): | |
| return default | |
| def get_database_config(self) -> Dict[str, Any]: | |
| """Get database configuration.""" | |
| return self.get('database', {}) | |
| def get_openai_config(self, component: str = None) -> Dict[str, Any]: | |
| """ | |
| Get OpenAI configuration. | |
| Args: | |
| component: Specific component configuration (e.g., 'intent_classifier') | |
| Returns: | |
| OpenAI configuration dictionary | |
| """ | |
| if component: | |
| return self.get(f'openai.{component}', {}) | |
| return self.get('openai', {}) | |
| def get_vector_store_config(self) -> Dict[str, Any]: | |
| """Get vector store configuration.""" | |
| return self.get('vector_store', {}) | |
| def get_search_config(self) -> Dict[str, Any]: | |
| """Get search configuration.""" | |
| return self.get('search', {}) | |
| def get_entity_extraction_config(self) -> Dict[str, Any]: | |
| """Get entity extraction configuration.""" | |
| return self.get('entity_extraction', {}) | |
| def get_business_logic_config(self) -> Dict[str, Any]: | |
| """Get business logic configuration.""" | |
| return self.get('business_logic', {}) | |
| def get_app_config(self) -> Dict[str, Any]: | |
| """Get application configuration.""" | |
| return self.get('app', {}) | |
| def is_feature_enabled(self, feature_name: str) -> bool: | |
| """ | |
| Check if a feature is enabled. | |
| Args: | |
| feature_name: Name of the feature to check | |
| Returns: | |
| True if feature is enabled, False otherwise | |
| """ | |
| return self.get(f'app.features.{feature_name}', True) | |
| # Global configuration instance | |
| _config_manager = None | |
| def get_config() -> ConfigManager: | |
| """Get the global configuration manager instance.""" | |
| global _config_manager | |
| if _config_manager is None: | |
| _config_manager = ConfigManager() | |
| return _config_manager | |
| def reload_config(): | |
| """Reload the configuration from file.""" | |
| global _config_manager | |
| _config_manager = ConfigManager() |