auth added

Dockerfile

@@ -45,5 +45,5 @@ ENV HOME=/home/user \
 COPY --chown=user . $HOME
 #CMD ["python3", "-m", "app"]
 # Start the FastAPI app on port 7860, the default port expected by Spaces
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
 #ENTRYPOINT ["python3", "-m", "llama_cpp.server", "--hf_model_repo_id", "Qwen/Qwen1.5-0.5B-Chat-GGUF", "--model", "*q4_0.gguf", "--host", "0.0.0.0"]

app/auth.py

@@ -0,0 +1,40 @@
+from datetime import datetime, timedelta
+from typing import Optional
+
+import jwt
+from fastapi import HTTPException, Depends, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from app.db.database import get_db
+from app.models.user import User
+from app.schemas.user import UserOut
+
+SECRET_KEY = "supersecretkey"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def verify_access_token(token: str, db: Session):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
+        user = db.query(User).filter(User.id == user_id).first()
+        if user is None:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                                 detail="User not found")
+        return user
+    except jwt.PyJWTError:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
+
+def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    return verify_access_token(token, db)

app/config.py

@@ -0,0 +1,7 @@
+#from pydantic import BaseSettings
+from pydantic_settings import BaseSettings
+class Settings(BaseSettings):
+    SECRET_KEY: str = "your_secret_key"
+    DATABASE_URL: str = "sqlite:///./app.db"
+
+settings = Settings()

app/db/database.py

@@ -0,0 +1,19 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from app.config import settings
+
+DATABASE_URL = settings.DATABASE_URL
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def create_tables():
+    Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/fapp.py

@@ -0,0 +1,62 @@
+import os
+import urllib.request
+from llama_cpp import Llama
+from fastapi import FastAPI
+
+app = FastAPI(docs_url="/")
+
+def download_file(file_link, filename):
+    # Checks if the file already exists before downloading
+    if not os.path.isfile(filename):
+        urllib.request.urlretrieve(file_link, filename)
+        print("File downloaded successfully.")
+    else:
+        print("File already exists.")
+
+
+# Dowloading GGML model from HuggingFace
+ggml_model_path = "https://huggingface.co/TheBloke/zephyr-7B-beta-GGUF/resolve/main/zephyr-7b-beta.Q4_0.gguf"
+filename = "zephyr-7b-beta.Q4_0.gguf"
+
+#download_file(ggml_model_path, filename)
+
+
+
+llm = Llama(model_path="/home/mo/Desktop/web/oGBackend/qwen1_5-0_5b-chat-q2_k.gguf", n_ctx=512, n_batch=126, chat_format="llama")
+
+
+def generate_text(
+    prompt="Who is the COlor of Apple?",
+    max_tokens=256,
+    temperature=0.7,
+    top_p=0.5,
+    echo=False,
+    stop=["#"],
+):
+    output = llm(
+        prompt,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        echo=echo,
+        stop=stop,
+    )
+    output_text = output["choices"][0]["text"]
+    return output_text
+
+
+def generate_prompt_from_template(input):
+    chat_prompt_template = f"""<|im_start|>system
+You are a helpful chatbot.<|im_end|>
+<|im_start|>user
+{input}<|im_end|>"""
+    return chat_prompt_template
+
+@app.get("/generate")
+def generate(text: str):
+    prompt = generate_prompt_from_template(text) 
+
+    generate_text(
+        prompt,
+        max_tokens=356,
+    )

app/gtts.py

@@ -0,0 +1,119 @@
+import random
+import time
+
+import speech_recognition as sr
+
+
+def recognize_speech_from_mic(recognizer, microphone):
+    """Transcribe speech from recorded from `microphone`.
+
+    Returns a dictionary with three keys:
+    "success": a boolean indicating whether or not the API request was
+               successful
+    "error":   `None` if no error occured, otherwise a string containing
+               an error message if the API could not be reached or
+               speech was unrecognizable
+    "transcription": `None` if speech could not be transcribed,
+               otherwise a string containing the transcribed text
+    """
+    # check that recognizer and microphone arguments are appropriate type
+    if not isinstance(recognizer, sr.Recognizer):
+        raise TypeError("`recognizer` must be `Recognizer` instance")
+
+    if not isinstance(microphone, sr.Microphone):
+        raise TypeError("`microphone` must be `Microphone` instance")
+
+    # adjust the recognizer sensitivity to ambient noise and record audio
+    # from the microphone
+    with microphone as source:
+        recognizer.adjust_for_ambient_noise(source)
+        audio = recognizer.listen(source)
+
+    # set up the response object
+    response = {
+        "success": True,
+        "error": None,
+        "transcription": None
+    }
+
+    # try recognizing the speech in the recording
+    # if a RequestError or UnknownValueError exception is caught,
+    #     update the response object accordingly
+    try:
+        response["transcription"] = recognizer.recognize_google(audio)
+    except sr.RequestError:
+        # API was unreachable or unresponsive
+        response["success"] = False
+        response["error"] = "API unavailable"
+    except sr.UnknownValueError:
+        # speech was unintelligible
+        response["error"] = "Unable to recognize speech"
+
+    return response
+
+
+if __name__ == "__main__":
+    # set the list of words, maxnumber of guesses, and prompt limit
+    WORDS = ["apple", "banana", "grape", "orange", "mango", "lemon"]
+    NUM_GUESSES = 3
+    PROMPT_LIMIT = 5
+
+    # create recognizer and mic instances
+    recognizer = sr.Recognizer()
+    microphone = sr.Microphone()
+
+    # get a random word from the list
+    word = random.choice(WORDS)
+
+    # format the instructions string
+    instructions = (
+        "I'm thinking of one of these words:\n"
+        "{words}\n"
+        "You have {n} tries to guess which one.\n"
+    ).format(words=', '.join(WORDS), n=NUM_GUESSES)
+
+    # show instructions and wait 3 seconds before starting the game
+    print(instructions)
+    time.sleep(3)
+
+    for i in range(NUM_GUESSES):
+        # get the guess from the user
+        # if a transcription is returned, break out of the loop and
+        #     continue
+        # if no transcription returned and API request failed, break
+        #     loop and continue
+        # if API request succeeded but no transcription was returned,
+        #     re-prompt the user to say their guess again. Do this up
+        #     to PROMPT_LIMIT times
+        for j in range(PROMPT_LIMIT):
+            print('Guess {}. Speak!'.format(i+1))
+            guess = recognize_speech_from_mic(recognizer, microphone)
+            if guess["transcription"]:
+                break
+            if not guess["success"]:
+                break
+            print("I didn't catch that. What did you say?\n")
+
+        # if there was an error, stop the game
+        if guess["error"]:
+            print("ERROR: {}".format(guess["error"]))
+            break
+
+        # show the user the transcription
+        print("You said: {}".format(guess["transcription"]))
+
+        # determine if guess is correct and if any attempts remain
+        guess_is_correct = guess["transcription"].lower() == word.lower()
+        user_has_more_attempts = i < NUM_GUESSES - 1
+
+        # determine if the user has won the game
+        # if not, repeat the loop if user has more attempts
+        # if no attempts left, the user loses the game
+        if guess_is_correct:
+            print("Correct! You win!".format(word))
+            break
+        elif user_has_more_attempts:
+            print("Incorrect. Try again.\n")
+        else:
+            print("Sorry, you lose!\nI was thinking of '{}'.".format(word))
+            break

app/hello.py

@@ -0,0 +1,7 @@
+import llama_cpp
+model = llama_cpp.Llama(
+     model_path="/home/mo/Desktop/web/oGBackend/qwen1_5-0_5b-chat-q2_k.gguf",
+     chat_format="llama-2",
+ )
+x = model.create_completion("Write a story about robotics?")
+print(x)

app/models/user.py

@@ -0,0 +1,9 @@
+from sqlalchemy import Column, Integer, String
+from app.db.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    password = Column(String)

app/routers/llm.py

@@ -0,0 +1,136 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app.db.database import get_db
+from app.models.user import User
+from app.schemas.user import UserCreate, UserOut
+from app.auth import create_access_token, get_current_user
+
+
+
+import fastapi
+from fastapi.responses import JSONResponse
+from time import time
+#from fastapi.middleware.cors import CORSMiddleware
+import logging
+import llama_cpp
+import llama_cpp.llama_tokenizer
+from pydantic import BaseModel
+
+
+
+
+
+router = APIRouter(prefix="/llm", tags=["llm"])
+
+
+class GenModel(BaseModel):
+    question: str
+    system: str = "You are a helpful medical AI chat assistant. Help as much as you can.Also continuously ask for possible symptoms in order to atat a conclusive ailment or sickness and possible solutions.Remember, response in English."
+    temperature: float = 0.8
+    seed: int = 101
+    mirostat_mode: int=2
+    mirostat_tau: float=4.0
+    mirostat_eta: float=1.1
+
+class ChatModel(BaseModel):
+    question: list
+    system: str = "You are a helpful medical AI chat assistant. Help as much as you can.Also continuously ask for possible symptoms in order to atat a conclusive ailment or sickness and possible solutions.Remember, response in English."
+    temperature: float = 0.8
+    seed: int = 101
+    mirostat_mode: int=2
+    mirostat_tau: float=4.0
+    mirostat_eta: float=1.1
+llm_chat = llama_cpp.Llama.from_pretrained(
+    repo_id="Qwen/Qwen1.5-0.5B-Chat-GGUF",
+    filename="*q4_0.gguf",
+    tokenizer=llama_cpp.llama_tokenizer.LlamaHFTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B"),
+    verbose=False,
+     n_ctx=1024,
+     n_gpu_layers=0,
+    #chat_format="llama-2"
+)
+llm_generate = llama_cpp.Llama.from_pretrained(
+    repo_id="Qwen/Qwen1.5-0.5B-Chat-GGUF",
+    filename="*q4_0.gguf",
+    tokenizer=llama_cpp.llama_tokenizer.LlamaHFTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B"),
+    verbose=False,
+     n_ctx=4096,
+     n_gpu_layers=0,
+    mirostat_mode=2,
+    mirostat_tau=4.0,
+    mirostat_eta=1.1
+    #chat_format="llama-2"
+)
+# Logger setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+
+
+@router.get("/")
+def index():
+    return fastapi.responses.RedirectResponse(url="/docs")
+
+@router.get("/health")
+def health():
+    return {"status": "ok"}
+    
+# Chat Completion API
+@router.post("/chat/")
+async def chat(chatm:ChatModel):
+    try:
+        st = time()
+        output = llm_chat.create_chat_completion(
+            messages = chatm.question,
+            temperature = chatm.temperature,
+            seed = chatm.seed,
+            #stream=True
+        )
+        #print(output)
+        et = time()
+        output["time"] = et - st
+        #messages.append({'role': "assistant", "content": output['choices'][0]['message']['content']})
+        #print(messages)
+        return output
+    except Exception as e:
+        logger.error(f"Error in /complete endpoint: {e}")
+        return JSONResponse(
+            status_code=500, content={"message": "Internal Server Error"}
+        )
+
+# Chat Completion API
+@router.post("/generate")
+async def generate(gen:GenModel):
+    gen.system = "You are an helpful medical AI assistant."
+    gen.temperature = 0.5
+    gen.seed = 42
+    try:
+        st = time()
+        output = llm_generate.create_chat_completion(
+            messages=[
+                {"role": "system", "content": gen.system},
+                {"role": "user", "content": gen.question},
+            ],
+            temperature = gen.temperature,
+            seed= gen.seed,
+            #stream=True,
+            #echo=True
+        )
+        """
+        for chunk in output:
+            delta = chunk['choices'][0]['delta']
+            if 'role' in delta:
+                print(delta['role'], end=': ')
+            elif 'content' in delta:
+                print(delta['content'], end='')
+            #print(chunk)
+        """
+        et = time()
+        output["time"] = et - st
+        return output
+    except Exception as e:
+        logger.error(f"Error in /generate endpoint: {e}")
+        return JSONResponse(
+            status_code=500, content={"message": "Internal Server Error"}
+        )

app/routers/user.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app.db.database import get_db
+from app.models.user import User
+from app.schemas.user import UserCreate, UserOut
+from app.auth import create_access_token, get_current_user
+
+router = APIRouter(prefix="/user", tags=["user"])
+
+@router.post("/register", response_model=UserOut)
+def register(user: UserCreate, db: Session = Depends(get_db)):
+    existing_user = db.query(User).filter(User.username == user.username).first()
+    if existing_user:
+        raise HTTPException(status_code=400,
+                            #status.HTTP_400_BAD_REQUEST, 
+                            detail="Username already taken")
+
+    hashed_password = user.password  # Hashing is needed here
+    db_user = User(username=user.username, password=hashed_password)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.post("/login")
+def login(user: UserCreate, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.username == user.username).first()
+    if not db_user or db_user.password != user.password:
+        raise HTTPException(status_code=400,
+                            #status.HTTP.400_BAD_REQUEST, 
+                            detail="Invalid credentials")
+
+    access_token = create_access_token(data={"sub": str(db_user.id)})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.get("/me", response_model=UserOut)
+def read_users_me(current_user: User = Depends(get_current_user)):
+    return current_user

app/schemas/user.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+
+class UserInDB(BaseModel):
+    id: int
+    username: str
+    password: str
+
+class UserCreate(BaseModel):
+    username: str
+    password: str
+
+class UserOut(BaseModel):
+    id: int
+    username: str
+
+    class Config:
+        orm_mode = True

app/security.py

@@ -0,0 +1,9 @@
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def hash_password(password: str):
+    return pwd_context.hash(password)
+
+def verify_password(plain_password: str, hashed_password: str):
+    return pwd_context.verify(plain_password, hashed_password)

main.py

@@ -0,0 +1,25 @@
+"""
+from fastapi import FastAPI
+from app.routers import user
+from app.db import database
+
+app = FastAPI()
+
+# Include user router
+app.include_router(user.router)
+
+# Create tables
+database.create_tables()
+"""
+from fastapi import FastAPI
+from app.db import database # Base, engine
+from app.routers import user, llm
+
+#Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="OpenGenAI",
+    description="Your Excellect AI Physician", docs_url="/")
+
+
+app.include_router(llm.router)
+app.include_router(user.router)

requirements.txt

@@ -1,6 +1,56 @@
-fastapi
-uvicorn[standard]
-llama_cpp_python[server]==0.2.59
-huggingface-hub
-transformers
-tensorflow[and-cuda]
+annotated-types==0.6.0
+anyio==4.3.0
+certifi==2024.2.2
+cffi==1.16.0
+charset-normalizer==3.3.2
+click==8.1.7
+cryptography==42.0.5
+diskcache==5.6.3
+dnspython==2.6.1
+email_validator==2.1.1
+exceptiongroup==1.2.0
+fastapi==0.110.1
+filelock==3.13.4
+fsspec==2024.3.1
+greenlet==3.0.3
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+huggingface-hub==0.22.2
+idna==3.7
+itsdangerous==2.1.2
+Jinja2==3.1.3
+jwt==1.3.1
+llama_cpp_python==0.2.61
+MarkupSafe==2.1.5
+numpy==1.26.4
+orjson==3.10.0
+packaging==24.0
+passlib==1.7.4
+pycparser==2.22
+pydantic==2.7.0
+pydantic-extra-types==2.6.0
+pydantic-settings==2.2.1
+pydantic_core==2.18.1
+python-dotenv==1.0.1
+python-multipart==0.0.9
+PyYAML==6.0.1
+regex==2023.12.25
+requests==2.31.0
+safetensors==0.4.2
+sniffio==1.3.1
+SQLAlchemy==2.0.29
+starlette==0.37.2
+tokenizers==0.15.2
+tqdm==4.66.2
+transformers==4.39.3
+typing_extensions==4.11.0
+ujson==5.9.0
+urllib3==2.2.1
+uvicorn==0.29.0
+uvloop==0.19.0
+watchfiles==0.21.0
+websockets==12.0
+tensorflow
+pytorch