Upload folder using huggingface_hub

.gitignore

@@ -2,4 +2,10 @@
 prompt.txt
 
 #cache
-__pycache__
+__pycache__
+
+# documentations
+llm_documentation.md
+
+# enironment variable
+.env

app/main.py

@@ -1,11 +1,25 @@
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
 
+# ==========================
+# 📄 PDF Module
+# ==========================
+from app.routers.pdf import pdf_tools
+
 # ==========================
 # 📌 Image Module
 # ==========================
 from app.routers.image import jpgcompressor
 
+# ==========================
+# 🔒 Security Module
+# ==========================
+from app.routers.security import password_generator 
+
+# ==========================
+# 🛡️ Auth Module (NEW)
+# ==========================
+from app.routers.auth import system as auth_system
 
 # ==========================
 # 🧪 Test Utilities
@@ -13,7 +27,7 @@ from app.routers.image import jpgcompressor
 from app.routers.testers import random_number_generator
 from app.routers.testers import help
 from app.routers.testers import calculator
-
+from app.routers.testers import server_status  # <-- NEW IMPORT
 
 # ==========================
 # 🚀 App Initialization
@@ -24,10 +38,15 @@ app = FastAPI()
 # ==========================
 # 🔗 Router Registration
 # ==========================
+app.include_router(pdf_tools.router)                  # pdf manipulation
 app.include_router(jpgcompressor.router)              # Image compression handler
+app.include_router(password_generator.router)         # Generate a powerfull password that are harder to crack
 app.include_router(random_number_generator.router)    # Random number tester
 app.include_router(help.router)                       # Helper/test info
 app.include_router(calculator.router)                 # Mini calculator service
+app.include_router(auth_system.router)                # <-- NEW AUTH SYSTEM
+app.include_router(server_status.router)              # function to check the system
+
 
 
 # ==========================
@@ -38,4 +57,4 @@ def greet_json():
     return """
     <h2>Go to the Swagger docs 👇</h2>
     <a href="/docs">Click here for API Docs</a>
-    """
+    """

app/routers/auth/database.py

@@ -0,0 +1,22 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+# This creates a file named "sql_app.db" in your project root
+SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
+
+# connect_args is needed only for SQLite
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+# Dependency to get the DB session in endpoints
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/routers/auth/models.py

@@ -0,0 +1,11 @@
+from sqlalchemy import Column, Integer, String, Boolean
+from .database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)

app/routers/auth/schemas.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+class UserCreate(BaseModel):
+    username: str
+    email: str
+    password: str
+
+class UserOut(BaseModel):
+    username: str
+    email: str
+    is_active: bool
+
+    class Config:
+        from_attributes = True

app/routers/auth/system.py

@@ -0,0 +1,90 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from jose import JWTError, jwt
+
+# Import local modules
+from . import models, schemas, database
+from .utils import verify_password, create_access_token, get_password_hash, SECRET_KEY, ALGORITHM
+
+# Create tables automatically
+models.Base.metadata.create_all(bind=database.engine)
+
+router = APIRouter(
+    prefix="/auth",
+    tags=["Authentication"],
+)
+
+# Define the OAuth2 scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/token")
+
+# ==========================================
+# 🔐 The Missing Dependency (Add this back!)
+# ==========================================
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(database.get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        # Decode the token
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    
+    # Check if user exists in DB
+    user = db.query(models.User).filter(models.User.username == username).first()
+    if user is None:
+        raise credentials_exception
+        
+    return user
+
+# ==========================================
+# 🚀 Endpoints
+# ==========================================
+
+@router.post("/register", response_model=schemas.UserOut)
+def register_user(user: schemas.UserCreate, db: Session = Depends(database.get_db)):
+    # 1. Check if user already exists
+    db_user = db.query(models.User).filter(models.User.username == user.username).first()
+    if db_user:
+        raise HTTPException(status_code=400, detail="Username already registered")
+    
+    # 2. Hash the password
+    hashed_pw = get_password_hash(user.password)
+    
+    # 3. Save to DB
+    new_user = models.User(
+        username=user.username, 
+        email=user.email, 
+        hashed_password=hashed_pw
+    )
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    
+    return new_user
+
+@router.post("/token")
+async def login_for_access_token(
+    form_data: OAuth2PasswordRequestForm = Depends(), 
+    db: Session = Depends(database.get_db)
+):
+    # 1. Fetch user from DB
+    user = db.query(models.User).filter(models.User.username == form_data.username).first()
+    
+    # 2. Verify password
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+        
+    # 3. Create Token
+    access_token = create_access_token(data={"sub": user.username})
+    return {"access_token": access_token, "token_type": "bearer"}

app/routers/auth/utils.py

@@ -0,0 +1,29 @@
+from datetime import datetime, timedelta
+from typing import Union
+from passlib.context import CryptContext
+from jose import jwt
+
+# ⚙️ CONFIGURATION (In production, load these from .env)
+SECRET_KEY = "CHANGE_THIS_TO_A_REALLY_LONG_RANDOM_STRING"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# Password Hashing Wrapper
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Union[timedelta, None] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt

app/routers/pdf/pdf_tools.py

@@ -0,0 +1,83 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException, Security
+from fastapi.responses import FileResponse
+from pypdf import PdfReader, PdfWriter
+import os
+import shutil
+import tempfile
+
+# Define the APIRouter object
+router = APIRouter(
+    prefix="/pdf",
+    tags=["PDF Manipulation"],
+)
+
+@router.post("/merge")
+async def merge_pdfs(files: list[UploadFile] = File(description="List of PDFs to merge")):
+    """
+    Merges multiple uploaded PDF files into a single PDF.
+    """
+    if len(files) < 2:
+        raise HTTPException(status_code=400, detail="Please upload at least two PDF files to merge.")
+
+    pdf_writer = PdfWriter()
+    
+    # Create a temporary directory to store files
+    with tempfile.TemporaryDirectory() as temp_dir:
+        output_path = os.path.join(temp_dir, "merged_output.pdf")
+        
+        for file in files:
+            # Save the uploaded file temporarily
+            temp_file_path = os.path.join(temp_dir, file.filename)
+            with open(temp_file_path, "wb") as buffer:
+                shutil.copyfileobj(file.file, buffer)
+            
+            # Read and append pages
+            try:
+                reader = PdfReader(temp_file_path)
+                for page in reader.pages:
+                    pdf_writer.add_page(page)
+            except Exception as e:
+                 raise HTTPException(status_code=500, detail=f"Error reading PDF file {file.filename}: {e}")
+        
+        # Write the merged PDF to the output path
+        with open(output_path, "wb") as output_file:
+            pdf_writer.write(output_file)
+            
+        # Return the merged file as a response
+        return FileResponse(output_path, media_type="application/pdf", filename="merged_document.pdf")
+
+@router.post("/rotate")
+async def rotate_pdf(
+    file: UploadFile = File(description="PDF file to rotate"),
+    degrees: int = 90  # Default rotation is 90 degrees clockwise
+):
+    """
+    Rotates all pages of a single PDF by a specified degree (90, 180, or 270).
+    """
+    if degrees not in [90, 180, 270]:
+        raise HTTPException(status_code=400, detail="Rotation must be 90, 180, or 270 degrees.")
+        
+    pdf_writer = PdfWriter()
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        input_path = os.path.join(temp_dir, file.filename)
+        output_path = os.path.join(temp_dir, "rotated_output.pdf")
+        
+        # Save the uploaded file temporarily
+        with open(input_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Read, rotate, and write
+        try:
+            reader = PdfReader(input_path)
+            for page in reader.pages:
+                page.rotate(degrees)
+                pdf_writer.add_page(page)
+        except Exception as e:
+             raise HTTPException(status_code=500, detail=f"Error processing PDF: {e}")
+
+        # Write the rotated PDF
+        with open(output_path, "wb") as output_file:
+            pdf_writer.write(output_file)
+
+        return FileResponse(output_path, media_type="application/pdf", filename=f"rotated_{degrees}.pdf")

app/routers/security/password_generator.py

@@ -0,0 +1,44 @@
+import random
+import string
+from fastapi import APIRouter, Query, Depends  # Added 'Depends'
+from app.routers.auth.system import get_current_user  # Import our Auth System
+
+# Define the APIRouter object as per documentation standards
+router = APIRouter(
+    prefix="/security",         # Endpoints will start with /security
+    tags=["Password Tools"],
+)
+
+@router.get("/generate-password")
+def generate_password(
+    length: int = Query(12, ge=8, le=64, description="Length of the password (8-64)"),
+    include_uppercase: bool = True,
+    include_numbers: bool = True,
+    include_symbols: bool = True,
+    # 👇 This line locks the endpoint!
+    current_user: dict = Depends(get_current_user) 
+):
+    """
+    Generates a secure, random password. 
+    **Requires Authentication.**
+    """
+    # Base character set
+    chars = string.ascii_lowercase
+    
+    # Advanced logic to append character sets based on flags
+    if include_uppercase:
+        chars += string.ascii_uppercase
+    if include_numbers:
+        chars += string.digits
+    if include_symbols:
+        chars += string.punctuation
+
+    # Generate the password
+    generated_password = "".join(random.choice(chars) for _ in range(length))
+
+    return {
+        "requested_by": current_user.username, # We can now see who asked for it!
+        "password": generated_password, 
+        "length": length,
+        "complexity": "Advanced"
+    }

app/routers/testers/help.py

@@ -1,4 +1,5 @@
-from fastapi import APIRouter
+from fastapi import APIRouter , Depends
+from app.routers.auth.system import get_current_user  # Import our Auth System
 
 # Create the router for help/info endpoints
 router = APIRouter(
@@ -7,13 +8,15 @@ router = APIRouter(
 )
 
 @router.get("/")
-def get_api_info():
+def get_api_info(current_user: dict = Depends(get_current_user) ):
     """
     Returns general information about the API and available endpoints.
     """
     return {
+        "requested_by": current_user.username,
         "api_name": "My Awesome FastAPI",
         "version": "1.0",
         "available_sections": ["/random", "/help"],
         "message": "Use the /docs endpoint for interactive API documentation."
+        
     }

app/routers/testers/server_status.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter, status
+from fastapi.responses import JSONResponse
+import platform
+import psutil
+
+# Initialize the router for this feature
+router = APIRouter(
+    prefix="/server-status",
+    tags=["Server Info"],
+    responses={404: {"description": "Not found"}},
+)
+
+@router.get(
+    "/full-info", 
+    summary="Get complete server/PC status and information",
+    status_code=status.HTTP_200_OK
+)
+def get_server_status():
+    """
+    Retrieves detailed hardware and software status of the server.
+    """
+    
+    # --- System Information ---
+    system_info = {
+        "system": platform.system(),
+        "node_name": platform.node(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+    }
+    
+    # --- CPU Information ---
+    cpu_info = {
+        "physical_cores": psutil.cpu_count(logical=False),
+        "total_cores": psutil.cpu_count(logical=True),
+        "cpu_usage_percent": psutil.cpu_percent(interval=1),
+        "cpu_frequency_mhz": f"{psutil.cpu_freq().current:.2f}",
+    }
+
+    # --- Memory Information (RAM) ---
+    virtual_memory = psutil.virtual_memory()
+    memory_info = {
+        "total_gb": f"{virtual_memory.total / (1024**3):.2f}",
+        "available_gb": f"{virtual_memory.available / (1024**3):.2f}",
+        "used_gb": f"{virtual_memory.used / (1024**3):.2f}",
+        "usage_percent": virtual_memory.percent,
+    }
+    
+    # --- Disk Usage Information (Root partition) ---
+    disk_usage = psutil.disk_usage('/')
+    disk_info = {
+        "total_gb": f"{disk_usage.total / (1024**3):.2f}",
+        "used_gb": f"{disk_usage.used / (1024**3):.2f}",
+        "free_gb": f"{disk_usage.free / (1024**3):.2f}",
+        "usage_percent": disk_usage.percent,
+    }
+    
+    # --- Network Information (Simple) ---
+    network_info = {
+        "bytes_sent_mb": f"{psutil.net_io_counters().bytes_sent / (1024**2):.2f}",
+        "bytes_recv_mb": f"{psutil.net_io_counters().bytes_recv / (1024**2):.2f}",
+    }
+
+    response_data = {
+        "system_information": system_info,
+        "cpu_status": cpu_info,
+        "memory_status": memory_info,
+        "disk_status": disk_info,
+        "network_io": network_info,
+    }
+
+    return JSONResponse(content=response_data, status_code=status.HTTP_200_OK)

requirements.txt

@@ -2,4 +2,7 @@ fastapi
 uvicorn
 requests
 pillow
-python-multipart
+python-multipart
+pypdf
+python-dotenv
+pydantic-settings