Docker optimise

Dockerfile

@@ -1,20 +1,77 @@
+# # Use an official Python runtime as a parent image
+# FROM python:3.12-slim
+
+# WORKDIR /code
+
+# COPY ./requirements.txt /code/requirements.txt
+
+# RUN pip install --no-cache-dir --upgrade pip && \
+#     pip install --no-cache-dir -r requirements.txt
+
+# # Copy application code
+# COPY ./app /code/app
+# # Copy static files and templates
+# COPY ./static /code/static
+# COPY ./templates /code/templates
+
+# EXPOSE 7860
+
+# # Command to run the FastAPI application
+# CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+
 # Use an official Python runtime as a parent image
+FROM python:3.12-slim as builder
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PYTHONOPTIMIZE=2
+
+WORKDIR /build
+
+# Copy only requirements first to leverage Docker caching
+COPY ./requirements.txt .
+
+# Install dependencies into a virtual environment
+RUN python -m venv /venv && \
+    /venv/bin/pip install --no-cache-dir --upgrade pip && \
+    /venv/bin/pip install --no-cache-dir -r requirements.txt
+
+# Final stage
 FROM python:3.12-slim
 
-WORKDIR /code
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONOPTIMIZE=2 \
+    PATH="/venv/bin:$PATH"
 
-COPY ./requirements.txt /code/requirements.txt
+WORKDIR /app
 
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+# Create a non-root user
+RUN addgroup --system app && \
+    adduser --system --group app && \
+    chown -R app:app /app
 
-# Copy application code
-COPY ./app /code/app
-# Copy static files and templates
-COPY ./static /code/static
-COPY ./templates /code/templates
+# Copy the virtual environment from the builder stage
+COPY --from=builder /venv /venv
 
+# Copy application code and assets
+COPY --chown=app:app ./app ./app
+COPY --chown=app:app ./static ./static
+COPY --chown=app:app ./templates ./templates
+
+# Expose the port
 EXPOSE 7860
 
-# Command to run the FastAPI application
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Switch to non-root user
+USER app
+
+# Add healthcheck
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Command to run the FastAPI application with optimized settings
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "4", "--proxy-headers"]

README.md

@@ -10,7 +10,6 @@ short_description: An app demonstrating Gradio, FastAPI, Docker & SQL DB
 app_file: app/main.py
 python_version: 3.12
 port: 7860
-fullWidth: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/api.py

@@ -1,4 +1,3 @@
-# app/api.py
 from fastapi import APIRouter, HTTPException, status, Depends, WebSocket, WebSocketDisconnect
 import logging
 
@@ -9,8 +8,8 @@ from .dependencies import get_required_current_user
 router = APIRouter()
 logger = logging.getLogger(__name__)
 
-# --- FIX THE DECORATORS HERE ---
-@router.post("/register", status_code=status.HTTP_201_CREATED, response_model=models.User) # <-- FIX HERE
+
+@router.post("/register", status_code=status.HTTP_201_CREATED, response_model=models.User)
 async def register_user(user_in: schemas.UserCreate):
     existing_user = await crud.get_user_by_email(user_in.email)
     if existing_user:
@@ -23,14 +22,13 @@ async def register_user(user_in: schemas.UserCreate):
     if not created_user: raise HTTPException(status_code=500, detail="Failed to retrieve created user")
     return models.User(id=created_user.id, email=created_user.email)
 
-@router.post("/login", response_model=schemas.Token) # <-- FIX HERE
+@router.post("/login", response_model=schemas.Token)
 async def login_for_access_token(form_data: schemas.UserLogin):
     user = await crud.get_user_by_email(form_data.email)
     if not user or not auth.verify_password(form_data.password, user.hashed_password):
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect email or password", headers={"WWW-Authenticate": "Bearer"})
     access_token = auth.create_session_token(user_id=user.id)
     return {"access_token": access_token, "token_type": "bearer"}
-# --- END FIXES ---
 
 @router.get("/users/me", response_model=models.User)
 async def read_users_me(current_user: models.User = Depends(get_required_current_user)):

app/auth.py

@@ -1,5 +1,4 @@
 import os
-from datetime import datetime, timedelta, timezone
 from passlib.context import CryptContext
 from itsdangerous import URLSafeTimedSerializer, SignatureExpired, BadSignature
 from dotenv import load_dotenv
@@ -8,8 +7,8 @@ from . import crud, models
 
 load_dotenv()
 
-SECRET_KEY = os.getenv("SECRET_KEY", "super-secret") # Fallback, but .env should be used
-# Use URLSafeTimedSerializer for session tokens that expire
+SECRET_KEY = os.getenv("SECRET_KEY", "super-secret")
+
 serializer = URLSafeTimedSerializer(SECRET_KEY)
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
@@ -20,8 +19,6 @@ def verify_password(plain_password: str, hashed_password: str) -> bool:
 def get_password_hash(password: str) -> str:
     return pwd_context.hash(password)
 
-# Session Token generation (using itsdangerous for simplicity)
-# Stores user_id securely signed with a timestamp
 def create_session_token(user_id: int) -> str:
     return serializer.dumps(user_id)
 
@@ -30,8 +27,7 @@ async def get_user_id_from_token(token: str) -> Optional[int]:
     if not token:
         return None
     try:
-        # Set max_age to something reasonable, e.g., 1 day
-        user_id = serializer.loads(token, max_age=86400) # 24 hours * 60 min * 60 sec
+        user_id = serializer.loads(token, max_age=86400)
         return int(user_id)
     except (SignatureExpired, BadSignature, ValueError):
         return None
@@ -43,6 +39,5 @@ async def get_current_user_from_token(token: str) -> Optional[models.User]:
         return None
     user = await crud.get_user_by_id(user_id)
     if user:
-        # Return the public User model, not UserInDB
         return models.User(id=user.id, email=user.email)
     return None

app/database.py

@@ -1,135 +1,33 @@
-# # app/database.py
-# import os
-# from databases import Database
-# from dotenv import load_dotenv
-# # --- Keep only these SQLAlchemy imports ---
-# from sqlalchemy import MetaData, Table, Column, Integer, String
-# import logging
-# from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
-
-# load_dotenv()
-# logger = logging.getLogger(__name__)
-
-# # --- Database URL Configuration ---
-# DEFAULT_DB_PATH = "/tmp/app.db" # Store DB in the temporary directory
-# raw_db_url = os.getenv("DATABASE_URL", f"sqlite+aiosqlite:///{DEFAULT_DB_PATH}")
-
-# final_database_url = raw_db_url
-# if raw_db_url.startswith("sqlite+aiosqlite"):
-#     parsed_url = urlparse(raw_db_url)
-#     query_params = parse_qs(parsed_url.query)
-#     if 'check_same_thread' not in query_params:
-#         query_params['check_same_thread'] = ['False']
-#         new_query = urlencode(query_params, doseq=True)
-#         final_database_url = urlunparse(parsed_url._replace(query=new_query))
-#     logger.info(f"Using final async DB URL: {final_database_url}")
-# else:
-#     logger.info(f"Using non-SQLite async DB URL: {final_database_url}")
-
-# # --- Async Database Instance ---
-# database = Database(final_database_url)
-
-# # --- Metadata and Table Definition (Still needed for DDL generation) ---
-# metadata = MetaData()
-# users = Table(
-#     "users",
-#     metadata,
-#     Column("id", Integer, primary_key=True),
-#     Column("email", String, unique=True, index=True, nullable=False),
-#     Column("hashed_password", String, nullable=False),
-# )
-
-# # --- REMOVE ALL SYNCHRONOUS ENGINE AND TABLE CREATION LOGIC ---
-
-# # --- Keep and refine Async connect/disconnect functions ---
-# async def connect_db():
-#     """Connects to the database, ensuring the parent directory exists."""
-#     try:
-#         # Ensure the directory exists just before connecting
-#         db_file_path = final_database_url.split("sqlite:///")[-1].split("?")[0]
-#         db_dir = os.path.dirname(db_file_path)
-#         if db_dir: # Only proceed if a directory path was found
-#              if not os.path.exists(db_dir):
-#                  logger.info(f"Database directory {db_dir} does not exist. Attempting creation...")
-#                  try:
-#                      os.makedirs(db_dir, exist_ok=True)
-#                      logger.info(f"Created database directory {db_dir}.")
-#                  except Exception as mkdir_err:
-#                      # Log error but proceed, connection might still work if path is valid but dir creation failed weirdly
-#                      logger.error(f"Failed to create directory {db_dir}: {mkdir_err}")
-#              # Check writability after ensuring existence attempt
-#              if os.path.exists(db_dir) and not os.access(db_dir, os.W_OK):
-#                   logger.error(f"CRITICAL: Directory {db_dir} exists but is not writable!")
-#              elif not os.path.exists(db_dir):
-#                   logger.error(f"CRITICAL: Directory {db_dir} does not exist and could not be created!")
-
-
-#         # Now attempt connection
-#         await database.connect()
-#         logger.info(f"Database connection established (async): {final_database_url}")
-#         # Table creation will happen in main.py lifespan event using this connection
-#     except Exception as e:
-#         logger.exception(f"Failed to establish async database connection: {e}")
-#         raise # Reraise critical error during startup
-
-# async def disconnect_db():
-#     """Disconnects from the database if connected."""
-#     try:
-#         if database.is_connected:
-#              await database.disconnect()
-#              logger.info("Database connection closed (async).")
-#         else:
-#              logger.info("Database already disconnected (async).")
-#     except Exception as e:
-#         logger.exception(f"Error closing async database connection: {e}")
-
-
-
-# app/database.py
 import os
 from databases import Database
 from dotenv import load_dotenv
-# --- Keep only these SQLAlchemy imports ---
-# MetaData and Table are needed for defining the table structure
-# which is used by crud.py and for DDL generation in main.py
 from sqlalchemy import MetaData, Table, Column, Integer, String
 import logging
 from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
 
-# Load environment variables from .env file (if it exists)
 load_dotenv()
 logger = logging.getLogger(__name__)
 
-# --- Database URL Configuration ---
-# Use /tmp directory for the SQLite file as it's generally writable in containers
+
 DEFAULT_DB_PATH = "/tmp/app.db"
-# Get the URL from environment or use the default /tmp path
 raw_db_url = os.getenv("DATABASE_URL", f"sqlite+aiosqlite:///{DEFAULT_DB_PATH}")
 
 final_database_url = raw_db_url
-# Ensure 'check_same_thread=False' is in the URL query string for SQLite async connection
+
 if raw_db_url.startswith("sqlite+aiosqlite"):
     parsed_url = urlparse(raw_db_url)
     query_params = parse_qs(parsed_url.query)
     if 'check_same_thread' not in query_params:
-        query_params['check_same_thread'] = ['False'] # Value needs to be a list for urlencode
+        query_params['check_same_thread'] = ['False'] 
         new_query = urlencode(query_params, doseq=True)
-        # Rebuild the URL using _replace method of the named tuple
         final_database_url = urlunparse(parsed_url._replace(query=new_query))
     logger.info(f"Using final async DB URL: {final_database_url}")
 else:
     logger.info(f"Using non-SQLite async DB URL: {final_database_url}")
 
 
-# --- Async Database Instance ---
-# This 'database' object will be used by crud.py and main.py lifespan
 database = Database(final_database_url)
 
-
-# --- Metadata and Table Definition ---
-# These definitions are needed by:
-# 1. crud.py to construct queries (e.g., users.select())
-# 2. main.py (lifespan) to generate the CREATE TABLE statement
 metadata = MetaData()
 users = Table(
     "users",
@@ -139,13 +37,9 @@ users = Table(
     Column("hashed_password", String, nullable=False),
 )
 
-
-# --- Async connect/disconnect functions ---
-# Called by the FastAPI lifespan event handler in main.py
 async def connect_db():
     """Connects to the database defined by 'final_database_url'."""
     try:
-        # Optional: Check/create directory if using file-based DB like SQLite
         if final_database_url.startswith("sqlite"):
             db_file_path = final_database_url.split("sqlite:///")[-1].split("?")[0]
             db_dir = os.path.dirname(db_file_path)
@@ -162,16 +56,14 @@ async def connect_db():
                  elif not os.path.exists(db_dir):
                       logger.error(f"CRITICAL: DB directory '{db_dir}' does not exist and could not be created!")
 
-        # Connect using the 'databases' library instance
         if not database.is_connected:
             await database.connect()
             logger.info(f"Database connection established: {final_database_url}")
         else:
             logger.info("Database connection already established.")
-        # Note: Table creation happens in main.py lifespan after connection
     except Exception as e:
         logger.exception(f"FATAL: Failed to establish async database connection: {e}")
-        raise # Stop application startup if DB connection fails
+        raise
 
 async def disconnect_db():
     """Disconnects from the database if connected."""

app/dependencies.py

@@ -1,10 +1,8 @@
 from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer # Use FastAPI's built-in helper
+from fastapi.security import OAuth2PasswordBearer
 from typing import Optional
 from . import auth, models
 
-# Setup OAuth2 scheme pointing to the login *API* endpoint
-# tokenUrl relative to the path where the app is mounted
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/login")
 
 async def get_optional_current_user(token: str = Depends(oauth2_scheme)) -> Optional[models.User]:
@@ -14,25 +12,20 @@ async def get_optional_current_user(token: str = Depends(oauth2_scheme)) -> Opti
     Handles potential exceptions during token decoding/validation gracefully for optional user.
     """
     try:
-        # OAuth2PasswordBearer already extracts the token from the header
         user = await auth.get_current_user_from_token(token)
         return user
-    except Exception: # Catch exceptions if the token is invalid but we don't want to fail hard
+    except Exception:
         return None
 
 async def get_required_current_user(token: str = Depends(oauth2_scheme)) -> models.User:
     """
     Dependency to get the current user, raising HTTP 401 if not authenticated.
     """
-    # OAuth2PasswordBearer will raise a 401 if the header is missing/malformed
     user = await auth.get_current_user_from_token(token)
     if user is None:
-        # This case covers valid token format but expired/invalid signature/user not found
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Could not validate credentials", # Keep detail generic
+            detail="Could not validate credentials",
             headers={"WWW-Authenticate": "Bearer"},
         )
-    return user
-
-# Modify the /users/me endpoint in api.py to use the new dependency
+    return user

app/main.py

@@ -1,27 +1,13 @@
-# app/main.py
-# Remove Gradio imports if any remain
-# import gradio as gr <--- REMOVE
-
-import httpx # Keep if needed, but not used in this version of main.py
-import websockets # Keep if needed, but not used in this version of main.py
-import asyncio
-import json
-import os
 import logging
 from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, Depends, Request # Add Request
-from fastapi.responses import HTMLResponse    # Add HTMLResponse
-from fastapi.staticfiles import StaticFiles     # Add StaticFiles
-from fastapi.templating import Jinja2Templates # Add Jinja2Templates (optional, but good practice)
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse 
+from fastapi.staticfiles import StaticFiles
 
-# --- Import necessary items from database.py ---
-from .database import connect_db, disconnect_db, database, metadata, users
+from .database import connect_db, disconnect_db, database, users
 from .api import router as api_router
-from . import schemas, auth, dependencies
-from .websocket import manager # Keep
 
-# --- Import SQLAlchemy helpers for DDL generation ---
 from sqlalchemy.schema import CreateTable
 from sqlalchemy.dialects import sqlite
 
@@ -29,13 +15,8 @@ from sqlalchemy.dialects import sqlite
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- REMOVE API_BASE_URL if not needed elsewhere ---
-# API_BASE_URL = "http://127.0.0.1:7860/api"
-
-# --- Lifespan Event (remains the same) ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # ... (same DB setup code as previous correct version) ...
     logger.info("Application startup: Connecting DB...")
     await connect_db()
     logger.info("Application startup: DB Connected. Checking/Creating tables...")
@@ -65,22 +46,12 @@ async def lifespan(app: FastAPI):
     logger.info("Application shutdown: DB Disconnected.")
 
 
-# Create the main FastAPI app instance
 app = FastAPI(lifespan=lifespan)
 
-# Mount API routes FIRST
 app.include_router(api_router, prefix="/api")
 
-# --- Mount Static files ---
-# Ensure the path exists relative to where you run uvicorn (or use absolute paths)
-# Since main.py is in app/, static/ is one level up
-# Adjust 'directory' path if needed based on your execution context
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
-# --- Optional: Use Jinja2Templates for more flexibility ---
-# templates = Jinja2Templates(directory="templates")
-
-# --- Serve the main HTML page ---
 @app.get("/", response_class=HTMLResponse)
 async def read_root(request: Request):
     # Simple way: Read the file directly
@@ -91,16 +62,7 @@ async def read_root(request: Request):
     except FileNotFoundError:
         logger.error("templates/index.html not found!")
         return HTMLResponse(content="<html><body><h1>Error: Frontend not found</h1></body></html>", status_code=500)
-    # Jinja2 way (if using templates):
-    # return templates.TemplateResponse("index.html", {"request": request})
-
-
-# --- REMOVE Gradio mounting ---
-# app = gr.mount_gradio_app(app, demo, path="/")
 
-# --- Uvicorn run command (no changes needed here) ---
 if __name__ == "__main__":
     import uvicorn
-    # Note: If running from the project root directory (fastapi_gradio_auth/),
-    # the app path is "app.main:app"
     uvicorn.run("app.main:app", host="0.0.0.0", port=7860, reload=True)

app/websocket.py

@@ -1,15 +1,12 @@
 from fastapi import WebSocket
 from typing import List, Dict, Optional
-import json
 import logging
 
 logger = logging.getLogger(__name__)
 
 class ConnectionManager:
     def __init__(self):
-        # Store connections with user ID if available for targeted messaging later
         self.active_connections: Dict[Optional[int], List[WebSocket]] = {}
-        # Map websocket to user_id for easier removal
         self.websocket_to_user: Dict[WebSocket, Optional[int]] = {}
 
     async def connect(self, websocket: WebSocket, user_id: Optional[int] = None):
@@ -43,14 +40,7 @@ class ConnectionManager:
         logger.info(f"Broadcasting to {len(all_websockets)} connections (excluding sender if ID matches). Sender ID: {sender_id}")
 
         for websocket in all_websockets:
-             # Send to all *other* users (or all if sender_id is None)
             ws_user_id = self.websocket_to_user.get(websocket)
-            # Requirement: "all *other* connected users should see"
-            # Send if the websocket isn't associated with the sender_id
-            # (Note: If a user has multiple tabs/connections open, they might still receive it
-            # if the sender_id check only excludes one specific connection. This simple broadcast
-            # targets users based on their ID at connection time).
-            # Let's refine: Send if the user_id associated with the WS is not the sender_id
             if ws_user_id != sender_id:
                 try:
                     await websocket.send_text(message)

requirements.txt

@@ -1,6 +1,5 @@
 fastapi==0.111.0
 uvicorn[standard]==0.29.0
-# gradio==4.29.0 # REMOVE
 bcrypt==4.1.3
 passlib[bcrypt]==1.7.4
 python-dotenv==1.0.1
@@ -10,5 +9,5 @@ pydantic==2.7.1
 python-multipart==0.0.9
 itsdangerous==2.1.2
 websockets>=11.0.3,<13.0
-aiofiles==23.2.1 # <-- ADD for StaticFiles
-httpx==0.27.0    # <-- ADD (useful if backend needs to call itself, good practice)
+aiofiles==23.2.1
+httpx==0.27.0   

tests/api.py

@@ -0,0 +1,405 @@
+# import requests
+# import time
+# from faker import Faker
+
+
+# class AuthClient:
+#     """
+#     Python client for interacting with the Authentication API
+#     """
+    
+#     def __init__(self, base_url="http://localhost:7860/api"):
+#         """
+#         Initialize the client with the API base URL
+        
+#         Args:
+#             base_url (str): The base URL of the API
+#         """
+#         self.base_url = base_url
+#         self.token = None
+    
+#     def register(self, email, password):
+#         """
+#         Register a new user
+        
+#         Args:
+#             email (str): User's email
+#             password (str): User's password (should be at least 8 characters)
+            
+#         Returns:
+#             dict: The user data returned by the API
+            
+#         Raises:
+#             Exception: If registration fails
+#         """
+#         url = f"{self.base_url}/register"
+#         data = {
+#             "email": email,
+#             "password": password
+#         }
+        
+#         response = requests.post(url, json=data)
+        
+#         if response.status_code == 201:
+#             return response.json()
+#         else:
+#             error_detail = response.json().get("detail", "Unknown error")
+#             raise Exception(f"Registration failed: {error_detail} (Status: {response.status_code})")
+    
+#     def login(self, email, password):
+#         """
+#         Login to obtain an authentication token
+        
+#         Args:
+#             email (str): User's email
+#             password (str): User's password
+            
+#         Returns:
+#             dict: The token data returned by the API
+            
+#         Raises:
+#             Exception: If login fails
+#         """
+#         url = f"{self.base_url}/login"
+#         data = {
+#             "email": email,
+#             "password": password
+#         }
+        
+#         response = requests.post(url, json=data)
+        
+#         if response.status_code == 200:
+#             token_data = response.json()
+#             self.token = token_data["access_token"]
+#             return token_data
+#         else:
+#             error_detail = response.json().get("detail", "Unknown error")
+#             raise Exception(f"Login failed: {error_detail} (Status: {response.status_code})")
+    
+#     def get_current_user(self):
+#         """
+#         Get information about the current logged-in user
+        
+#         Returns:
+#             dict: The user data returned by the API
+            
+#         Raises:
+#             Exception: If not authenticated or request fails
+#         """
+#         if not self.token:
+#             raise Exception("Not authenticated. Please login first.")
+        
+#         url = f"{self.base_url}/users/me"
+#         headers = {"Authorization": f"Bearer {self.token}"}
+        
+#         response = requests.get(url, headers=headers)
+        
+#         if response.status_code == 200:
+#             return response.json()
+#         else:
+#             error_detail = response.json().get("detail", "Unknown error")
+#             raise Exception(f"Failed to get user info: {error_detail} (Status: {response.status_code})")
+    
+#     def logout(self):
+#         """Clear the authentication token"""
+#         self.token = None
+
+
+# # Example usage
+# def main():
+#     # Initialize the client
+#     client = AuthClient("https://amaye15-authenticationapp.hf.space/api")
+    
+#     # Initialize Faker
+#     fake = Faker()
+    
+#     for i in range(10):
+#         try:
+#             # Generate random user data
+#             first_name = fake.first_name()
+#             last_name = fake.last_name()
+#             email = fake.email()
+#             password = fake.password(length=12, special_chars=True, digits=True, upper_case=True, lower_case=True)
+            
+#             # Register a new user
+#             print(f"Registering a new user: {first_name} {last_name}...")
+#             try:
+#                 user = client.register(email, password)
+#                 print(f"Registered user: {user}")
+#             except Exception as e:
+#                 print(f"Registration failed: {e}")
+            
+#             # Login
+#             print("\nLogging in...")
+#             token_data = client.login(email, password)
+#             print(f"Login successful, token: {token_data['access_token'][:10]}...")
+            
+#             # Get current user
+#             print("\nGetting current user info...")
+#             user_info = client.get_current_user()
+#             print(f"Current user: {user_info}")
+            
+#             # Logout
+#             print("\nLogging out...")
+#             client.logout()
+#             print("Logged out successfully")
+            
+#         except Exception as e:
+#             print(f"Error: {e}")
+
+
+# if __name__ == "__main__":
+#     main()
+
+import asyncio
+import aiohttp
+import time
+from faker import Faker
+
+
+class AuthClient:
+    """
+    Asynchronous Python client for interacting with the Authentication API
+    """
+    
+    def __init__(self, base_url="http://localhost:7860/api"):
+        """
+        Initialize the client with the API base URL
+        
+        Args:
+            base_url (str): The base URL of the API
+        """
+        self.base_url = base_url
+        self.token = None
+        self.session = None
+    
+    async def __aenter__(self):
+        """Create and enter an aiohttp session"""
+        self.session = aiohttp.ClientSession()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Close the aiohttp session"""
+        if self.session:
+            await self.session.close()
+    
+    async def _get_session(self):
+        """Get or create an aiohttp session"""
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+        return self.session
+    
+    async def register(self, email, password):
+        """
+        Register a new user
+        
+        Args:
+            email (str): User's email
+            password (str): User's password (should be at least 8 characters)
+            
+        Returns:
+            dict: The user data returned by the API
+            
+        Raises:
+            Exception: If registration fails
+        """
+        url = f"{self.base_url}/register"
+        data = {
+            "email": email,
+            "password": password
+        }
+        
+        session = await self._get_session()
+        async with session.post(url, json=data) as response:
+            if response.status == 201:
+                return await response.json()
+            else:
+                error_data = await response.json()
+                error_detail = error_data.get("detail", "Unknown error")
+                raise Exception(f"Registration failed: {error_detail} (Status: {response.status})")
+    
+    async def login(self, email, password):
+        """
+        Login to obtain an authentication token
+        
+        Args:
+            email (str): User's email
+            password (str): User's password
+            
+        Returns:
+            dict: The token data returned by the API
+            
+        Raises:
+            Exception: If login fails
+        """
+        url = f"{self.base_url}/login"
+        data = {
+            "email": email,
+            "password": password
+        }
+        
+        session = await self._get_session()
+        async with session.post(url, json=data) as response:
+            if response.status == 200:
+                token_data = await response.json()
+                self.token = token_data["access_token"]
+                return token_data
+            else:
+                error_data = await response.json()
+                error_detail = error_data.get("detail", "Unknown error")
+                raise Exception(f"Login failed: {error_detail} (Status: {response.status})")
+    
+    async def get_current_user(self):
+        """
+        Get information about the current logged-in user
+        
+        Returns:
+            dict: The user data returned by the API
+            
+        Raises:
+            Exception: If not authenticated or request fails
+        """
+        if not self.token:
+            raise Exception("Not authenticated. Please login first.")
+        
+        url = f"{self.base_url}/users/me"
+        headers = {"Authorization": f"Bearer {self.token}"}
+        
+        session = await self._get_session()
+        async with session.get(url, headers=headers) as response:
+            if response.status == 200:
+                return await response.json()
+            else:
+                error_data = await response.json()
+                error_detail = error_data.get("detail", "Unknown error")
+                raise Exception(f"Failed to get user info: {error_detail} (Status: {response.status})")
+    
+    def logout(self):
+        """Clear the authentication token"""
+        self.token = None
+
+
+# Load testing function
+async def load_test(num_users=10, concurrency=5, base_url="https://amaye15-authenticationapp.hf.space/api"):
+    """
+    Run a load test with multiple simulated users
+    
+    Args:
+        num_users (int): Total number of users to simulate
+        concurrency (int): Number of concurrent users
+        base_url (str): The base URL of the API
+    """
+    fake = Faker()
+    
+    start_time = time.time()
+    completed = 0
+    success_count = 0
+    failure_count = 0
+    
+    # Semaphore to limit concurrency
+    sem = asyncio.Semaphore(concurrency)
+    
+    # For progress tracking
+    progress_lock = asyncio.Lock()
+    
+    async def run_single_user():
+        nonlocal completed, success_count, failure_count
+        
+        async with sem:  # This limits concurrency
+            async with AuthClient(base_url) as client:
+                try:
+                    # Generate random user data
+                    email = fake.email()
+                    password = fake.password(length=12, special_chars=True, digits=True, 
+                                          upper_case=True, lower_case=True)
+                    
+                    # Complete user flow
+                    await client.register(email, password)
+                    await client.login(email, password)
+                    await client.get_current_user()
+                    client.logout()
+                    
+                    async with progress_lock:
+                        completed += 1
+                        success_count += 1
+                        # Print progress
+                        print(f"Progress: {completed}/{num_users} users completed", end="\r")
+                        
+                except Exception as e:
+                    async with progress_lock:
+                        completed += 1
+                        failure_count += 1
+                        print(f"Error: {e}")
+                        print(f"Progress: {completed}/{num_users} users completed", end="\r")
+    
+    # Create all tasks
+    tasks = [run_single_user() for _ in range(num_users)]
+    
+    # Display start message
+    print(f"Starting load test with {num_users} users (max {concurrency} concurrent)...")
+    
+    # Run all tasks
+    await asyncio.gather(*tasks)
+    
+    # Calculate stats
+    end_time = time.time()
+    duration = end_time - start_time
+    
+    # Display results
+    print("\n\n--- Load Test Results ---")
+    print(f"Total users: {num_users}")
+    print(f"Concurrency level: {concurrency}")
+    print(f"Successful flows: {success_count} ({success_count/num_users*100:.1f}%)")
+    print(f"Failed flows: {failure_count} ({failure_count/num_users*100:.1f}%)")
+    print(f"Total duration: {duration:.2f} seconds")
+    
+    if success_count > 0:
+        print(f"Average time per successful user: {duration/success_count:.2f} seconds")
+        print(f"Requests per second: {success_count/duration:.2f}")
+
+
+# Example usage
+async def main():
+    # Initialize the client
+    base_url = "https://amaye15-authenticationapp.hf.space/api"
+    
+    # Run a simple example with a single user
+    fake = Faker()
+    async with AuthClient(base_url) as client:
+        # Generate random user data
+        first_name = fake.first_name()
+        last_name = fake.last_name()
+        email = fake.email()
+        password = fake.password(length=12, special_chars=True, digits=True, upper_case=True, lower_case=True)
+        
+        try:
+            # Register a new user
+            print(f"Registering a new user: {first_name} {last_name}...")
+            user = await client.register(email, password)
+            print(f"Registered user: {user}")
+            
+            # Login
+            print("\nLogging in...")
+            token_data = await client.login(email, password)
+            print(f"Login successful, token: {token_data['access_token'][:10]}...")
+            
+            # Get current user
+            print("\nGetting current user info...")
+            user_info = await client.get_current_user()
+            print(f"Current user: {user_info}")
+            
+            # Logout
+            print("\nLogging out...")
+            client.logout()
+            print("Logged out successfully")
+            
+        except Exception as e:
+            print(f"Error: {e}")
+    
+    # Run a load test
+    print("\nRunning load test...")
+    await load_test(10, 5, base_url)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())