Update app.py

app.py

@@ -1,8 +1,8 @@
 import os
 import torch
-from fastapi import FastAPI, HTTPException, UploadFile, File, Form, Depends, BackgroundTasks, Request, Query, APIRouter, Path, Body, status, Response, Header
-from fastapi.responses import StreamingResponse, JSONResponse, FileResponse, HTMLResponse, PlainTextResponse, RedirectResponse
-from pydantic import BaseModel, validator, Field, root_validator, EmailStr, constr, ValidationError
+from fastapi import FastAPI, HTTPException, UploadFile, File, Depends, BackgroundTasks, Request
+from fastapi.responses import StreamingResponse, JSONResponse, FileResponse, HTMLResponse
+from pydantic import BaseModel, validator, Field, root_validator, EmailStr, constr
 from transformers import (
     AutoModelForCausalLM,
     AutoTokenizer,
@@ -19,90 +19,55 @@ from transformers import (
     AutoModelForTokenClassification,
     AutoModelForMaskedLM,
     AutoModelForObjectDetection,
-    AutoModelForSeq2SeqLM
+    AutoImageProcessor,
 )
 from io import BytesIO
 import boto3
-from botocore.exceptions import NoCredentialsError, ClientError
+from botocore.exceptions import ClientError
 from huggingface_hub import snapshot_download
-import asyncio
 import tempfile
 import hashlib
 from PIL import Image
-import base64
 from typing import Optional, List, Union, Dict, Any
 import uuid
-import subprocess
-import json
-from starlette.middleware.cors import CORSMiddleware
-import numpy as np
-from typing import Dict, Any
+import logging
+import sqlite3
+from passlib.context import CryptContext
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.middleware.gzip import GZipMiddleware
-from transformers import AutoImageProcessor, pipeline
 from fastapi.security import APIKeyHeader, OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from fastapi.security.api_key import APIKeyCookie
-from fastapi import Depends, Security, status, APIRouter, UploadFile, File, Request
-from fastapi.security import APIKeyHeader, OAuth2PasswordRequestForm
-from passlib.context import CryptContext
-from jose import JWTError, jwt
-from datetime import datetime, timedelta
-from starlette.requests import Request
-import logging
-from pydantic import EmailStr, constr, ValidationError
-from database import insert_user, get_user, delete_user, update_user, create_db_and_table
-from starlette.middleware import Middleware
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from starlette.types import ASGIApp
-import uvicorn
-from starlette.responses import StreamingResponse
-import logging
-from pydantic import EmailStr, constr, ValidationError
-from database import insert_user, get_user, delete_user, update_user, create_db_and_table, get_all_users
-from starlette.middleware import Middleware
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from starlette.types import ASGIApp
-import uvicorn
-from starlette.responses import StreamingResponse
-import logging
-from fastapi.exceptions import RequestValidationError
-from fastapi import Request, status, Depends
-from fastapi.security import OAuth2PasswordRequestForm, OAuth2PasswordBearer
-from jose import JWTError, jwt
-from passlib.context import CryptContext
-from datetime import datetime, timedelta
-from pydantic import BaseModel, field_validator, model_validator, Field, EmailStr, constr, ValidationError
-from typing import Optional, List, Union
+from starlette.middleware.cors import CORSMiddleware
+
 
-#setting up logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(filename)s - %(lineno)d - %(message)s')
 logger = logging.getLogger(__name__)
 
-#JWT Settings
 SECRET_KEY = os.getenv("SECRET_KEY")
 if not SECRET_KEY:
     raise ValueError("SECRET_KEY must be set.")
 ALGORITHM = "HS256"
 ACCESS_TOKEN_EXPIRE_MINUTES = 30
 
-#Password Hashing
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
-#Database connection - replace with your database setup
-#Example using SQLite
-import sqlite3
 conn = sqlite3.connect('users.db')
 cursor = conn.cursor()
+cursor.execute('''
+    CREATE TABLE IF NOT EXISTS users (
+        username TEXT PRIMARY KEY,
+        email TEXT UNIQUE,
+        hashed_password TEXT
+    )
+''')
+conn.commit()
 
-#OAuth2
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-#API Key
 API_KEY = os.getenv("API_KEY")
 api_key_header = APIKeyHeader(name="X-API-Key")
 
-#Configuration
 AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
 AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
 AWS_REGION = os.getenv("AWS_REGION")
@@ -115,15 +80,8 @@ TEMPLATES = Jinja2Templates(directory="templates")
 app = FastAPI()
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 app.add_middleware(GZipMiddleware)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 
-origins = ["*"]
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
 
 class User(BaseModel):
     username: constr(min_length=3, max_length=50)
@@ -131,9 +89,9 @@ class User(BaseModel):
     password: constr(min_length=8)
 
 class GenerateRequest(BaseModel):
-    model_name: str
-    input_text: Optional[str] = Field(None, description="Input text for generation.")
-    task_type: str = Field(..., description="Type of generation task (text, image, audio, video, classification, translation, question-answering, speech-to-text, text-to-speech, image-segmentation, feature-extraction, token-classification, fill-mask, image-inpainting, image-super-resolution, object-detection, image-captioning, audio-transcription, summarization).")
+    model_id: str
+    input_text: Optional[str] = Field(None)
+    task_type: str = Field(...)
     temperature: float = 1.0
     max_new_tokens: int = 200
     stream: bool = True
@@ -149,10 +107,10 @@ class GenerateRequest(BaseModel):
     target_language: Optional[str] = None
     context: Optional[str] = None
     audio_file: Optional[UploadFile] = None
-    raw_input: Optional[Union[str, bytes]] = None  # for feature extraction
-    masked_text: Optional[str] = None  # for fill-mask
-    mask_image: Optional[UploadFile] = None  # for image inpainting
-    low_res_image: Optional[UploadFile] = None  # for image super-resolution
+    raw_input: Optional[Union[str, bytes]] = None
+    masked_text: Optional[str] = None
+    mask_image: Optional[UploadFile] = None
+    low_res_image: Optional[UploadFile] = None
 
     @field_validator('task_type')
     def validate_task_type(cls, value):
@@ -182,6 +140,7 @@ class GenerateRequest(BaseModel):
             raise ValueError("low_res_image is required for image super-resolution.")
         return values
 
+
 class S3ModelLoader:
     def __init__(self, bucket_name, aws_access_key_id, aws_secret_access_key, aws_region):
         self.bucket_name = bucket_name
@@ -286,40 +245,43 @@ class S3ModelLoader:
                 raise ValueError("Unsupported task type")
 
 async def stream_text(model, tokenizer, input_text, generation_config, stop_sequences, device, chunk_delay):
-    encoded_input = tokenizer(input_text, return_tensors="pt", truncation=True).to(device)
-    input_length = encoded_input["input_ids"].shape[1]
-    max_length = model.config.max_length
-    remaining_tokens = max_length - input_length
-    if remaining_tokens <= 0:
-        yield ""
-    generation_config.max_new_tokens = min(remaining_tokens, generation_config.max_new_tokens)
-    def stop_criteria(input_ids, scores):
-        decoded_output = tokenizer.decode(input_ids[0][-1], skip_special_tokens=True)
-        return decoded_output in stop_sequences
-    stopping_criteria = StoppingCriteriaList([stop_criteria])
-    outputs = model.generate(
-        **encoded_input,
-        do_sample=generation_config.do_sample,
-        max_new_tokens=generation_config.max_new_tokens,
-        temperature=generation_config.temperature,
-        top_p=generation_config.top_p,
-        top_k=generation_config.top_k,
-        repetition_penalty=generation_config.repetition_penalty,
-        num_return_sequences=generation_config.num_return_sequences,
-        stopping_criteria=stopping_criteria,
-        output_scores=True,
-        return_dict_in_generate=True
-    )
-    for output in outputs.sequences:
-        for token_id in output:
-            token = tokenizer.decode(token_id, skip_special_tokens=True)
-            yield token
+    try:
+        encoded_input = tokenizer(input_text, return_tensors="pt", truncation=True).to(device)
+        input_length = encoded_input["input_ids"].shape[1]
+        max_length = model.config.max_length
+        remaining_tokens = max_length - input_length
+        if remaining_tokens <= 0:
+            yield ""
+        generation_config.max_new_tokens = min(remaining_tokens, generation_config.max_new_tokens)
+        def stop_criteria(input_ids, scores):
+            decoded_output = tokenizer.decode(input_ids[0][-1], skip_special_tokens=True)
+            return decoded_output in stop_sequences
+        stopping_criteria = StoppingCriteriaList([stop_criteria])
+        outputs = model.generate(
+            **encoded_input,
+            do_sample=generation_config.do_sample,
+            max_new_tokens=generation_config.max_new_tokens,
+            temperature=generation_config.temperature,
+            top_p=generation_config.top_p,
+            top_k=generation_config.top_k,
+            repetition_penalty=generation_config.repetition_penalty,
+            num_return_sequences=generation_config.num_return_sequences,
+            stopping_criteria=stopping_criteria,
+            output_scores=True,
+            return_dict_in_generate=True
+        )
+        for output in outputs.sequences:
+            for token_id in output:
+                token = tokenizer.decode(token_id, skip_special_tokens=True)
+                yield token
+    except Exception as e:
+        yield f"Error during text generation: {e}"
 
 
 model_loader = S3ModelLoader(S3_BUCKET_NAME, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION)
 
 def get_model_data(request: GenerateRequest):
-    return model_loader.load_model_and_tokenizer(request.model_name, request.task_type)
+    return model_loader.load_model_and_tokenizer(request.model_id, request.task_type)
 
 async def verify_api_key(api_key: str = Depends(api_key_header)):
     if api_key != API_KEY:
@@ -327,7 +289,7 @@ async def verify_api_key(api_key: str = Depends(api_key_header)):
 
 
 @app.post("/generate", dependencies=[Depends(verify_api_key)])
-async def generate(request: GenerateRequest, background_tasks: BackgroundTasks, model_data = Depends(get_model_data)):
+async def generate(request: GenerateRequest, background_tasks: BackgroundTasks, model_data=Depends(get_model_data)):
     try:
         device = "cuda" if torch.cuda.is_available() else "cpu"
         if request.task_type == "text":
@@ -342,31 +304,31 @@ async def generate(request: GenerateRequest, background_tasks: BackgroundTasks,
                 do_sample=request.do_sample,
                 num_return_sequences=request.num_return_sequences,
             )
-            async def stream_with_tokens():
-                async for token in stream_text(model, tokenizer, request.input_text, generation_config, request.stop_sequences, device, request.chunk_delay):
-                    yield f"Token: {token}\n"
-            return StreamingResponse(stream_with_tokens(), media_type="text/plain")
+            return StreamingResponse(stream_text(model, tokenizer, request.input_text, generation_config, request.stop_sequences, device, request.chunk_delay), media_type="text/plain")
         elif request.task_type in ["image", "audio", "video"]:
-            pipeline = model_data["pipeline"]
-            result = pipeline(request.input_text)
-            if request.task_type == "image":
-                image = result[0]
-                img_byte_arr = BytesIO()
-                image.save(img_byte_arr, format="PNG")
-                img_byte_arr.seek(0)
-                return StreamingResponse(img_byte_arr, media_type="image/png")
-            elif request.task_type == "audio":
-                audio = result[0]
-                audio_byte_arr = BytesIO()
-                audio.save(audio_byte_arr, format="wav")
-                audio_byte_arr.seek(0)
-                return StreamingResponse(audio_byte_arr, media_type="audio/wav")
-            elif request.task_type == "video":
-                video = result[0]
-                video_byte_arr = BytesIO()
-                video.save(video_byte_arr, format="mp4")
-                video_byte_arr.seek(0)
-                return StreamingResponse(video_byte_arr, media_type="video/mp4")
+            pipeline_func = model_data["pipeline"]
+            try:
+                result = pipeline_func(request.input_text)
+                if request.task_type == "image":
+                    image = result[0]
+                    img_byte_arr = BytesIO()
+                    image.save(img_byte_arr, format="PNG")
+                    img_byte_arr.seek(0)
+                    return StreamingResponse(img_byte_arr, media_type="image/png")
+                elif request.task_type == "audio":
+                    audio = result[0]
+                    audio_byte_arr = BytesIO()
+                    audio.save(audio_byte_arr, format="wav")
+                    audio_byte_arr.seek(0)
+                    return StreamingResponse(audio_byte_arr, media_type="audio/wav")
+                elif request.task_type == "video":
+                    video = result[0]
+                    video_byte_arr = BytesIO()
+                    video.save(video_byte_arr, format="mp4")
+                    video_byte_arr.seek(0)
+                    return StreamingResponse(video_byte_arr, media_type="video/mp4")
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Error processing {request.task_type}: {e}")
         elif request.task_type == "classification":
             if request.image_file is None:
                 raise HTTPException(status_code=400, detail="Image file is required for classification.")
@@ -406,38 +368,39 @@ async def generate(request: GenerateRequest, background_tasks: BackgroundTasks,
             if request.audio_file is None:
                 raise HTTPException(status_code=400, detail="Audio file is required for speech-to-text.")
             contents = await request.audio_file.read()
-            pipeline = model_data["pipeline"]
+            pipeline_func = model_data["pipeline"]
             try:
-                transcription = pipeline(contents, sampling_rate=16000)[0]["text"]  # Assuming 16kHz sampling rate
+                transcription = pipeline_func(contents, sampling_rate=16000)[0]["text"]
                 return JSONResponse({"transcription": transcription})
             except Exception as e:
                 raise HTTPException(status_code=500, detail=f"Error during speech-to-text: {str(e)}")
-
         elif request.task_type == "text-to-speech":
             if not request.input_text:
                 raise HTTPException(status_code=400, detail="Input text is required for text-to-speech.")
-            pipeline = model_data["pipeline"]
+            pipeline_func = model_data["pipeline"]
             try:
-                audio = pipeline(request.input_text)[0]
+                audio = pipeline_func(request.input_text)[0]
                 file_path = os.path.join(TEMP_DIR, f"{uuid.uuid4()}.wav")
                 audio.save(file_path)
                 background_tasks.add_task(os.remove, file_path)
                 return FileResponse(file_path, media_type="audio/wav")
             except Exception as e:
                 raise HTTPException(status_code=500, detail=f"Error during text-to-speech: {str(e)}")
-
         elif request.task_type == "image-segmentation":
             if request.image_file is None:
                 raise HTTPException(status_code=400, detail="Image file is required for image segmentation.")
             contents = await request.image_file.read()
             image = Image.open(BytesIO(contents)).convert("RGB")
-            pipeline = model_data["pipeline"]
-            result = pipeline(image)
-            mask = result[0]['mask']
-            mask_byte_arr = BytesIO()
-            mask.save(mask_byte_arr, format="PNG")
-            mask_byte_arr.seek(0)
-            return StreamingResponse(mask_byte_arr, media_type="image/png")
+            pipeline_func = model_data["pipeline"]
+            try:
+                result = pipeline_func(image)
+                mask = result[0]['mask']
+                mask_byte_arr = BytesIO()
+                mask.save(mask_byte_arr, format="PNG")
+                mask_byte_arr.seek(0)
+                return StreamingResponse(mask_byte_arr, media_type="image/png")
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Error during image segmentation: {e}")
         elif request.task_type == "feature-extraction":
             if request.raw_input is None:
                 raise HTTPException(status_code=400, detail="raw_input is required for feature extraction.")
@@ -450,7 +413,7 @@ async def generate(request: GenerateRequest, background_tasks: BackgroundTasks,
                     inputs = feature_extractor(images=image, return_tensors="pt")
                 else:
                     raise ValueError("Unsupported raw_input type.")
-                features = inputs.pixel_values  # Adjust according to your feature extractor
+                features = inputs.pixel_values
                 return JSONResponse({"features": features.tolist()})
             except Exception as fe:
                 raise HTTPException(status_code=400, detail=f"Error during feature extraction: {fe}")
@@ -484,70 +447,81 @@ async def generate(request: GenerateRequest, background_tasks: BackgroundTasks,
             image_contents = await request.image_file.read()
             mask_contents = await request.mask_image.read()
             image = Image.open(BytesIO(image_contents)).convert("RGB")
-            mask = Image.open(BytesIO(mask_contents)).convert("L")  # Assuming mask is grayscale
-            pipeline = model_data["pipeline"]
-            result = pipeline(image, mask)
-            inpainted_image = result[0]
-            img_byte_arr = BytesIO()
-            inpainted_image.save(img_byte_arr, format="PNG")
-            img_byte_arr.seek(0)
-            return StreamingResponse(img_byte_arr, media_type="image/png")
+            mask = Image.open(BytesIO(mask_contents)).convert("L")
+            pipeline_func = model_data["pipeline"]
+            try:
+                result = pipeline_func(image, mask)
+                inpainted_image = result[0]
+                img_byte_arr = BytesIO()
+                inpainted_image.save(img_byte_arr, format="PNG")
+                img_byte_arr.seek(0)
+                return StreamingResponse(img_byte_arr, media_type="image/png")
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Error during image inpainting: {e}")
         elif request.task_type == "image-super-resolution":
             if request.low_res_image is None:
                 raise HTTPException(status_code=400, detail="low_res_image is required for image super-resolution.")
             contents = await request.low_res_image.read()
             image = Image.open(BytesIO(contents)).convert("RGB")
-            pipeline = model_data["pipeline"]
-            result = pipeline(image)
-            upscaled_image = result[0]
-            img_byte_arr = BytesIO()
-            upscaled_image.save(img_byte_arr, format="PNG")
-            img_byte_arr.seek(0)
-            return StreamingResponse(img_byte_arr, media_type="image/png")
+            pipeline_func = model_data["pipeline"]
+            try:
+                result = pipeline_func(image)
+                upscaled_image = result[0]
+                img_byte_arr = BytesIO()
+                upscaled_image.save(img_byte_arr, format="PNG")
+                img_byte_arr.seek(0)
+                return StreamingResponse(img_byte_arr, media_type="image/png")
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Error during image super-resolution: {e}")
         elif request.task_type == "object-detection":
             if request.image_file is None:
                 raise HTTPException(status_code=400, detail="Image file is required for object detection.")
             contents = await request.image_file.read()
             image = Image.open(BytesIO(contents)).convert("RGB")
-            pipeline = model_data["pipeline"]
+            pipeline_func = model_data["pipeline"]
             image_processor = model_data["image_processor"]
             inputs = image_processor(images=image, return_tensors="pt")
             with torch.no_grad():
-                outputs = pipeline(image)
-            detections = outputs
-            return JSONResponse({"detections": detections})
+                try:
+                    outputs = pipeline_func(image)
+                    detections = outputs
+                    return JSONResponse({"detections": detections})
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Error during object detection: {e}")
         elif request.task_type == "image-captioning":
             if request.image_file is None:
                 raise HTTPException(status_code=400, detail="Image file is required for image captioning.")
             contents = await request.image_file.read()
             image = Image.open(BytesIO(contents)).convert("RGB")
-            pipeline = model_data["pipeline"]
-            caption = pipeline(image)[0]['generated_text']
-            return JSONResponse({"caption": caption})
+            pipeline_func = model_data["pipeline"]
+            try:
+                caption = pipeline_func(image)[0]['generated_text']
+                return JSONResponse({"caption": caption})
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Error during image captioning: {e}")
         elif request.task_type == "audio-transcription":
             if request.audio_file is None:
                 raise HTTPException(status_code=400, detail="Audio file is required for audio transcription.")
+            contents = await request.audio_file.read()
+            pipeline_func = model_data["pipeline"]
             try:
-                contents = await request.audio_file.read()
-                pipeline = model_data["pipeline"]
-                try:
-                    transcription = pipeline(contents, sampling_rate=16000)[0]["text"]  # Assuming 16kHz sampling rate
-                    return JSONResponse({"transcription": transcription})
-                except Exception as e:
-                    raise HTTPException(status_code=500, detail=f"Error during audio transcription (pipeline): {str(e)}")
+                transcription = pipeline_func(contents, sampling_rate=16000)[0]["text"]
+                return JSONResponse({"transcription": transcription})
             except Exception as e:
-                raise HTTPException(status_code=500, detail=f"Error during audio transcription (file read): {str(e)}")
+                raise HTTPException(status_code=500, detail=f"Error during audio transcription: {str(e)}")
         elif request.task_type == "summarization":
             if request.input_text is None:
                 raise HTTPException(status_code=400, detail="Input text is required for summarization.")
             model = model_data["model"].to(device)
             tokenizer = model_data["tokenizer"]
-            inputs = tokenizer(request.input_text, return_tensors="pt", truncation=True, max_length=512)  # added max_length for summarization
+            inputs = tokenizer(request.input_text, return_tensors="pt", truncation=True, max_length=512)
             with torch.no_grad():
-                outputs = model.generate(**inputs)
-            summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
-            return JSONResponse({"summary": summary})
-
+                try:
+                    outputs = model.generate(**inputs)
+                    summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
+                    return JSONResponse({"summary": summary})
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Error during summarization: {e}")
         else:
             raise HTTPException(status_code=500, detail=f"Unsupported task type")
     except Exception as e:
@@ -563,25 +537,24 @@ async def root(request: Request):
 async def health_check():
     return {"status": "healthy"}
 
-# Authentication Endpoints
+class Token(BaseModel):
+    access_token: str
+    token_type: str
 
 @app.post("/token", response_model=Token)
 async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
     user = authenticate_user(form_data.username, form_data.password)
     if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect username or password",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password", headers={"WWW-Authenticate": "Bearer"})
     access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
     access_token = create_access_token(data={"sub": user["username"]}, expires_delta=access_token_expires)
     return {"access_token": access_token, "token_type": "bearer"}
 
 def authenticate_user(username: str, password: str):
-    user = get_user(username)
-    if user and pwd_context.verify(password, user.hashed_password):
-        return {"username": user.username}
+    cursor.execute("SELECT * FROM users WHERE username = ?", (username,))
+    user = cursor.fetchone()
+    if user and pwd_context.verify(password, user[2]):
+        return {"username": username}
     return None
 
 def create_access_token(data: Dict[str, Any], expires_delta: timedelta = None):
@@ -594,30 +567,22 @@ def create_access_token(data: Dict[str, Any], expires_delta: timedelta = None):
     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
     return encoded_jwt
 
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
 
 @app.get("/users/me")
 async def read_users_me(current_user: str = Depends(get_current_user)):
     return {"username": current_user}
 
 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"},
-    )
+    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])
         username: str = payload.get("sub")
         if username is None:
             raise credentials_exception
-        token_data = {"username": username, "token": token}
     except JWTError:
         raise credentials_exception
-    user = get_user(username)
+    cursor.execute("SELECT * FROM users WHERE username = ?", (username,))
+    user = cursor.fetchone()
     if user is None:
         raise credentials_exception
     return username
@@ -627,12 +592,11 @@ async def get_current_user(token: str = Depends(oauth2_scheme)):
 async def create_user(user: User):
     try:
         hashed_password = pwd_context.hash(user.password)
-        new_user = {"username": user.username, "email": user.email, "hashed_password": hashed_password}
-        inserted_user = insert_user(new_user)
-        if inserted_user:
-            return User(**inserted_user)
-        else:
-            raise HTTPException(status_code=500, detail="Failed to create user.")
+        cursor.execute("INSERT INTO users (username, email, hashed_password) VALUES (?, ?, ?)", (user.username, user.email, hashed_password))
+        conn.commit()
+        return user
+    except sqlite3.IntegrityError:
+        raise HTTPException(status_code=400, detail="Username or email already exists")
     except Exception as e:
         logger.error(f"Error creating user: {e}")
         raise HTTPException(status_code=500, detail=f"Error creating user: {e}")
@@ -642,27 +606,20 @@ async def create_user(user: User):
 async def update_user_data(username: str, user: User):
     try:
         hashed_password = pwd_context.hash(user.password)
-        updated_user_data = {"email": user.email, "hashed_password": hashed_password}
-        updated_user = update_user(username, updated_user_data)
-        if updated_user:
-            return User(**updated_user)
-        else:
-            raise HTTPException(status_code=404, detail="User not found")
-
+        cursor.execute("UPDATE users SET email = ?, hashed_password = ? WHERE username = ?", (user.email, hashed_password, username))
+        conn.commit()
+        return user
     except Exception as e:
         logger.error(f"Error updating user: {e}")
         raise HTTPException(status_code=500, detail="Error updating user.")
 
 
-
 @app.delete("/users/{username}", dependencies=[Depends(get_current_user)])
 async def delete_user_account(username: str):
     try:
-        deleted_user = delete_user(username)
-        if deleted_user:
-            return JSONResponse({"message": "User deleted successfully."}, status_code=200)
-        else:
-            raise HTTPException(status_code=404, detail="User not found")
+        cursor.execute("DELETE FROM users WHERE username = ?", (username,))
+        conn.commit()
+        return JSONResponse({"message": "User deleted successfully."}, status_code=200)
     except Exception as e:
         logger.error(f"Error deleting user: {e}")
         raise HTTPException(status_code=500, detail="Error deleting user.")
@@ -670,20 +627,14 @@ async def delete_user_account(username: str):
 
 @app.get("/users", dependencies=[Depends(get_current_user)])
 async def get_all_users_route():
-    return get_all_users()
-
+    cursor.execute("SELECT username, email FROM users")
+    users = cursor.fetchall()
+    return [{"username": user[0], "email": user[1]} for user in users]
 
 
 @app.exception_handler(RequestValidationError)
 async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-        content=json.dumps({"detail": exc.errors(), "body": exc.body}),
-    )
-
+    return JSONResponse(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, content=json.dumps({"detail": exc.errors(), "body": exc.body}))
 
 if __name__ == "__main__":
-
-    create_db_and_table() # Initialize database on startup
-
     uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)