refactor

Author: legout

web_ui/app.py

@@ -3,17 +3,19 @@
 Main Sanic application with htpy templates and Datastar integration
 """
 
-from sanic import Sanic, Request
-from sanic.response import html, json
-from sanic_ext import Extend
-from datastar_py.sanic import ServerSentEventGenerator, datastar_respond, SSE_HEADERS
-import htpy as h
 import asyncio
-from typing import List, Dict, Any
 import json as json_module
 import os
-from datetime import datetime
 import uuid
+from datetime import datetime
+from typing import Any, Dict, List
+
+import htpy as h
+from datastar_py.sanic import (SSE_HEADERS, ServerSentEventGenerator,
+                               datastar_respond)
+from sanic import Request, Sanic
+from sanic.response import html, json
+from sanic_ext import Extend
 
 # Initialize Sanic app
 app = Sanic("FlowerPowerWeb")

web_ui/config.py

@@ -3,80 +3,93 @@
 """
 
 import os
-from typing import Dict, Any
+from typing import Any, Dict
+
 
 class Config:
     """Base configuration class"""
-    
+
     # Server settings
     HOST = os.getenv("FLOWERPOWER_WEB_HOST", "0.0.0.0")
     PORT = int(os.getenv("FLOWERPOWER_WEB_PORT", "8000"))
     DEBUG = os.getenv("FLOWERPOWER_WEB_DEBUG", "true").lower() == "true"
-    
+
     # Application settings
     APP_NAME = "FlowerPowerWeb"
     VERSION = "1.0.0"
-    
+
     # CORS settings
     CORS_ORIGINS = os.getenv("FLOWERPOWER_WEB_CORS_ORIGINS", "*")
-    
+
     # Static files
     STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
-    
+
     # Database settings (for future use)
     DATABASE_URL = os.getenv("FLOWERPOWER_DATABASE_URL", "sqlite:///flowerpower.db")
-    
+
     # Security settings
-    SECRET_KEY = os.getenv("FLOWERPOWER_SECRET_KEY", "dev-secret-key-change-in-production")
-    
+    SECRET_KEY = os.getenv(
+        "FLOWERPOWER_SECRET_KEY", "dev-secret-key-change-in-production"
+    )
+
     # Datastar settings
     DATASTAR_STREAM_ENDPOINT = "/datastar/stream"
-    
+
     # Pagination settings
     PROJECTS_PER_PAGE = int(os.getenv("FLOWERPOWER_PROJECTS_PER_PAGE", "10"))
-    
+
     @classmethod
     def get_settings(cls) -> Dict[str, Any]:
         """Get all configuration settings as a dictionary"""
         return {
             key: getattr(cls, key)
             for key in dir(cls)
-            if not key.startswith('_') and not callable(getattr(cls, key))
+            if not key.startswith("_") and not callable(getattr(cls, key))
         }
 
+
 class DevelopmentConfig(Config):
     """Development configuration"""
+
     DEBUG = True
     HOST = "127.0.0.1"
 
+
 class ProductionConfig(Config):
     """Production configuration"""
+
     DEBUG = False
     SECRET_KEY = os.getenv("FLOWERPOWER_SECRET_KEY")
-    
+
     @classmethod
     def validate(cls):
         """Validate production configuration"""
         if not os.getenv("FLOWERPOWER_SECRET_KEY"):
-            raise ValueError("FLOWERPOWER_SECRET_KEY environment variable must be set in production")
+            raise ValueError(
+                "FLOWERPOWER_SECRET_KEY environment variable must be set in production"
+            )
+
 
 class TestingConfig(Config):
     """Testing configuration"""
+
     DEBUG = True
     TESTING = True
     DATABASE_URL = "sqlite:///:memory:"
 
+
 # Configuration mapping
 config = {
-    'development': DevelopmentConfig,
-    'production': ProductionConfig,
-    'testing': TestingConfig,
-    'default': DevelopmentConfig
+    "development": DevelopmentConfig,
+    "production": ProductionConfig,
+    "testing": TestingConfig,
+    "default": DevelopmentConfig,
 }
 
+
 def get_config(config_name: str = None) -> Config:
     """Get configuration class based on environment"""
     if config_name is None:
-        config_name = os.getenv('FLOWERPOWER_WEB_ENV', 'default')
-    
-    return config.get(config_name, DevelopmentConfig)
+        config_name = os.getenv("FLOWERPOWER_WEB_ENV", "default")
+
+    return config.get(config_name, DevelopmentConfig)

web_ui/run.py

@@ -3,25 +3,22 @@
 Startup script for FlowerPower Web UI
 """
 
-import sys
 import subprocess
+import sys
 from pathlib import Path
 
+
 def check_dependencies():
     """Check if required dependencies are installed"""
-    required_packages = [
-        'sanic',
-        'htpy', 
-        'datastar_py'
-    ]
-    
+    required_packages = ["sanic", "htpy", "datastar_py"]
+
     missing_packages = []
     for package in required_packages:
         try:
             __import__(package)
         except ImportError:
             missing_packages.append(package)
-    
+
     if missing_packages:
         print("❌ Missing required packages:")
         for package in missing_packages:
@@ -31,38 +28,41 @@ def check_dependencies():
         print("   # or with uv:")
         print("   uv pip install -r requirements.txt")
         return False
-    
+
     print("✅ All dependencies are installed")
     return True
 
+
 def main():
     """Main startup function"""
     print("🌸 FlowerPower Web UI Startup")
     print("=" * 40)
-    
+
     # Check if we're in the right directory
     if not Path("app.py").exists():
         print("❌ Error: app.py not found")
         print("💡 Make sure you're running this from the web_ui directory")
         sys.exit(1)
-    
+
     # Check dependencies
     if not check_dependencies():
         sys.exit(1)
-    
+
     # Start the application
     print("\n🚀 Starting FlowerPower Web UI...")
     print("📍 URL: http://localhost:8000")
     print("🛑 Press Ctrl+C to stop\n")
-    
+
     try:
         from app import app
+
         app.run(host="0.0.0.0", port=8000, debug=True)
     except KeyboardInterrupt:
         print("\n👋 FlowerPower Web UI stopped")
     except Exception as e:
         print(f"❌ Error starting application: {e}")
         sys.exit(1)
 
+
 if __name__ == "__main__":
-    main()
+    main()

web_ui/test_app.py

@@ -4,128 +4,128 @@
 
 import asyncio
 import json
+
 from app import app
 
+
 async def test_routes():
     """Test basic route accessibility"""
     print("🧪 Testing FlowerPower Web UI Routes")
     print("=" * 40)
-    
+
     # Create test client
     request, response = await app.asgi_client.get("/")
     assert response.status == 200
     assert "FlowerPower" in response.text
     print("✅ Home page loads correctly")
-    
+
     # Test projects list
     request, response = await app.asgi_client.get("/projects")
     assert response.status == 200
     assert "Projects" in response.text
     print("✅ Projects page loads correctly")
-    
+
     # Test new project form
     request, response = await app.asgi_client.get("/projects/new")
     assert response.status == 200
     assert "Create New Project" in response.text
     print("✅ New project form loads correctly")
-    
+
     # Test API endpoint
     request, response = await app.asgi_client.get("/api/projects")
     assert response.status == 200
     data = json.loads(response.text)
     assert "projects" in data
     print("✅ API endpoint works correctly")
-    
+
     # Test project detail
     request, response = await app.asgi_client.get("/projects/1")
     assert response.status == 200
     print("✅ Project detail page loads correctly")
-    
+
     # Test non-existent project
     request, response = await app.asgi_client.get("/projects/999")
     assert response.status == 200
     assert "Project Not Found" in response.text
     print("✅ 404 handling works correctly")
-    
+
     print("\n🎉 All tests passed!")
 
+
 async def test_project_creation():
     """Test project creation via form submission"""
     print("\n🧪 Testing Project Creation")
     print("=" * 30)
-    
+
     # Test valid project creation
-    form_data = {
-        "name": "Test Project",
-        "description": "A test project for validation"
-    }
-    
+    form_data = {"name": "Test Project", "description": "A test project for validation"}
+
     request, response = await app.asgi_client.post("/projects", data=form_data)
     assert response.status == 200
     data = json.loads(response.text)
     assert data["status"] == "success"
     print("✅ Project creation works correctly")
-    
+
     # Test empty name validation
-    form_data = {
-        "name": "",
-        "description": "Project with empty name"
-    }
-    
+    form_data = {"name": "", "description": "Project with empty name"}
+
     request, response = await app.asgi_client.post("/projects", data=form_data)
     assert response.status == 200
     data = json.loads(response.text)
     assert data["status"] == "error"
     print("✅ Empty name validation works correctly")
-    
+
     print("\n🎉 Project creation tests passed!")
 
+
 def test_template_generation():
     """Test htpy template generation"""
     print("\n🧪 Testing Template Generation")
     print("=" * 30)
-    
+
     from app import base_layout, project_card
     from htpy import html as h
-    
+
     # Test base layout
     content = h.div("Test content")
     layout = base_layout("Test Page", content)
     assert "Test Page - FlowerPower" in layout
     assert "Test content" in layout
     assert "data-ds-stream" in layout
     print("✅ Base layout generation works correctly")
-    
+
     # Test project card
     test_project = {
         "id": 1,
         "name": "Test Project",
         "description": "Test description",
-        "created_at": "2025-01-23T12:00:00Z"
+        "created_at": "2025-01-23T12:00:00Z",
     }
-    
+
     card_html = str(project_card(test_project))
     assert "Test Project" in card_html
     assert "Test description" in card_html
     assert "2025-01-23" in card_html
     print("✅ Project card generation works correctly")
-    
+
     print("\n🎉 Template generation tests passed!")
 
+
 async def main():
     """Run all tests"""
     try:
         test_template_generation()
         await test_routes()
         await test_project_creation()
-        
+
         print("\n" + "=" * 50)
         print("🎉 All FlowerPower Web UI tests passed!")
         print("✨ Application is ready for deployment")
-        
+
     except Exception as e:
         print(f"\n❌ Test failed: {e}")
         raise
 
+
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())