Merge pull request #167 from nanotaboada/feature/async

refactor!: support for async code

Author: nanotaboada

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+concurrency = thread,gevent

data/player_database.py

@@ -2,11 +2,38 @@
 # Database
 # ------------------------------------------------------------------------------
 
-from sqlalchemy import create_engine
-from sqlalchemy.orm import scoped_session, sessionmaker, declarative_base
+import logging
+from typing import AsyncGenerator
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker, declarative_base
 
-DATABASE_URL = "sqlite:///./data/players-sqlite3.db"
+DATABASE_URL = "sqlite+aiosqlite:///./data/players-sqlite3.db"
+
+logger = logging.getLogger("uvicorn")
+logging.getLogger("sqlalchemy.engine.Engine").handlers = logger.handlers
+
+async_engine = create_async_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False},
+    echo=True
+)
+
+async_sessionmaker = sessionmaker(
+    bind=async_engine,
+    class_=AsyncSession,
+    autocommit=False,
+    autoflush=False
+)
 
-engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
-OrmSession = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))
 Base = declarative_base()
+
+
+async def generate_async_session() -> AsyncGenerator[AsyncSession, None]:
+    """
+    Dependency function to yield an async SQLAlchemy ORM session.
+
+    Yields:
+        AsyncSession: An instance of an async SQLAlchemy ORM session.
+    """
+    async with async_sessionmaker() as async_session:
+        yield async_session

main.py

@@ -10,11 +10,16 @@
 
 
 @asynccontextmanager
-async def lifespan(app: FastAPI):
+async def lifespan_context_manager(_):
+    """
+    Context manager for the FastAPI app lifespan.
+
+    Initializes  FastAPICache with an InMemoryBackend for the duration of the app's lifespan.
+    """
     FastAPICache.init(InMemoryBackend())
     yield
 
-app = FastAPI(lifespan=lifespan,
+app = FastAPI(lifespan=lifespan_context_manager,
               title="python-samples-fastapi-restful",
               description="🧪 Proof of Concept for a RESTful API made with Python 3 and FastAPI",
               version="1.0.0",)

requirements.txt

@@ -1,40 +1,48 @@
 aiohttp==3.9.5
 aiosignal==1.3.1
+aiosqlite==0.20.0
 annotated-types==0.7.0
 anyio==4.4.0
+asttokens==2.4.1
 attrs==23.2.0
+backcall==0.2.0
+bleach==6.1.0
 certifi==2024.7.4
 charset-normalizer==3.3.2
 click==8.1.7
-colorclass==2.2.2
 coverage==7.6.0
+decorator==5.1.1
+defusedxml==0.7.1
 dnspython==2.6.1
-docopt==0.6.2
 email_validator==2.2.0
 fastapi==0.111.1
 fastapi-cache2==0.2.1
 fastapi-cli==0.0.4
+fastjsonschema==2.20.0
 flake8==7.1.0
 frozenlist==1.4.1
+gevent==24.2.1
 greenlet==3.0.3
 h11==0.14.0
 httpcore==1.0.5
 httptools==0.6.1
 httpx==0.27.0
 idna==3.7
-ijson==3.3.0
 iniconfig==2.0.0
+jedi==0.19.1
 Jinja2==3.1.4
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
 markdown-it-py==3.0.0
 MarkupSafe==2.1.5
 mccabe==0.7.0
 mdurl==0.1.2
 multidict==6.0.5
 orjson==3.10.6
 packaging==24.1
+parso==0.8.4
 pendulum==3.0.0
 pluggy==1.5.0
-pur==7.3.2
 pycodestyle==2.12.0
 pydantic==2.8.2
 pydantic_core
@@ -48,10 +56,13 @@ python-dateutil==2.9.0.post0
 python-dotenv==1.0.1
 python-multipart==0.0.9
 PyYAML==6.0.1
+pyzmq==26.0.3
+referencing==0.35.1
 requests==2.32.3
 responses==0.25.3
 rfc3986==2.0.0
 rich==13.7.1
+rpds-py==0.19.1
 setuptools==71.1.0
 shellingham==1.5.4
 six==1.16.0
@@ -60,9 +71,8 @@ SQLAlchemy==2.0.31
 starlette
 stdlib-list==0.10.0
 termcolor==2.4.0
-terminaltables==3.1.10
 time-machine==2.14.2
-tree-sitter==0.22.3
+tornado==6.4.1
 typer==0.12.3
 typing_extensions==4.12.2
 tzdata==2024.1
@@ -71,5 +81,9 @@ urllib3==2.2.2
 uvicorn==0.30.3
 uvloop==0.19.0
 watchfiles==0.22.0
+wcwidth==0.2.13
+webencodings==0.5.1
 websockets==12.0
 yarl==1.9.4
+zope.event==5.0
+zope.interface==6.4.post2

routes/player_route.py

@@ -4,33 +4,18 @@
 
 from typing import List
 from fastapi import APIRouter, Body, Depends, HTTPException, status, Path
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
 from fastapi_cache import FastAPICache
 from fastapi_cache.decorator import cache
-from data.player_database import OrmSession
+
+from data.player_database import generate_async_session
 from models.player_model import PlayerModel
 from services import player_service
 
 api_router = APIRouter()
 
 CACHING_TIME_IN_SECONDS = 600
 
-# https://fastapi.tiangolo.com/tutorial/sql-databases/#create-a-dependency
-
-
-def get_orm_session():
-    """
-    Dependency function to yield a scoped SQLAlchemy ORM session.
-
-    Yields:
-        OrmSession: An instance of a scoped SQLAlchemy ORM session.
-    """
-    orm_session = OrmSession()
-    try:
-        yield orm_session
-    finally:
-        orm_session.close()
-
 # POST -------------------------------------------------------------------------
 
 
@@ -40,28 +25,25 @@ def get_orm_session():
     summary="Creates a new Player",
     tags=["Players"]
 )
-def post(
+async def post(
     player_model: PlayerModel = Body(...),
-    orm_session: Session = Depends(get_orm_session)
+    async_session: AsyncSession = Depends(generate_async_session)
 ):
     """
     Endpoint to create a new player.
 
     Args:
-        player_model (PlayerModel): The data model representing a Player.
-        orm_session (Session): The SQLAlchemy ORM session.
+        player_model (PlayerModel): The Pydantic model representing the Player to create.
+        async_session (AsyncSession): The async version of a SQLAlchemy ORM session.
 
     Raises:
         HTTPException: HTTP 409 Conflict error if the Player already exists.
     """
-    player = player_service.retrieve_by_id(orm_session, player_model.id)
-
+    player = await player_service.retrieve_by_id(async_session, player_model.id)
     if player:
         raise HTTPException(status_code=status.HTTP_409_CONFLICT)
-
-    player_service.create(orm_session, player_model)
-
-    FastAPICache.clear()
+    await player_service.create(async_session, player_model)
+    await FastAPICache.clear()
 
 # GET --------------------------------------------------------------------------
 
@@ -74,20 +56,19 @@ def post(
     tags=["Players"]
 )
 @cache(expire=CACHING_TIME_IN_SECONDS)
-def get_all(
-    orm_session: Session = Depends(get_orm_session)
+async def get_all(
+    async_session: AsyncSession = Depends(generate_async_session)
 ):
     """
     Endpoint to retrieve all players.
 
     Args:
-        orm_session (Session): The SQLAlchemy ORM session.
+        async_session (AsyncSession): The async version of a SQLAlchemy ORM session.
 
     Returns:
-        List[PlayerModel]: A list of data models representing all players.
+        List[PlayerModel]: A list of Pydantic models representing all players.
     """
-    players = player_service.retrieve_all(orm_session)
-
+    players = await player_service.retrieve_all(async_session)
     return players
 
 
@@ -99,28 +80,26 @@ def get_all(
     tags=["Players"]
 )
 @cache(expire=CACHING_TIME_IN_SECONDS)
-def get_by_id(
+async def get_by_id(
     player_id: int = Path(..., title="The ID of the Player"),
-    orm_session: Session = Depends(get_orm_session)
+    async_session: AsyncSession = Depends(generate_async_session)
 ):
     """
     Endpoint to retrieve a Player by its ID.
 
     Args:
         player_id (int): The ID of the Player to retrieve.
-        orm_session (Session): The SQLAlchemy ORM session.
+        async_session (AsyncSession): The async version of a SQLAlchemy ORM session.
 
     Returns:
-        PlayerModel: A data model representing the Player.
+        PlayerModel: The Pydantic model representing the matching Player.
 
     Raises:
         HTTPException: Not found error if the Player with the specified ID does not exist.
     """
-    player = player_service.retrieve_by_id(orm_session, player_id)
-
+    player = await player_service.retrieve_by_id(async_session, player_id)
     if not player:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-
     return player
 
 
@@ -132,28 +111,26 @@ def get_by_id(
     tags=["Players"]
 )
 @cache(expire=CACHING_TIME_IN_SECONDS)
-def get_by_squad_number(
+async def get_by_squad_number(
     squad_number: int = Path(..., title="The Squad Number of the Player"),
-    orm_session: Session = Depends(get_orm_session)
+    async_session: AsyncSession = Depends(generate_async_session)
 ):
     """
     Endpoint to retrieve a Player by its Squad Number.
 
     Args:
         squad_number (int): The Squad Number of the Player to retrieve.
-        orm_session (Session): SQLAlchemy ORM session.
+        async_session (AsyncSession): The async version of a SQLAlchemy ORM session.
 
     Returns:
-        PlayerModel: A data model representing the Player.
+        PlayerModel: The Pydantic model representing the matching Player.
 
     Raises:
         HTTPException: HTTP 404 Not Found error if the Player with the specified Squad Number does not exist.
     """
-    player = player_service.retrieve_by_squad_number(orm_session, squad_number)
-
+    player = await player_service.retrieve_by_squad_number(async_session, squad_number)
     if not player:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-
     return player
 
 # PUT --------------------------------------------------------------------------
@@ -165,30 +142,27 @@ def get_by_squad_number(
     summary="Updates an existing Player",
     tags=["Players"]
 )
-def put(
+async def put(
     player_id: int = Path(..., title="The ID of the Player"),
     player_model: PlayerModel = Body(...),
-    orm_session: Session = Depends(get_orm_session)
+    async_session: AsyncSession = Depends(generate_async_session)
 ):
     """
     Endpoint to entirely update an existing Player.
 
     Args:
         player_id (int): The ID of the Player to update.
-        player_model (PlayerModel): The data model representing the Player to update.
-        orm_session (Session): The SQLAlchemy ORM session.
+        player_model (PlayerModel): The Pydantic model representing the Player to update.
+        async_session (AsyncSession): The async version of a SQLAlchemy ORM session.
 
     Raises:
         HTTPException: HTTP 404 Not Found error if the Player with the specified ID does not exist.
     """
-    player = player_service.retrieve_by_id(orm_session, player_id)
-
+    player = await player_service.retrieve_by_id(async_session, player_id)
     if not player:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-
-    player_service.update(orm_session, player_model)
-
-    FastAPICache.clear()
+    await player_service.update(async_session, player_model)
+    await FastAPICache.clear()
 
 # DELETE -----------------------------------------------------------------------
 
@@ -199,25 +173,22 @@ def put(
     summary="Deletes an existing Player",
     tags=["Players"]
 )
-def delete(
+async def delete(
     player_id: int = Path(..., title="The ID of the Player"),
-    orm_session: Session = Depends(get_orm_session)
+    async_session: AsyncSession = Depends(generate_async_session)
 ):
     """
     Endpoint to delete an existing Player.
 
     Args:
         player_id (int): The ID of the Player to delete.
-        orm_session (Session): The SQLAlchemy ORM session.
+        async_session (AsyncSession): The async version of a SQLAlchemy ORM session.
 
     Raises:
         HTTPException: HTTP 404 Not Found error if the Player with the specified ID does not exist.
     """
-    player = player_service.retrieve_by_id(orm_session, player_id)
-
+    player = await player_service.retrieve_by_id(async_session, player_id)
     if not player:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-
-    player_service.delete(orm_session, player_id)
-
-    FastAPICache.clear()
+    await player_service.delete(async_session, player_id)
+    await FastAPICache.clear()