Custom Error Handling

• A robust error handling mechanism is in place, providing meaningful error messages and status codes for various application-specific exceptions. This includes:
  • User-related errors (e.g., user already exists, user not found).
  • Token-related errors (e.g., invalid or revoked tokens).
  • Permission-related errors (e.g., insufficient permissions).
  • Resource-related errors (e.g., book or tag not found).

Background Processing with Celery

Overview

Celery is integrated into the Readify-Backend to handle asynchronous tasks and background processing. This allows the API to offload time-consuming operations, improving response times and overall user experience.

Features

• Asynchronous Task Queue: Celery enables the execution of tasks in the background, freeing up the main thread to handle incoming requests.
• Task Scheduling: You can schedule tasks to run at specific intervals or times, making it ideal for repetitive jobs.
• Redis as Broker: Redis is used as the message broker, facilitating communication between the FastAPI app and Celery workers.

Installation

To set up Celery, ensure you have Redis running and then install the necessary dependencies:

pip install celery

Unit and Mock Testing

Overview

Unit testing and mocking are essential for ensuring the reliability and correctness of your application. This project uses Pytest for testing.

Setting Up Testing

1. Install Dependencies: Make sure you have the necessary testing libraries installed:

   pip install pytest pytest-mock
   

Code Formatting with Black

To ensure consistent code formatting, this project uses Black. Install Black using pip:

pip install black

Database Connection Pooling

This project uses SQLAlchemy with connection pooling to manage database connections efficiently. The connection pooling parameters are configured in src/db/main.py.

Configuration

• pool_size: Number of connections to keep open inside the connection pool (default: 20).
• max_overflow: Number of connections to allow in overflow (default: 10).
• pool_timeout: Maximum number of seconds to wait for a connection to become available (default: 30).
• pool_recycle: Number of seconds after which a connection is automatically recycled (default: 1800).

These parameters can be adjusted based on application's requirements and the database server's capacity.

In-Memory Caching

This project uses aiocache for in-memory caching. To install aiocache, run:

pip install aiocache

Avoiding N+1 Query Problem

To avoid the N+1 query problem, this project uses eager loading with SQLAlchemy. Eager loading can be achieved using selectinload or joinedload options in your queries.

Example

In src/books/routes.py, the get_all_books endpoint uses selectinload to eagerly load the related Author objects:

from sqlalchemy.future import select
from sqlalchemy.orm import selectinload

Directory

Dockerfile

The Dockerfile sets up the environment for the Readify-Backend application. It utilizes a lightweight Python image and includes all necessary dependencies.

Build the Docker Image:

docker build -t fastapi-app .

Run the Docker Container:

docker run -p 8000:8000 fastapi-app

Mastering Django through Projects is a repo of Django and Django REST framework projects to help developers improve their skills in full-stack and backend web development with Python.