Initialized schema and fastapi app

backend/__init__.py

@@ -0,0 +1,52 @@
+import mysql.connector
+from mysql.connector import errorcode
+
+from fastapi import FastAPI, status
+from fastapi.exceptions import HTTPException
+
+from backend.utils import DBConnection
+
+from langchain.llms import CTransformers
+from langchain.chains import LLMChain
+from langchain import PromptTemplate 
+
+app = FastAPI(title="DocGup-Tea",
+              version="V0.0.1",
+              description="API for automatic code documentation generation!"
+              )
+
+from backend import router
+
+try:
+    dbconnection = DBConnection()
+    test_conn = DBConnection.get_client().get_server_info()
+
+    # send prompt codellama-13b-instruct-GGUF model
+    with open("docguptea/utils/prompt.txt",'r') as f:
+        prompt = f.read()
+        print(prompt)
+
+    prompt = PromptTemplate(template=prompt,
+                            input_variables=['query'])
+    
+    llm = CTransformers(
+        model = "docguptea/static/models/codellama-13b-instruct.Q4_K_M.gguf",
+        model_type="llama",
+        max_new_tokens = 1096,
+        temperature = 0.25,
+        repetition_penalty = 1.13,
+        stream=True,
+        gpu_layers = 10,
+    )
+
+    llmchain = LLMChain(
+        prompt=prompt,
+        llm=llm
+    )
+
+    app.state.llmchain = llmchain
+
+except mysql.connector.Error as err:
+    raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(err))    
+
+

backend/models/__init__.py

@@ -0,0 +1,3 @@
+from .auth import *
+from .generic import *
+from .inference import *

backend/models/auth.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field, EmailStr
+from typing import Union, List, Tuple
+
+from .generic import Base
+
+
+class TokenSchema(Base):
+    access_token: str
+    refresh_token: str
+
+
+class UserAuth(Base):
+    username: str = Field(..., description="username")
+    password: str = Field(..., min_length=5, max_length=24, description="user password")
+    email: EmailStr
+
+
+class User(Base):
+    username: str
+    email: EmailStr
+
+class TokenPayload(Base):
+    sub: str = None
+    exp: int = None
+
+
+class LoginCreds(Base):
+    username: str
+    password: str
+
+class APIKey(Base):
+    api_key: str

backend/models/generic.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import List
+
+
+class Base(BaseModel):
+    @classmethod
+    def get_instance(cls, **kwargs):
+        return cls(**kwargs)
+
+
+class GeneralResponse(Base):
+    status:str
+    message: List[str]
+    data:dict

backend/models/inference.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+from typing import List
+from .generic import Base
+
+class Inference(Base):
+    docstr:str

backend/router.py

@@ -0,0 +1,65 @@
+from fastapi import Request, Depends, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+
+from docguptea import app
+from docguptea.utils import DBConnection
+from docguptea.models import *
+from docguptea.services.auth import *
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/api/response_check", tags=["Resource Server"])
+def api_response_check():
+    response_result = GeneralResponse.get_instance(data={},
+                                      status="not_allowed",
+                                      message=["Not authenticated"]
+                                      )
+
+    try:
+        db_msg = ""
+        if DBConnection.is_connected():
+            db_msg = "Connection Successful to db!"
+        else:
+            db_msg = "Connection failed to db"
+
+        response_result.message.append(db_msg)
+
+    except Exception as e:
+        print("Exception :", e)
+
+    return response_result
+
+@app.post("/auth/signup", summary="Creates new user account", response_model=GeneralResponse, tags=["Auth Server"])
+async def signup(response: UserAuth):
+    response_result = GeneralResponse.get_instance(data={},
+                                      status="not_allowed",
+                                      message=["Not authenticated"]
+                                      )
+    ops_signup(response_result, response)
+
+    return response_result
+
+@app.post("/auth/login", summary="Logs in user", response_model=TokenSchema, tags=["Auth Server"])
+async def login(response:LoginCreds):
+    return ops_login(response)
+
+@app.put("/auth/regenerate_api_key",summary="Forget Password",response_model=APIKey,tags=["Auth Server"],dependencies=[Depends(JWTBearer())])
+async def regenerate_api_key(access_token: str = Depends(JWTBearer())):
+    user_sub=Auth.get_user_credentials(access_token)
+
+    return ops_regenerate_api_key(user_sub)
+
+@app.post("/api/inference", summary="Inference", response_model=Inference, tags=["Resource Server"], dependencies=[Depends(JWTBearer())])
+async def inference(code_block:str, api_key: str,access_token:str=Depends(JWTBearer())):
+    user_sub=Auth.get_user_credentials(access_token)
+
+    print("after res")
+    
+    return ops_inference(code_block,api_key,user_sub)

requirements.txt

@@ -0,0 +1,2 @@
+streamlit
+fastapi