Hier is een voorbeeld van een Python-script dat je kunt gebruiken om configuratie-instellingen te beheren, inclusief ondersteuning voor verschillende omgevingen en validatie. Het script gebruikt JSON-bestanden voor de configuratie en biedt functies om te lezen, schrijven, standaardwaarden te gebruiken en te valideren. ### Voorbeeld configuratiestructuur (JSON) ```json { "ontwikkeling": { "database_url": "sqlite:///development.db", "api_key": "dev12345", "debug": true, "max_verbindingen": 10 }, "testen": { "database_url": "sqlite:///test.db", "api_key": "test12345", "debug": true, "max_verbindingen": 5 }, "productie": { "database_url": "postgresql://user:pass@localhost/prod", "api_key": "prod12345", "debug": false, "max_verbindingen": 50 } } ``` ### Python-script ```python import json import os # Definieer standaardwaarden DEFAULT_CONFIG = { "database_url": "sqlite:///default.db", "api_key": "", "debug": False, "max_verbindingen": 10 } # Functie om configuratie te laden uit een JSON-bestand def lees_config(bestandsnaam, omgeving): if not os.path.exists(bestandsnaam): print(f"Configuratiebestand '{bestandsnaam}' niet gevonden. Gebruik standaardinstellingen.") return DEFAULT_CONFIG.copy() with open(bestandsnaam, 'r') as f: alle_config = json.load(f) config = alle_config.get(omgeving, {}) # Vul ontbrekende opties aan met defaults volledige_config = {**DEFAULT_CONFIG, **config} return volledige_config # Functie om configuratie naar een JSON-bestand te schrijven def schrijf_config(bestandsnaam, omgeving, config): if os.path.exists(bestandsnaam): with open(bestandsnaam, 'r') as f: alle_config = json.load(f) else: alle_config = {} alle_config[omgeving] = config with open(bestandsnaam, 'w') as f: json.dump(alle_config, f, indent=4) print(f"Configuratie voor '{omgeving}' opgeslagen in '{bestandsnaam}'.") # Validatiefunctie voor de configuratie def valideer_config(config): fouten = [] if not isinstance(config.get("database_url"), str) or not config["database_url"]: fouten.append(" 'database_url' moet een niet-lege string zijn.") if not isinstance(config.get("api_key"), str): fouten.append(" 'api_key' moet een string zijn.") if not isinstance(config.get("debug"), bool): fouten.append(" 'debug' moet een boolean zijn.") if not isinstance(config.get("max_verbindingen"), int) or config["max_verbindingen"] <= 0: fouten.append(" 'max_verbindingen' moet een positief geheel getal zijn.") return fouten # Voorbeeldgebruik def main(): bestandsnaam = "config.json" omgeving = "ontwikkeling" # Lees bestaande configuratie of gebruik defaults config = lees_config(bestandsnaam, omgeving) print(f"Huidige configuratie voor {omgeving}: {config}") # Simuleer wijziging van een instelling config["max_verbindingen"] = 20 # Valideer de gewijzigde configuratie fouten = valideer_config(config) if fouten: print("Fouten in de configuratie:", fouten) else: # Sla de nieuwe configuratie op schrijf_config(bestandsnaam, omgeving, config) if __name__ == "__main__": main() ``` ### Samenvatting - Het script leest de configuratie voor een specifieke omgeving uit een JSON-bestand. - Als het bestand of de omgeving niet bestaat, worden standaardwaarden gebruikt. - Je kunt configuratie-instellingen aanpassen en opslaan. - Voor validatie worden eenvoudige checks uitgevoerd op de types en waarden. - De structuur van de JSON maakt het mogelijk om meerdere omgevingen te beheren binnen één bestand. Wil je nog verdere uitbreidingen of specifieke voorbeelden?

Hier is een volledig Python-script voor configuratiebeheer met JSON-bestanden en omgevingsondersteuning: ```python import json import os from typing import Dict, Any, Optional from pathlib import Path class ConfigManager: def __init__(self, config_dir: str = "config", env: str = "ontwikkeling"): self.config_dir = Path(config_dir) self.env = env self.default_config = { "database": { "host": "localhost", "port": 5432, "name": "mijn_app", "username": "gebruiker", "password": "wachtwoord" }, "server": { "port": 8000, "debug": True, "host": "0.0.0.0" }, "logging": { "level": "INFO", "file": "app.log", "max_size": "10MB" } } # Maak configuratiemap aan als deze niet bestaat self.config_dir.mkdir(exist_ok=True) def get_config_path(self) -> Path: """Retourneert het pad naar het configuratiebestand voor de huidige omgeving""" return self.config_dir / f"config_{self.env}.json" def load_config(self) -> Dict[str, Any]: """Laadt configuratie uit bestand of gebruikt defaults""" config_path = self.get_config_path() if config_path.exists(): try: with open(config_path, 'r', encoding='utf-8') as f: loaded_config = json.load(f) print(f"Configuratie geladen van: {config_path}") return self._merge_configs(self.default_config, loaded_config) except (json.JSONDecodeError, IOError) as e: print(f"Fout bij laden configuratie: {e}. Gebruik standaardwaarden.") return self.default_config.copy() else: print("Configuratiebestand niet gevonden. Gebruik standaardwaarden.") return self.default_config.copy() def save_config(self, config: Dict[str, Any]) -> bool: """Slaat configuratie op naar bestand""" try: config_path = self.get_config_path() with open(config_path, 'w', encoding='utf-8') as f: json.dump(config, f, indent=4, ensure_ascii=False) print(f"Configuratie opgeslagen in: {config_path}") return True except IOError as e: print(f"Fout bij opslaan configuratie: {e}") return False def _merge_configs(self, default: Dict, custom: Dict) -> Dict: """Voegt aangepaste configuratie samen met defaults""" result = default.copy() for key, value in custom.items(): if key in result and isinstance(result[key], dict) and isinstance(value, dict): result[key] = self._merge_configs(result[key], value) else: result[key] = value return result def validate_config(self, config: Dict[str, Any]) -> tuple[bool, list[str]]: """Valideert de configuratie-instellingen""" errors = [] # Database validatie db_config = config.get("database", {}) if not db_config.get("host"): errors.append("Database host is verplicht") if not isinstance(db_config.get("port"), int) or db_config.get("port", 0) <= 0: errors.append("Database port moet een positief geheel getal zijn") # Server validatie server_config = config.get("server", {}) if not 1 <= server_config.get("port", 0) <= 65535: errors.append("Server port moet tussen 1 en 65535 liggen") if not isinstance(server_config.get("debug"), bool): errors.append("Server debug moet een boolean zijn") # Logging validatie logging_config = config.get("logging", {}) valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] if logging_config.get("level") not in valid_levels: errors.append(f"Logging level moet een van {valid_levels} zijn") return len(errors) == 0, errors def update_setting(self, section: str, key: str, value: Any) -> bool: """Werkt een specifieke instelling bij""" config = self.load_config() if section not in config: config[section] = {} config[section][key] = value is_valid, errors = self.validate_config(config) if not is_valid: print(f"Validatiefouten: {errors}") return False return self.save_config(config) def get_setting(self, section: str, key: str, default: Any = None) -> Any: """Haalt een specifieke instelling op""" config = self.load_config() return config.get(section, {}).get(key, default) # Gebruiksvoorbeelden def main(): # Initialiseer configuratie manager voor ontwikkelomgeving config_manager = ConfigManager(env="ontwikkeling") # Laad configuratie config = config_manager.load_config() print("Huidige configuratie:") print(json.dumps(config, indent=2, ensure_ascii=False)) # Valideer configuratie is_valid, errors = config_manager.validate_config(config) if is_valid: print("✓ Configuratie is geldig") else: print("✗ Configuratie bevat fouten:") for error in errors: print(f" - {error}") # Update een specifieke instelling print("\n--- Database host bijwerken ---") success = config_manager.update_setting("database", "host", "dev-db.example.com") if success: print("Database host succesvol bijgewerkt") # Haal een specifieke instelling op db_port = config_manager.get_setting("database", "port") print(f"\nDatabase poort: {db_port}") # Toon configuratiebestand locatie print(f"\nConfiguratiebestand: {config_manager.get_config_path()}") # Voorbeeld van een aangepaste configuratie structuur voorbeeld_config = { "database": { "host": "localhost", "port": 5432, "name": "mijn_app_development", "username": "dev_user", "password": "dev_pass" }, "server": { "port": 8080, "debug": True, "host": "127.0.0.1" }, "logging": { "level": "DEBUG", "file": "development.log", "max_size": "5MB" }, "api": { "timeout": 30, "retry_attempts": 3 } } if __name__ == "__main__": main() ``` **Aanvullend voorbeeld: Omgevingsspecifieke configuratie** ```python # config_ontwikkeling.json (wordt automatisch aangemaakt) { "database": { "host": "localhost", "port": 5432, "name": "mijn_app_development", "username": "dev_user", "password": "dev_pass" }, "server": { "port": 8080, "debug": true, "host": "127.0.0.1" }, "logging": { "level": "DEBUG", "file": "development.log" } } # Gebruik in je applicatie: config_manager = ConfigManager(env="ontwikkeling") config = config_manager.load_config() # Voor productie: # config_manager = ConfigManager(env="productie") ``` **Belangrijkste kenmerken:** 1. **Omgevingsondersteuning**: Verschillende configuratiebestanden per omgeving 2. **Defaults**: Standaardwaarden worden gebruikt wanneer instellingen ontbreken 3. **Validatie**: Controleert dat instellingen geldige waarden hebben 4. **Merging**: Aangepaste instellingen worden samengevoegd met defaults 5. **Foutafhandeling**: Robuuste foutafhandeling voor bestandsoperaties Het script maakt automatisch de configuratiemap aan en genereert JSON-bestanden voor elke omgeving.