1
[project]
2
name = "adaptable-backend-python"
3
version = "0.1.0"
4
description = "An adaptable backend"
5
requires-python = ">=3.12"
6
dependencies = []

1
from pydantic import BaseModel, Field
2

3
class NoteDto(BaseModel):
4
    id: int = Field(..., example=1)
5
    content: str = Field(..., example="Hello World")

1
from fastapi import APIRouter
2
from .note_dto import NoteDto
3

4
class NoteRestController:
5
    def __init__(self) -> None:
6
        self.router = APIRouter(prefix="/notes", tags=["notes"])
7
        self._setup_routes()
8

9
    def _setup_routes(self) -> None:
10
        self.router.add_api_route(
11
            "/",
12
            self.get_notes,
13
            methods=["GET"],
14
            response_model=list[NoteDto],
15
            summary="Get all notes",
16
        )
17

18
    async def get_notes(self) -> list[NoteDto]:
19
        return [
20
            NoteDto(id=1, content="Hello 1"),
21
            NoteDto(id=2, content="Hello 2"),
22
        ]
23

24
note_controller = NoteRestController()
25
router = note_controller.router

1
from fastapi import FastAPI
2
from fastapi.middleware.cors import CORSMiddleware
3
import uvicorn
4

5
from .route import router as api_router
6

7
class FastAPIServerFactory:
8
    @staticmethod
9
    def create() -> "FastAPIServer":
10
        app = FastAPI(
11
            title="AdaptNotes API",
12
            description="The AdaptNotes API documentation",
13
            version="1.0.0",
14
            docs_url="/docs",
15
        )
16

17
        app.add_middleware(
18
            CORSMiddleware,
19
            allow_origins=["*"],
20
            allow_credentials=True,
21
            allow_methods=["*"],
22
            allow_headers=["*"],
23
        )
24

25
        app.include_router(api_router)
26

27
        return FastAPIServer(app)
28

29
class FastAPIServer:
30
    def __init__(self, app: FastAPI):
31
        self.app = app
32
        self.server = None
33

34
    async def listen(self, port: int) -> None:
35
        config = uvicorn.Config(self.app, host="0.0.0.0", port=port, log_level="info")
36
        self.server = uvicorn.Server(config)
37
        await self.server.serve()

1
from .frameworks.fastapi.fastapi_server_factory import FastAPIServerFactory
2

3
class Server:
4
    servers = {
5
        "fastapi": FastAPIServerFactory,
6
    }
7

8
    def __init__(self) -> None:
9
        self.server = None
10

11
    async def run(self, port: int) -> None:
12
        framework = "fastapi"
13
        self.server = self.servers[framework].create()
14
        await self.server.listen(port)

1
import asyncio
2
from src.apps.rest_api.server import Server
3

4
async def main() -> None:
5
    server = Server()
6
    await server.run(port=3000)
7

8
if __name__ == "__main__":
9
    asyncio.run(main())

1
.PHONY: dev help
2

3
help:
4
  @echo "Available commands:"
5
  @echo "  make dev  - Run the REST API development server"
6

7
dev:
8
  uv run python src/apps/rest_api/main.py

1
import os
2
from pathlib import Path
3
from typing import Any, Literal, TypedDict
4
from dataclasses import dataclass
5

6
class EnvConfig(TypedDict, total=False):
7
    NODE_ENV: Literal["development", "production", "test"]
8
    PORT: int
9

10
@dataclass
11
class EnvVarSchema:
12
    required: bool
13
    type: type
14
    default: Any = None
15

16
class Configuration:
17
    _instance: "Configuration | None" = None
18

19
    def __init__(self) -> None:
20
        self._config: dict[str, Any] = {}
21
        # Define schema with validation rules
22
        self._env_schema: dict[str, EnvVarSchema] = {
23
            "NODE_ENV": EnvVarSchema(required=True, type=str),
24
            "PORT": EnvVarSchema(required=True, type=int),
25
        }
26
        self._load_env_file()
27
        self._validate_config()
28

29
    def __new__(cls) -> "Configuration":
30
        if cls._instance is None:
31
            cls._instance = super(Configuration, cls).__new__(cls)
32
        return cls._instance
33

34
    def get(self, key: str) -> Any:
35
        return self._config.get(key)
36

37
    def _validate_config(self) -> None:
38
        # Validates all environment variables against schema
39
        # Raises ValueError if required variables are missing
40
        # ... (implementation details)
41

42
    def _parse_value(self, value: str, value_type: type) -> Any:
43
        # Converts string values to correct types (int, str, etc.)
44
        # ... (implementation details)
45

46
    def _load_env_file(self) -> None:
47
        # Loads .env file and populates os.environ
48
        # ... (implementation details)
49

50
config = Configuration()

1
import uvicorn
2
from src.core.configuration.configuration import config
3
from src.apps.rest_api.frameworks.fastapi.fastapi_server_factory import FastAPIServerFactory
4

5
factory = FastAPIServerFactory()
6
server = factory.create()
7
app = server.app
8

9
if __name__ == "__main__":
10
    import signal
11
    import sys
12

13
    def handle_exit(sig, frame):
14
        print("\nShutting down gracefully...")
15
        sys.exit(0)
16

17
    signal.signal(signal.SIGINT, handle_exit)
18
    signal.signal(signal.SIGTERM, handle_exit)
19

20
    port = config.get("PORT")
21
    env = config.get("NODE_ENV")
22

23
    reload = env == "development"
24

25
    try:
26
        uvicorn.run(
27
            "src.apps.rest_api.main:app",
28
            host="0.0.0.0",
29
            port=port,
30
            reload=reload,
31
            log_level="info"
32
        )
33
    except KeyboardInterrupt:
34
        pass