Fix: issue #385 - Resctructured to follow bigger apps layout

Author: DimitriZC

Dockerfile

@@ -45,13 +45,13 @@ COPY requirements.txt   .
 RUN pip install --no-cache-dir --no-index --find-links /app/wheelhouse -r requirements.txt && \
     rm -rf /app/wheelhouse
 
-# Copy application source code
-COPY main.py            ./
-COPY databases/         ./databases/
-COPY models/            ./models/
-COPY routes/            ./routes/
-COPY schemas/           ./schemas/
-COPY services/          ./services/
+# Copy application source code 
+COPY app/main.py            ./
+COPY app/databases/         ./databases/
+COPY app/models/            ./models/
+COPY app/routes/            ./routes/
+COPY app/schemas/           ./schemas/
+COPY app/services/          ./services/
 
 # https://rules.sonarsource.com/docker/RSPEC-6504/
 
@@ -78,4 +78,4 @@ HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
     CMD ["./healthcheck.sh"]
 
 ENTRYPOINT ["./entrypoint.sh"]
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "9000"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "9000"]

databases/__init__.py app/__init__.pydatabases/__init__.py renamed to app/__init__.py

@@ -12,7 +12,7 @@
 import logging
 from typing import AsyncIterator
 from fastapi import FastAPI
-from routes import player_route, health_route
+from app.routes import player, health
 
 # https://github.com/encode/uvicorn/issues/562
 UVICORN_LOGGER = "uvicorn.error"
@@ -35,5 +35,5 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
     version="1.0.0",
 )
 
-app.include_router(player_route.api_router)
-app.include_router(health_route.api_router)
+app.include_router(player.router)
+app.include_router(health.router)

models/__init__.py app/databases/__init__.pymodels/__init__.py renamed to app/databases/__init__.py

@@ -7,10 +7,10 @@
 
 from fastapi import APIRouter
 
-api_router = APIRouter()
+router = APIRouter()
 
 
-@api_router.get("/health", tags=["Health"])
+@router.get("/health", tags=["Health"])
 async def health_check():
     """
     Simple health check endpoint.

databases/player_database.py app/databases/player.pydatabases/player_database.py renamed to app/databases/player.py

@@ -22,20 +22,22 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from aiocache import SimpleMemoryCache
 
-from databases.player_database import generate_async_session
-from models.player_model import PlayerModel
-from services import player_service
+from app.databases.player import generate_async_session
+from app.models.player import PlayerModel
+from app.services import player
 
-api_router = APIRouter()
+router = APIRouter()
 simple_memory_cache = SimpleMemoryCache()
 
 CACHE_KEY = "players"
 CACHE_TTL = 600  # 10 minutes
 
+PLAYER_TITLE = "The ID of the Player"
+
 # POST -------------------------------------------------------------------------
 
 
-@api_router.post(
+@router.post(
     "/players/",
     status_code=status.HTTP_201_CREATED,
     summary="Creates a new Player",
@@ -56,17 +58,17 @@ async def post_async(
     Raises:
         HTTPException: HTTP 409 Conflict error if the Player already exists.
     """
-    player = await player_service.retrieve_by_id_async(async_session, player_model.id)
-    if player:
+    player_res = await player.retrieve_by_id_async(async_session, player_model.id)
+    if player_res:
         raise HTTPException(status_code=status.HTTP_409_CONFLICT)
-    await player_service.create_async(async_session, player_model)
+    await player.create_async(async_session, player_model)
     await simple_memory_cache.clear(CACHE_KEY)
 
 
 # GET --------------------------------------------------------------------------
 
 
-@api_router.get(
+@router.get(
     "/players/",
     response_model=List[PlayerModel],
     status_code=status.HTTP_200_OK,
@@ -88,21 +90,21 @@ async def get_all_async(
     players = await simple_memory_cache.get(CACHE_KEY)
     response.headers["X-Cache"] = "HIT"
     if not players:
-        players = await player_service.retrieve_all_async(async_session)
+        players = await player.retrieve_all_async(async_session)
         await simple_memory_cache.set(CACHE_KEY, players, ttl=CACHE_TTL)
         response.headers["X-Cache"] = "MISS"
     return players
 
 
-@api_router.get(
+@router.get(
     "/players/{player_id}",
     response_model=PlayerModel,
     status_code=status.HTTP_200_OK,
     summary="Retrieves a Player by its Id",
     tags=["Players"],
 )
 async def get_by_id_async(
-    player_id: int = Path(..., title="The ID of the Player"),
+    player_id: int = Path(..., title=PLAYER_TITLE),
     async_session: AsyncSession = Depends(generate_async_session),
 ):
     """
@@ -119,13 +121,13 @@ async def get_by_id_async(
         HTTPException: Not found error if the Player with the specified ID does not
         exist.
     """
-    player = await player_service.retrieve_by_id_async(async_session, player_id)
-    if not player:
+    player_res = await player.retrieve_by_id_async(async_session, player_id)
+    if not player_res:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-    return player
+    return player_res
 
 
-@api_router.get(
+@router.get(
     "/players/squadnumber/{squad_number}",
     response_model=PlayerModel,
     status_code=status.HTTP_200_OK,
@@ -150,25 +152,25 @@ async def get_by_squad_number_async(
         HTTPException: HTTP 404 Not Found error if the Player with the specified
         Squad Number does not exist.
     """
-    player = await player_service.retrieve_by_squad_number_async(
+    player_res = await player.retrieve_by_squad_number_async(
         async_session, squad_number
     )
-    if not player:
+    if not player_res:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-    return player
+    return player_res
 
 
 # PUT --------------------------------------------------------------------------
 
 
-@api_router.put(
+@router.put(
     "/players/{player_id}",
     status_code=status.HTTP_204_NO_CONTENT,
     summary="Updates an existing Player",
     tags=["Players"],
 )
 async def put_async(
-    player_id: int = Path(..., title="The ID of the Player"),
+    player_id: int = Path(..., title=PLAYER_TITLE),
     player_model: PlayerModel = Body(...),
     async_session: AsyncSession = Depends(generate_async_session),
 ):
@@ -185,24 +187,24 @@ async def put_async(
         HTTPException: HTTP 404 Not Found error if the Player with the specified ID
         does not exist.
     """
-    player = await player_service.retrieve_by_id_async(async_session, player_id)
-    if not player:
+    player_res = await player.retrieve_by_id_async(async_session, player_id)
+    if not player_res:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-    await player_service.update_async(async_session, player_model)
+    await player.update_async(async_session, player_model)
     await simple_memory_cache.clear(CACHE_KEY)
 
 
 # DELETE -----------------------------------------------------------------------
 
 
-@api_router.delete(
+@router.delete(
     "/players/{player_id}",
     status_code=status.HTTP_204_NO_CONTENT,
     summary="Deletes an existing Player",
     tags=["Players"],
 )
 async def delete_async(
-    player_id: int = Path(..., title="The ID of the Player"),
+    player_id: int = Path(..., title=PLAYER_TITLE),
     async_session: AsyncSession = Depends(generate_async_session),
 ):
     """
@@ -216,8 +218,8 @@ async def delete_async(
         HTTPException: HTTP 404 Not Found error if the Player with the specified ID
         does not exist.
     """
-    player = await player_service.retrieve_by_id_async(async_session, player_id)
-    if not player:
+    player_res = await player.retrieve_by_id_async(async_session, player_id)
+    if not player_res:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-    await player_service.delete_async(async_session, player_id)
+    await player.delete_async(async_session, player_id)
     await simple_memory_cache.clear(CACHE_KEY)