github/privateGPT
1
0
Fork 1
mirror of https://github.com/imartinez/privateGPT.git synced 2025-08-17 15:06:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated with docker file"

Browse Source
This commit is contained in:
Saurab-Shrestha 2024-05-07 13:03:43 +05:45
parent e1e940bbbd
commit 333a3f3913
7 changed files with 148 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
local_data/.gitignore vendored
View File

@ -1,2 +1,3 @@
* *
/private_gpt/
!.gitignore !.gitignore

3
private_gpt/server/completions/completions_router.py
View File

@ -118,9 +118,10 @@ def create_chat_item(db, sender, content, conversation_id):
content=content, content=content,
conversation_id=conversation_id conversation_id=conversation_id
) )
chat_history = crud.chat.get_conversation(db, conversation_id=conversation_id)
chat_history.generate_title()
return crud.chat_item.create(db, obj_in=chat_item_create) return crud.chat_item.create(db, obj_in=chat_item_create)
@completions_router.post( @completions_router.post(
"/chat", "/chat",
response_model=None, response_model=None,

16
private_gpt/users/api/v1/routers/audits.py
View File

@ -44,10 +44,10 @@ def list_auditlog(
def filter_auditlog( def filter_auditlog(
db: Session = Depends(deps.get_db), db: Session = Depends(deps.get_db),
filter_in= Depends(schemas.AuditFilter), filter_in= Depends(schemas.AuditFilter),
current_user: models.User = Security( # current_user: models.User = Security(
deps.get_current_user, # deps.get_current_user,
scopes=[Role.SUPER_ADMIN["name"]], # scopes=[Role.SUPER_ADMIN["name"]],
), # ),
) -> List[schemas.Audit]: ) -> List[schemas.Audit]:
logs = crud.audit.filter(db, obj_in=filter_in) logs = crud.audit.filter(db, obj_in=filter_in)
return convert_audit_logs(db, logs) return convert_audit_logs(db, logs)
@ -56,10 +56,10 @@ def filter_auditlog(
def download_auditlog( def download_auditlog(
db: Session = Depends(deps.get_db), db: Session = Depends(deps.get_db),
filter_in= Depends(schemas.ExcelFilter), filter_in= Depends(schemas.ExcelFilter),
current_user: models.User = Security( # current_user: models.User = Security(
deps.get_current_user, # deps.get_current_user,
scopes=[Role.SUPER_ADMIN["name"]], # scopes=[Role.SUPER_ADMIN["name"]],
), # ),
): ):
logs = crud.audit.excel_filter(db, obj_in=filter_in) logs = crud.audit.excel_filter(db, obj_in=filter_in)
username = filter_in.username if filter_in.username else None username = filter_in.username if filter_in.username else None

252
private_gpt/users/api/v1/routers/chat_history.py
View File

@ -1,126 +1,126 @@
import logging import logging
import traceback import traceback
import uuid import uuid
from sqlalchemy.orm import Session from sqlalchemy.orm import Session
from fastapi.responses import JSONResponse from fastapi.responses import JSONResponse
from fastapi import APIRouter, Depends, HTTPException, status, Security from fastapi import APIRouter, Depends, HTTPException, status, Security
from fastapi_pagination import Page, paginate from fastapi_pagination import Page, paginate
from private_gpt.users.api import deps from private_gpt.users.api import deps
from private_gpt.users import crud, models, schemas from private_gpt.users import crud, models, schemas
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
router = APIRouter(prefix="/c", tags=["Chat Histories"]) router = APIRouter(prefix="/c", tags=["Chat Histories"])
@router.get("", response_model=Page[schemas.Chat]) @router.get("", response_model=Page[schemas.Chat])
def list_chat_histories( def list_chat_histories(
db: Session = Depends(deps.get_db), db: Session = Depends(deps.get_db),
current_user: models.User = Security( current_user: models.User = Security(
deps.get_current_user, deps.get_current_user,
), ),
) -> Page[schemas.Chat]: ) -> Page[schemas.Chat]:
""" """
Retrieve a list of chat histories with pagination support. Retrieve a list of chat histories with pagination support.
""" """
try: try:
chat_histories = crud.chat.get_chat_history( chat_histories = crud.chat.get_chat_history(
db, user_id=current_user.id) db, user_id=current_user.id)
return paginate(chat_histories) return paginate(chat_histories)
except Exception as e: except Exception as e:
print(traceback.format_exc()) print(traceback.format_exc())
logger.error(f"Error listing chat histories: {str(e)}") logger.error(f"Error listing chat histories: {str(e)}")
raise HTTPException( raise HTTPException(
status_code=500, status_code=500,
detail="Internal Server Error", detail="Internal Server Error",
) )
@router.post("/create", response_model=schemas.ChatHistory) @router.post("/create", response_model=schemas.ChatHistory)
def create_chat_history( def create_chat_history(
db: Session = Depends(deps.get_db), db: Session = Depends(deps.get_db),
current_user: models.User = Security( current_user: models.User = Security(
deps.get_current_user, deps.get_current_user,
), ),
) -> schemas.ChatHistory: ) -> schemas.ChatHistory:
""" """
Create a new chat history Create a new chat history
""" """
try: try:
chat_history_in = schemas.CreateChatHistory( chat_history_in = schemas.CreateChatHistory(
user_id= current_user.id user_id= current_user.id
) )
chat_history = crud.chat.create( chat_history = crud.chat.create(
db=db, obj_in=chat_history_in) db=db, obj_in=chat_history_in)
return chat_history return chat_history
except Exception as e: except Exception as e:
print(traceback.format_exc()) print(traceback.format_exc())
logger.error(f"Error creating chat history: {str(e)}") logger.error(f"Error creating chat history: {str(e)}")
raise HTTPException( raise HTTPException(
status_code=500, status_code=500,
detail="Internal Server Error", detail="Internal Server Error",
) )
@router.get("/{conversation_id}", response_model=schemas.ChatHistory) @router.get("/{conversation_id}", response_model=schemas.ChatHistory)
def read_chat_history( def read_chat_history(
conversation_id: uuid.UUID, conversation_id: uuid.UUID,
skip: int = 0, skip: int = 0,
limit: int = 20, limit: int = 20,
db: Session = Depends(deps.get_db), db: Session = Depends(deps.get_db),
current_user: models.User = Security( current_user: models.User = Security(
deps.get_current_user, deps.get_current_user,
), ),
) -> schemas.ChatHistory: ) -> schemas.ChatHistory:
""" """
Read a chat history by ID Read a chat history by ID
""" """
try: try:
chat_history = crud.chat.get_by_id(db, id=conversation_id, skip=skip, limit=limit) chat_history = crud.chat.get_by_id(db, id=conversation_id, skip=skip, limit=limit)
if chat_history is None or chat_history.user_id != current_user.id: if chat_history is None or chat_history.user_id != current_user.id:
raise HTTPException( raise HTTPException(
status_code=404, detail="Chat history not found") status_code=404, detail="Chat history not found")
return chat_history return chat_history
except Exception as e: except Exception as e:
print(traceback.format_exc()) print(traceback.format_exc())
logger.error(f"Error reading chat history: {str(e)}") logger.error(f"Error reading chat history: {str(e)}")
raise HTTPException( raise HTTPException(
status_code=500, status_code=500,
detail="Internal Server Error", detail="Internal Server Error",
) )
@router.post("/delete") @router.post("/delete")
def delete_chat_history( def delete_chat_history(
chat_history_in: schemas.ChatDelete, chat_history_in: schemas.ChatDelete,
db: Session = Depends(deps.get_db), db: Session = Depends(deps.get_db),
current_user: models.User = Security( current_user: models.User = Security(
deps.get_current_user, deps.get_current_user,
), ),
): ):
""" """
Delete a chat history by ID Delete a chat history by ID
""" """
try: try:
chat_history_id = chat_history_in.conversation_id chat_history_id = chat_history_in.conversation_id
chat_history = crud.chat.get_by_id(db, id=chat_history_id) chat_history = crud.chat.get_by_id(db, id=chat_history_id)
if chat_history is None or chat_history.user_id != current_user.id: if chat_history is None or chat_history.user_id != current_user.id:
raise HTTPException( raise HTTPException(
status_code=404, detail="Chat history not found") status_code=404, detail="Chat history not found")
crud.chat.remove(db=db, id=chat_history_id) crud.chat.remove(db=db, id=chat_history_id)
return JSONResponse( return JSONResponse(
status_code=status.HTTP_200_OK, status_code=status.HTTP_200_OK,
content={ content={
"message": "Chat history deleted successfully", "message": "Chat history deleted successfully",
}, },
) )
except Exception as e: except Exception as e:
print(traceback.format_exc()) print(traceback.format_exc())
logger.error(f"Error deleting chat history: {str(e)}") logger.error(f"Error deleting chat history: {str(e)}")
raise HTTPException( raise HTTPException(
status_code=500, status_code=500,
detail="Internal Server Error", detail="Internal Server Error",
) )

9
private_gpt/users/crud/chat_crud.py
View File

@ -28,7 +28,14 @@ class CRUDChat(CRUDBase[ChatHistory, ChatHistoryCreate, ChatHistoryCreate]):
.all() .all()
) )
return chat_history return chat_history
def get_conversation(self, db: Session, conversation_id: uuid.UUID) -> Optional[ChatHistory]:
return (
db.query(self.model)
.filter(ChatHistory.conversation_id == conversation_id)
.first()
)
def get_chat_history( def get_chat_history(
self, db: Session, *,user_id:int self, db: Session, *,user_id:int
) -> List[ChatHistory]: ) -> List[ChatHistory]:

3
private_gpt/users/models/chat.py
View File

@ -33,7 +33,8 @@ class ChatHistory(Base):
item for item in self.chat_items if item.sender == "user"] item for item in self.chat_items if item.sender == "user"]
if user_chat_items: if user_chat_items:
first_user_chat_item = user_chat_items[0] first_user_chat_item = user_chat_items[0]
self.title = first_user_chat_item.content[:30] print("Chat items: ", first_user_chat_item.content['text'])
self.title = first_user_chat_item.content['text'][:30]
else: else:
self.title = str(self.conversation_id) self.title = str(self.conversation_id)

1
private_gpt/users/schemas/chat.py
View File

@ -41,6 +41,7 @@ class ChatHistoryUpdate(ChatHistoryBase):
class Chat(BaseModel): class Chat(BaseModel):
conversation_id: uuid.UUID conversation_id: uuid.UUID
title: Optional[str]
class ChatHistory(ChatHistoryBase): class ChatHistory(ChatHistoryBase):
conversation_id: uuid.UUID conversation_id: uuid.UUID