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

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

Author: Lexian-droid

.env.example

@@ -1,11 +1,12 @@
 # Configuration System
 
-This Python template includes a Laravel-inspired configuration system that allows you to manage application settings through Python files and environment variable overrides.
+This Python template includes a Laravel-inspired configuration system that allows you to manage application settings through Python files and settings overrides.
 
 ## Features
 
 - **Multiple Config Files**: Organize your configuration into separate Python files (e.g., `app.py`)
-- **Environment Overrides**: Use `.env` file or environment variables to override config values
+- **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)
 - **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
@@ -30,22 +31,37 @@ if helpers.has_config('app.name'):
 all_app_config = helpers.get_all_config('app')
 ```
 
-### Environment Variable Overrides
+### Settings File Overrides
 
-Environment variables take precedence over config files. Use uppercase and underscores:
+Settings take precedence over config files but can be overridden by environment variables. Use uppercase and underscores:
 
 - `app.name` → `APP_NAME`
 - `app.response_number` → `APP_RESPONSE_NUMBER`
 - `app.logging.level` → `APP_LOGGING_LEVEL`
 
-Example `.env` file:
+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:
+
 ```bash
-APP_NAME=My Custom App
-APP_DEBUG=true
-APP_RESPONSE_NUMBER=100
-APP_MESSAGE=Hello from the environment!
+export APP_NAME="Production App"
+export APP_DEBUG=false
 ```
 
+**Precedence Order (highest to lowest):**
+1. Environment variables
+2. Settings file (`config/settings.py`)
+3. Config files (`config/*.py`)
+
 ### Runtime Configuration Changes
 
 ```python
@@ -85,6 +101,7 @@ 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
 
@@ -94,7 +111,7 @@ cache = {
 from config_manager import ConfigManager
 
 # Create a custom config manager
-config = ConfigManager(config_dir="custom_config", env_file="custom.env")
+config = ConfigManager(config_dir="custom_config", settings_file="custom_settings")
 
 # Use the manager directly
 value = config.get('custom.setting', 'default')
@@ -112,10 +129,11 @@ 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 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
+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
 
 ## Example: Full Configuration Workflow
 
@@ -141,4 +159,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.
+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.

CONFIG.md

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

build.spec

@@ -0,0 +1,15 @@
+"""
+Application-wide settings and overrides.
+This file contains environment-specific settings that can override config values.
+Unlike traditional .env files, this is bundled with the application.
+"""
+
+# Application Settings - these override config/app.py values
+APP_NAME = "My Custom App"
+APP_ENV = "development"
+APP_DEBUG = True
+APP_RESPONSE_NUMBER = 100
+APP_MESSAGE = "Hello from the bundled settings!"
+
+# Logging Settings
+APP_LOGGING_LEVEL = "DEBUG"

config/settings.py

@@ -1,6 +1,6 @@
 """
 Laravel-like configuration manager for Python applications.
-Supports loading config files from the config directory and environment overrides.
+Supports loading config files from the config directory and settings overrides.
 """
 
 import os
@@ -10,26 +10,35 @@
 
 
 class ConfigManager:
-    """Manages application configuration with support for multiple config files and environment overrides."""
+    """Manages application configuration with support for multiple config files and settings overrides."""
 
-    def __init__(self, config_dir: str = "config", env_file: str = ".env"):
+    def __init__(self, config_dir: str = "config", settings_file: str = "settings"):
         self.config_dir = Path(config_dir)
-        self.env_file = Path(env_file)
+        self.settings_file = settings_file
         self._config_cache: Dict[str, Dict[str, Any]] = {}
-        self._env_vars: Dict[str, str] = {}
+        self._settings_vars: Dict[str, str] = {}
 
-        # Load environment variables from .env file
-        self._load_env_file()
+        # Load settings variables from settings file
+        self._load_settings_file()
 
-    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_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_config_file(self, config_name: str) -> Dict[str, Any]:
         """Load a specific config file."""
@@ -56,21 +65,28 @@ 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 take precedence over config files.
+        Environment variables have highest precedence, then settings variables, then config files.
         """
-        # Check for environment variable override first
+        # Check for environment variable override first (highest precedence)
         env_key = key.upper().replace('.', '_')
-        if env_key in self._env_vars:
-            value = self._env_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'
             return value
-        if env_key in os.environ:
-            value = os.environ[env_key]
+        
+        # Check for settings variable override second
+        if env_key in self._settings_vars:
+            value = self._settings_vars[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
@@ -124,7 +140,7 @@ def reload(self, config_name: Optional[str] = None) -> None:
                 del self._config_cache[config_name]
         else:
             self._config_cache.clear()
-            self._load_env_file()
+            self._load_settings_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_env_overrides():
-    """Test environment variable overrides."""
-    print("Testing environment overrides...")
+def test_settings_overrides():
+    """Test settings file overrides."""
+    print("Testing settings overrides...")
 
     with tempfile.TemporaryDirectory() as temp_dir:
         config_dir = Path(temp_dir) / "config"
@@ -62,21 +62,21 @@ def test_env_overrides():
 debug = False
 """)
 
-        # Create .env file
-        env_file = Path(temp_dir) / ".env"
-        env_file.write_text("""
-APP_NAME=Override App
-APP_DEBUG=true
+        # Create settings file
+        settings_file = config_dir / "settings.py"
+        settings_file.write_text("""
+APP_NAME = "Override App"
+APP_DEBUG = True
 """)
 
         # Test config manager
-        manager = ConfigManager(config_dir=str(config_dir), env_file=str(env_file))
+        manager = ConfigManager(config_dir=str(config_dir), settings_file="settings")
 
-        # Test environment overrides
+        # Test settings overrides
         assert manager.get('app.name') == "Override App"
         assert manager.get('app.debug') == True
 
-        print("✓ Environment overrides work")
+        print("✓ Settings overrides work")
 
 
 def test_runtime_config_changes():
@@ -93,8 +93,8 @@ def test_runtime_config_changes():
 name = "Original App"
 """)
 
-        # Test config manager with no .env file
-        manager = ConfigManager(config_dir=str(config_dir), env_file="/nonexistent/.env")
+        # Test config manager with no settings file
+        manager = ConfigManager(config_dir=str(config_dir), settings_file="nonexistent")
 
         # Test runtime changes
         original_name = manager.get('app.name')
@@ -133,7 +133,7 @@ def run_tests():
 
     try:
         test_config_loading()
-        test_env_overrides()
+        test_settings_overrides()
         test_runtime_config_changes()
         test_helpers_integration()