rate limit and tier models, schemas, routes; create_first_tier script and docker-compose; cache fix to work with paginated

Author: igorbenav

docker-compose.yml

@@ -46,17 +46,18 @@ services:
       - redis-data:/data
 
   # #-------- uncomment to create first superuser --------
-  # create_superuser:
-  #   build: 
-  #     context: .
-  #     dockerfile: Dockerfile
-  #   env_file:
-  #     - ./src/.env
-  #   depends_on:
-  #     - db
-  #   command: python -m src.scripts.create_first_superuser
-  #   volumes:
-  #     - ./src:/code/src
+  create_superuser:
+    build: 
+      context: .
+      dockerfile: Dockerfile
+    env_file:
+      - ./src/.env
+    depends_on:
+      - db
+      - web
+    command: python -m src.scripts.create_first_superuser
+    volumes:
+      - ./src:/code/src
 
   # #-------- uncomment to run tests --------
   # pytest:
@@ -73,6 +74,21 @@ services:
   #   volumes:
   #     - ./src:/code/src
 
+# #-------- uncomment to create first tier --------
+  create_tier:
+    build: 
+      context: .
+      dockerfile: Dockerfile
+    env_file:
+      - ./src/.env
+    depends_on:
+      - db
+      - web
+    command: python -m src.scripts.create_first_tier
+    volumes:
+      - ./src:/code/src
+
 volumes:
   postgres-data:
   redis-data:
+ 

src/app/api/dependencies.py

@@ -8,15 +8,17 @@
 from fastapi import (
     Depends, 
     HTTPException, 
-    Request, 
+    Request,
     status
 )
 
 from app.core.database import async_get_db
 from app.core.models import TokenData
+# from app.core.rate_limit import is_rate_limited
 from app.models.user import User
-from app.crud.crud_users import crud_users
 from app.api.exceptions import credentials_exception, privileges_exception
+from app.crud.crud_users import crud_users
+from app.crud.crud_tier import crud_tiers
 
 async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)], db: Annotated[AsyncSession, Depends(async_get_db)]) -> User:
     try:

src/app/api/v1/__init__.py

@@ -4,9 +4,13 @@
 from app.api.v1.users import router as users_router
 from app.api.v1.posts import router as posts_router
 from app.api.v1.tasks import router as tasks_router
+from app.api.v1.tiers import router as tiers_router
+from app.api.v1.rate_limits import router as rate_limits_router
 
 router = APIRouter(prefix="/v1")
 router.include_router(login_router)
 router.include_router(users_router)
 router.include_router(posts_router)
 router.include_router(tasks_router)
+router.include_router(tiers_router)
+router.include_router(rate_limits_router)

src/app/api/v1/posts.py

@@ -39,7 +39,11 @@ async def write_post(
 
 
 @router.get("/{username}/posts", response_model=PaginatedListResponse[PostRead])
-@cache(key_prefix="{username}_posts", resource_id_name="username")
+@cache(
+    key_prefix="{username}_posts:page_{page}:items_per_page:{items_per_page}", 
+    resource_id_name="username",
+    expiration=60
+)
 async def read_posts(
     request: Request,
     username: str,
@@ -164,5 +168,5 @@ async def erase_db_post(
     if db_post is None:
         raise HTTPException(status_code=404, detail="Post not found")
 
-    await crud_posts.db_delete(db=db, db_object=db_post, id=id)
+    await crud_posts.db_delete(db=db, id=id)
     return {"message": "Post deleted from the database"}

src/app/api/v1/rate_limits.py

@@ -0,0 +1,124 @@
+from typing import Annotated
+
+from fastapi import Request, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+import fastapi
+
+from app.schemas.rate_limit import (
+    RateLimitRead,
+    RateLimitCreate,
+    RateLimitCreateInternal,
+    RateLimitUpdate
+)
+from app.api.dependencies import get_current_superuser
+from app.core.database import async_get_db
+from app.crud.crud_rate_limit import crud_rate_limits
+from app.crud.crud_tier import crud_tiers
+from app.api.paginated import PaginatedListResponse, paginated_response, compute_offset
+
+router = fastapi.APIRouter(tags=["rate_limits"])
+
+@router.post("/tier/{tier_id}/rate_limit", dependencies=[Depends(get_current_superuser)], status_code=201)
+async def write_rate_limit(
+    request: Request, 
+    tier_id: int,
+    rate_limit: RateLimitCreate, 
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.exists(db=db, id=tier_id)
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Tier not found")
+
+    rate_limit_internal_dict = rate_limit.model_dump()
+    rate_limit_internal_dict["tier_id"] = tier_id
+
+    db_rate_limit = await crud_rate_limits.exists(db=db, name=rate_limit_internal_dict["name"])
+    if db_rate_limit:
+        raise HTTPException(status_code=400, detail="Rate Limit Name not available")
+    
+    rate_limit_internal = RateLimitCreateInternal(**rate_limit_internal_dict)
+    return await crud_rate_limits.create(db=db, object=rate_limit_internal)
+
+
+@router.get("/tier/{tier_id}/rate_limits", response_model=PaginatedListResponse[RateLimitRead])
+async def read_rate_limits(
+    request: Request,
+    tier_id: int,
+    db: Annotated[AsyncSession, Depends(async_get_db)],
+    page: int = 1,
+    items_per_page: int = 10
+):
+    db_tier = await crud_tiers.exists(db=db, id=tier_id)
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Tier not found")
+
+    rate_limits_data = await crud_rate_limits.get_multi(
+        db=db,
+        offset=compute_offset(page, items_per_page),
+        limit=items_per_page,
+        schema_to_select=RateLimitRead,
+        tier_id=tier_id
+    )
+
+    return paginated_response(
+        crud_data=rate_limits_data, 
+        page=page, 
+        items_per_page=items_per_page
+    )
+
+
+@router.get("/tier/{tier_id}/rate_limit/{id}", response_model=RateLimitRead)
+async def read_rate_limit(
+    request: Request,
+    tier_id: int,
+    id: int, 
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.exists(db=db, id=tier_id)
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Tier not found")
+    
+    db_rate_limit = await crud_rate_limits.get(db=db, schema_to_select=RateLimitRead, id=id)
+    if db_rate_limit is None:
+        raise HTTPException(status_code=404, detail="Rate Limit not found")
+
+    return db_rate_limit
+
+
+@router.patch("/tier/{tier_id}/rate_limit/{id}", dependencies=[Depends(get_current_superuser)])
+async def patch_rate_limit(
+    request: Request,
+    tier_id: int,
+    id: int,
+    values: RateLimitUpdate,
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.exists(db=db, id=tier_id)
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Tier not found")
+    
+    db_rate_limit = await crud_rate_limits.get(db=db, schema_to_select=RateLimitRead, id=id)
+    if db_rate_limit is None:
+        raise HTTPException(status_code=404, detail="Rate Limit not found")
+    
+    await crud_rate_limits.update(db=db, object=values, id=id)
+    return {"message": "Rate Limit updated"}
+
+
+@router.delete("/tier/{tier_id}/rate_limit/{id}", dependencies=[Depends(get_current_superuser)])
+async def erase_rate_limit(
+    request: Request,
+    tier_id: int,
+    id: int, 
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.exists(db=db, id=tier_id)
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Tier not found")
+    
+    db_rate_limit = await crud_rate_limits.get(db=db, schema_to_select=RateLimitRead, id=id)
+    if db_rate_limit is None:
+        raise HTTPException(status_code=404, detail="Rate Limit not found")
+    
+    await crud_rate_limits.delete(db=db, db_row=db_rate_limit, id=id)
+    return {"message": "Rate Limit deleted"}

src/app/api/v1/tasks.py

@@ -4,8 +4,7 @@
 from app.core import queue
 from app.schemas.job import Job
 
-router = APIRouter(prefix="/tasks", tags=["Tasks"])
-
+router = APIRouter(prefix="/tasks", tags=["tasks"])
 
 @router.post("/task", response_model=Job, status_code=201)
 async def create_task(message: str):

src/app/api/v1/tiers.py

@@ -0,0 +1,95 @@
+from typing import List, Annotated
+
+from fastapi import Request, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+import fastapi
+
+from app.schemas.tier import (
+    TierRead,
+    TierCreate,
+    TierCreateInternal,
+    TierUpdate
+)
+from app.api.dependencies import get_current_superuser
+from app.core.database import async_get_db
+from app.crud.crud_tier import crud_tiers
+from app.api.paginated import PaginatedListResponse, paginated_response, compute_offset
+
+router = fastapi.APIRouter(tags=["tiers"])
+
+@router.post("/tier", dependencies=[Depends(get_current_superuser)], status_code=201)
+async def write_tier(
+    request: Request, 
+    tier: TierCreate, 
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):  
+    tier_internal_dict = tier.model_dump()
+    db_tier = await crud_tiers.exists(db=db, name=tier_internal_dict["name"])
+    if db_tier:
+        raise HTTPException(status_code=400, detail="Tier Name not available")
+    
+    tier_internal = TierCreateInternal(**tier_internal_dict)
+    return await crud_tiers.create(db=db, object=tier_internal)
+
+
+@router.get("/tiers", response_model=PaginatedListResponse[TierRead])
+async def read_tiers(
+    request: Request,
+    db: Annotated[AsyncSession, Depends(async_get_db)],
+    page: int = 1,
+    items_per_page: int = 10
+):
+    tiers_data = await crud_tiers.get_multi(
+        db=db,
+        offset=compute_offset(page, items_per_page),
+        limit=items_per_page,
+        schema_to_select=TierRead
+    )
+
+    return paginated_response(
+        crud_data=tiers_data, 
+        page=page, 
+        items_per_page=items_per_page
+    )
+
+
+@router.get("/tier/{id}", response_model=TierRead)
+async def read_tier(
+    request: Request,
+    id: int, 
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.get(db=db, schema_to_select=TierRead, id=id)
+    if db_tier is None:
+        raise HTTPException(status_code=404, detail="Tier not found")
+
+    return db_tier
+
+
+@router.patch("/tier/{id}", dependencies=[Depends(get_current_superuser)])
+async def patch_tier(
+    request: Request, 
+    values: TierUpdate,
+    id: int,
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.get(db=db, schema_to_select=TierRead, id=id)
+    if db_tier is None:
+        raise HTTPException(status_code=404, detail="Tier not found")
+    
+    await crud_tiers.update(db=db, object=values, id=id)
+    return {"message": "Tier updated"}
+
+
+@router.delete("/tier/{id}", dependencies=[Depends(get_current_superuser)])
+async def erase_tier(
+    request: Request,
+    id: int, 
+    db: Annotated[AsyncSession, Depends(async_get_db)]
+):
+    db_tier = await crud_tiers.get(db=db, schema_to_select=TierRead, id=id)
+    if db_tier is None:
+        raise HTTPException(status_code=404, detail="Tier not found")
+    
+    await crud_tiers.delete(db=db, db_row=db_tier, id=id)
+    return {"message": "Tier deleted"}

src/app/core/cache.py

@@ -220,7 +220,6 @@ async def inner(request: Request, *args, **kwargs) -> Response:
 
                 cached_data = await client.get(cache_key)
                 if cached_data:
-                    print("cache hit")
                     return json.loads(cached_data.decode())
 
             result = await func(request, *args, **kwargs)

src/app/core/config.py

@@ -1,6 +1,5 @@
 from enum import Enum
 
-#from decouple import config
 from starlette.config import Config
 from pydantic_settings import BaseSettings
 

src/app/core/rate_limit.py

@@ -8,6 +8,8 @@
 from app.core.logger import logging
 from app.schemas.user import UserRead
 from app.schemas.tier import TierRead
+from app.crud.crud_users import crud_users
+
 
 logger = logging.getLogger(__name__)