Merge pull request #4 from LexianDEV/copilot/fix-b0d0c987-905e-4993-921c-a4b95eee0759

Implement async foundation and modularize application structure

Author: Lexian-droid

main.py

@@ -1,42 +1,17 @@
-import helpers
+"""
+General Python Template - Main Entry Point
+Minimal async-coordinated entry point that delegates to modules.
+"""
+
+import asyncio
+from modules import AppModule
+
+
+async def main():
+    """Main application entry point with async foundation."""
+    app = AppModule()
+    await app.start()
 
-def main():
-    print("=== General Python Template ===")
-    print(f"Current time: {helpers.time()}")
-    print()
-    
-    # Get basic app configuration
-    app_name = helpers.get_config('app.name', 'Unknown App')
-    app_version = helpers.get_config('app.version', '0.0.0')
-    app_env = helpers.get_config('app.env', 'unknown')
-    app_debug = helpers.get_config('app.debug', False)
-    
-    print(f"App: {app_name} v{app_version}")
-    print(f"Environment: {app_env} (Debug: {app_debug})")
-    print()
-    
-    # Demonstrate the configurable response number
-    response_number = helpers.get_config('app.response_number', 0)
-    message = helpers.get_config('app.message', 'Hello, World!')
-    
-    print("=== App Response ===")
-    print(f"Message: {message}")
-    print(f"Response Number: {response_number}")
-    print()
-    
-    # Show environment variable overrides
-    print("=== Configuration Source ===")
-    env_number = helpers.env('APP_RESPONSE_NUMBER')
-    if env_number:
-        print(f"Response number is overridden by environment variable: {env_number}")
-    else:
-        print(f"Response number is from config file: {response_number}")
-    
-    env_message = helpers.env('APP_MESSAGE')
-    if env_message:
-        print(f"Message is overridden by environment variable: {env_message}")
-    else:
-        print(f"Message is from config file: {message}")
 
 if __name__ == '__main__':
-    main()
+    asyncio.run(main())

modules/.gitkeep

@@ -0,0 +1,9 @@
+"""
+Modules package for the General Python Template.
+Contains organized functionality extracted from main application.
+"""
+
+from .app import AppModule
+from .display import DisplayModule
+
+__all__ = ['AppModule', 'DisplayModule']

modules/__init__.py

@@ -0,0 +1,52 @@
+"""
+Main application module with async foundation.
+Coordinates application logic and flow.
+"""
+
+import asyncio
+from .display import DisplayModule
+
+
+class AppModule:
+    """Main application module with async support."""
+    
+    def __init__(self):
+        """Initialize the application module."""
+        self.display = DisplayModule()
+    
+    async def run(self):
+        """Run the main application logic asynchronously."""
+        # Run all display sections
+        await self.display.show_all()
+    
+    async def initialize(self):
+        """Initialize the application (async setup)."""
+        # Placeholder for any async initialization
+        # This could include database connections, API setup, etc.
+        pass
+    
+    async def cleanup(self):
+        """Clean up resources (async teardown)."""
+        # Placeholder for any async cleanup
+        # This could include closing connections, saving state, etc.
+        pass
+    
+    async def start(self):
+        """Start the application with full lifecycle management."""
+        try:
+            await self.initialize()
+            await self.run()
+        finally:
+            await self.cleanup()
+    
+    async def start_with_async_demo(self):
+        """
+        Start the application with async demonstration.
+        Shows how the async foundation can be utilized.
+        """
+        try:
+            await self.initialize()
+            # Use the async demo display method
+            await self.display.show_with_delay(0.05)
+        finally:
+            await self.cleanup()

modules/app.py

@@ -0,0 +1,87 @@
+"""
+Display module for managing application output and presentation.
+Handles all display-related functionality with async support.
+"""
+
+import asyncio
+import helpers
+
+
+class DisplayModule:
+    """Handles application display and output functionality."""
+    
+    def __init__(self):
+        """Initialize the display module."""
+        pass
+    
+    async def show_header(self):
+        """Display the application header."""
+        print("=== General Python Template ===")
+        print(f"Current time: {helpers.time()}")
+        print()
+    
+    async def show_app_info(self):
+        """Display application information."""
+        # Get basic app configuration
+        app_name = helpers.get_config('app.name', 'Unknown App')
+        app_version = helpers.get_config('app.version', '0.0.0')
+        app_env = helpers.get_config('app.env', 'unknown')
+        app_debug = helpers.get_config('app.debug', False)
+        
+        print(f"App: {app_name} v{app_version}")
+        print(f"Environment: {app_env} (Debug: {app_debug})")
+        print()
+    
+    async def show_app_response(self):
+        """Display the application response section."""
+        response_number = helpers.get_config('app.response_number', 0)
+        message = helpers.get_config('app.message', 'Hello, World!')
+        
+        print("=== App Response ===")
+        print(f"Message: {message}")
+        print(f"Response Number: {response_number}")
+        print()
+    
+    async def show_config_source(self):
+        """Display configuration source information."""
+        response_number = helpers.get_config('app.response_number', 0)
+        message = helpers.get_config('app.message', 'Hello, World!')
+        
+        print("=== Configuration Source ===")
+        
+        # Check response number source
+        env_number = helpers.env('APP_RESPONSE_NUMBER')
+        if env_number:
+            print(f"Response number is overridden by environment variable: {env_number}")
+        else:
+            print(f"Response number is from config file: {response_number}")
+        
+        # Check message source
+        env_message = helpers.env('APP_MESSAGE')
+        if env_message:
+            print(f"Message is overridden by environment variable: {env_message}")
+        else:
+            print(f"Message is from config file: {message}")
+    
+    async def show_all(self):
+        """Display all application information sections."""
+        await self.show_header()
+        await self.show_app_info()
+        await self.show_app_response()
+        await self.show_config_source()
+    
+    async def show_with_delay(self, delay_seconds: float = 0.1):
+        """
+        Example of async functionality - show all sections with small delays.
+        This demonstrates the async foundation in action.
+        """
+        await self.show_header()
+        await asyncio.sleep(delay_seconds)
+        
+        await self.show_app_info()
+        await asyncio.sleep(delay_seconds)
+        
+        await self.show_app_response()
+        await asyncio.sleep(delay_seconds)
+        
+        await self.show_config_source()

modules/display.py

@@ -0,0 +1,66 @@
+"""
+Simple test for async functionality.
+"""
+
+import asyncio
+import sys
+import os
+
+# Add the project root to the path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from modules import AppModule, DisplayModule
+
+
+async def test_async_foundation():
+    """Test that async foundation works properly."""
+    print("Testing async foundation...")
+    
+    # Test display module async methods
+    display = DisplayModule()
+    
+    # These should run without error
+    await display.show_header()
+    await display.show_app_info()
+    await display.show_app_response()
+    await display.show_config_source()
+    
+    print("✓ All async display methods work")
+    
+    # Test app module
+    app = AppModule()
+    await app.initialize()
+    await app.cleanup()
+    
+    print("✓ App module lifecycle methods work")
+    
+    return True
+
+
+async def test_main_functionality():
+    """Test the main app functionality through async interface."""
+    print("Testing main app functionality through async...")
+    
+    app = AppModule()
+    # This should produce the same output as before
+    await app.run()
+    
+    print("✓ Main functionality works through async interface")
+    return True
+
+
+async def run_async_tests():
+    """Run all async tests."""
+    try:
+        await test_async_foundation()
+        await test_main_functionality()
+        print("\n✅ All async tests passed!")
+        return True
+    except Exception as e:
+        print(f"\n❌ Async test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    success = asyncio.run(run_async_tests())
+    sys.exit(0 if success else 1)