Login API implemented

.env

@@ -0,0 +1 @@
+EC_ADMIN_PWD='$2b$12$zybxm7XMoGCVV3ovNDcXt.r2QJUhtj7miYfEfuBw9UGqViTIRFg72'

Dockerfile

@@ -12,28 +12,30 @@ RUN useradd -m -u 1000 user
 # Set environment variables for the non-root user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH \
-    NAME=EduConnect \
-    EC_ADMIN_PWD='$2b$12$zybxm7XMoGCVV3ovNDcXt.r2QJUhtj7miYfEfuBw9UGqViTIRFg72'
+    NAME=EduConnect
 
 # Set the non-root user's home directory as the working directory
 WORKDIR $HOME
 
-# Copy the application files into the non-root user's home directory, ensuring the user owns the copied files
-COPY --chown=user:user . ./app
-
 # Create the /home/user/data directory and ensure it has the correct permissions
 RUN mkdir -p ./data && chown user:user ./data
 
 # Change to the non-root user
 USER user
 
-# Set the working directory to where the application files are
+# Set the working directory to where the application files will be located
 WORKDIR $HOME/app
 
+# Copy only the requirements.txt first to leverage Docker cache
+COPY --chown=user:user requirements.txt ./
+
 # Install any needed packages specified in requirements.txt
 # As the non-root user, ensure packages are installed to the user's home directory
 RUN pip install --no-cache-dir --user -r requirements.txt
 
+# Copy the rest of the application files into the container
+COPY --chown=user:user . .
+
 # Make port 7860 available to the world outside this container
 EXPOSE 7860
 
@@ -42,4 +44,4 @@ EXPOSE 7860
 VOLUME /home/user/data
 
 # Run the FastAPI application using Uvicorn, binding to port 7860
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -16,13 +16,12 @@ EduConnect/
 │   ├── __init__.py                  # Initializes the FastAPI app and global configurations
 │   ├── main.py                      # Entry point for the FastAPI application, defining routes
 │   ├── dependencies.py              # Dependency utilities for JWT token verification, etc.
-│   ├── models.py                    # Database models for ORM
-│   ├── schemas.py                   # Pydantic schemas for request and response validation
 │   ├── api/
 │   │   ├── __init__.py
 │   │   ├── userlogin.py             # Endpoint for user login functionality
 │   │   ├── userlogout.py            # Endpoint for user logout functionality
 │   │   ├── userchat.py              # Endpoint for chat functionality
+│   │   ├── userupload.py            # Endpoint for file upload functionality
 │   │   └── userhistory.py           # Endpoint for loading chat history
 │   ├── admin/
 │   │   ├── __init__.py
@@ -32,11 +31,13 @@ EduConnect/
 │   │       └── user_registration.html # Template for user registration page
 │   └── utils/
 │       ├── __init__.py
+│       ├── db.py                    # Centraized DB functions for ChromaDB collections, TinyDB
+│       ├── jwt_utils.py             # Utility for JWT tokens
 │       └── ec_image_utils.py        # Integrates MTCNN and Facenet for login authentication
 ├── static/
-│   ├── css/
-│   ├── js/
-│   └── images/
+│   ├── css/                         # CSS for the administration portal
+│   ├── js/                          # Javascripts if any for administration portal
+│   └── images/                      # UI rendering images for administration page
 ├── Dockerfile                       # Docker configuration for setting up the environment
 ├── requirements.txt                 # Lists all Python library dependencies
 └── .env                             # Environment variables for configuration settings

app/api/login.py

@@ -1,23 +0,0 @@
-# # app/api/login.py
-# from fastapi import APIRouter, HTTPException, Depends, File, UploadFile
-# from ..utils.authentication import verify_user
-# from ..schemas import LoginSchema
-# from ..crud import get_user_by_email, create_access_token
-
-# router = APIRouter()
-
-# @router.post("/login/")
-# async def login(user_image: UploadFile = File(...)):
-#     # Use MTCNN and Facenet to embed the image and verify user
-#     user_verified, user_email = verify_user(user_image.file)
-#     if not user_verified:
-#         raise HTTPException(status_code=400, detail="Authentication Failed")
-
-#     # Query ChromaDB for similarity and retrieve user details
-#     user = get_user_by_email(user_email)
-#     if not user:
-#         raise HTTPException(status_code=404, detail="User not found")
-
-#     # Generate JWT session token
-#     access_token = create_access_token(data={"sub": user.email})
-#     return {"access_token": access_token, "token_type": "bearer"}

app/api/userchat.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter, Depends, HTTPException, Body
+from ..dependencies import get_current_user
+from typing import Any
+
+router = APIRouter()
+
+@router.post("/user/chat")
+async def chat_with_llama(user_input: str = Body(..., embed=True), current_user: Any = Depends(get_current_user)):
+    # Implement your logic to interact with LlamaV2 LLM here.
+    # Example response, replace with actual chat logic
+    chat_response = "Hello, how can I assist you today?"
+    return {"response": chat_response}

app/api/userlogin.py

@@ -0,0 +1,56 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from fastapi import APIRouter, File, UploadFile, HTTPException
+from ..utils.db import tinydb_helper, chromadb_face_helper
+from ..utils.jwt_utils import create_access_token
+from ..utils.ec_image_utils import get_user_cropped_image_from_photo
+import os
+import uuid
+
+router = APIRouter()
+L2_FACE_THRESHOLD = 0.85 # distance value closer to 0 =>best match, >1 =>poor match
+
+async def verify_user_face(file_path: str) -> Optional[dict]:
+    # Assuming `get_user_cropped_image_from_photo` returns the cropped face as expected by ChromaDB
+    face_img = get_user_cropped_image_from_photo(file_path)
+    if face_img is None:
+        return None
+
+    # Query the user's face in ChromaDB
+    query_results = chromadb_face_helper.query_user_face(face_img)
+    if query_results and len(query_results["ids"][0]) > 0:
+        
+        chromadb_face_helper.print_query_results(query_results)
+
+        # Assuming the first result is the best match
+        l2_distance = query_results["distances"][0][0]
+        if l2_distance < L2_FACE_THRESHOLD: # l2 distance threshold for top matched face
+            user_id = query_results["ids"][0][0]
+            metadata = query_results["metadatas"][0][0]
+            return {"user_id": user_id, "metadata":metadata}
+    return None
+
+@router.post("/user/login")
+async def user_login(file: UploadFile = File(...)):
+    file_path = f"/tmp/{uuid.uuid4()}.jpg"  # Generates a unique filename
+    with open(file_path, "wb") as buffer:
+        contents = await file.read()
+        buffer.write(contents)
+
+    # Perform face verification
+    verification_result = await verify_user_face(file_path)
+    if verification_result:
+        user_id = verification_result["user_id"]
+        metadata = verification_result["metadata"]
+        # Generate JWT token with user information
+        access_token = create_access_token(data={"sub": user_id, "name": metadata["name"], "role": metadata["role"]})
+
+        # Calculate expiration time for the token
+        expires_at = (datetime.utcnow() + timedelta(minutes=30)).isoformat()  # Example expiration time
+        
+        # Store the token in TinyDB
+        tinydb_helper.insert_token(user_id, access_token, expires_at)
+
+        return {"access_token": access_token, "token_type": "bearer"}
+    else:
+        raise HTTPException(status_code=400, detail="Face not recognized")

app/api/userlogout.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter, Depends, HTTPException
+from ..utils.db import tinydb_helper  # Ensure this import is correct based on your project structure
+from ..dependencies import oauth2_scheme
+
+router = APIRouter()
+
+@router.post("/user/logout")
+async def user_logout(token: str = Depends(oauth2_scheme)):
+    try:
+        # Invalidate the token by removing it from the database
+        tinydb_helper.remove_token_by_value(token)
+        return {"message": "User logged out successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error during logout: {str(e)}")

app/api/userupload.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter, UploadFile, File
+
+router = APIRouter()
+
+@router.post("/user/upload")
+async def upload_file(file: UploadFile = File(...)):
+    file_location = f"/path/to/your/uploads/{file.filename}"
+    with open(file_location, "wb") as buffer:
+        contents = await file.read()
+        buffer.write(contents)
+    return {"filename": file.filename, "location": file_location}

app/dependencies.py

@@ -0,0 +1,25 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import jwt, JWTError
+from .utils.db import tinydb_helper  # Ensure correct import path
+from .utils.jwt_utils import SECRET_KEY, ALGORITHM  # Ensure these are defined in your jwt_utils.py
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+        token_data = tinydb_helper.query_token(user_id, token)
+        if not token_data:
+            raise credentials_exception
+        return token_data  # Or return a user model based on the token_data
+    except JWTError:
+        raise credentials_exception

app/main.py

@@ -7,20 +7,13 @@ from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse
 from fastapi.templating import Jinja2Templates
 
 from .admin import admin_functions as admin
-from .utils.ec_image_utils import UserFaceEmbeddingFunction
+from .utils.db import UserFaceEmbeddingFunction,ChromaDBFaceHelper
+from .api import userlogin, userlogout, userchat, userupload
+from .utils.db import tinydb_helper, ChromaDBFaceHelper
 
-app = FastAPI()
-
-# Persitent storage for chromadb setup in /data volume
-ec_client = chromadb.PersistentClient("/home/user/data/chromadb")
-user_faces_db = ec_client.get_or_create_collection(name="user_faces_db", embedding_function=UserFaceEmbeddingFunction())
-
-@app.on_event("startup")
-async def startup_event():
-    # Perform any necessary ChromaDB setup or checks here
-    ec_client.heartbeat()
-    print("ChromaDB setup completed.")
+CHROMADB_LOC = "/home/user/data/chromadb"
 
+app = FastAPI()
 
 # Add middleware
 # Set all origins to wildcard for simplicity, but you should limit this in production
@@ -32,6 +25,21 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Persitent storage for chromadb setup in /data volume
+ec_client = chromadb.PersistentClient(CHROMADB_LOC)
+# The following collection reference is needed for admin function to register face
+user_faces_db = ec_client.get_or_create_collection(name="user_faces_db", embedding_function=UserFaceEmbeddingFunction())
+
+
+@app.on_event("startup")
+async def startup_event():
+    global chromadb_face_helper
+    # Assuming chromadb persistent store client for APIs is in helper
+    db_path = CHROMADB_LOC
+    chromadb_face_helper = ChromaDBFaceHelper(db_path) # Used by APIs
+    # Perform any other startup tasks here
+
+
 # Mount static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
@@ -68,4 +76,9 @@ async def handle_user_registration(request: Request, email: str = Form(...), nam
         return templates.TemplateResponse("registration_success.html", {"request": request})
     else:
         # Reload registration page with error message
-        return templates.TemplateResponse("user_registration.html", {"request": request, "error": "Registration failed"})
+        return templates.TemplateResponse("user_registration.html", {"request": request, "error": "Registration failed"})
+    
+app.include_router(userlogin.router)
+app.include_router(userlogout.router)
+app.include_router(userchat.router)
+app.include_router(userupload.router)

app/utils/chat_rag.py

@@ -0,0 +1,2 @@
+# Model import
+# Implement RAG using wvvocer

app/utils/db.py

@@ -0,0 +1,76 @@
+
+from tinydb import TinyDB, Query, where
+from tinydb.storages import MemoryStorage
+import chromadb
+from chromadb.api.types import EmbeddingFunction, Embeddings, Image, Images
+from keras_facenet import FaceNet
+from typing import Any
+from datetime import datetime, timedelta
+
+CHROMADB_LOC = "/home/user/data/chromadb"
+
+class TinyDBHelper:
+    def __init__(self):
+        self.db = TinyDB(storage=MemoryStorage)
+        self.tokens_table = self.db.table('tokens')
+
+    def insert_token(self, user_id: str, token: str, expires_at: str):
+        self.tokens_table.insert({'user_id': user_id, 'token': token, 'expires_at': expires_at})
+
+    def query_token(self, user_id: str, token: str) -> bool:
+        """Query to check if the token exists and is valid."""
+        User = Query()
+        # Assuming your tokens table contains 'user_id', 'token', and 'expires_at'
+        result = self.tokens_table.search((User.user_id == user_id) & (User.token == token))
+        # Optionally, check if the token is expired
+        expires_at = datetime.fromisoformat(result[0]['expires_at'])
+        if datetime.utcnow() > expires_at:
+            return False
+        
+        return bool(result)
+
+    def remove_token_by_value(self, token: str):
+        """Remove a token based on its value."""
+        self.tokens_table.remove((where('token') == token))
+
+###### Class implementing Custom Embedding function for chroma db
+#
+class UserFaceEmbeddingFunction(EmbeddingFunction[Images]):
+    def __init__(self):
+        # Intitialize the FaceNet model
+        self.facenet = FaceNet()
+
+    def __call__(self, input: Images) -> Embeddings:
+        # Since the input images are assumed to be `numpy.ndarray` objects already,
+        # we can directly use them for embeddings extraction without additional processing.
+        # Ensure the input images are pre-cropped face images ready for embedding extraction.
+
+        # Extract embeddings using FaceNet for the pre-cropped face images.
+        embeddings_array = self.facenet.embeddings(input)
+
+        # Convert numpy array of embeddings to list of lists, as expected by Chroma.
+        return embeddings_array.tolist()
+
+
+# Usage example:
+# user_face_embedding_function = UserFaceEmbeddingFunction()
+# Assuming `images` is a list of `numpy.ndarray` objects where each represents a pre-cropped face image ready for embedding extraction.
+# embeddings = user_face_embedding_function(images)
+
+
+class ChromaDBFaceHelper:
+    def __init__(self, db_path: str):
+        self.client = chromadb.PersistentClient(db_path)
+        self.user_faces_db = self.client.get_or_create_collection(name="user_faces_db", embedding_function=UserFaceEmbeddingFunction())
+
+    def query_user_face(self, presented_face: Any, n_results: int = 1):
+        return self.user_faces_db.query(query_images=[presented_face], n_results=n_results)
+    
+    def print_query_results(self, query_results: dict) -> None:
+        for id, distance, metadata in zip(query_results["ids"][0], query_results['distances'][0], query_results['metadatas'][0]):
+            print(f'id: {id}, distance: {distance}, metadata: {metadata}')
+
+
+# Initialize these helpers globally if they are to be used across multiple modules
+tinydb_helper = TinyDBHelper()
+chromadb_face_helper = ChromaDBFaceHelper(CHROMADB_LOC)  # Initialization requires db_path

app/utils/ec_image_utils.py

@@ -1,9 +1,6 @@
 import cv2
 from mtcnn.mtcnn import MTCNN
 import numpy as np
-from keras_facenet import FaceNet
-from chromadb.api.types import EmbeddingFunction, Embeddings, Image, Images
-from typing import List
 
 
 def load_image(filename):
@@ -79,27 +76,3 @@ def get_user_cropped_image_from_photo(filename):
     return cropped_face[0]
 
 
-###### Class implementing Custom Embedding function for chroma db
-#
-class UserFaceEmbeddingFunction(EmbeddingFunction[Images]):
-    def __init__(self):
-        # Intitialize the FaceNet model
-        self.facenet = FaceNet()
-
-    def __call__(self, input: Images) -> Embeddings:
-        # Since the input images are assumed to be `numpy.ndarray` objects already,
-        # we can directly use them for embeddings extraction without additional processing.
-        # Ensure the input images are pre-cropped face images ready for embedding extraction.
-
-        # Extract embeddings using FaceNet for the pre-cropped face images.
-        embeddings_array = self.facenet.embeddings(input)
-
-        # Convert numpy array of embeddings to list of lists, as expected by Chroma.
-        return embeddings_array.tolist()
-
-
-# Usage example:
-# user_face_embedding_function = UserFaceEmbeddingFunction()
-# Assuming `images` is a list of `numpy.ndarray` objects where each represents a pre-cropped face image ready for embedding extraction.
-# embeddings = user_face_embedding_function(images)
-

app/utils/jwt_utils.py

@@ -0,0 +1,48 @@
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+from typing import Any, Union
+from tinydb import TinyDB, Query
+from tinydb.storages import MemoryStorage
+
+
+# Secret key to encode JWT tokens. In production, use a more secure key and keep it secret!
+SECRET_KEY = "a_very_secret_key"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30  # The expiration time for the access token
+
+db = TinyDB(storage=MemoryStorage)
+tokens_table = db.table('tokens')
+
+def insert_token(user_id: str, token: str, expires_in: timedelta):
+    expiration = datetime.utcnow() + expires_in
+    tokens_table.insert({'user_id': user_id, 'token': token, 'expires_at': expiration.isoformat()})
+
+def validate_token(user_id: str, token: str) -> bool:
+    User = Query()
+    result = tokens_table.search((User.user_id == user_id) & (User.token == token))
+    if not result:
+        return False
+    # Check token expiration
+    expires_at = datetime.fromisoformat(result[0]['expires_at'])
+    if datetime.utcnow() > expires_at:
+        return False
+    return True
+
+def create_access_token(data: dict, expires_delta: Union[timedelta, None] = None) -> str:
+    """
+    Creates a JWT access token.
+
+    :param data: A dictionary of claims (e.g., {"sub": user_id}) to include in the token.
+    :param expires_delta: A timedelta object representing how long the token is valid.
+    :return: A JWT token as a string.
+    """
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        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
+
+# Additional functions can be added here for verifying tokens, decoding tokens, etc.

docker-compose.yml

@@ -0,0 +1,18 @@
+version: '3.8'
+services:
+  educonnect:
+    image: python:3.9
+    command: ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--reload"]
+    volumes:
+      - /Users/tyago/Workspace/EduConnect:/home/user/app
+    ports:
+      - "7860:7860"
+    environment:
+      - HOME=/home/user
+      - PATH=/home/user/.local/bin:$PATH
+      - NAME=EduConnect
+      - EC_ADMIN_PWD=$2b$12$zybxm7XMoGCVV3ovNDcXt.r2QJUhtj7miYfEfuBw9UGqViTIRFg72
+    user: "1000:1000"
+    working_dir: /home/user/app
+    env_file:
+      - .env

requirements.txt

@@ -13,4 +13,5 @@ jinja2==3.0.*                  # For Admin site redndering
 bcrypt==4.1.*                  # For hashing secrets
 opencv-python-headless==4.5.5.* # For image handling images
 tensorflow                     # Tensorflow is needed by MTCNN for facial recognition
-scipy                          # The scipy is required for keras-facenet
+scipy                          # The scipy is required for keras-facenet
+tinydb                         # The in memory database for storing JWT tokens