Added endpoints for graph

app.py

@@ -1,5 +1,8 @@
 import io
 import tempfile
+from ipaddress import ip_address
+from typing import Optional
+
 import jwt
 import base64
 import json
@@ -8,7 +11,7 @@ from jwt import ExpiredSignatureError, InvalidTokenError
 from starlette import status
 from functions import *
 import pandas as pd
-from fastapi import FastAPI, File, UploadFile, HTTPException,Request
+from fastapi import FastAPI, File, UploadFile, HTTPException, Request, Query
 from pydantic import BaseModel
 from fastapi.middleware.cors import CORSMiddleware
 from src.api.speech_api import speech_translator_router
@@ -19,8 +22,6 @@ from collections import Counter, defaultdict
 from datetime import datetime, timedelta
 from dateutil.parser import isoparse
 
-
-
 nltk.download('punkt_tab')
 
 app = FastAPI(title="ConversAI", root_path="/api/v1")
@@ -265,15 +266,15 @@ async def loadPDF(vectorstore: str, pdf: UploadFile = File(...)):
         "output": text,
         "source": source
     }
-    dct = json.dumps(dct, indent = 1).encode("utf-8")
-    fileName = createDataSourceName(sourceName = source)
+    dct = json.dumps(dct, indent=1).encode("utf-8")
+    fileName = createDataSourceName(sourceName=source)
     response = supabase.storage.from_("ConversAI").upload(file=dct, path=f"{fileName}_data.json")
     response = (
         supabase.table("ConversAI_ChatbotDataSources")
-        .insert({"username": username, 
-                 "chatbotName": chatbotName, 
-                 "dataSourceName": fileName, 
-                 "sourceEndpoint": "/loadPDF", 
+        .insert({"username": username,
+                 "chatbotName": chatbotName,
+                 "dataSourceName": fileName,
+                 "sourceEndpoint": "/loadPDF",
                  "sourceContentURL": os.path.join(os.environ["SUPABASE_PUBLIC_BASE_URL"], f"{fileName}_data.json")})
         .execute()
     )
@@ -282,7 +283,6 @@ async def loadPDF(vectorstore: str, pdf: UploadFile = File(...)):
     }
 
 
-
 @app.post("/loadImagePDF")
 async def loadImagePDF(vectorstore: str, pdf: UploadFile = File(...)):
     username, chatbotName = vectorstore.split("$")[1], vectorstore.split("$")[2]
@@ -293,15 +293,15 @@ async def loadImagePDF(vectorstore: str, pdf: UploadFile = File(...)):
         "output": text,
         "source": source
     }
-    dct = json.dumps(dct, indent = 1).encode("utf-8")
-    fileName = createDataSourceName(sourceName = source)
+    dct = json.dumps(dct, indent=1).encode("utf-8")
+    fileName = createDataSourceName(sourceName=source)
     response = supabase.storage.from_("ConversAI").upload(file=dct, path=f"{fileName}_data.json")
     response = (
         supabase.table("ConversAI_ChatbotDataSources")
-        .insert({"username": username, 
-                 "chatbotName": chatbotName, 
-                 "dataSourceName": fileName, 
-                 "sourceEndpoint": "/loadImagePDF", 
+        .insert({"username": username,
+                 "chatbotName": chatbotName,
+                 "dataSourceName": fileName,
+                 "sourceEndpoint": "/loadImagePDF",
                  "sourceContentURL": os.path.join(os.environ["SUPABASE_PUBLIC_BASE_URL"], f"{fileName}_data.json")})
         .execute()
     )
@@ -310,7 +310,6 @@ async def loadImagePDF(vectorstore: str, pdf: UploadFile = File(...)):
     }
 
 
-
 class AddText(BaseModel):
     vectorstore: str
     text: str
@@ -324,15 +323,15 @@ async def loadText(addTextConfig: AddText):
         "output": text,
         "source": "Text"
     }
-    dct = json.dumps(dct, indent = 1).encode("utf-8")
-    fileName = createDataSourceName(sourceName = "Text")
+    dct = json.dumps(dct, indent=1).encode("utf-8")
+    fileName = createDataSourceName(sourceName="Text")
     response = supabase.storage.from_("ConversAI").upload(file=dct, path=f"{fileName}_data.json")
     response = (
         supabase.table("ConversAI_ChatbotDataSources")
-        .insert({"username": username, 
-                 "chatbotName": chatbotName, 
-                 "dataSourceName": fileName, 
-                 "sourceEndpoint": "/loadText", 
+        .insert({"username": username,
+                 "chatbotName": chatbotName,
+                 "dataSourceName": fileName,
+                 "sourceEndpoint": "/loadText",
                  "sourceContentURL": os.path.join(os.environ["SUPABASE_PUBLIC_BASE_URL"], f"{fileName}_data.json")})
         .execute()
     )
@@ -366,7 +365,6 @@ async def addQAPairData(addQaPair: AddQAPair):
         }
 
 
-
 class LoadWebsite(BaseModel):
     vectorstore: str
     urls: list[str]
@@ -377,20 +375,20 @@ class LoadWebsite(BaseModel):
 async def loadWebURLs(loadWebsite: LoadWebsite):
     vectorstore, urls, source = loadWebsite.vectorstore, loadWebsite.urls, loadWebsite.source
     username, chatbotName = vectorstore.split("$")[1], vectorstore.split("$")[2]
-    text = extractTextFromUrlList(urls=urls)    
+    text = extractTextFromUrlList(urls=urls)
     dct = {
         "output": text,
         "source": source
     }
-    dct = json.dumps(dct, indent = 1).encode("utf-8")
-    fileName = createDataSourceName(sourceName = source)
+    dct = json.dumps(dct, indent=1).encode("utf-8")
+    fileName = createDataSourceName(sourceName=source)
     response = supabase.storage.from_("ConversAI").upload(file=dct, path=f"{fileName}_data.json")
     response = (
         supabase.table("ConversAI_ChatbotDataSources")
-        .insert({"username": username, 
-                 "chatbotName": chatbotName, 
-                 "dataSourceName": fileName, 
-                 "sourceEndpoint": "/loadWebURLs", 
+        .insert({"username": username,
+                 "chatbotName": chatbotName,
+                 "dataSourceName": fileName,
+                 "sourceEndpoint": "/loadWebURLs",
                  "sourceContentURL": os.path.join(os.environ["SUPABASE_PUBLIC_BASE_URL"], f"{fileName}_data.json")})
         .execute()
     )
@@ -399,15 +397,19 @@ async def loadWebURLs(loadWebsite: LoadWebsite):
     }
 
 
-
 @app.post("/answerQuery")
-async def answerQuestion(query: str, vectorstore: str, llmModel: str = "llama3-70b-8192"):
+async def answerQuestion(request: Request, query: str, vectorstore: str, llmModel: str = "llama3-70b-8192"):
     username, chatbotName = vectorstore.split("$")[1], vectorstore.split("$")[2]
     output = answerQuery(query=query, vectorstore=vectorstore, llmModel=llmModel)
+    ip_address = request.client.host
+    response_token_count = len(output["output"])
+    city = get_ip_info(ip_address)
+
     response = (
         supabase.table("ConversAI_ChatHistory")
         .insert({"username": username, "chatbotName": chatbotName, "llmModel": llmModel, "question": query,
-                 "response": output["output"]})
+                 "response": output["output"], "IpAddress": ip_address, "ResponseTokenCount": response_token_count,
+                 "vectorstore": vectorstore, "City": city})
         .execute()
     )
     return output
@@ -456,15 +458,15 @@ async def loadYoutubeTranscript(ytTranscript: YtTranscript):
         "output": text,
         "source": "www.youtube.com"
     }
-    dct = json.dumps(dct, indent = 1).encode("utf-8")
-    fileName = createDataSourceName(sourceName = "youtube")
+    dct = json.dumps(dct, indent=1).encode("utf-8")
+    fileName = createDataSourceName(sourceName="youtube")
     response = supabase.storage.from_("ConversAI").upload(file=dct, path=f"{fileName}_data.json")
     response = (
         supabase.table("ConversAI_ChatbotDataSources")
-        .insert({"username": username, 
-                 "chatbotName": chatbotName, 
-                 "dataSourceName": fileName, 
-                 "sourceEndpoint": "/getYoutubeTranscript", 
+        .insert({"username": username,
+                 "chatbotName": chatbotName,
+                 "dataSourceName": fileName,
+                 "sourceEndpoint": "/getYoutubeTranscript",
                  "sourceContentURL": os.path.join(os.environ["SUPABASE_PUBLIC_BASE_URL"], f"{fileName}_data.json")})
         .execute()
     )
@@ -506,7 +508,8 @@ async def chatHistory(vectorstore: str):
 @app.post("/listChatbotSources")
 async def listChatbotSources(vectorstore: str):
     username, chatbotName = vectorstore.split("$")[1], vectorstore.split("$")[2]
-    result = supabase.table("ConversAI_ChatbotDataSources").select("*").eq("username", username).eq("chatbotName", chatbotName).execute().data
+    result = supabase.table("ConversAI_ChatbotDataSources").select("*").eq("username", username).eq("chatbotName",
+                                                                                                    chatbotName).execute().data
     return result
 
 
@@ -520,14 +523,18 @@ async def trainChatbot(trainChatbotConfig: TrainChatbot):
     vectorstore, UrlSources = trainChatbotConfig.vectorstore, trainChatbotConfig.urls
     texts = []
     sources = []
-    fileTypes = [supabase.table("ConversAI_ChatbotDataSources").select("sourceEndpoint").eq("sourceContentURL", x).execute().data[0]["sourceEndpoint"] for x in UrlSources]
+    fileTypes = [supabase.table("ConversAI_ChatbotDataSources").select("sourceEndpoint").eq("sourceContentURL",
+                                                                                            x).execute().data[0][
+                     "sourceEndpoint"] for x in UrlSources]
     for source, fileType in zip(UrlSources, fileTypes):
         if ((fileType == "/loadPDF") | (fileType == "/loadImagePDF")):
             r = requests.get(source)
             file = eval(r.content.decode("utf-8"))
             content = file["output"]
             fileSource = file["source"]
-            texts.append(".".join([base64.b64decode(content[key].encode("utf-8")).decode("utf-8") for key in content.keys()]).replace("\n", " "))
+            texts.append(".".join(
+                [base64.b64decode(content[key].encode("utf-8")).decode("utf-8") for key in content.keys()]).replace(
+                "\n", " "))
             sources.append(fileSource)
         elif fileType == "/loadText":
             r = requests.get(source)
@@ -541,9 +548,188 @@ async def trainChatbot(trainChatbotConfig: TrainChatbot):
             file = eval(r.content.decode("utf-8"))
             content = file["output"]
             fileSource = file["source"]
-            texts.append(".".join([base64.b64decode(content[key].encode("utf-8")).decode("utf-8") for key in content.keys()]).replace("\n", " "))
+            texts.append(".".join(
+                [base64.b64decode(content[key].encode("utf-8")).decode("utf-8") for key in content.keys()]).replace(
+                "\n", " "))
             sources.append(fileSource)
         else:
             pass
     texts = [(text, source) for text, source in zip(texts, sources)]
-    return addDocuments(texts = texts, vectorstore = vectorstore)        
+    return addDocuments(texts=texts, vectorstore=vectorstore)
+
+
+def get_ip_info(ip: str):
+    try:
+        response = requests.get(f"https://ipinfo.io/{ip}/json")
+        data = response.json()
+        return data.get("city", "Unknown")
+    except Exception as e:
+        return "Unknown"
+
+
+@app.post("/daily_chat_count")
+async def daily_chat_count(
+        start_date: Optional[str] = Query(None, description="Start date in ISO format (YYYY-MM-DD)"),
+        end_date: Optional[str] = Query(None, description="End date in ISO format (YYYY-MM-DD)")
+):
+    if not start_date or not end_date:
+        end_date = datetime.now().astimezone().date()
+        start_date = end_date - timedelta(days=7)
+    else:
+        start_date = isoparse(start_date).date()
+        end_date = isoparse(end_date).date()
+
+    response = supabase.table("ConversAI_ChatHistory").select("*").execute().data
+
+    dates = [
+        isoparse(i["timestamp"]).date()
+        for i in response
+        if start_date <= isoparse(i["timestamp"]).date() <= end_date
+    ]
+
+    date_count = Counter(dates)
+
+    data = [{"date": date.isoformat(), "count": count} for date, count in date_count.items()]
+
+    return {"data": data}
+
+
+@app.post("/daily_active_end_user")
+async def daily_active_end_user(
+        start_date: Optional[str] = Query(None, description="Start date in ISO format (YYYY-MM-DD)"),
+        end_date: Optional[str] = Query(None, description="End date in ISO format (YYYY-MM-DD)")
+):
+    if not start_date or not end_date:
+        end_date = datetime.now().astimezone().date()
+        start_date = end_date - timedelta(days=7)
+    else:
+        start_date = isoparse(start_date).date()
+        end_date = isoparse(end_date).date()
+
+    response = supabase.table("ConversAI_ChatHistory").select("*").execute().data
+
+    ip_by_date = defaultdict(set)
+
+    for i in response:
+        timestamp = isoparse(i["timestamp"])
+        ip_address = i["IpAddress"]
+        if start_date <= timestamp.date() <= end_date:
+            date = timestamp.date()
+            ip_by_date[date].add(ip_address)
+
+    data = [{"date": date.isoformat(), "terminal": len(ips)} for date, ips in ip_by_date.items() if len(ips) > 1]
+
+    return {"data": data}
+
+
+@app.post("/average_session_interaction")
+async def average_session_interaction(
+        start_date: Optional[str] = Query(None, description="Start date in ISO format (YYYY-MM-DD)"),
+        end_date: Optional[str] = Query(None, description="End date in ISO format (YYYY-MM-DD)")
+):
+    if not start_date or not end_date:
+        end_date = datetime.now().astimezone().date()
+        start_date = end_date - timedelta(days=7)
+    else:
+        start_date = isoparse(start_date).date()
+        end_date = isoparse(end_date).date()
+
+    response = supabase.table("ConversAI_ChatHistory").select("*").execute().data
+
+    total_messages_by_date = defaultdict(int)
+    unique_ips_by_date = defaultdict(set)
+
+    for i in response:
+        timestamp = isoparse(i["timestamp"])
+        ip_address = i["IpAddress"]
+        if start_date <= timestamp.date() <= end_date:
+            date = timestamp.date()
+            total_messages_by_date[date] += 1
+            unique_ips_by_date[date].add(ip_address)
+
+    data = []
+    for date in sorted(total_messages_by_date.keys()):
+        total_messages = total_messages_by_date[date]
+        unique_ips = len(unique_ips_by_date[date])
+        average_interactions = total_messages / unique_ips if unique_ips > 0 else 0
+        data.append({"date": date.isoformat(), "interactions": average_interactions})
+
+    return {"data": data}
+
+
+@app.post("/token_usages")
+async def token_usages(
+        start_date: Optional[str] = Query(None, description="Start date in ISO format (YYYY-MM-DD)"),
+        end_date: Optional[str] = Query(None, description="End date in ISO format (YYYY-MM-DD)")
+):
+    if not start_date or not end_date:
+        end_date = datetime.now().astimezone().date()
+        start_date = end_date - timedelta(days=7)
+    else:
+        start_date = isoparse(start_date).date()
+        end_date = isoparse(end_date).date()
+
+    response = supabase.table("ConversAI_ChatHistory").select("*").execute().data
+
+    token_usage_by_date = defaultdict(int)
+
+    for i in response:
+        timestamp = isoparse(i["timestamp"])
+        if start_date <= timestamp.date() <= end_date:
+            date = timestamp.date()
+            response_token_count = i.get("ResponseTokenCount")
+            if response_token_count is not None:
+                token_usage_by_date[date] += response_token_count
+
+    data = [{"date": date.isoformat(), "total_tokens": total_tokens} for date, total_tokens in
+            token_usage_by_date.items()]
+
+    return {"data": data}
+
+
+@app.post("/add_feedback")
+async def add_feedback(request: Request, feedback: str, user_id: str):
+    client_ip = request.client.host
+    city = get_ip_info(client_ip)
+
+    response = supabase.table("ConversAI_Feedback").insert(
+        {"feedback": feedback, "user_id": user_id, "city": city, "ip": client_ip}).execute()
+
+    return {"message": "success"}
+
+
+@app.post("/user_satisfaction_rate")
+async def user_satisfaction_rate(
+        start_date: Optional[str] = Query(None, description="Start date in ISO format (YYYY-MM-DD)"),
+        end_date: Optional[str] = Query(None, description="End date in ISO format (YYYY-MM-DD)")
+):
+    if not start_date or not end_date:
+        end_date = datetime.now().astimezone().date()
+        start_date = end_date - timedelta(days=7)
+    else:
+        start_date = isoparse(start_date).date()
+        end_date = isoparse(end_date).date()
+
+    response = supabase.table("ConversAI_Feedback").select("*").execute().data
+
+    feedback_counts = defaultdict(lambda: {"like": 0, "dislike": 0})
+
+    for i in response:
+        timestamp = isoparse(i["timestamp"])
+        if start_date <= timestamp.date() <= end_date:
+            date = timestamp.date()
+            feedback = i.get("feedback")
+            if feedback == "like":
+                feedback_counts[date]["like"] += 1
+            elif feedback == "dislike":
+                feedback_counts[date]["dislike"] += 1
+
+    data = []
+    for date in sorted(feedback_counts.keys()):
+        like_count = feedback_counts[date]["like"]
+        dislike_count = feedback_counts[date]["dislike"]
+        total_feedback = like_count + dislike_count
+        satisfaction_rate = (like_count / total_feedback * 100) if total_feedback > 0 else 0
+        data.append({"date": date.isoformat(), "rate": satisfaction_rate})
+
+    return {"data": data}