feat: implement API module with FastAPI and initial route handlers

Author: npv2k1

main.py

@@ -3,55 +3,21 @@
 import logging
 import os
 from pathlib import Path
-from typing import Optional
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-)
-logger = logging.getLogger(__name__)
-
-
-def setup_environment() -> dict[str, str]:
-    """Load environment variables from .env file."""
-    env_vars = {}
-    env_path = Path(".env")
-    
-    if env_path.exists():
-        with env_path.open() as f:
-            for line in f:
-                line = line.strip()
-                if line and not line.startswith("#"):
-                    key, value = line.split("=", 1)
-                    env_vars[key.strip()] = value.strip()
-    
-    return env_vars
+from typing import Dict
+
 
 
-def main() -> None:
-    """Main application entry point."""
-    try:
-        # Load environment variables
-        env_vars = setup_environment()
-        app_name = env_vars.get("APP_NAME", "template-python")
-        env = env_vars.get("ENV", "development")
-        debug = env_vars.get("DEBUG", "false").lower() == "true"
 
-        # Configure logging level based on debug setting
-        if debug:
-            logging.getLogger().setLevel(logging.DEBUG)
-            logger.debug("Debug mode enabled")
 
-        logger.info(f"Starting {app_name} in {env} environment")
 
-        # Your application initialization code here
-        # For example:
-        # app = create_app()
-        # app.run()
+def main() -> None:
+    """Main application entry point."""
+    try:
+        print("Start app...")
+        import src.modules.api
 
     except Exception as e:
-        logger.error(f"Application failed to start: {e}", exc_info=True)
+        print(f"Application failed to start: {e}", exc_info=True)
         raise
 
 

pyproject.toml

@@ -5,6 +5,7 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "fastapi[standard]>=0.115.8",
     "ipykernel>=6.29.5",
     "numpy>=2.2.3",
     "pytest>=8.3.4",

src/modules/api/__init__.py

@@ -0,0 +1,3 @@
+"""API module initialization."""
+print("API module loaded.")
+import src.modules.api.index

src/modules/api/app.py

@@ -0,0 +1,39 @@
+"""FastAPI application factory."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .routes import v1_router
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        
+    )
+
+    # Add CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include routers
+    app.include_router(v1_router)
+
+    @app.on_event("startup")
+    async def startup_event():
+        """Run startup events."""
+        pass
+
+    @app.on_event("shutdown")
+    async def shutdown_event():
+        """Run shutdown events."""
+        pass
+
+    return app
+
+# Create default app instance
+app = create_app()

src/modules/api/index.py

@@ -0,0 +1,17 @@
+import uvicorn 
+from .app import app as api_app
+
+def main():
+    """Main application entry point."""
+    try:
+        print("Start api...")
+        uvicorn.run(
+            api_app,
+            host="0.0.0.0",
+            port=8800,
+            reload=False,
+        )
+    except Exception as e:
+        print(f"Application failed to start: {e}", exc_info=True)
+        raise
+main()

src/modules/api/routes.py

@@ -0,0 +1,5 @@
+"""API routes package."""
+
+from .v1 import router as v1_router
+
+__all__ = ["v1_router"]

src/modules/api/routes/__init__.py

@@ -0,0 +1,26 @@
+"""API v1 route handlers."""
+
+from fastapi import APIRouter
+from typing import Dict, List
+
+
+# Create v1 router
+router = APIRouter(prefix='/v1', tags=['v1'])
+
+@router.get("/hello")
+async def hello_world() -> Dict[str, str]:
+    """Hello world endpoint."""
+    return {"message": "Hello, World!"}
+
+@router.get("/health")
+async def health_check() -> Dict[str, str]:
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+@router.get("/metrics")
+async def metrics() -> Dict[str, int]:
+    """Application metrics endpoint."""
+    return {
+        "total_routes": len(router.routes),
+        "api_version": 1
+    }

src/modules/api/routes/v1.py

@@ -0,0 +1,65 @@
+"""Module loader utilities."""
+
+import logging
+import uvicorn
+from typing import Any, Optional
+
+from src.modules.api.app import app as api_app
+from src.modules.api.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+class ModuleLoader:
+    """Utility class for loading and running modules."""
+    
+    @staticmethod
+    def load_api(
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        reload: bool = False,
+        **kwargs: Any
+    ) -> None:
+        """Load and run the API module.
+        
+        Args:
+            host: Host to bind the server to
+            port: Port to bind the server to
+            reload: Enable auto-reload for development
+            **kwargs: Additional uvicorn configuration
+        """
+        logger.info(f"Starting API server on {host}:{port}")
+        logger.debug(f"API Settings: {settings.dict()}")
+        
+        config = uvicorn.Config(
+            api_app,
+            host=host,
+            port=port,
+            reload=reload,
+            log_level="debug" if settings.debug else "info",
+            **kwargs
+        )
+        
+        server = uvicorn.Server(config)
+        server.run()
+
+    @classmethod
+    def load_module(
+        cls,
+        module_name: str,
+        **kwargs: Any
+    ) -> Optional[Any]:
+        """Generic module loader.
+        
+        Args:
+            module_name: Name of the module to load
+            **kwargs: Module-specific configuration
+            
+        Returns:
+            Optional[Any]: Module instance if applicable
+        """
+        if module_name == "api":
+            cls.load_api(**kwargs)
+            return api_app
+        else:
+            logger.error(f"Unknown module: {module_name}")
+            return None