chore: Add API service files

.env.original

@@ -0,0 +1,6 @@
+# Test variables
+POSTGRES_DB=sp3
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=adlibitum
+DATABASE_HOST=db
+SECRET_KEY=S09WWWHXBAJDIUEREHCN3752346572452VGGGVWWW526194

api/.env.original

@@ -0,0 +1,4 @@
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=adlibitum
+DATABASE_HOST=db
+POSTGRES_DB=sp3

api/Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.8.13 AS base
+
+ENV PYTHONPATH=$PYTHONPATH:/src/
+
+COPY ./requirements.txt /src/requirements.txt
+
+WORKDIR /src
+
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY ./ /src/ 
+
+FROM base AS test
+RUN ["python", "-m", "pytest", "-v", "/src/tests"]
+
+FROM base AS build
+
+CMD gunicorn -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:5000 main:app

api/Dockerfile.populate

@@ -0,0 +1,16 @@
+FROM python:3.8.13
+
+# 1. Copy the requirements.txt file to the image
+ENV PYTHONPATH=$PYTHONPATH:/src/
+COPY ./requirements.txt /src/requirements.txt
+
+WORKDIR /src
+
+# 2. Install the dependencies
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# 3. Copy the content of the current directory to the image
+COPY ./ /src/
+
+# 4. Run the populate_db.py script
+CMD ["python", "populate_db.py"]

api/app/auth/jwt.py

@@ -0,0 +1,90 @@
+from datetime import datetime, timedelta
+
+from app.settings import SECRET_KEY
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+
+from . import schema
+
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+
+def create_access_token(data: dict) -> str:
+    """
+    Generates a JWT access token with an expiration time.
+
+    This function creates a JWT (JSON Web Token) that includes the provided
+    data and an expiration time. The token is signed using a secret key and
+    a specified algorithm.
+
+    Args:
+        data (dict): A dictionary containing the data to be included in the token.
+
+    Returns:
+        str: The encoded JWT token as a string.
+    """
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+def verify_token(token: str, credentials_exception):
+    """
+    Verifies the provided JWT token and extracts the user information.
+
+    This function decodes the given JWT token using the secret key and specified
+    algorithm. It checks for the presence of the user's email in the token's payload.
+    If the email is not found or the token is invalid, an exception is raised.
+
+    Args:
+        token (str): The JWT token to be verified.
+        credentials_exception: The exception to raise if the token is invalid or the email is not found.
+
+    Returns:
+        TokenData: An object containing the user's email extracted from the token.
+
+    Raises:
+        credentials_exception: If the token is invalid or does not contain an email.
+    """
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        email: str = payload.get("sub")
+        if email is None:
+            raise credentials_exception
+        token_data = schema.TokenData(email=email)
+    except JWTError:
+        raise credentials_exception
+    return token_data
+
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+
+
+def get_current_user(token: str = Depends(oauth2_scheme)):
+    """
+    Retrieves the current authenticated user based on the provided JWT token.
+
+    This function extracts the JWT token from the request, verifies it, and returns
+    the user data associated with the token. If the token is invalid or cannot be
+    verified, an HTTP 401 Unauthorized exception is raised.
+
+    Args:
+        token (str, optional): The JWT token extracted from the request using the OAuth2
+                               password flow. Defaults to being fetched via `Depends(oauth2_scheme)`.
+
+    Returns:
+        TokenData: An object containing the user's information extracted from the token.
+
+    Raises:
+        HTTPException: If the token is invalid or the credentials cannot be validated.
+    """
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    return verify_token(token, credentials_exception)

api/app/auth/router.py

@@ -0,0 +1,29 @@
+from app import db
+from app.user import hashing
+from app.user.models import User
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+
+from .jwt import create_access_token
+
+router = APIRouter(tags=["auth"])
+
+
+@router.post("/login")
+def login(
+    request: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(db.get_db)
+):
+    user = db.query(User).filter(User.email == request.username).first()
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Invalid credentials"
+        )
+    if not hashing.verify_password(request.password, user.password):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Incorrect password"
+        )
+
+    access_token = create_access_token(data={"sub": user.email})
+    return {"access_token": access_token, "token_type": "bearer"}

api/app/auth/schema.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class Login(BaseModel):
+    username: str
+    password: str
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    email: Optional[str] = None

api/app/db.py

@@ -0,0 +1,38 @@
+from app import settings as config
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+DATABASE_USERNAME = config.DATABASE_USERNAME
+DATABASE_PASSWORD = config.DATABASE_PASSWORD
+DATABASE_HOST = config.DATABASE_HOST
+DATABASE_NAME = config.DATABASE_NAME
+
+SQLALCHEMY_DATABASE_URL = f"postgresql://{DATABASE_USERNAME}:{DATABASE_PASSWORD}@{DATABASE_HOST}/{DATABASE_NAME}"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    """
+    Provides a database session for dependency injection.
+
+    This function is used to obtain a new database session instance from the
+    `SessionLocal` factory. It is intended to be used with dependency injection
+    in FastAPI to manage database sessions.
+
+    Yields:
+        Session: A SQLAlchemy database session.
+
+    Notes:
+        The session is automatically closed after use to ensure proper resource management.
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

api/app/feedback/models.py

@@ -0,0 +1,24 @@
+from app.db import Base
+from sqlalchemy import Column, Float, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+
+
+class Feedback(Base):
+    __tablename__ = "feedbacks"
+
+    id = Column(Integer, primary_key=True, index=True)
+    score = Column(Float)
+    predicted_class = Column(String(50))
+    feedback = Column(String(255))
+    user_id = Column(Integer, ForeignKey("users.id"))
+    image_file_name = Column(String(255))
+    user = relationship("User", back_populates="feedbacks")
+
+    def __init__(
+        self, score, predicted_class, feedback, image_file_name, user, *args, **kwargs
+    ):
+        self.predicted_class = predicted_class
+        self.feedback = feedback
+        self.score = score
+        self.image_file_name = image_file_name
+        self.user = user

api/app/feedback/router.py

@@ -0,0 +1,28 @@
+from typing import List
+
+from app import db
+from app.auth.jwt import get_current_user
+from app.user.schema import User
+from fastapi import APIRouter, Depends, status
+from sqlalchemy.orm import Session
+
+from . import schema, services
+
+router = APIRouter(tags=["Feedback"], prefix="/feedback")
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_feedback(
+    request: schema.Feedback,
+    database: Session = Depends(db.get_db),
+    current_user: User = Depends(get_current_user),
+):
+    return await services.new_feedback(request, current_user, database)
+
+
+@router.get("/", response_model=List[schema.DisplayFeedback])
+async def get_all_feedback(
+    database: Session = Depends(db.get_db),
+    current_user: User = Depends(get_current_user),
+):
+    return await services.all_feedback(database, current_user)

api/app/feedback/schema.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+
+
+class Feedback(BaseModel):
+    score: float
+    predicted_class: str
+    image_file_name: str
+    feedback: str
+
+
+class DisplayFeedback(BaseModel):
+    id: int
+    score: float
+    predicted_class: str
+    image_file_name: str
+    feedback: str
+
+    class Config:
+        orm_mode = True

api/app/feedback/services.py

@@ -0,0 +1,66 @@
+from app.auth.schema import TokenData
+from app.user.models import User
+from sqlalchemy.orm import Session
+
+from . import models, schema
+
+
+async def new_feedback(
+    request: schema.Feedback, current_user: TokenData, database: Session
+) -> models.Feedback:
+    """
+    Adds new feedback to the database associated with the current user.
+
+    This asynchronous function creates a new feedback entry in the database using
+    the provided feedback data and associates it with the current user. It first
+    retrieves the user from the database based on the email in the `current_user` object,
+    then creates and stores the new feedback entry.
+
+    Args:
+        request (schema.Feedback): An object containing the feedback details such as score,
+                                   image file name, predicted class, and feedback text.
+        current_user (TokenData): An object containing the email of the currently authenticated user.
+        database (Session): The database session used for querying and committing changes to the database.
+
+    Returns:
+        models.Feedback: The newly created feedback entry stored in the database.
+
+    Raises:
+        Exception: If there is an issue with adding or committing the feedback to the database.
+    """
+    user = database.query(User).filter(User.email == current_user.email).first()
+    new_feedback = models.Feedback(
+        score=request.score,
+        image_file_name=request.image_file_name,
+        predicted_class=request.predicted_class,
+        user=user,
+        feedback=request.feedback,
+    )
+    database.add(new_feedback)
+    database.commit()
+    database.refresh(new_feedback)
+    return new_feedback
+
+
+async def all_feedback(database: Session, current_user: TokenData) -> models.Feedback:
+    """
+    Retrieves all feedback entries associated with the current user from the database.
+
+    This asynchronous function queries the database for all feedback entries linked to
+    the user identified by the `current_user` object. It returns a list of feedback entries
+    associated with the user's ID.
+
+    Args:
+        database (Session): The database session used for querying the database.
+        current_user (TokenData): An object containing the email of the currently authenticated user.
+
+    Returns:
+        list[models.Feedback]: A list of feedback entries associated with the current user.
+
+    Raises:
+        Exception: If there is an issue with querying the feedback entries from the database.
+    """
+    user = database.query(User).filter(User.email == current_user.email).first()
+    return (
+        database.query(models.Feedback).filter(models.Feedback.user_id == user.id).all()
+    )

api/app/model/router.py

@@ -0,0 +1,45 @@
+import os
+
+from app import settings as config
+from app import utils
+from app.auth.jwt import get_current_user
+from app.model.schema import PredictResponse
+from app.model.services import model_predict
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, status  # File
+
+router = APIRouter(tags=["Model"], prefix="/model")
+
+
+@router.post("/predict")
+async def predict(file: UploadFile, current_user=Depends(get_current_user)):
+    rpse = {"success": False, "prediction": None, "score": None}
+
+    # Check a file was sent and that file is an image
+    if not file or not utils.allowed_file(file.filename):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="File type is not supported.",
+        )
+
+    # Store the image to disk, calculate hash before to avoid re-writing an image already uploaded.
+    new_filename = await utils.get_file_hash(file)
+    file_path = os.path.join(config.UPLOAD_FOLDER, new_filename)
+
+    if not os.path.exists(file_path):
+        with open(file_path, "wb") as out_file:
+            content = await file.read()
+            out_file.write(content)
+
+        # Reset file pointer to the beginning
+        await file.seek(0)
+
+    # Send the file to be processed by the model service
+    prediction, score = await model_predict(file_path)
+
+    # Update and return rpse dict with the corresponding values
+    rpse["success"] = True
+    rpse["prediction"] = prediction
+    rpse["score"] = score
+    rpse["image_file_name"] = new_filename
+
+    return PredictResponse(**rpse)

api/app/model/schema.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class PredictRequest(BaseModel):
+    file: str
+
+
+class PredictResponse(BaseModel):
+    success: bool
+    prediction: str
+    score: float
+    image_file_name: str

api/app/model/services.py

@@ -0,0 +1,61 @@
+import json
+import time
+from uuid import uuid4
+
+import redis
+
+from .. import settings
+
+# Connect to Redis
+db = redis.Redis(
+    host=settings.REDIS_IP, port=settings.REDIS_PORT, db=settings.REDIS_DB_ID
+)
+
+
+async def model_predict(image_name):
+    print(f"Processing image {image_name}...")
+    """
+    Receives an image name and queues the job into Redis.
+    Will loop until getting the answer from our ML service.
+
+    Parameters
+    ----------
+    image_name : str
+        Name for the image uploaded by the user.
+
+    Returns
+    -------
+    prediction, score : tuple(str, float)
+        Model predicted class as a string and the corresponding confidence
+        score as a number.
+    """
+    prediction = None
+    score = None
+
+    # Assign an unique ID for this job and add it to the queue.
+    job_id = str(uuid4())
+
+    # Create a dict with the job data we will send through Redis
+    job_data = {"id": job_id, "image_name": image_name}
+
+    # Send the job to the model service using Redis
+    db.lpush(settings.REDIS_QUEUE, json.dumps(job_data))
+
+    # Loop until we received the response from our ML model
+    while True:
+        # Attempt to get model predictions using job_id
+        output = db.get(job_id)
+
+        # Check if the text was correctly processed by the ML model
+        if output is not None:
+            output = json.loads(output.decode("utf-8"))
+            prediction = output["prediction"]
+            score = output["score"]
+
+            db.delete(job_id)
+            break
+
+        # Sleep some time waiting for model results
+        time.sleep(settings.API_SLEEP)
+
+    return prediction, score

api/app/settings.py

@@ -0,0 +1,34 @@
+import os
+
+import dotenv
+
+# Load environment variables from .env file
+dotenv.load_dotenv()
+
+# Run API in Debug mode
+API_DEBUG = True
+
+# We will store images uploaded by the user on this folder
+UPLOAD_FOLDER = "uploads/"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# REDIS settings
+
+# Queue name
+REDIS_QUEUE = "service_queue"
+# Port
+REDIS_PORT = 6379
+# DB Id
+REDIS_DB_ID = 0
+# Host IP
+REDIS_IP = os.getenv("REDIS_IP", "redis")
+# Sleep parameters which manages the
+# interval between requests to our redis queue
+API_SLEEP = 0.05
+
+# Database settings
+DATABASE_USERNAME = os.getenv("POSTGRES_USER")
+DATABASE_PASSWORD = os.getenv("POSTGRES_PASSWORD")
+DATABASE_HOST = os.getenv("DATABASE_HOST")
+DATABASE_NAME = os.getenv("POSTGRES_DB")
+SECRET_KEY = os.getenv("SECRET_KEY", "S09WWWHXBAJDIUEREHCN3752346572452VGGGVWWW526194")

api/app/user/hashing.py

@@ -0,0 +1,37 @@
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+
+
+def verify_password(plain_password, hashed_password):
+    """
+    Verifies if the provided plain password matches the hashed password.
+
+    This function compares a plain password with a hashed password to check if they
+    match using the Argon2 hashing algorithm. It returns `True` if the passwords match,
+    otherwise returns `False`.
+
+    Args:
+        plain_password (str): The plain text password to be verified.
+        hashed_password (str): The hashed password to compare against.
+
+    Returns:
+        bool: `True` if the plain password matches the hashed password, otherwise `False`.
+    """
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password):
+    """
+    Hashes the provided password using the Argon2 algorithm.
+
+    This function generates a hashed version of the given plain text password using
+    the Argon2 hashing algorithm. The resulting hash can be used for secure password storage.
+
+    Args:
+        password (str): The plain text password to be hashed.
+
+    Returns:
+        str: The hashed password.
+    """
+    return pwd_context.hash(password)

api/app/user/models.py

@@ -0,0 +1,23 @@
+from app.db import Base
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.orm import relationship
+
+from . import hashing
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(50))
+    email = Column(String(255), unique=True)
+    password = Column(String(255))
+    feedbacks = relationship("Feedback", back_populates="user")
+
+    def __init__(self, name, email, password, *args, **kwargs):
+        self.name = name
+        self.email = email
+        self.password = hashing.get_password_hash(password)
+
+    def check_password(self, password):
+        return hashing.verify_password(self.password, password)

api/app/user/router.py

@@ -0,0 +1,51 @@
+# from typing import List
+from app import db
+from app.auth.jwt import get_current_user
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from . import schema, services, validator
+
+router = APIRouter(tags=["Users"], prefix="/user")
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_user_registration(
+    request: schema.User, database: Session = Depends(db.get_db)
+):
+    # Verify the user email doesn't already exist
+    if await validator.verify_email_exist(email=request.email, database=database):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Email already registered"
+        )
+
+    #  If the email doesn't exist, create a new user
+    new_user = await services.new_user_register(request=request, database=database)
+
+    return new_user
+
+
+@router.get("/")
+async def get_all_users(
+    database: Session = Depends(db.get_db),
+    current_user: schema.User = Depends(get_current_user),
+):
+    return await services.all_users(database)
+
+
+@router.get("/{id}", response_model=schema.DisplayUser)
+async def get_user_by_id(
+    id: int,
+    database: Session = Depends(db.get_db),
+    current_user: schema.User = Depends(get_current_user),
+):
+    return await services.get_user_by_id(id, database)
+
+
+@router.delete("/{id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_user_by_id(
+    id: int,
+    database: Session = Depends(db.get_db),
+    current_user: schema.User = Depends(get_current_user),
+):
+    return await services.delete_user_by_id(id, database)

api/app/user/schema.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, EmailStr, constr
+
+
+class User(BaseModel):
+    name: constr(min_length=2, max_length=50)
+    email: EmailStr
+    password: str
+
+
+class DisplayUser(BaseModel):
+    id: int
+    name: str
+    email: str
+
+    class Config:
+        orm_mode = True

api/app/user/services.py

@@ -0,0 +1,84 @@
+from fastapi import HTTPException, status
+from sqlalchemy.orm import Session
+
+from . import models, schema
+
+
+async def new_user_register(request: schema.User, database: Session) -> models.User:
+    """
+    Registers a new user in the database.
+
+    This asynchronous function creates a new user entry in the database using the provided
+    user details from the request. It adds the user to the database, commits the changes,
+    and returns the newly created user.
+
+    Args:
+        request (schema.User): An object containing user details such as name, email, and password.
+        database (Session): The database session used for adding and committing the user to the database.
+
+    Returns:
+        models.User: The newly created user entry stored in the database.
+    """
+    new_user = models.User(
+        name=request.name, email=request.email, password=request.password
+    )
+    database.add(new_user)
+    database.commit()
+    database.refresh(new_user)
+    return new_user
+
+
+async def all_users(database: Session) -> models.User:
+    """
+    Retrieves all users from the database.
+
+    This asynchronous function queries the database to retrieve a list of all users.
+
+    Args:
+        database (Session): The database session used for querying the database.
+
+    Returns:
+        list[models.User]: A list of all user entries in the database.
+    """
+    return database.query(models.User).all()
+
+
+async def get_user_by_id(id: int, database: Session) -> models.User:
+    """
+    Retrieves a user from the database by their ID.
+
+    This asynchronous function queries the database for a user with the specified ID.
+    If the user is not found, an HTTP 404 Not Found exception is raised.
+
+    Args:
+        id (int): The ID of the user to retrieve.
+        database (Session): The database session used for querying the database.
+
+    Returns:
+        models.User: The user entry with the specified ID.
+
+    Raises:
+        HTTPException: If the user with the specified ID is not found.
+    """
+    user = database.query(models.User).filter(models.User.id == id).first()
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"User with the id {id} is not available",
+        )
+    return user
+
+
+async def delete_user_by_id(id: int, database: Session):
+    """
+    Deletes a user from the database by their ID.
+
+    This asynchronous function removes the user with the specified ID from the database
+    and commits the changes.
+
+    Args:
+        id (int): The ID of the user to delete.
+        database (Session): The database session used for querying and committing changes to the database.
+    """
+    database.query(models.User).filter(models.User.id == id).delete()
+    database.commit()

api/app/user/validator.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from sqlalchemy.orm import Session
+
+from .models import User
+
+
+async def verify_email_exist(email: str, database: Session) -> Optional[User]:
+    """
+    Checks if a user with the specified email exists in the database.
+
+    This asynchronous function queries the database to find a user with the given email.
+    It returns the user object if found, or `None` if no user with that email exists.
+
+    Args:
+        email (str): The email address to check for existence.
+        database (Session): The database session used for querying the database.
+
+    Returns:
+        Optional[User]: The user object if a user with the specified email exists, otherwise `None`.
+    """
+    return database.query(User).filter(User.email == email).first()

api/app/utils.py

@@ -0,0 +1,59 @@
+import hashlib
+import os
+
+
+def allowed_file(filename):
+    """
+    Checks if the format for the file received is acceptable. For this
+    particular case, we must accept only image files. This is, files with
+    extension ".png", ".jpg", ".jpeg" or ".gif".
+
+    Parameters
+    ----------
+    filename : str
+        Filename from werkzeug.datastructures.FileStorage file.
+
+    Returns
+    -------
+    bool
+        True if the file is an image, False otherwise.
+    """
+    # Check if the file extension of the filename received is in the set of allowed extensions (".png", ".jpg", ".jpeg", ".gif")
+    allowed_extensions = [".png", ".jpg", ".jpeg", ".gif"]
+
+    return (
+        os.path.splitext(filename)[1].lower() in allowed_extensions
+    )  # Alternatively use Path.suffix
+
+
+async def get_file_hash(file):
+    """
+    Returns a new filename based on the file content using MD5 hashing.
+    It uses hashlib.md5() function from Python standard library to get
+    the hash.
+
+    Parameters
+    ----------
+    file : werkzeug.datastructures.FileStorage
+        File sent by user.
+
+    Returns
+    -------
+    str
+        New filename based in md5 file hash.
+    """
+    # Read file content (byte string)
+    content = await file.read()
+
+    # Generate MD5 hash from content
+    file_hash = hashlib.md5(  # Apply MD5 hash
+        content
+    ).hexdigest()  # hexdigest converts the result into a readable hex string
+
+    # Get the file extension
+    _, ext = os.path.splitext(file.filename)
+
+    # Reset file pointer to the beginning
+    await file.seek(0)
+
+    return f"{file_hash}{ext}"

api/compose.yml

@@ -0,0 +1,16 @@
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile.populate
+    environment:
+      POSTGRES_DB: $POSTGRES_DB
+      POSTGRES_USER: $POSTGRES_USER
+      POSTGRES_PASSWORD: $POSTGRES_PASSWORD
+      DATABASE_HOST: $DATABASE_HOST
+    networks:
+      - shared_network
+
+networks:
+  shared_network:
+    external: true

api/main.py

@@ -0,0 +1,12 @@
+from app.auth import router as auth_router
+from app.feedback import router as feedback_router
+from app.model import router as model_router
+from app.user import router as user_router
+from fastapi import FastAPI
+
+app = FastAPI(title="Image Prediction API", version="0.0.1")
+
+app.include_router(auth_router.router)
+app.include_router(model_router.router)
+app.include_router(user_router.router)
+app.include_router(feedback_router.router)

api/populate_db.py

@@ -0,0 +1,72 @@
+import psycopg2
+from app import settings as config
+from app.db import Base
+from app.user.models import User
+from psycopg2.errors import DuplicateDatabase
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+# Database configuration
+DATABASE_USERNAME = config.DATABASE_USERNAME
+DATABASE_PASSWORD = config.DATABASE_PASSWORD
+DATABASE_HOST = config.DATABASE_HOST
+DATABASE_NAME = config.DATABASE_NAME
+
+# Create the initial connection URL to PostgreSQL (without specifying the database)
+initial_connection_url = (
+    f"postgresql://{DATABASE_USERNAME}:{DATABASE_PASSWORD}@{DATABASE_HOST}/postgres"
+)
+
+print(initial_connection_url)
+
+conn = None
+
+# Connect to PostgreSQL to create the database if it doesn't exist
+try:
+    conn = psycopg2.connect(initial_connection_url)
+    conn.autocommit = True
+    cursor = conn.cursor()
+
+    # Create the database
+    cursor.execute(f"CREATE DATABASE {DATABASE_NAME}")
+    print(f"Database '{DATABASE_NAME}' created successfully")
+
+except DuplicateDatabase as e:
+    if "already exists" in str(e):
+        print(f"Database '{DATABASE_NAME}' already exists.")
+    else:
+        print(f"Error creating database: {e}")
+finally:
+    if conn:
+        cursor.close()
+        conn.close()
+
+# Database connection URL to the newly created database
+SQLALCHEMY_DATABASE_URL = f"postgresql://{DATABASE_USERNAME}:{DATABASE_PASSWORD}@{DATABASE_HOST}/{DATABASE_NAME}"
+print(SQLALCHEMY_DATABASE_URL)
+
+# Create engine
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+# Drop all tables if they exist
+Base.metadata.drop_all(engine)
+print("Tables dropped")
+
+# Create all tables
+Base.metadata.create_all(engine)
+print("Tables created")
+
+# Populate database with a default user
+print("Populating database with default user")
+Session = sessionmaker(bind=engine)
+session = Session()
+
+user = User(
+    name="Admin User",
+    password="admin",
+    email="admin@example.com",
+)
+
+session.add(user)
+session.commit()
+print("Default user added")

api/requirements.txt

@@ -0,0 +1,77 @@
+gunicorn==20.1.0
+redis==4.1.4
+werkzeug==2.0.3
+alembic==1.6.5
+psycopg2-binary==2.9.1
+amqp==5.1.1
+anyio==3.6.2
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+black==22.12.0
+boto3==1.21.32
+botocore==1.24.46
+certifi==2022.12.7
+cffi==1.15.1
+click==8.1.3
+click-didyoumean==0.3.0
+click-plugins==1.1.1
+click-repl==0.2.0
+cryptography==38.0.4
+Deprecated==1.2.13
+dnspython==2.2.1
+ecdsa==0.18.0
+email-validator==1.3.0
+exceptiongroup==1.1.0
+Faker==15.3.4
+fastapi==0.88.0
+h11==0.14.0
+httpcore==0.16.3
+httptools==0.5.0
+httpx==0.23.1
+idna==3.4
+iniconfig==1.1.1
+itsdangerous==2.1.2
+Jinja2==3.1.2
+jmespath==1.0.1
+kombu==5.2.4
+Mako==1.2.4
+MarkupSafe==2.1.1
+mypy-extensions==0.4.3
+orjson==3.8.3
+packaging==22.0
+passlib==1.7.4
+pathspec==0.10.3
+platformdirs==2.6.0
+pluggy==1.0.0
+prompt-toolkit==3.0.36
+pyasn1==0.4.8
+pycparser==2.21
+pydantic==1.10.2
+pytest==7.2.0
+pytest-asyncio==0.20.3
+pytest-mock==3.10.0
+python-dateutil==2.8.2
+python-dotenv==0.21.0
+python-editor==1.0.4
+python-jose==3.3.0
+python-multipart==0.0.5
+pytz==2022.7
+PyYAML==6.0
+rfc3986==1.5.0
+rsa==4.9
+s3transfer==0.5.2
+six==1.16.0
+sniffio==1.3.0
+SQLAlchemy==1.3.24
+starlette==0.22.0
+tomli==2.0.1
+typing_extensions==4.4.0
+ujson==5.6.0
+urllib3==1.26.13
+uvicorn==0.20.0
+uvloop==0.17.0
+vine==5.0.0
+watchfiles==0.18.1
+wcwidth==0.2.5
+websockets==10.4
+wrapt==1.14.1

api/tests/test_router_feedback.py

@@ -0,0 +1,84 @@
+from unittest import mock
+
+import pytest
+from app import db
+from app.auth.jwt import get_current_user
+from app.feedback.schema import DisplayFeedback, Feedback
+from app.user.schema import User
+from fastapi.testclient import TestClient
+from main import app
+from sqlalchemy.orm import Session
+
+client = TestClient(app)
+
+sample_user = User(
+    id=1,
+    username="testuser",
+    email="testuser@example.com",
+    name="Test User",
+    password="password",
+)
+sample_feedback = Feedback(
+    feedback="Great service!",
+    image_file_name="testimage.jpg",
+    predicted_class="dog",
+    score=0.95,
+)
+
+
+@pytest.fixture
+def mock_db_session():
+    return mock.create_autospec(Session, instance=True)
+
+
+@pytest.fixture
+def mock_get_current_user():
+    return sample_user
+
+
+@mock.patch("app.feedback.router.services.new_feedback")
+def test_create_feedback(mock_new_feedback, mock_db_session, mock_get_current_user):
+    mock_new_feedback.return_value = sample_feedback
+
+    payload = {
+        "feedback": "Great service!",
+        "image_file_name": "testimage.jpg",
+        "predicted_class": "dog",
+        "score": 0.95,
+    }
+
+    app.dependency_overrides[db.get_db] = lambda: mock_db_session
+    app.dependency_overrides[get_current_user] = lambda: mock_get_current_user
+
+    response = client.post(
+        "/feedback/",
+        json=payload,
+    )
+
+    assert response.status_code == 201
+
+    mock_new_feedback.assert_called_once_with(payload, sample_user, mock_db_session)
+
+
+@mock.patch("app.feedback.router.services.all_feedback")
+def test_get_all_feedback(mock_all_feedback, mock_db_session, mock_get_current_user):
+    # Setup the mock service to return a list of feedback
+    mock_all_feedback.return_value = [
+        DisplayFeedback(
+            id=1,
+            feedback="Great service!",
+            score=0.95,
+            predicted_class="dog",
+            image_file_name="testimage.jpg",
+        )
+    ]
+
+    app.dependency_overrides[db.get_db] = lambda: mock_db_session
+    app.dependency_overrides[get_current_user] = lambda: mock_get_current_user
+    response = client.get(
+        "/feedback/",
+    )
+
+    assert response.status_code == 200
+
+    mock_all_feedback.assert_called_once_with(mock_db_session, sample_user)

api/tests/test_router_model.py

@@ -0,0 +1,96 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from app.auth.jwt import get_current_user
+
+# from app.model.schema import PredictResponse
+from fastapi import UploadFile
+
+# from fastapi.testclient import TestClient
+from httpx import AsyncClient
+from main import app
+
+# 💡 NOTE Run tests with: pytest tests/test_router_model.py -v
+
+
+@pytest.mark.asyncio
+async def test_predict():
+    mock_file = AsyncMock(spec=UploadFile)
+    mock_file.filename = "test_image.png"
+    mock_file.read = AsyncMock(return_value=b"fake-image-data")
+
+    mock_user = MagicMock()
+    mock_user.id = 1
+
+    mock_current_user = MagicMock()
+    mock_current_user.return_value = "testtoken"
+
+    app.dependency_overrides[get_current_user] = lambda: mock_current_user
+
+    with patch("app.model.router.utils.get_file_hash", return_value="fakehash123"):
+        with patch(
+            "app.model.router.model_predict", new_callable=AsyncMock
+        ) as mock_model_predict:
+            with patch("app.model.router.os.path.exists", return_value=False):
+                mock_model_predict.return_value = ("cat", 0.95)
+                with patch("builtins.open", new_callable=MagicMock):
+                    async with AsyncClient(app=app, base_url="http://test") as ac:
+                        response = await ac.post(
+                            "/model/predict",
+                            files={
+                                "file": (
+                                    "test_image.png",
+                                    mock_file.read.return_value,
+                                    "image/png",
+                                )
+                            },
+                            headers={"Authorization": "Bearer testtoken"},
+                        )
+
+                        assert response.status_code == 200
+
+                        response_data = response.json()
+                        assert response_data["success"] is True
+                        assert response_data["prediction"] == "cat"
+                        assert response_data["score"] == 0.95
+                        assert response_data["image_file_name"] == "fakehash123"
+
+
+@pytest.mark.asyncio
+async def test_predict_fails_bad_extension():
+    mock_file = AsyncMock(spec=UploadFile)
+    mock_file.filename = "test_image.png"
+    mock_file.read = AsyncMock(return_value=b"fake-image-data")
+
+    mock_user = MagicMock()
+    mock_user.id = 1
+
+    mock_current_user = MagicMock()
+    mock_current_user.return_value = "testtoken"
+
+    app.dependency_overrides[get_current_user] = lambda: mock_current_user
+
+    with patch("app.model.router.utils.get_file_hash", return_value="fakehash123"):
+        with patch(
+            "app.model.router.model_predict", new_callable=AsyncMock
+        ) as mock_model_predict:
+            with patch("app.model.router.os.path.exists", return_value=False):
+                mock_model_predict.return_value = ("cat", 0.95)
+                with patch("builtins.open", new_callable=MagicMock):
+                    async with AsyncClient(app=app, base_url="http://test") as ac:
+                        response = await ac.post(
+                            "/model/predict",
+                            files={
+                                "file": (
+                                    "test_image.pdf",
+                                    mock_file.read.return_value,
+                                    "image/png",
+                                )
+                            },
+                            headers={"Authorization": "Bearer testtoken"},
+                        )
+
+                        assert response.status_code == 400
+                        assert response.json() == {
+                            "detail": "File type is not supported."
+                        }

api/tests/test_router_user.py

@@ -0,0 +1,69 @@
+from unittest.mock import MagicMock
+
+import pytest
+from app import db
+from app.auth.jwt import create_access_token
+from app.user.models import User
+from app.user.schema import User as UserSchema
+from httpx import AsyncClient
+from main import app
+from sqlalchemy.orm import Session
+
+# 💡 NOTE Run tests with: pytest ./tests/test_router_user.py -v
+
+
+@pytest.mark.asyncio
+async def test_all_users():
+    mock_session = MagicMock(spec=Session)
+    mock_user = User(
+        name="John Doe", email="john@yahoo.com", password="123456", kwargs={"id": 1}
+    )
+
+    mock_session.query(User).all.return_value = [mock_user]
+
+    app.dependency_overrides[db.get_db] = lambda: mock_session
+
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        user_access_token = create_access_token({"sub": "john@gmail.com"})
+        response = await ac.get(
+            "/user/", headers={"Authorization": f"Bearer {user_access_token}"}
+        )
+    assert response.status_code == 200
+    users = response.json()
+    assert len(users) == 1
+    assert users[0]["name"] == "John Doe"
+
+
+@pytest.mark.asyncio
+async def test_create_user_registration_success():
+    mock_session = MagicMock(spec=Session)
+    request = UserSchema(
+        id=0, name="John Doe", email="john@gmail.com", password="123456"
+    )
+
+    mock_session.query(User).filter.return_value.first.return_value = None
+
+    app.dependency_overrides[db.get_db] = lambda: mock_session
+
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        response = await ac.post("/user/", json=request.dict())
+
+    assert response.status_code == 201
+
+
+@pytest.mark.asyncio
+async def test_create_user_registration_fails():
+    mock_session = MagicMock(spec=Session)
+    mock_user = User(id=0, name="John Doe", email="john@gmail.com", password="123456")
+    request = UserSchema(
+        id=0, name="John Doe", email="john@gmail.com", password="123456"
+    )
+
+    mock_session.query(User).filter.return_value.first.return_value = mock_user
+
+    app.dependency_overrides[db.get_db] = lambda: mock_session
+
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        response = await ac.post("/user/", json=request.dict())
+
+    assert response.status_code == 400

api/tests/test_utils.py

@@ -0,0 +1,38 @@
+# import os
+from io import BytesIO
+
+import app.utils as utils
+import pytest
+from fastapi import UploadFile
+from werkzeug.datastructures import FileStorage
+
+
+def test_allowed_file():
+    # 💡 NOTE Run test with: pytest ./tests/test_utils.py::test_allowed_file -v
+    assert utils.allowed_file("cat.JPG")
+    assert utils.allowed_file("cat.jpeg")
+    assert utils.allowed_file("cat.JPEG")
+    assert utils.allowed_file("../../car.PNG")
+    assert utils.allowed_file("/usr/var/src/car.gif")
+
+    assert not utils.allowed_file("cat.JPGG")
+    assert not utils.allowed_file("invoice.pdf")
+    assert not utils.allowed_file("/usr/src/slides.odt")
+    assert not utils.allowed_file("/usr/src/api")
+    assert not utils.allowed_file("/usr/src/api/")
+    assert not utils.allowed_file("/usr/src/dog.")
+    assert not utils.allowed_file("/usr/src/dog./")
+
+
+@pytest.mark.asyncio
+async def test_get_file_hash():
+    # 💡 NOTE Run test with: pytest ./tests/test_utils.py::test_get_file_hash -v
+    filename = "tests/dog.jpeg"
+    md5_filename = "0a7c757a80f2c5b13fa7a2a47a683593.jpeg"
+    with open(filename, "rb") as fp:
+        file = FileStorage(fp)
+        file = UploadFile(file=BytesIO(file.read()), filename="dog.jpeg")
+
+    new_filename = await utils.get_file_hash(file)
+
+    assert md5_filename == new_filename

compose.yml

@@ -1,4 +1,3 @@
-version: "3.2"
 services:
   api:
     image: flask_api