Merge pull request #6 from LexianDEV/revert-5-copilot/fix-30608041-4694-46cc-8bd1-2ce8b482dc47

Revert "Replace .env file with bundled settings.py for application distribution"

Author: Lexian-droid

.env.example

@@ -0,0 +1,12 @@
+# Environment Configuration
+# This file contains environment-specific settings that override config files
+
+# Application Settings
+APP_NAME="My Custom App"
+APP_ENV=development
+APP_DEBUG=true
+APP_RESPONSE_NUMBER=100
+APP_MESSAGE="Hello from the environment!"
+
+# Logging
+APP_LOGGING_LEVEL=DEBUG

CONFIG.md

@@ -1,12 +1,11 @@
 # Configuration System
 
-This Python template includes a Laravel-inspired configuration system that allows you to manage application settings through Python files and settings overrides.
+This Python template includes a Laravel-inspired configuration system that allows you to manage application settings through Python files and environment variable overrides.
 
 ## Features
 
 - **Multiple Config Files**: Organize your configuration into separate Python files (e.g., `app.py`)
-- **Settings Overrides**: Use `config/settings.py` file or environment variables to override config values
-- **Bundled Settings**: Settings are bundled with the application binary (no external .env files needed)
+- **Environment Overrides**: Use `.env` file or environment variables to override config values
 - **Dot Notation Access**: Access nested configuration using dot notation (e.g., `app.name`, `app.logging.level`)
 - **Runtime Changes**: Modify configuration values at runtime for testing or dynamic behavior
 - **Helper Functions**: Easy-to-use helper functions for common config operations
@@ -31,37 +30,22 @@ if helpers.has_config('app.name'):
 all_app_config = helpers.get_all_config('app')
 ```
 
-### Settings File Overrides
+### Environment Variable Overrides
 
-Settings take precedence over config files but can be overridden by environment variables. Use uppercase and underscores:
+Environment variables take precedence over config files. Use uppercase and underscores:
 
 - `app.name` → `APP_NAME`
 - `app.response_number` → `APP_RESPONSE_NUMBER`
 - `app.logging.level` → `APP_LOGGING_LEVEL`
 
-Example `config/settings.py` file:
-```python
-# Application Settings - these override config/app.py values
-APP_NAME = "My Custom App"
-APP_DEBUG = True
-APP_RESPONSE_NUMBER = 100
-APP_MESSAGE = "Hello from the bundled settings!"
-```
-
-### Environment Variable Overrides
-
-Environment variables have the highest precedence and will override both config files and settings:
-
+Example `.env` file:
 ```bash
-export APP_NAME="Production App"
-export APP_DEBUG=false
+APP_NAME=My Custom App
+APP_DEBUG=true
+APP_RESPONSE_NUMBER=100
+APP_MESSAGE=Hello from the environment!
 ```
 
-**Precedence Order (highest to lowest):**
-1. Environment variables
-2. Settings file (`config/settings.py`)
-3. Config files (`config/*.py`)
-
 ### Runtime Configuration Changes
 
 ```python
@@ -101,7 +85,6 @@ cache = {
 ### Existing Config Files
 
 - **`app.py`**: Application-wide settings (name, version, debug mode, response number, etc.)
-- **`settings.py`**: Override settings bundled with the application
 
 ## Advanced Usage
 
@@ -111,7 +94,7 @@ cache = {
 from config_manager import ConfigManager
 
 # Create a custom config manager
-config = ConfigManager(config_dir="custom_config", settings_file="custom_settings")
+config = ConfigManager(config_dir="custom_config", env_file="custom.env")
 
 # Use the manager directly
 value = config.get('custom.setting', 'default')
@@ -129,11 +112,10 @@ value = helpers.env('app.name')  # Falls back to config if no env var
 ## Best Practices
 
 1. **Organize by Feature**: Create separate config files for different aspects (database, mail, cache, etc.)
-2. **Use Settings File**: For non-sensitive application-specific overrides that should be bundled
-3. **Use Environment Variables**: For sensitive data and deployment-specific settings
-4. **Provide Defaults**: Always provide sensible default values
-5. **Document Settings**: Add comments to explain complex configuration options
-6. **Validate Config**: Add validation for critical configuration values in your application startup
+2. **Use Environment Variables**: For sensitive data and environment-specific settings
+3. **Provide Defaults**: Always provide sensible default values
+4. **Document Settings**: Add comments to explain complex configuration options
+5. **Validate Config**: Add validation for critical configuration values in your application startup
 
 ## Example: Full Configuration Workflow
 
@@ -159,4 +141,4 @@ if helpers.get_config('app.env') == 'testing':
     helpers.set_config('database.default', 'sqlite')
 ```
 
-This configuration system provides the flexibility of Laravel's config system while maintaining Python's simplicity and power. Settings are now bundled with the application for easier distribution.
+This configuration system provides the flexibility of Laravel's config system while maintaining Python's simplicity and power.

build.spec

@@ -5,7 +5,7 @@ a = Analysis(
     ['main.py'],
     pathex=[],
     binaries=[],
-    datas=[('config/settings.py', 'config')],
+    datas=[],
     hiddenimports=[],
     hookspath=[],
     hooksconfig={},

config/settings.py

@@ -1,6 +1,6 @@
 """
 Laravel-like configuration manager for Python applications.
-Supports loading config files from the config directory and settings overrides.
+Supports loading config files from the config directory and environment overrides.
 """
 
 import os
@@ -10,35 +10,26 @@
 
 
 class ConfigManager:
-    """Manages application configuration with support for multiple config files and settings overrides."""
+    """Manages application configuration with support for multiple config files and environment overrides."""
 
-    def __init__(self, config_dir: str = "config", settings_file: str = "settings"):
+    def __init__(self, config_dir: str = "config", env_file: str = ".env"):
         self.config_dir = Path(config_dir)
-        self.settings_file = settings_file
+        self.env_file = Path(env_file)
         self._config_cache: Dict[str, Dict[str, Any]] = {}
-        self._settings_vars: Dict[str, str] = {}
+        self._env_vars: Dict[str, str] = {}
 
-        # Load settings variables from settings file
-        self._load_settings_file()
+        # Load environment variables from .env file
+        self._load_env_file()
 
-    def _load_settings_file(self) -> None:
-        """Load settings variables from settings.py file if it exists."""
-        settings_file_path = self.config_dir / f"{self.settings_file}.py"
-        if settings_file_path.exists():
-            # Load the settings file as a module
-            spec = importlib.util.spec_from_file_location(self.settings_file, settings_file_path)
-            if spec is None or spec.loader is None:
-                return
-                
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-            
-            # Extract all non-private attributes as settings values
-            for attr_name in dir(module):
-                if not attr_name.startswith('_') and not callable(getattr(module, attr_name)):
-                    value = getattr(module, attr_name)
-                    # Store as string for consistency with old env behavior
-                    self._settings_vars[attr_name] = str(value)
+    def _load_env_file(self) -> None:
+        """Load environment variables from .env file if it exists."""
+        if self.env_file.exists():
+            with open(self.env_file, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        key, value = line.split('=', 1)
+                        self._env_vars[key.strip()] = value.strip().strip('"').strip("'")
 
     def _load_config_file(self, config_name: str) -> Dict[str, Any]:
         """Load a specific config file."""
@@ -65,28 +56,21 @@ def _load_config_file(self, config_name: str) -> Dict[str, Any]:
     def get(self, key: str, default: Any = None) -> Any:
         """
         Get a configuration value using dot notation (e.g., 'app.name' or 'database.host').
-        Environment variables have highest precedence, then settings variables, then config files.
+        Environment variables take precedence over config files.
         """
-        # Check for environment variable override first (highest precedence)
+        # Check for environment variable override first
         env_key = key.upper().replace('.', '_')
-        if env_key in os.environ:
-            value = os.environ[env_key]
+        if env_key in self._env_vars:
+            value = self._env_vars[env_key]
             # Convert string boolean values
             if value.lower() in ('true', 'false'):
                 return value.lower() == 'true'
             return value
-        
-        # Check for settings variable override second
-        if env_key in self._settings_vars:
-            value = self._settings_vars[env_key]
+        if env_key in os.environ:
+            value = os.environ[env_key]
             # Convert string boolean values
             if value.lower() in ('true', 'false'):
                 return value.lower() == 'true'
-            # Try to convert to int if it looks like a number
-            try:
-                return int(value)
-            except ValueError:
-                pass
             return value
 
         # Parse the key to get config file and setting
@@ -140,7 +124,7 @@ def reload(self, config_name: Optional[str] = None) -> None:
                 del self._config_cache[config_name]
         else:
             self._config_cache.clear()
-            self._load_settings_file()
+            self._load_env_file()
 
     def all(self, config_name: str) -> Dict[str, Any]:
         """Get all configuration values for a specific config file."""

config_manager.py

@@ -47,9 +47,9 @@ def test_config_loading():
         print("✓ Config file loading works")
 
 
-def test_settings_overrides():
-    """Test settings file overrides."""
-    print("Testing settings overrides...")
+def test_env_overrides():
+    """Test environment variable overrides."""
+    print("Testing environment overrides...")
 
     with tempfile.TemporaryDirectory() as temp_dir:
         config_dir = Path(temp_dir) / "config"
@@ -62,21 +62,21 @@ def test_settings_overrides():
 debug = False
 """)
 
-        # Create settings file
-        settings_file = config_dir / "settings.py"
-        settings_file.write_text("""
-APP_NAME = "Override App"
-APP_DEBUG = True
+        # Create .env file
+        env_file = Path(temp_dir) / ".env"
+        env_file.write_text("""
+APP_NAME=Override App
+APP_DEBUG=true
 """)
 
         # Test config manager
-        manager = ConfigManager(config_dir=str(config_dir), settings_file="settings")
+        manager = ConfigManager(config_dir=str(config_dir), env_file=str(env_file))
 
-        # Test settings overrides
+        # Test environment overrides
         assert manager.get('app.name') == "Override App"
         assert manager.get('app.debug') == True
 
-        print("✓ Settings overrides work")
+        print("✓ Environment overrides work")
 
 
 def test_runtime_config_changes():
@@ -93,8 +93,8 @@ def test_runtime_config_changes():
 name = "Original App"
 """)
 
-        # Test config manager with no settings file
-        manager = ConfigManager(config_dir=str(config_dir), settings_file="nonexistent")
+        # Test config manager with no .env file
+        manager = ConfigManager(config_dir=str(config_dir), env_file="/nonexistent/.env")
 
         # Test runtime changes
         original_name = manager.get('app.name')
@@ -133,7 +133,7 @@ def run_tests():
 
     try:
         test_config_loading()
-        test_settings_overrides()
+        test_env_overrides()
         test_runtime_config_changes()
         test_helpers_integration()