UPLOAD

.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt ./
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ReviveAnalyticsPvtLtd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

analyticsHub/components/__init__.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass, field
+
+@dataclass
+class REPLManager:
+    manager: dict = field(default_factory=dict)
+replManager = REPLManager()

analyticsHub/components/codeGeneratorAgent.py

@@ -0,0 +1,31 @@
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from ..utils.functions import readYaml, getConfig
+from ..utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from ..utils.logger import logger
+import os
+
+class CodeGenerator:
+    def __init__(self):
+        logger.info("Initializing CodeGenerator.")
+        self.yamlPath = os.path.join(os.getcwd(), "params.yaml")
+        self.config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+
+    def getCodeGeneratorChain(self):
+        try:
+            logger.info("Constructing code generation chain.")
+            promptTemplate = readYaml(self.yamlPath)["codeGeneratorAgentPrompt"]
+            codeGeneratorPrompt = PromptTemplate.from_template(promptTemplate)
+            llm = ChatCerebras(
+                model=self.config.get("CODEGENERATOR", "model"),
+                temperature=self.config.getfloat("CODEGENERATOR", "temperature")
+            )
+            codeGeneratorParser = StrOutputParser()
+            codeGeneratorChain = RunnablePassthrough() | codeGeneratorPrompt | llm | codeGeneratorParser
+            logger.info("code generation chain constructed successfully.")
+            return codeGeneratorChain
+        except Exception as e:
+            logger.error(f"Error constructing code generation chain: {e}")
+            raise CustomException(e)

analyticsHub/components/failsafeAgent.py

@@ -0,0 +1,31 @@
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from ..utils.functions import readYaml, getConfig
+from ..utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from ..utils.logger import logger
+import os
+
+class FailsafeCodeGenerator:
+    def __init__(self):
+        logger.info("Initializing Failsafe.")
+        self.yamlPath = os.path.join(os.getcwd(), "params.yaml")
+        self.config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+
+    def getFailsafeCodeGeneratorChain(self):
+        try:
+            logger.info("Constructing failsafe code generation chain.")
+            promptTemplate = readYaml(self.yamlPath)["codeDebuggerAgentPrompt"]
+            codeGeneratorPrompt = PromptTemplate.from_template(promptTemplate)
+            llm = ChatCerebras(
+                model=self.config.get("FAILSAFECODEGENERATOR", "model"),
+                temperature=self.config.getfloat("FAILSAFECODEGENERATOR", "temperature")
+            )
+            codeGeneratorParser = StrOutputParser()
+            failsafeCodeGeneratorChain = RunnablePassthrough() | codeGeneratorPrompt | llm | codeGeneratorParser
+            logger.info("failsafe code generation chain constructed successfully.")
+            return failsafeCodeGeneratorChain
+        except Exception as e:
+            logger.error(f"Error constructing failsafe code generation chain: {e}")
+            raise CustomException(e)

analyticsHub/components/metadataGenerator.py

@@ -0,0 +1,33 @@
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnableLambda
+from ..utils.functions import readYaml, getConfig
+from ..utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from ..utils.logger import logger
+import os
+
+class MetadataGenerator:
+    def __init__(self):
+        logger.info("Initializing MetadataGenerator.")
+        self.yamlPath = os.path.join(os.getcwd(), "params.yaml")
+        self.config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+
+    def getMetadataChain(self):
+        try:
+            logger.info("Constructing metadata generation chain.")
+            promptTemplate = readYaml(self.yamlPath)["metadataGeneratorPrompt"]
+            prompt = ChatPromptTemplate.from_template(promptTemplate)
+            llm = ChatCerebras(
+                model=self.config.get("METADATAGENERATOR", "model"),
+                temperature=self.config.getfloat("METADATAGENERATOR", "temperature")
+            )
+            outputParser = StrOutputParser()
+            chain = {
+                "metadata": RunnableLambda(lambda x: x["metadata"])
+            } | prompt | llm | outputParser
+            logger.info("Metadata generation chain constructed successfully.")
+            return chain
+        except Exception as e:
+            logger.error(f"Error constructing metadata generation chain: {e}")
+            raise CustomException(e)

analyticsHub/components/queryRephraserAgent.py

@@ -0,0 +1,43 @@
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_core.prompts import PromptTemplate
+from ..utils.functions import readYaml, getConfig
+from ..utils.exceptions import CustomException
+from pydantic import Field, BaseModel
+from langchain_cerebras import ChatCerebras
+from ..utils.logger import logger
+import os
+
+class QueryRephraseOutput(BaseModel):
+    rephrasedOutput: str | None = Field(
+        description="A clear and concise rephrased version of the user's query. If the query is unclear, invalid, or requires clarification, this will be `None`."
+    )
+    doubt: str | None = Field(
+        description="A message indicating any doubt, required clarification, or reason why the input query is invalid. If the query is successfully rephrased, this will be `None`."
+    )
+
+class QueryRephaser:
+    def __init__(self):
+        logger.info("Initializing QueryRephaser.")
+        self.yamlPath = os.path.join(os.getcwd(), "params.yaml")
+        self.config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+
+    def getQueryRephraserChain(self):
+        try:
+            logger.info("Constructing query rephraser chain.")
+            queryRephraseParser = JsonOutputParser(pydantic_object = QueryRephraseOutput)
+            queryRephrasePrompt = PromptTemplate(
+                template = readYaml(self.yamlPath)["queryRephraserAgentPrompt"],
+                input_variables = ["metadata", "query"],
+                partial_variables = {"format_instructions": queryRephraseParser.get_format_instructions()}
+            )
+            llm = ChatCerebras(
+                model=self.config.get("QUERYREPHRASER", "model"),
+                temperature=self.config.getfloat("QUERYREPHRASER", "temperature"),
+                max_tokens=self.config.getint("QUERYREPHRASER", "maxTokens")
+            )
+            queryRephraseChain = queryRephrasePrompt | llm | queryRephraseParser
+            logger.info("Query rephraser chain constructed successfully.")
+            return queryRephraseChain
+        except Exception as e:
+            logger.error(f"Error constructing query rephraser chain: {e}")
+            raise CustomException(e)

analyticsHub/components/speechToText.py

@@ -0,0 +1,23 @@
+from ..utils.functions import readYaml, getConfig
+from ..utils.exceptions import CustomException
+from ..utils.logger import logger
+from groq import Groq
+import os
+
+class SpeechToText:
+    def __init__(self):
+        logger.info("Initializing speech-to-text Model.")
+        self.config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+        self.client = Groq()
+
+    def getTranscript(self, b64String = str) -> str:
+        try:
+            logger.info("generating transcript.")
+            transcription = self.client.audio.transcriptions.create(
+                url = f'data:audio/webm;base64,{b64String}',
+                model = self.config.get("SPEECHTOTEXT", "model")
+            )
+            return transcription.text.strip()
+        except Exception as e:
+            logger.error(f"Error constructing metadata generation chain: {e}")
+            raise CustomException(e)

analyticsHub/models/requestModels.py

@@ -0,0 +1,105 @@
+from pydantic import BaseModel
+
+class SignUp(BaseModel):
+    email: str
+    password: str
+
+class Login(BaseModel):
+    email: str
+    password: str
+
+class LoginWithProvider(BaseModel):
+    email: str
+    sub: str | None = None
+    id: str | None = None
+    nodeId: str | None = None
+    provider: str
+
+class OnboardingDetails(BaseModel):
+    usage: str
+    fullName: str
+    email: str
+    role: str
+    companyName: str
+    industryType: str
+    companySize: str
+    country: str
+    goals: str
+    source: str
+
+class NewCredentials(BaseModel):
+    newPassword: str
+
+class UpdateProjectState(BaseModel):
+    projectId: str
+    action: str
+
+class CreateProject(BaseModel):
+    projectName: str
+    projectDescription: str | None = None
+
+class GenerateChartInput(BaseModel):
+    inputQuery: str
+    projectId: str
+
+class SpeechToTextModel(BaseModel):
+    b64String: str
+
+class DeleteTable(BaseModel):
+    projectId: str
+    tableName: str
+
+class EditMetadata(BaseModel):
+    projectId: str
+    tableName: str
+    tableDescription: str | None = None
+    columnName: str | None = None
+    columnDescription: str | None = None
+
+class PanelChartDetails(BaseModel):
+    projectId: str
+    chartType: str
+    xAxis: str
+    yAxis: str
+    dataSource: str
+    aggregationMetric: str
+
+class CreateDataBlend(BaseModel):
+    projectId: str
+    blendOn: list[str]
+    blendName: str
+    tables: list[str]
+    joinTypes: list[str]
+
+class GetFieldsFromSources(BaseModel):
+    projectId: str
+    tableName: str
+
+class LoadMySQLorPostgreSQL(BaseModel):
+    projectId: str
+    user: str
+    password: str
+    host: str
+    port: int
+    db: str
+    table: str
+
+class LoadMongoDB(BaseModel):
+    projectId: str
+    connectionString: str
+    db: str
+    collection: str
+
+class CreatePage(BaseModel):
+    projectId: str
+    pageName: str
+
+class ExportToDashboard(BaseModel):
+    projectId: str
+    page: str
+    chartType: str
+    title: str
+    xLabels: list[str]
+    yLabels: list[str]
+    data: dict[str, list]
+    layout: dict[str, int]

analyticsHub/pipelines/pipeline.py

@@ -0,0 +1,78 @@
+from ..components.metadataGenerator import MetadataGenerator
+from ..workflows.reportingWorkflow import reportingToolWorkflow
+from ..components.speechToText import SpeechToText
+from ..utils.exceptions import CustomException
+from ..utils.functions import readYaml
+from ..components import replManager
+from supabase import create_client
+from urllib.request import urlopen
+from ..utils.logger import logger
+import orjson
+import os
+
+class CompletePipeline:
+    def __init__(self):
+        logger.info("Initializing CompletePipeline components.")
+        self.speechToTextModule = SpeechToText()
+        self.metadataGenerator = MetadataGenerator()
+        self.yamlPath = os.path.join(os.getcwd(), "params.yaml")
+        self.supabaseClient = create_client(
+            supabase_url = os.environ["SUPABASE_URL"],
+            supabase_key = os.environ["SUPABASE_KEY"]
+        )
+
+    def generateMetadata(self, projectId: str) -> dict:
+        try:
+            dataFiles = [x.get("name") for x in self.supabaseClient.storage.from_("AnalyticsHub").list(path = projectId) if x.get("name").endswith(".parquet")]
+            results = ""
+            for fileName in dataFiles:
+                dataframeName = fileName.replace(".parquet", "")
+                codeString = readYaml(self.yamlPath)["attributeInfoCode"].format(dataframeName = dataframeName, projectId = projectId)
+                results += replManager.manager[projectId].run(codeString)
+            metadataChain = self.metadataGenerator.getMetadataChain()
+            metadata = metadataChain.invoke({"metadata": results})
+            metadataParts = metadata.split("```")
+            metadata = metadataParts[-2]
+            metadata = orjson.loads("\n".join(metadata.split("\n")[1:]).encode())
+            return metadata
+        except Exception as e:
+            logger.error(CustomException(e))
+            raise CustomException(e)
+
+    def generateChart(self, inputQuery: str, metadata: dict, projectId: str) -> dict:
+        try:
+            response = reportingToolWorkflow.invoke({
+                "inputQuery": inputQuery,
+                "metadata": metadata,
+                "projectId": projectId
+            })
+            return response
+        except Exception as e:
+            logger.error(CustomException(e))
+            raise CustomException(e)
+        
+    def generateChartFromPanel(self, projectId: str, chartType: str, xAxis: str, yAxis: str, aggregationMetric: str, dataSource: str) -> dict:
+        try:
+            blendConfigUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "blendConfig.json").replace(".parquet", "")
+            blendConfig = orjson.loads(urlopen(blendConfigUrl).read())
+            blendedTables = list(blendConfig.keys())
+            if dataSource in blendedTables:
+                tablesUsed = blendConfig[dataSource].get("tables")
+                joinTypes = blendConfig[dataSource].get("joinTypes")
+                blendOn = blendConfig[dataSource].get("blendOn")
+                response = replManager.manager[projectId].run(f"getDataForChart(projectId='{projectId}', chartType='{chartType}', xAxis='{xAxis}', yAxis='{yAxis}', aggregationMetric='{aggregationMetric}', tablesUsed={tablesUsed}, joinTypes={joinTypes}, blendOn={blendOn})")
+            else:
+                response = replManager.manager[projectId].run(f"getDataForChart(projectId='{projectId}', chartType='{chartType}', xAxis='{xAxis}', yAxis='{yAxis}', aggregationMetric='{aggregationMetric}', tablesUsed='{dataSource}')")    
+            response = orjson.loads(response.encode())
+            return response
+        except Exception as e:
+            logger.error(CustomException(e))
+            raise CustomException(e)
+
+    def speechToText(self, b64String: str) -> str:
+        try:
+            return self.speechToTextModule.getTranscript(b64String = b64String)
+        except Exception as e:
+            logger.error(CustomException(e))
+            raise CustomException(e)
+        

analyticsHub/routers/__init__.py

@@ -0,0 +1,2 @@
+from ..pipelines.pipeline import CompletePipeline
+pipeline = CompletePipeline()

analyticsHub/routers/authentication.py

@@ -0,0 +1,245 @@
+from ..models.requestModels import SignUp, Login, LoginWithProvider, OnboardingDetails, NewCredentials
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi import APIRouter, HTTPException, Depends
+from supabase.lib.client_options import ClientOptions
+from fastapi.responses import JSONResponse
+from ..utils.functions import verifyToken
+from supabase import create_client
+from typing import Annotated
+from jose import jwt
+import pandas as pd
+import datetime
+import hashlib
+import os
+
+router = APIRouter()
+security = HTTPBearer()
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"],
+    options=ClientOptions(
+        auto_refresh_token=False,
+        persist_session=False,
+    )
+)
+
+@router.post("/signUp")
+async def signup(signupDetails: SignUp):
+    try:
+        passwordString = signupDetails.password + os.environ["SECRET_KEY"]
+        hashedPassword = hashlib.md5(passwordString.encode("utf-8")).hexdigest()
+        allUsers = list()
+        page = 1
+        while True:
+            response = client.auth.admin.list_users(page = page, per_page = 1000)
+            if response == []:
+                break
+            else:
+                allUsers.extend(response)
+                page += 1
+        allUsers = [x.email for x in allUsers]
+        if signupDetails.email not in allUsers:
+            response = client.auth.sign_up(
+                {"email": signupDetails.email, "password": hashedPassword}
+            )
+            client.table(table_name = "Users").insert(
+                {
+                    "userId": response.user.id,
+                    "email": signupDetails.email,
+                    "password": hashedPassword
+                }
+            ).execute()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "userId": response.user.id})
+        else:
+            return JSONResponse(status_code = 409, content = {"status": "ERROR", "errorDetail": "User Already Exists"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.get("/confirmMail/{userId}")
+async def confirmMail(userId: str):
+    try:
+        allUsers = list()
+        page = 1
+        while True:
+            response = client.auth.admin.list_users(page = page, per_page = 1000)
+            if response == []:
+                break
+            else:
+                allUsers.extend(response)
+                page += 1
+        email = list(filter(lambda x: True if x.id == userId else False, allUsers))[0].email
+        response = client.auth.resend({
+        "type": "signup",
+        "email": email,
+        "options": {
+            "email_redirect_to": "https://localhost:3000/login"
+        }
+        })
+        return JSONResponse(status_code = 200, content = {"status": "SUCCESS"}) 
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.post("/login")
+async def login(loginDetails: Login):
+    try:
+        passwordString = loginDetails.password + os.environ["SECRET_KEY"]
+        hashedPassword = hashlib.md5(passwordString.encode("utf-8")).hexdigest()
+        allUsers = list()
+        page = 1
+        while True:
+            response = client.auth.admin.list_users(page = page, per_page = 1000)
+            if response == []:
+                break
+            else:
+                allUsers.extend(response)
+                page += 1
+        filteredResult = list(filter(lambda x: True if x.email == loginDetails.email else False, allUsers))
+        if filteredResult == []:
+            return JSONResponse(status_code = 404, content = {"status": "ERROR", "errorDetail": "User not found"})
+        elif filteredResult[0].user_metadata.get("email_verified") == False:
+            return JSONResponse(status_code = 401, content = {"status": "ERROR", "errorDetail": "Email not verified"})
+        else:  
+            allData = pd.DataFrame(client.table("Users").select("userId", "email", "password", "onboarded").execute().data, columns = ["userId", "email", "password", "onboarded"])
+            dataSlice = allData[allData["email"] == loginDetails.email].iloc[0, :]
+            if dataSlice["password"] != hashedPassword:
+                return JSONResponse(status_code = 401, content = {"status": "ERROR", "errorDetail": "Invalid email or password"})
+            else:
+                sessionStartTime = str(datetime.datetime.utcnow())
+                dictItems = {
+                    "userId": dataSlice["userId"],
+                    "email": loginDetails.email,
+                    "password": hashedPassword,
+                    "sessionStartTime": sessionStartTime
+                }
+                accessToken = jwt.encode(dictItems, os.environ["SECRET_KEY"], "HS256")
+                client.table("Sessions").insert({
+                    "userId": dataSlice["userId"],
+                    "email": dataSlice["email"],
+                    "accessToken": accessToken,
+                    "sessionStartTime": sessionStartTime,
+                    "lastActivity": sessionStartTime
+                }).execute()
+                response = {
+                    "status": "SUCCESS",
+                    "userId": dataSlice["userId"],
+                    "email": dataSlice["email"],
+                    "accessToken": accessToken,
+                    "onboarded": int(dataSlice["onboarded"])
+                }
+                return JSONResponse(status_code = 200, content = response)
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/loginWithProvider")
+async def loginWithProvider(loginDetails: LoginWithProvider):
+    try:
+        passwordString = str(loginDetails.sub) + str(loginDetails.id) + str(loginDetails.nodeId) + os.environ["SECRET_KEY"]
+        hashedPassword = hashlib.md5(passwordString.encode("utf-8")).hexdigest()
+        registeredUsers = pd.DataFrame(client.table("Users").select("userId", "email", "password", "onboarded").execute().data, columns = ["userId", "email", "password", "onboarded"])
+        if loginDetails.email not in registeredUsers["email"].unique():
+            response = client.table(table_name = "Users").insert(
+                {
+                    "email": loginDetails.email,
+                    "password": hashedPassword
+                }
+            ).execute()
+            registeredUsers = pd.DataFrame(client.table("Users").select("userId", "email", "password", "onboarded").execute().data, columns = ["userId", "email", "password", "onboarded"])
+        else:
+            pass
+        dataSlice = registeredUsers[registeredUsers["email"] == loginDetails.email].iloc[0, :]
+        sessionStartTime = str(datetime.datetime.utcnow())
+        dictItems = {
+            "userId": dataSlice["userId"],
+            "email": loginDetails.email,
+            "password": hashedPassword,
+            "sessionStartTime": sessionStartTime
+        }
+        accessToken = jwt.encode(dictItems, os.environ["SECRET_KEY"], "HS256")
+        client.table("Sessions").insert({
+            "userId": dataSlice["userId"],
+            "email": dataSlice["email"],
+            "accessToken": accessToken,
+            "sessionStartTime": sessionStartTime,
+            "lastActivity": sessionStartTime
+        }).execute()
+        response = {
+            "status": "SUCCESS",
+            "userId": dataSlice["userId"],
+            "email": dataSlice["email"],
+            "accessToken": accessToken,
+            "onboarded": int(dataSlice["onboarded"])
+        }
+        return JSONResponse(status_code = 200, content = response)
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/onboarding")
+async def onboarding(onboardingDetails: OnboardingDetails, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            dataToUpdate = {
+                "onboarded": 1,
+                "usage": onboardingDetails.usage,
+                "fullName": onboardingDetails.fullName,
+                "role": onboardingDetails.role,
+                "companyName": onboardingDetails.companyName,
+                "industryType": onboardingDetails.industryType,
+                "companySize": onboardingDetails.companySize,
+                "country": onboardingDetails.country,
+                "goals": onboardingDetails.goals,
+                "source": onboardingDetails.source
+            }
+            response = client.table("Users").update(dataToUpdate).eq("email", onboardingDetails.email).execute()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "User onboarded successfully."})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})        
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.get("/initiatePasswordReset")
+async def initiatePasswordReset(emailId: str):
+    try:
+        client.auth.reset_password_for_email(
+            emailId,
+            {
+                "redirect_to": "http://localhost:3000/login/create-new-password"
+            }
+        )
+        return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Password reset initiated successfully."})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")    
+
+@router.patch("/resetPassword")
+async def resetPassword(email: str, newCredentials: NewCredentials):
+    try:
+        passwordString = newCredentials.newPassword + os.environ["SECRET_KEY"]
+        hashedPassword = hashlib.md5(passwordString.encode("utf-8")).hexdigest()
+        allUsers = list()
+        page = 1
+        while True:
+            response = client.auth.admin.list_users(page = page, per_page = 1000)
+            if response == []:
+                break
+            else:
+                allUsers.extend(response)
+                page += 1
+        filteredResult = list(filter(lambda x: True if x.email == email else False, allUsers))[0]
+        response = client.auth.admin.update_user_by_id(
+            filteredResult.id,
+            {"password": hashedPassword}
+        )
+        response = client.table("Users").update({"password": hashedPassword}).eq("email", email).execute()
+        return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Password updated successfully!"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.get("/logout")
+async def logout(credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            response = client.table("Sessions").delete().eq("accessToken", credentials.credentials).execute()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Session logged out successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/routers/blends.py

@@ -0,0 +1,118 @@
+from ..models.requestModels import CreateDataBlend, GetFieldsFromSources
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+from ..utils.functions import verifyToken
+from fastapi import APIRouter, Depends
+from urllib.request import urlopen
+from supabase import create_client
+from typing import Annotated
+import json
+import os
+import io
+
+router = APIRouter()
+security = HTTPBearer()
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+    
+@router.post("/createDataBlend")
+async def createDataBlend(blendDetails: CreateDataBlend, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            joinConfig = {
+                "tables": blendDetails.tables,
+                "blendOn": blendDetails.blendOn,
+                "joinTypes": blendDetails.joinTypes
+            }
+            project = client.table("Projects").select("projectId", "projectName", "dataTables").eq("projectId", blendDetails.projectId).execute().data[0]
+            if "blendConfig.json" in [x.get("name") for x in client.storage.from_("AnalyticsHub").list(path = blendDetails.projectId)]:
+                fileUrl = os.environ["FILE_URL"].format(projectId = blendDetails.projectId, fileName = "blendConfig.json").replace(".parquet", "")
+                blendConfig = json.loads(urlopen(fileUrl).read())
+                blendConfig[blendDetails.blendName] = joinConfig
+            else:
+                blendConfig = {blendDetails.blendName: joinConfig}
+            with io.BytesIO() as buffer:
+                buffer.write(json.dumps(blendConfig, indent=4).encode("utf-8"))
+                buffer.seek(0)
+                _ = client.storage.from_("AnalyticsHub").upload(path = f"{blendDetails.projectId}/blendConfig.json", file = buffer.getvalue(), file_options = {"upsert": "true"})
+            if blendDetails.blendName in project["dataTables"].split(", "):
+                pass
+            elif project["dataTables"]:
+                projectData = project["dataTables"] + f", {blendDetails.blendName}"
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", blendDetails.projectId).execute()
+            else:
+                projectData = blendDetails.blendName
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", blendDetails.projectId).execute()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Blend created successfully."})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})   
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.get("/getDataSources")
+async def getDataSources(projectId: str, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            if "blendConfig.json" in [x.get("name") for x in client.storage.from_("AnalyticsHub").list(path = projectId)]:
+                blendConfigUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "blendConfig.json").replace(".parquet", "")
+                blendConfig = json.loads(urlopen(blendConfigUrl).read())
+                blendedTables = list(blendConfig.keys())
+                blends = [
+                    {"blendName": x, "tables": blendConfig[x].get("tables"), "joinTypes": blendConfig[x].get("joinTypes"), "blendOn": blendConfig[x].get("blendOn")} for x in blendedTables
+                ]
+            else:
+                blends, blendedTables = list(), list()
+            metadataUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "metadata.json").replace(".parquet", "")
+            metadata = json.loads(urlopen(metadataUrl).read())
+            rawTables = list(metadata.keys())
+            dataSources = {
+                "blends": blends,
+                "rawTables": rawTables,
+                "blendedTables": blendedTables
+            }
+            return JSONResponse(status_code = 200, content = dataSources)
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})   
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.post("/getFieldsFromSources")
+async def getFieldsFromSources(details: GetFieldsFromSources, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            blendConfigUrl = os.environ["FILE_URL"].format(projectId = details.projectId, fileName = "blendConfig.json").replace(".parquet", "")
+            metadataUrl = os.environ["FILE_URL"].format(projectId = details.projectId, fileName = "metadata.json").replace(".parquet", "")
+            blendConfig = json.loads(urlopen(blendConfigUrl).read())
+            metadata = json.loads(urlopen(metadataUrl).read())
+            blendedTables = list(blendConfig.keys())
+            allFields = list()
+            if details.tableName in blendedTables:
+                tablesUsed = blendConfig[details.tableName].get("tables")
+                for table in tablesUsed:
+                    allFields.extend(metadata[table]["columns"])
+            else:
+                allFields = metadata[details.tableName]["columns"]
+            numericals = ["int64", "float64", "float32", "int32"]
+            categoricals = ["bool", "category", "object", "string"]
+            datetimeTypes = ["datetime64[ns]", "datetime64[ns, tz]"]
+            numericalColumns, categoricalColumns, datetimeColumns = list(), list(), list()
+            for column in allFields:
+                if column.get("type") in categoricals:
+                    categoricalColumns.append(column["name"])
+                elif column["type"] in numericals:
+                    numericalColumns.append(column["name"])
+                elif column["type"] in datetimeTypes:
+                    datetimeColumns.append(column["name"])
+            response = {
+                "numericalColumns": numericalColumns,
+                "categoricalColumns": categoricalColumns,
+                "datetimeColumns": datetimeColumns
+            } 
+            return JSONResponse(status_code = 200, content = response)
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})   
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/routers/dashboard.py

@@ -0,0 +1,104 @@
+from ..models.requestModels import CreatePage, ExportToDashboard
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+from ..utils.functions import verifyToken
+from fastapi import APIRouter, Depends
+from supabase import create_client
+from urllib.request import urlopen
+from typing import Annotated
+import uuid
+import json
+import os
+import io
+
+router = APIRouter()
+security = HTTPBearer()
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+
+@router.post("/createPage")
+async def createPage(details: CreatePage, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            pageId = str(uuid.uuid4())
+            if "dashboardConfig.json" in [x.get("name") for x in client.storage.from_("AnalyticsHub").list(path = details.projectId)]:
+                fileUrl = os.environ["FILE_URL"].format(projectId = details.projectId, fileName = "dashboardConfig.json").replace(".parquet", "")
+                dashboardConfig = json.loads(urlopen(fileUrl).read())
+                dashboardConfig[pageId] = {"name": details.pageName, "widgets": []}
+            else:
+                dashboardConfig = {pageId: {"name": details.pageName, "widgets": []}}
+            with io.BytesIO() as buffer:
+                buffer.write(json.dumps(dashboardConfig, indent=4).encode("utf-8"))
+                buffer.seek(0)
+                _ = client.storage.from_("AnalyticsHub").upload(path = f"{details.projectId}/dashboardConfig.json", file = buffer.getvalue(), file_options = {"upsert": "true"})            
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "pageId": pageId})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.get("/getAllPages")
+async def getAllPages(projectId: str, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            if "dashboardConfig.json" in [x.get("name") for x in client.storage.from_("AnalyticsHub").list(path = projectId)]:
+                fileUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "dashboardConfig.json").replace(".parquet", "")
+                dashboardConfig = json.loads(urlopen(fileUrl).read())
+                pages = [dashboardConfig[x]["name"] for x in dashboardConfig.keys()]
+            else:
+                pages = list()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "pages": pages})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/exportToDashboard")
+async def exportToDashboard(details: ExportToDashboard, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            fileUrl = os.environ["FILE_URL"].format(projectId = details.projectId, fileName = "dashboardConfig.json").replace(".parquet", "")
+            dashboardConfig = json.loads(urlopen(fileUrl).read())
+            for pageDict in dashboardConfig.values():
+                if pageDict.get("name") == details.page:
+                    pageDict = pageDict
+                else:
+                    continue
+            widgetId = str(uuid.uuid4())
+            newWidget = {
+                "id": widgetId,
+                "chartType": details.chartType,
+                "title": details.title,
+                "xLabels": details.xLabels,
+                "yLabels": details.yLabels,
+                "data": details.data,
+                "layout": details.layout
+            }
+            pageDict["widgets"].append(newWidget)
+            dashboardConfig[details.page] = pageDict
+            with io.BytesIO() as buffer:
+                buffer.write(json.dumps(dashboardConfig, indent=4).encode("utf-8"))
+                buffer.seek(0)
+                _ = client.storage.from_("AnalyticsHub").upload(path = f"{details.projectId}/dashboardConfig.json", file = buffer.getvalue(), file_options = {"upsert": "true"})       
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "widgetId": widgetId})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.get("/getData")
+async def getData(projectId: str, page: str, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            fileUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "dashboardConfig.json").replace(".parquet", "")
+            dashboardConfig = json.loads(urlopen(fileUrl).read())
+            pageInfo = dashboardConfig.get(page)
+            pageInfo["id"] = page
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "pageData": pageInfo})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/routers/dataLoader.py

@@ -0,0 +1,174 @@
+from ..models.requestModels import DeleteTable, LoadMySQLorPostgreSQL, LoadMongoDB
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi import APIRouter, Depends, UploadFile, File, Form
+from fastapi.exceptions import HTTPException
+from pymongo.mongo_client import MongoClient
+from fastapi.responses import JSONResponse
+from ..utils.functions import verifyToken
+from pymongo.server_api import ServerApi
+from sqlalchemy import create_engine
+from urllib.request import urlopen
+from supabase import create_client
+from fastapi import APIRouter
+import fireducks.pandas as pd
+from typing import Annotated
+import tempfile
+import json
+import io
+import os
+
+router = APIRouter()
+security = HTTPBearer()
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+
+@router.post("/loadCsvData")
+async def loadCsvData(projectId: Annotated[str, Form()], file: Annotated[UploadFile, File()], credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            project = client.table("Projects").select("projectId", "projectName", "dataTables").eq("projectId", projectId).execute().data[0]                
+            with tempfile.NamedTemporaryFile(delete = True, suffix = ".parquet") as temp:
+                pd.read_csv(io.BytesIO(await file.read())).to_parquet(temp.name, compression = "snappy")
+                _ = client.storage.from_("AnalyticsHub").upload(
+                    file = temp.name,
+                    path = f"{projectId}/{os.path.splitext(file.filename)[0] + '.parquet'}"
+                )
+                if project["dataTables"]:
+                    projectData = project["dataTables"] + f", {os.path.splitext(file.filename)[0]}"
+                else:
+                    projectData = os.path.splitext(file.filename)[0]
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", projectId).execute()
+                temp.close()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Data loaded successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/loadExcelData")
+async def loadExcelData(projectId: Annotated[str, Form()], file: Annotated[UploadFile, File()], credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)], sheetName: Annotated[str | None, Form()] = None):
+    try:
+        if verifyToken(token = credentials.credentials):
+            project = client.table("Projects").select("projectId", "projectName", "dataTables").eq("projectId", projectId).execute().data[0]                
+            with tempfile.NamedTemporaryFile(delete = True, suffix = ".parquet") as temp:
+                pd.read_excel(io.BytesIO(await file.read()), sheet_name = sheetName).to_parquet(temp.name, compression = "snappy")
+                if sheetName == None:
+                    fileName = f"{os.path.splitext(file.filename)[0] + '.parquet'}"
+                else:
+                    fileName = f"{os.path.splitext(file.filename)[0] + '_' + sheetName + '.parquet'}"
+                _ = client.storage.from_("AnalyticsHub").upload(
+                    file = temp.name,
+                    path = f"{projectId}/{fileName}"
+                )
+                if project["dataTables"]:
+                    projectData = project["dataTables"] + f", {fileName}"
+                else:
+                    projectData = fileName
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", projectId).execute()
+                temp.close()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Data loaded successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.post("/loadMySql")
+async def loadMySql(connection: LoadMySQLorPostgreSQL, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            project = client.table("Projects").select("projectId", "projectName", "dataTables").eq("projectId", connection.projectId).execute().data[0]                
+            with tempfile.NamedTemporaryFile(delete = True, suffix = ".parquet") as temp:
+                connStr = f"mysql+pymysql://{connection.user}:{connection.password}@{connection.host}:{connection.port}/{connection.db}"
+                engine = create_engine(connStr)
+                pd.read_sql(f"SELECT * FROM {connection.table}", engine).to_parquet(temp.name, compression = "snappy")
+                _ = client.storage.from_("AnalyticsHub").upload(
+                    file = temp.name,
+                    path = f"{connection.projectId}/{connection.table + '.parquet'}"
+                )
+                if project["dataTables"]:
+                    projectData = project["dataTables"] + f", {connection.table + '.parquet'}"
+                else:
+                    projectData = connection.table
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", connection.projectId).execute()
+                temp.close()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Data loaded successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/loadPostgreSQL")
+async def loadPostgreSQL(connection: LoadMySQLorPostgreSQL, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            project = client.table("Projects").select("projectId", "projectName", "dataTables").eq("projectId", connection.projectId).execute().data[0]                
+            with tempfile.NamedTemporaryFile(delete = True, suffix = ".parquet") as temp:
+                connStr = f"postgresql+psycopg2://{connection.user}:{connection.password}@{connection.host}:{connection.port}/{connection.db}"
+                engine = create_engine(connStr)
+                pd.read_sql(f"SELECT * FROM {connection.table}", engine).to_parquet(temp.name, compression = "snappy")
+                _ = client.storage.from_("AnalyticsHub").upload(
+                    file = temp.name,
+                    path = f"{connection.projectId}/{connection.table + '.parquet'}"
+                )
+                if project["dataTables"]:
+                    projectData = project["dataTables"] + f", {connection.table + '.parquet'}"
+                else:
+                    projectData = connection.table
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", connection.projectId).execute()
+                temp.close()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Data loaded successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/loadMongoDB")
+async def loadMongoDB(connection: LoadMongoDB, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            project = client.table("Projects").select("projectId", "projectName", "dataTables").eq("projectId", connection.projectId).execute().data[0]                
+            with tempfile.NamedTemporaryFile(delete = True, suffix = ".parquet") as temp:
+                mongoClient = MongoClient(connection.connectionString, server_api=ServerApi('1'))
+                records = list(mongoClient[connection.db][connection.collection].find())
+                for record in records: record.pop("_id")
+                pd.DataFrame(records).to_parquet(temp.name, compression = "snappy")
+                _ = client.storage.from_("AnalyticsHub").upload(
+                    file = temp.name,
+                    path = f"{connection.projectId}/{connection.collection + '.parquet'}"
+                )
+                if project["dataTables"]:
+                    projectData = project["dataTables"] + f", {connection.collection + '.parquet'}"
+                else:
+                    projectData = connection.collection
+                _ = client.table("Projects").update({"dataTables": projectData}).eq("projectId", connection.projectId).execute()
+                temp.close()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Data loaded successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.delete("/deleteTable")
+async def deleteTable(tableDetails: DeleteTable, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            _ = client.storage.from_("AnalyticsHub").remove(f"{tableDetails.projectId}/{tableDetails.tableName}" + ".parquet")
+            projectTables = client.table("Projects").select("dataTables").eq("projectId", tableDetails.projectId).execute().data[0]["dataTables"]
+            projectTables = projectTables.split(", ")
+            projectTables.remove(tableDetails.tableName)
+            projectTables = ", ".join(projectTables)
+            _ = client.table("Projects").update({"dataTables": projectTables}).eq("projectId", tableDetails.projectId).execute()
+            fileUrl = os.environ["FILE_URL"].format(projectId = tableDetails.projectId, fileName = "metadata.json").replace(".parquet", "")
+            jsonData = json.loads(urlopen(fileUrl).read())
+            jsonData.pop(tableDetails.tableName)
+            with io.BytesIO() as buffer:
+                buffer.write(json.dumps(jsonData, indent=4).encode("utf-8"))
+                buffer.seek(0)
+                client.storage.from_("AnalyticsHub").upload(path = f"{tableDetails.projectId}/metadata.json", file = buffer.getvalue(), file_options = {"upsert": "true"})
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Table deleted successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/routers/projectManager.py

@@ -0,0 +1,200 @@
+from ..models.requestModels import UpdateProjectState, CreateProject, EditMetadata
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from langchain_experimental.utilities import PythonREPL
+from ..utils.functions import verifyToken, readYaml
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+from ..components import replManager
+from fastapi import APIRouter, Depends
+from supabase import create_client
+from urllib.request import urlopen
+from typing import Annotated
+from . import pipeline
+from jose import jwt
+import pandas as pd
+import uuid
+import json
+import os
+import io
+
+router = APIRouter()
+security = HTTPBearer()
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+
+@router.post("/createProject")
+async def createProject(projectDetails: CreateProject, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            projectId = str(uuid.uuid4())
+            replManager.manager[projectId] = PythonREPL()
+            _ = replManager.manager[projectId].run(readYaml("params.yaml")["redisFunctionCode"])
+            _ = replManager.manager[projectId].run(readYaml("params.yaml")["jsonSerializer"])
+            _ = replManager.manager[projectId].run(("globals()['__name__'] = '__main__'"))
+            _ = replManager.manager[projectId].run("globals().update(locals())")
+            decodedToken = jwt.decode(
+                credentials.credentials,
+                os.environ["SECRET_KEY"],
+                algorithms = ["HS256"]
+            )
+            _ = client.table("Projects").insert({
+                "projectId": projectId,
+                "projectName": projectDetails.projectName,
+                "projectDescription": projectDetails.projectDescription,
+                "ownerUserId": decodedToken["userId"],
+                "ownerUserMail": decodedToken["email"]
+            }).execute()
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "projectId": projectId, "message": "Project created successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.get("/listProjects")
+async def listProjects(credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            decodedToken = jwt.decode(
+                credentials.credentials,
+                os.environ["SECRET_KEY"],
+                algorithms = ["HS256"]
+            )
+            data = pd.DataFrame(client.table("Projects").select("*").execute().data)
+            data = data[data["ownerUserId"] == decodedToken["userId"]]
+            return JSONResponse(status_code = 200, content = {"projects": data.to_dict(orient = "records")})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.patch("/updateBookmark")
+async def updateBookmark(updateBookmarkDetails: UpdateProjectState, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            if updateBookmarkDetails.action == "add":
+                _ = client.table("Projects").update({"isBookmarked": 1}).eq("projectId", updateBookmarkDetails.projectId).execute()
+            else:
+                _ = client.table("Projects").update({"isBookmarked": 0}).eq("projectId", updateBookmarkDetails.projectId).execute()                
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Project bookmark status updated successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.patch("/updateArchive")
+async def updateArchive(updateArchiveDetails: UpdateProjectState, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            if updateArchiveDetails.action == "add":
+                _ = client.table("Projects").update({"isArchived": 1}).eq("projectId", updateArchiveDetails.projectId).execute()
+            else:
+                _ = client.table("Projects").update({"isArchived": 0}).eq("projectId", updateArchiveDetails.projectId).execute()                
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Project archive status updated successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})   
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.patch("/updateTrash")
+async def updateTrash(updateTrashDetails: UpdateProjectState, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            if updateTrashDetails.action == "add":
+                _ = client.table("Projects").update({"isTrash": 1}).eq("projectId", updateTrashDetails.projectId).execute()
+            else:
+                _ = client.table("Projects").update({"isTrash": 0}).eq("projectId", updateTrashDetails.projectId).execute()                
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Project trash status updated successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/generateMetadata/{projectId}")
+async def generateMetadata(projectId: str, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            filenames = [x.get("name") for x in client.storage.from_("AnalyticsHub").list(projectId)]
+            if "metadata.json" in filenames:
+                fileUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "metadata.json").replace(".parquet", "")
+                jsonData = json.loads(urlopen(fileUrl).read())
+                jsonDataTables = set(jsonData.keys())
+                newMetadata = pipeline.generateMetadata(projectId = projectId)
+                newMetadataTables = set(newMetadata.keys())
+                newKeys = newMetadataTables.difference(jsonDataTables)
+                for key in newKeys: jsonData[key] = newMetadata[key]
+            else:
+                jsonData = pipeline.generateMetadata(projectId = projectId)
+                _ = replManager.manager[projectId].run(f'metadata = {jsonData}')
+            with io.BytesIO() as buffer:
+                buffer.write(json.dumps(jsonData, indent=4).encode("utf-8"))
+                buffer.seek(0)
+                client.storage.from_("AnalyticsHub").upload(path = f"{projectId}/metadata.json", file = buffer.getvalue(), file_options = {"upsert": "true"})
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "metadata": jsonData})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.get("/getMetadata/{projectId}")
+async def getMetadata(projectId: str, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            fileUrl = os.environ["FILE_URL"].format(projectId = projectId, fileName = "metadata.json").replace(".parquet", "")
+            jsonData = json.loads(urlopen(fileUrl).read())
+            newJson = {"tables": []}
+            for key in jsonData:
+                tableJson = {
+                    "tableName": key,
+                    "tableDesc": jsonData.get(key).get("description"),
+                    "shape": jsonData.get(key).get("shape"),
+                    "columns": jsonData.get(key).get("columns")
+                }
+                newJson.get("tables").append(tableJson)
+            return JSONResponse(status_code = 200, content = newJson)
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.put("/editMetadata")
+async def editMetadata(modifiedMetadata: EditMetadata, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            fileUrl = os.environ["FILE_URL"].format(projectId = modifiedMetadata.projectId, fileName = "metadata.json").replace(".parquet", "")
+            jsonData = json.loads(urlopen(fileUrl).read())
+            if modifiedMetadata.tableDescription and not (modifiedMetadata.columnName or modifiedMetadata.columnDescription):
+                jsonData[modifiedMetadata.tableName]["description"] = modifiedMetadata.tableDescription
+            elif (modifiedMetadata.columnName and modifiedMetadata.columnDescription) and not modifiedMetadata.tableDescription:
+                columns = jsonData[modifiedMetadata.tableName]["columns"]
+                for column in columns:
+                    if column["name"] == modifiedMetadata.columnName:
+                        idx = columns.index(column)
+                columns[idx]["description"] = modifiedMetadata.columnDescription
+                jsonData[modifiedMetadata.tableName]["columns"] = columns
+            else:
+                raise AttributeError("Invalid combination of parameters provided")
+            with io.BytesIO() as buffer:
+                buffer.write(json.dumps(jsonData, indent=4).encode("utf-8"))
+                buffer.seek(0)
+                client.storage.from_("AnalyticsHub").upload(path = f"{modifiedMetadata.projectId}/metadata.json", file = buffer.getvalue(), file_options = {"upsert": "true"})
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "metadata": jsonData})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+
+@router.delete("/deleteProject")
+async def deleteProject(projectId: str, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            _ = client.table("Projects").delete().eq("projectId", projectId).execute()
+            allFiles = client.storage.from_("AnalyticsHub").list(projectId)
+            fileNames = [os.path.join(projectId, x.get("name")) for x in allFiles]
+            _ = client.storage.from_("AnalyticsHub").remove(fileNames)
+            return JSONResponse(status_code = 200, content = {"status": "SUCCESS", "message": "Project deleted successfully"})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/routers/reportingTool.py

@@ -0,0 +1,48 @@
+from ..models.requestModels import GenerateChartInput, PanelChartDetails
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+from ..utils.functions import verifyToken
+from fastapi import APIRouter, Depends
+from urllib.request import urlopen
+from typing import Annotated
+from . import pipeline
+import json
+import os
+
+router = APIRouter()
+security = HTTPBearer()
+
+@router.post("/generateChart")
+async def generateChart(chartDetails: GenerateChartInput, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            fileUrl = os.environ["FILE_URL"].format(projectId = chartDetails.projectId, fileName = "metadata.json").replace(".parquet", "")
+            response = pipeline.generateChart(
+                inputQuery = chartDetails.inputQuery,
+                projectId = chartDetails.projectId,
+                metadata = json.loads(urlopen(fileUrl).read())
+            )
+            return JSONResponse(status_code = 200, content = response)
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")
+    
+@router.post("/generatePanelChart")
+async def generatePanelChart(panelChartDetails: PanelChartDetails, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            response = pipeline.generateChartFromPanel(
+                projectId = panelChartDetails.projectId,
+                chartType = panelChartDetails.chartType,
+                xAxis = panelChartDetails.xAxis,
+                yAxis = panelChartDetails.yAxis,
+                aggregationMetric = panelChartDetails.aggregationMetric,
+                dataSource = panelChartDetails.dataSource
+            )
+            return JSONResponse(status_code = 200, content = response)
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/routers/utilities.py

@@ -0,0 +1,28 @@
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from ..models.requestModels import SpeechToTextModel
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+from ..utils.functions import verifyToken
+from fastapi import APIRouter, Depends
+from supabase import create_client
+from typing import Annotated
+from . import pipeline
+import os
+
+router = APIRouter()
+security = HTTPBearer()
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+
+@router.post("/getSpeechTranscript")
+async def getSpeechTranscript(speechToText: SpeechToTextModel, credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]):
+    try:
+        if verifyToken(token = credentials.credentials):
+            transcriptText = pipeline.speechToText(b64String = speechToText.b64String)
+            return JSONResponse(status_code = 200, content = {"transcriptionText": transcriptText})
+        else:
+            return JSONResponse(status_code = 498, content = {"status": "ERROR", "errorDetail": "Invalid Token"})    
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = f"Endpoint says: {e}")

analyticsHub/utils/exceptions.py

@@ -0,0 +1,33 @@
+import sys
+
+class CustomException(Exception):
+    def __init__(self, errorMessage):
+        """
+        Initialize a CustomException with a detailed error message.
+
+        Args:
+            errorMessage (str): The error message to be logged.
+        """
+        super().__init__(errorMessage)
+        self.errorMessage = self.errorMessageDetail(errorMessage)
+
+    @staticmethod
+    def errorMessageDetail(error):
+        """
+        Generate a detailed error message.
+
+        Args:
+            error: The error object.
+
+        Returns:
+            str: A formatted error message including line number and filename.
+        """
+        _, _, exc_info = sys.exc_info()
+        filename = exc_info.tb_frame.f_code.co_filename
+        lineno = exc_info.tb_lineno
+        errorMessage = "Error encountered in line no [{}], filename : [{}], saying [{}]".format(lineno, filename, error)
+        return errorMessage
+
+    def __str__(self) -> str:
+        """Return the detailed error message."""
+        return self.errorMessage

analyticsHub/utils/functions.py

@@ -0,0 +1,27 @@
+from supabase import create_client
+import configparser
+import datetime
+import yaml
+import os
+
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+
+def verifyToken(token: str):
+    allTokens = [x["accessToken"] for x in client.table("Sessions").select("accessToken").execute().data]
+    if token in allTokens: 
+        response = client.table("Sessions").update({"lastActivity": str(datetime.datetime.utcnow())}).eq("accessToken", token).execute()
+        return True
+    else: return False
+
+def readYaml(filePath: str) -> dict:
+    with open(filePath, "r") as f:
+        content = yaml.safe_load(f)
+    return content 
+
+def getConfig(path: str) -> dict:
+    config = configparser.ConfigParser()
+    config.read(path)
+    return config

analyticsHub/utils/logger.py

@@ -0,0 +1,28 @@
+import logging
+import os
+
+# Create a logger instance
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)  
+
+# Define the directory for log files
+LOG_DIR = os.path.join(os.getcwd(), "logs")
+os.makedirs(LOG_DIR, exist_ok=True)  
+LOG_FILE = os.path.join(LOG_DIR, "runningLogs.log")
+
+# Initialize stream handler and file handler for console output
+streamHandler = logging.StreamHandler()
+fileHandler = logging.FileHandler(LOG_FILE)
+
+# Set the logging level for each handler
+streamHandler.setLevel(logging.INFO)  
+fileHandler.setLevel(logging.DEBUG)    
+
+# Configure the logging format for both handlers
+logFormatter = logging.Formatter("[%(asctime)s: %(levelname)s: %(module)s: %(message)s]")
+streamHandler.setFormatter(logFormatter)  
+fileHandler.setFormatter(logFormatter)    
+
+# Add the configured handlers to the logger
+logger.addHandler(streamHandler)
+logger.addHandler(fileHandler)

analyticsHub/workflows/reportingWorkflow.py

@@ -0,0 +1,100 @@
+from ..components.failsafeAgent import FailsafeCodeGenerator
+from ..components.queryRephraserAgent import QueryRephaser
+from ..components.codeGeneratorAgent import CodeGenerator
+from langgraph.graph import StateGraph, START, END
+from typing_extensions import TypedDict
+from ..components import replManager
+import json
+
+failsafeCodeGeneratorChain = FailsafeCodeGenerator().getFailsafeCodeGeneratorChain()
+queryRephraseChain = QueryRephaser().getQueryRephraserChain()
+codeGeneratorChain = CodeGenerator().getCodeGeneratorChain()
+
+class State(TypedDict):
+    projectId: str
+    inputQuery: str
+    metadata: str
+    rephrasedQuery: str
+    generatedCode: str
+    codeOutput: str
+    finalOutput: dict
+
+class ReportingToolWorkflow:
+    def __init__(self):
+        pass
+    def rephraseQuery(self, state: State):
+        response = queryRephraseChain.invoke({
+            "query": state["inputQuery"],
+            "metadata": state["metadata"]
+        })
+        return {
+            "rephrasedQuery": response
+        }
+    def generateCode(self, state: State):
+        response = codeGeneratorChain.invoke({
+            "query": state["rephrasedQuery"],
+            "metadata": state["metadata"]
+        })
+        return {
+            "generatedCode": f'fetch_data("{state["projectId"]}", '.join(response.split("fetch_data(")).replace("import pandas", "import fireducks.pandas").replace('indent=4', 'default=serializer')
+        }
+    def runInPythonSandbox(self, state: State):
+        code = "\n".join(state["generatedCode"].split("```")[-2].split("\n")[1:])
+        response = replManager.manager.get(state["projectId"]).run(code)
+        return {
+            "codeOutput": response
+        }
+    def outputEvaluationRouter(self, state: State):
+        try:
+            _ = json.loads(state["codeOutput"])
+            return "pass"
+        except json.JSONDecodeError:
+            return "fail"
+    def failsafe(self, state: State):
+        response = failsafeCodeGeneratorChain.invoke({
+            "user_query": state["rephrasedQuery"],
+            "metadata_context": state["metadata"],
+            "code_with_errors": state["generatedCode"],
+            "error_message": state["codeOutput"]
+        })
+        return {
+            "generatedCode": response
+        }
+    def formatJsonResponse(self, state: State):
+        if "codeOutput" in state.keys():
+            try:
+                response = json.loads(state["codeOutput"])
+            except Exception as e:
+                response = {"error": f"Endpoint says: {e}"}
+            return {
+                "finalOutput": response
+            }
+        else:
+            return {
+                "finalOutput": {"response": state["rephrasedQuery"]["doubt"]}
+            }
+    def router(self, state: State):
+        if state["rephrasedQuery"]["doubt"] == None:
+            return "continue"
+        else:
+            return "interrupt"
+    def createWorkflow(self):
+        workflow = StateGraph(State)
+        workflow.add_node("rephraseQuery", self.rephraseQuery)
+        workflow.add_node("generateCode", self.generateCode)
+        workflow.add_node("runInPythonSandbox", self.runInPythonSandbox)
+        workflow.add_node("failsafe", self.failsafe)
+        workflow.add_node("failsafePythonSandbox", self.runInPythonSandbox)
+        workflow.add_node("formatJsonResponse", self.formatJsonResponse)
+        workflow.add_edge(START, "rephraseQuery")
+        workflow.add_conditional_edges("rephraseQuery", self.router, {"continue": "generateCode", "interrupt": "formatJsonResponse"})
+        workflow.add_edge("generateCode", "runInPythonSandbox")
+        workflow.add_conditional_edges("runInPythonSandbox", self.outputEvaluationRouter, {"pass": "formatJsonResponse", "fail": "failsafe"})
+        workflow.add_edge("failsafe", "failsafePythonSandbox")
+        workflow.add_edge("failsafePythonSandbox", "formatJsonResponse")
+        workflow.add_edge("formatJsonResponse", END)
+        workflow = workflow.compile()
+        return workflow
+    
+graph = ReportingToolWorkflow()
+reportingToolWorkflow = graph.createWorkflow()

app.py

@@ -0,0 +1,53 @@
+from analyticsHub.routers import authentication, projectManager, dataLoader, reportingTool, utilities, blends, dashboard
+from langchain_experimental.utilities import PythonREPL
+from fastapi.middleware.cors import CORSMiddleware
+from analyticsHub.utils.functions import readYaml
+from analyticsHub.components import replManager
+from supabase import create_client
+from fastapi import FastAPI
+import uvicorn
+import os
+
+client = create_client(
+    supabase_url = os.environ["SUPABASE_URL"],
+    supabase_key = os.environ["SUPABASE_KEY"]
+)
+
+app = FastAPI(
+    title = "AnalyticsHub",
+    summary = "API Endpoints for AnalyticsHub.",
+    version = "1.0",
+    root_path = "/api/latest",
+    docs_url = "/documentation/docs",
+    redoc_url = "/documentation/redoc"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins = ["*"],
+    allow_credentials = True,
+    allow_methods = ["*"],
+    allow_headers = ["*"],
+)
+
+app.include_router(authentication.router, prefix = "/auth", tags = ["Authentication"])
+app.include_router(projectManager.router, prefix = "/projects", tags = ["Project Management"])
+app.include_router(dataLoader.router, prefix = "/loaders", tags = ["Data Loader"])
+app.include_router(blends.router, prefix = "/blends", tags = ["Blends"])
+app.include_router(reportingTool.router, prefix = "/reportingTool", tags = ["Reporting Tool"])
+app.include_router(dashboard.router, prefix = "/dashboard", tags = ["Dashboard"])
+app.include_router(utilities.router, prefix = "/utils", tags = ["Utilities"])
+
+@app.on_event("startup")
+async def startupEvent():
+    projectIds = [x["projectId"] for x in client.table("Projects").select("projectId").execute().data]
+    for id in projectIds:
+        replManager.manager[id] = PythonREPL()
+        _ = replManager.manager[id].run(readYaml("params.yaml")["redisFunctionCode"])
+        _ = replManager.manager[id].run(readYaml("params.yaml")["jsonSerializer"])
+        _ = replManager.manager[id].run(readYaml("params.yaml")["panelChartDataCode"])
+        _ = replManager.manager[id].run(("globals()['__name__'] = '__main__'"))
+        _ = replManager.manager[id].run("globals().update(locals())")
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host = "0.0.0.0", port = 8000, reload = True)

config.ini

@@ -0,0 +1,23 @@
+[QUERYREPHRASER]
+model = llama-3.3-70b
+temperature = 1
+maxTokens = 512
+
+[METADATAGENERATOR]
+model = llama-3.3-70b
+temperature = 1
+
+[CODEGENERATOR]
+model = llama-3.3-70b
+temperature = 1
+
+[FAILSAFECODEGENERATOR]
+model = llama-3.3-70b
+temperature = 1
+
+[SPEECHTOTEXT]
+model = whisper-large-v3-turbo
+
+[APPLICATION]
+host = 0.0.0.0
+port = 8000

params.yaml

@@ -0,0 +1,834 @@
+metadataGeneratorPrompt: |
+    I have a dataset consisting of several dataframes with associated attribute information provided below.
+
+    {metadata}
+
+    Generate a `metadata.json` file that strictly adheres to the structure outlined here. The output should be a JSON block only—no additional text, explanations, or comments. Each entry in the JSON should include the dataframe's name, a description, a detailed breakdown of its columns (including their names, data types, and descriptions), and a sample row showcasing representative values.
+
+    ### Notes:
+    - The terms `dataframe1`, `dataframe2`, `column1`, `column2`, etc., are placeholders and do not represent the actual names, column labels, or values from the dataset. Replace them with the real dataframe and column names provided in the dataset's metadata.
+    - Ensure all descriptions and examples provided in the output JSON are consistent with the given dataset's structure and attributes.
+    - Ensure that all the dataframes and columns are mentioned in the expected format in the output metadata.
+
+    ### Input Example:
+    For each dataframe:
+
+    DATAFRAME NAME: `<dataframe1>`
+    - `column1` (dtype: `<column1 dtype>`)
+    - `column2` (dtype: `<column2 dtype>`)
+    - `column3` (dtype: `<column3 dtype>`)
+    ...
+    Shape: (number of rows, number of columns)
+    Sample row:
+    | column1   | column2   | column3   |
+    |-----------|-----------|-----------|
+    | value1    | value2    | value3    |
+
+    DATAFRAME NAME: `<dataframe2>`
+    - `column1` (dtype: `<column1 dtype>`)
+    - `column2` (dtype: `<column2 dtype>`)
+    - `column3` (dtype: `<column3 dtype>`)
+    ...
+    Shape: (number of rows, number of columns)
+    Sample row:
+    | column1   | column2   | column3   |
+    |-----------|-----------|-----------|
+    | value1    | value2    | value3    |
+
+    ### Expected Output Format (JSON only):
+    ```json
+    {{
+        "<dataframe1>": {{
+            "description": "<Description of the dataframe>",
+            "shape": "<list of type [nunmber of rows, number of columns]>",
+            "columns": [
+                {{"name": "<column1>", "type": "<column1 datatype>", "description": "<column1 description>"}},
+                {{"name": "<column2>", "type": "<column2 datatype>", "description": "<column2 description>"}},
+                ...
+            ],
+            "sample_row": {{
+                "<column1>": "<value1>",
+                "<column2>": "<value2>",
+                ...
+            }}
+        }},
+        "<dataframe2>": {{
+            ...
+        }},
+        ...
+    }}
+    ```
+
+
+attributeInfoCode: |
+    import fireducks.pandas as pd
+    import os
+    {dataframeName} = pd.read_parquet(os.environ["FILE_URL"].format(projectId = "{projectId}", fileName = "{dataframeName}"))
+    attributeInfo = 'DATAFRAME NAME: {dataframeName}\\n'
+
+    for column in {dataframeName}.columns:
+        attributeInfo += '- ' + str(column) + ' (' + {dataframeName}.get(column).dtype.name + ')\\n'
+        
+    attributeInfo += 'SHAPE: ' + str({dataframeName}.shape) + '\\n'
+    attributeInfo += 'SAMPLE ROW:\\n' + str({dataframeName}.loc[{dataframeName}.index[:1]].to_string()) + '\\n'
+    print(attributeInfo)
+
+
+jsonSerializer: |
+    import numpy as np
+    import fireducks.pandas as pd
+    import datetime
+    import math
+    import json
+    def serializer(obj):
+        # Handle NumPy types
+        if isinstance(obj, (np.integer)):
+            return obj.item()  # Convert to native Python int
+        elif isinstance(obj, (np.floating)):
+            if np.isnan(obj) or np.isinf(obj):
+                return None  # Replace NaN/Infinity with JSON-compliant null
+            return obj.item()  # Convert to native Python float
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()  # Convert NumPy array to list
+        elif isinstance(obj, np.datetime64):
+            return str(obj)  # Convert to ISO 8601 string
+        # Handle Pandas DataFrames and Series
+        elif isinstance(obj, pd.DataFrame):
+            return obj.to_dict(orient="records")  # Convert to list of dicts
+        elif isinstance(obj, pd.Series):
+            return obj.tolist()  # Convert Series to list
+        # Handle datetime types
+        elif isinstance(obj, (datetime.datetime, datetime.date)):
+            return obj.isoformat()  # Convert to ISO 8601 string
+        # Handle sets and tuples
+        elif isinstance(obj, (set, tuple)):
+            return list(obj)
+        # Handle complex numbers
+        elif isinstance(obj, complex):
+            return {"real": obj.real, "imag": obj.imag}  # Convert to dict
+
+redisFunctionCode: |
+    def fetch_data(projectId: str, tableName: str):
+        import fireducks.pandas as pd
+        import redis
+        import os
+        import io
+        r = redis.Redis(host=os.environ["REDIS_HOST"], port=int(os.environ["REDIS_PORT"]), password=os.environ["REDIS_PASSWORD"])
+        key = f"{projectId}::{tableName}"
+        df = r.get(key)
+        if df is None:
+            buffer = io.BytesIO()
+            df = pd.read_parquet(os.environ["FILE_URL"].format(projectId = projectId, fileName = tableName))
+            df.to_parquet(buffer, compression = "snappy")
+            r.set(name = key, value = buffer.getvalue(), ex = 60)
+        else:
+            df = pd.read_parquet(io.BytesIO(df))
+        return df
+
+queryRephraserAgentPrompt: |
+  You are a **Query Rewriter AI Agent**, ensuring user queries are **clear, valid, and executable** based on dataset metadata.
+
+  ### **1. Understand the Query**
+  - Analyze the query within dataset context.
+  - Verify feasibility:
+    - Ensure required columns exist.
+    - Validate joins/merges via common columns.
+    - Check data type compatibility.
+    - Confirm transformations are practical.
+  - Verify the final transformed data can be stored in a DataFrame named `final_df`
+
+  ### **2. Validate the Query**
+  - Return a **simple, non-technical doubt message** if the query is:
+    - Unclear, logically impossible, or requires infeasible transformations.
+    - Involves joins/merges without clear relationships.
+    - Operates on non-existent or incompatible columns.
+  - If valid, proceed to rephrasing.
+
+  ### **3. Rephrase the Query**
+  - Convert it into a **standalone, precise version** including:
+    - **Objective:** Core analysis or visualization goal.
+    - **Transformations:**
+      - **MUST END with creating `final_df` containing the prepared data**
+      - Always specify:
+        1) Fetch required data using the `fetch_data` function
+        2) Join/merge operations if needed
+        3) Grouping/aggregation logic
+        4) Column selection/renaming
+        5) Final dataframe naming as `final_df`
+    - **Chart Type:**
+      - **MUST:** **Always analyze query intent and explicitly specify the optimal chart type** from: `line`, `scatter`, `bar`, `radar`, `bubble`, `polarArea`, `pie`, `doughnut`, `card`
+      - If no chart type is specified, **carefully infer the most suitable one based on the data and visualization needs out of: `line`, `scatter`, `bar`, `radar`, `bubble`, `polarArea`, `pie`, `doughnut`, `card`**.
+      - **Validate that the requested chart type is one of the following:**
+        - `line`, `scatter`, `bar`, `radar`, `bubble`, `polarArea`, `pie`, `doughnut`, `card`.
+
+      - **IMPORTANT CARD USAGE RESTRICTIONS:**
+        - **Use `card` EXCLUSIVELY for displaying a SINGLE KPI (one numeric data value with one label).**
+        - **A `card` chart MUST have EXACTLY ONE label and ONE singular data value (integer/float/string only).**
+        - **For example, a `card` is appropriate ONLY for: "Total Revenue: $1,000,000" or "Average Score: 85.7"**
+        - **NEVER use `card` for ANY OF THESE scenarios:**
+          - Multiple values (e.g., showing counts for multiple tables)
+          - Lists of items or metrics
+          - Comparisons between values
+          - Time series data
+          - Multiple KPIs even if related
+        - **If the query requests information about multiple entities (e.g., "row counts for all tables"), ALWAYS use a `bar` or other appropriate chart type instead of `card`.**
+
+      - If no chart type is specified, determine the most suitable option.
+      - For **comparison queries**, explicitly specify if multiple datasets are needed (e.g., `multi-dataset bar`, `grouped bar`, `multi-series line`).
+      - For **categorical comparisons**, specify when a hue/color encoding should be used (e.g., `bar chart with hue by category`).
+      - If the query involves dataset structure (e.g., number of rows, columns, or tables) and can be derived from metadata, select an appropriate chart type and extract the relevant metrics directly from the metadata available in memory.
+      - **You MUST determine and explicitly mention the most suitable chart type** after analyzing all details of the query, Always.
+
+  ### Example Input Format:
+  #### User Query:
+  A string describing what the user wants to do with the dataset.
+
+  #### Dataset Metadata:
+  ```yaml
+  {{
+    "<dataframe1>": {{
+      "description": "<Description of the dataframe>",
+      "shape": [number of rows, number of columns],
+      "columns": [
+        {{"name": "<column1>", "type": "<column1 datatype>", "description": "<column1 description>"}},
+        {{"name": "<column2>", "type": "<column2 datatype>", "description": "<column2 description>"}}
+      ],
+      "sample_row": {{
+        "<column1>": "<value1>",
+        "<column2>": "<value2>"
+      }}
+    }},
+    "<dataframe2>": {{
+      ...
+    }}
+  }}
+  ```
+
+  ### Example Expected Outputs:
+  - **Valid Query Example:**
+  ```json
+  {{
+    "rephrasedOutput": "Show average order value by customer segment using a bar chart. Steps: 1) Fetch orders data using fetch_data('orders'), 2) Join with customers data using fetch_data('customers') on customer_id, 3) Group by segment, 4) Calculate mean order value, 5) Name result as final_df",
+    "doubt": null
+  }}
+  ```
+
+  - **Multi-Dataset Example:**
+  **User Query:** "Compare sales performance this year vs last year by quarter"
+  ```json
+  {{
+      "rephrasedOutput": "Compare sales performance between current year and previous year by quarter using a multi-dataset bar chart. Steps: 1) Fetch sales data using fetch_data('sales'), 2) Extract and separate current year and previous year data, 3) Group both datasets by quarter, 4) Calculate total sales for each quarter in each year, 5) Name result as final_df",
+      "doubt": None
+  }}
+  ```
+
+  - **Invalid/Unclear Query Example:**
+  **User Query:** "Visualize customer satisfaction scores and their written feedback in a scatter plot."
+  ```json
+  {{
+    "rephrasedOutput": null,
+    "doubt": "Scatter plots require numerical values for both axes, but written customer feedback is text. Please try analyzing customer satisfaction scores with a bar chart instead."
+  }}
+  ```
+
+  ### **Strict Guidelines:**
+  - Keep **doubt messages simple, high-level, and non-technical**.
+  - Suggest alternative chart types **only if necessary**, with clear reasoning.
+  - For unclear queries, **request clarification without technical jargon**.
+  - Never expose **implementation details** in doubt messages.
+  - If a query is infeasible, **explain why concisely** without deep technical reasoning.
+  - For comparison queries, **explicitly mention when multiple datasets or hue categories are needed**.
+  - **Chart type determination is MANDATORY - never omit this analysis.**
+  - **If query doesn't specify chart type, You MUST determine and declare the optimal type in the rephrased query.**
+
+  ### **Rephrased Output Rules:**
+  - **Include the essential data transformations or methods to get required data** (extraction, filtering, joining, aggregation, metadata checks).
+  - **Focus on data preparation—exclude visualization steps.**
+  - Ensure implementation steps are **correct, clear, sequential, and are necessarily included in the rephrased query**.
+  - **Be precise without excessive detail.**
+  - **Use the `fetch_data` function to retrieve the necessary dataframes.**
+  - **For multi-dataset or hue-based charts, clearly specify how data should be organized for comparison.**
+
+  ### **Environment Constraints:**
+  - **Data is retrieved using the `fetch_data` function which takes the dataframe name as a string parameter.**
+  - **The input metadata is available as a dictionary in the `metadata` variable.** Mention use of the `metadata` variable explicitly if used in transformations.
+
+  ### **Format Instructions:**
+  - Return **ONLY the output JSON**—no extra text or commentary.
+  - Strictly follow format: `{format_instructions}`.
+
+  #### **Provided Inputs:**
+  - **Metadata (Already present in the `metadata` variable):** {metadata}
+  - **Query:** {query}
+
+
+codeGeneratorAgentPrompt: |
+    # ChartDataGenerator: Python Chart Data Generator for Chart.js
+
+    You are **ChartDataGenerator**, an AI expert in generating **JSON-formatted chart data** for Chart.js visualizations. Your role is to interpret the rephrased user query and the dataset metadata, then generate a fully executable **Python script** that produces the required JSON output.
+
+    ## ABSOLUTE NON-NEGOTIABLE RULES
+
+    1. **DO NOT assume dataframes are preloaded - ALWAYS use the `fetch_data` function to retrieve data.**
+    - **Usage of `fetch_data`:**
+        - Call the function with the dataframe's name (as a string) exactly as provided in the metadata.
+        - For example: `sales_data = fetch_data("sales_data")`
+    - **The `fetch_data` function is already defined in the environment - do not redefine it**
+
+    2. **The `metadata` variable is already present in the environment - do not redefine it or modify it**
+    - Use the metadata variable directly to access dataset information when needed
+
+    3. **DO NOT assume any new data or create placeholder/sample data.**
+
+    4. **ALWAYS use the exact dataframe names provided in the metadata when calling `fetch_data`.**
+
+    5. **THE FINAL TRANSFORMED DATAFRAME MUST BE NAMED `final_df`.**
+
+    6. **TRANSFORMATION STEPS MUST BE TRANSLATED TO CODE IN THE ORDER PROVIDED.**
+
+    7. **Only use `fetch_data` when it's specifically needed for the query - don't retrieve datasets that aren't required.**
+
+    ## Responsibilities
+
+    ### Query Validation
+    - Validate that the requested chart type is one of the following: `line`, `scatter`, `bar`, `radar`, `bubble`, `polarArea`, `pie`, `doughnut`, `card`.
+    - Confirm that the necessary columns exist in the metadata.
+
+    ### Data Transformation
+    - Retrieve dataframes using the `fetch_data` function with the exact dataframe names as listed in the metadata.
+    - Apply the necessary transformations as outlined in the rephrased query (e.g., filtering, joining, grouping, aggregation, metadata checks).
+    - Stick to basic filtering in pandas: use boolean indexing or .loc[] only. Always avoid .filter(), .query() and other complex methods.
+    - Ensure that the final dataframe is named `final_df`.
+    - For multi-dataset or hue-based charts, organize the data appropriately to support the visualization.
+
+    ### Chart.js JSON Output Structure
+    - **Standard Charts (`line`, `bar`, `radar`, `polarArea`, `pie`, `doughnut`):**
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",    # Only include for "bar" or "line"
+        "yLabels": "<Y-Axis Label>",    # Only include for "bar" or "line"
+        "data": {{
+            "labels": <labels>,
+            "datasets": [
+                {{
+                    "label": "<dataset_name>",
+                    "data": <values>
+                }}
+            ]
+        }}
+    }}
+    ```
+    - **Multiple Dataset Charts:**
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",    # Only include for "bar" or "line"
+        "yLabels": "<Y-Axis Label>",    # Only include for "bar" or "line"
+        "data": {{
+            "labels": <labels>,
+            "datasets": [
+                {{
+                    "label": "<dataset1_name>",
+                    "data": <values1>
+                }},
+                {{
+                    "label": "<dataset2_name>",
+                    "data": <values2>
+                }}
+                // Additional datasets as needed
+            ]
+        }}
+    }}
+    ```
+    - **Scatter & Bubble Charts:**
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",
+        "yLabels": "<Y-Axis Label>",
+        "data": {{
+            "datasets": [
+                {{
+                    "label": "<dataset_name>",
+                    "data": [ {{"x": value, "y": value}} ]  # Include 'r' for bubble chart
+                }}
+            ]
+        }}
+    }}
+    ```
+    - **Scatter & Bubble Charts with Multiple Categories/Hues:**
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",
+        "yLabels": "<Y-Axis Label>",
+        "data": {{
+            "datasets": [
+                {{
+                    "label": "<category1_name>",
+                    "data": [ {{"x": value, "y": value}} ]  # Include 'r' for bubble chart
+                }},
+                {{
+                    "label": "<category2_name>",
+                    "data": [ {{"x": value, "y": value}} ]  # Include 'r' for bubble chart 
+                }}
+                // Additional categories as needed
+            ]
+        }}
+    }}
+    ```
+    - **Card Data (Only a single numerical value and one label allowed):**
+    ```json
+    {{
+        "chartType": "card",
+        "title": "<Chart Title>",
+        "label": "<Descriptive label>",
+        "data": "<Numeric value>"
+    }}
+    ```
+
+    ### Metadata Format Explanation
+    - The metadata is provided as a JSON/YAML object containing keys for each available dataframe.
+    - **Each key (dataframe name)** has an object with:
+    - **description:** A string explaining the dataframe.
+    - **shape:** An array `[number_of_rows, number_of_columns]` indicating the size of the dataframe.
+    - **columns:** A list where each element is an object with:
+        - **name:** The name of the column.
+        - **type:** The data type (e.g., "int64", "float64", "object").
+        - **description:** A brief description of the column's content.
+    - **sample_row:** An object representing an example record from the dataframe.
+    - The metadata is accessible through the `metadata` variable. Use this information to verify columns and structure.
+
+    ### Python Script Requirements
+    - **Imports:** Include necessary imports (e.g., `json`, `pandas`).
+    - **Data Access:** Use the `fetch_data` function to retrieve data.
+    - **Transformations:** Follow the exact steps provided in the rephrased query to prepare the data.
+    - **Multi-Dataset Handling:** For comparisons or hue-based visualizations:
+    - Properly organize data into multiple datasets with appropriate labels
+    - Use clear naming conventions for each dataset
+    - Ensure consistent axis ranges and scales when appropriate
+    - **JSON Output:** Construct a JSON object following the Chart.js specifications and print it using `json.dumps(..., indent=4)`.
+    - **Error Handling:** If the query is invalid or unexecutable, generate a Python script that prints a JSON response indicating the issue:
+    ```python
+    import json
+
+    response = {{
+        "response": "The requested chart cannot be generated due to missing or incompatible data. Please refine your query."
+    }}
+
+    print(json.dumps(response, indent=4))
+    ```
+
+    ## Examples
+
+    ### Example 1: Bar Chart of Sales by Region
+
+    **User Query:**
+    "Generate a bar chart showing total sales by region. Steps: 1) Fetch sales data using fetch_data('sales'), 2) Group by region, 3) Calculate sum of amount, 4) Name result as final_df"
+
+    **Expected Output:**
+    ```python
+    import pandas as pd
+    import json
+
+    # Step 1: Fetch sales data
+    sales = fetch_data("sales")
+
+    # Step 2 & 3: Group by region and calculate sum of amount
+    final_df = sales.groupby("region")["amount"].sum().reset_index()
+
+    # Generate Chart.js compatible JSON
+    chart_data = {{
+        "chartType": "bar",
+        "title": "Total Sales by Region",
+        "xLabels": "Region",
+        "yLabels": "Total Sales (in USD)",
+        "data": {{
+            "labels": final_df["region"].tolist(),
+            "datasets": [
+                {{
+                    "label": "Total Sales by Region",
+                    "data": final_df["amount"].tolist()
+                }}
+            ]
+        }}
+    }}
+
+    # Output the JSON data
+    print(json.dumps(chart_data, indent=4))
+    ```
+
+    ### Example 2: Multi-Dataset Line Chart for Monthly Sales Comparison
+
+    **User Query:**
+    "Compare sales between 2023 and 2024 using a multi-dataset line chart. Steps: 1) Fetch sales data using fetch_data('sales'), 2) Extract and separate 2023 and 2024 data based on date column, 3) Group both datasets by month, 4) Calculate total sales for each month in each year, 5) Name result as final_df"
+
+    **Expected Output:**
+    ```python
+    import pandas as pd
+    import json
+    from datetime import datetime
+
+    # Step 1: Fetch sales data
+    sales = fetch_data("sales")
+
+    # Step 2: Extract and separate data by year
+    sales['year'] = pd.to_datetime(sales['date']).dt.year
+    sales['month'] = pd.to_datetime(sales['date']).dt.month_name()
+
+    sales_2023 = sales[sales['year'] == 2023]
+    sales_2024 = sales[sales['year'] == 2024]
+
+    # Step 3 & 4: Group by month and calculate total sales for each year
+    sales_2023_monthly = sales_2023.groupby('month')['amount'].sum().reset_index()
+    sales_2024_monthly = sales_2024.groupby('month')['amount'].sum().reset_index()
+
+    # Create a list of all months for proper ordering
+    month_order = ['January', 'February', 'March', 'April', 'May', 'June',
+                'July', 'August', 'September', 'October', 'November', 'December']
+
+    # Reindex to ensure all months are included even if they have no data
+    sales_2023_monthly = sales_2023_monthly.set_index('month').reindex(month_order).fillna(0).reset_index()
+    sales_2024_monthly = sales_2024_monthly.set_index('month').reindex(month_order).fillna(0).reset_index()
+
+    # Step 5: Create the final dataframe
+    final_df = pd.DataFrame({{
+        'month': month_order,
+        'sales_2023': sales_2023_monthly['amount'].values,
+        'sales_2024': sales_2024_monthly['amount'].values
+    }})
+
+    # Generate Chart.js compatible JSON
+    chart_data = {{
+        "chartType": "line",
+        "title": "Monthly Sales Comparison: 2023 vs 2024",
+        "xLabels": "Month",
+        "yLabels": "Total Sales (in USD)",
+        "data": {{
+            "labels": final_df["month"].tolist(),
+            "datasets": [
+                {{
+                    "label": "2023 Sales",
+                    "data": final_df["sales_2023"].tolist()
+                }},
+                {{
+                    "label": "2024 Sales",
+                    "data": final_df["sales_2024"].tolist()
+                }}
+            ]
+        }}
+    }}
+
+    # Output the JSON data
+    print(json.dumps(chart_data, indent=4))
+    ```
+
+    ### Example 3: Metadata variable usage
+
+    **User Query:**
+    "Display total number of tables using a card. Steps: 1) Access metadata from the metadata variable, 2) Count keys using len(), 3) Create final_df with count value"
+
+    **Expected Output:**
+    ```python
+    import pandas as pd
+    import json
+
+    # METADATA-ONLY SOLUTION: No fetch_data() required
+    # Access metadata directly to get table count directly, no need to load it again in any variable
+    table_count = len(metadata.keys())
+
+    # Create required final_df with count (single KPI format)
+    final_df = pd.DataFrame({{
+        "total_tables": [table_count]
+    }})
+
+    # Generate card JSON following strict format
+    print(json.dumps({{
+        "chartType": "card",
+        "title": "Table Inventory Overview",
+        "label": "Total Tables",
+        "data": final_df["total_tables"].iloc[0]  # Extract single value
+    }}, indent=4))
+    ```
+
+    ## Final Guidelines
+
+    - **ALWAYS use the `fetch_data` function to retrieve the dataframes you need.**
+    - **The `metadata` variable and `fetch_data` function are already defined - DO NOT redefine them.**
+    - **Only retrieve datasets that are specifically needed for the query.**
+    - **Ensure 100% JSON serializability.**
+    - **Return only a fully executable Python script—NO additional commentary or explanation.**
+    - **Follow the exact transformation steps provided in the query in the order given.**
+    - **The final transformed dataframe must always be named `final_df`.**
+
+    ## **Provided Inputs:**
+    - **Metadata (Already present in the `metadata` variable):** {metadata}
+    - **Query:** {query}
+
+
+codeDebuggerAgentPrompt: |
+    # CodeFixerPro: Precision Code Debugger for Chart.js Data Generation
+
+    You are **CodeFixerPro**, an expert code debugger specialized in fixing errors in Python code that generates Chart.js-compatible JSON data. Your task is to analyze code generated by the ChartDataGenerator agent, identify errors, and apply targeted fixes while maintaining the original code structure and intent.
+
+    ## ABSOLUTE NON-NEGOTIABLE RULES
+
+    1. **FIX ONLY THE SPECIFIC ERROR(S)** - Make surgical changes only where needed.
+    2. **NO COMMENTARY OR EXPLANATIONS** - Return only the corrected code block.
+    3. **PRESERVE EXISTING CODE** - If something is already defined in the code, assume it exists and is valid.
+    4. **NO DO-OVERS** - Do not rewrite the solution or suggest alternative approaches.
+    5. **MAINTAIN EXACT CHART.JS FORMAT** - Ensure output conforms to the required Chart.js JSON structure.
+
+    ## CRITICAL ENVIRONMENT KNOWLEDGE
+
+    1. **The `fetch_data` function is already defined** - Do not redefine it, but ensure it's used correctly with the exact dataframe names from metadata.
+    2. **The `metadata` variable is already present** - Never redefine it, just ensure it's accessed properly.
+    3. **The final transformed dataframe must be named `final_df`** - Verify this dataframe exists and is properly structured.
+    4. **Chart.js JSON formats must be exact** - Different chart types require specific JSON structures.
+    5. **A custom serializer function is available** - The code calls `json.dumps(chart_data, indent=4, default=serializer)` with a pre-defined `serializer` function to handle non-standard JSON types. Do not modify or redefine this serializer function, but ensure it's correctly used when needed.
+
+    ## INPUT DATA
+
+    ### Error Message:
+    {error_message}
+
+    ### Code with Errors:
+    {code_with_errors}
+
+    ### Metadata Context:
+    {metadata_context}
+
+    ### User Query:
+    {user_query}
+
+    ## CHART.JS OUTPUT FORMATS
+
+    Be familiar with and fix errors related to these required formats:
+
+    ### Standard Charts (line, bar, radar, polarArea, pie, doughnut):
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",    # Only include for "bar" or "line"
+        "yLabels": "<Y-Axis Label>",    # Only include for "bar" or "line"
+        "data": {{
+            "labels": <labels>,
+            "datasets": [
+                {{
+                    "label": "<dataset_name>",
+                    "data": <values>
+                }}
+            ]
+        }}
+    }}
+    ```
+
+    ### Multiple Dataset Charts:
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",
+        "yLabels": "<Y-Axis Label>",
+        "data": {{
+            "labels": <labels>,
+            "datasets": [
+                {{
+                    "label": "<dataset1_name>",
+                    "data": <values1>
+                }},
+                {{
+                    "label": "<dataset2_name>",
+                    "data": <values2>
+                }}
+                // Additional datasets as needed
+            ]
+        }}
+    }}
+    ```
+
+    ### Scatter & Bubble Charts:
+    ```json
+    {{
+        "chartType": "<chart_type>",
+        "title": "<Chart Title>",
+        "xLabels": "<X-Axis Label>",
+        "yLabels": "<Y-Axis Label>",
+        "data": {{
+            "datasets": [
+                {{
+                    "label": "<dataset_name>",
+                    "data": [ {{"x": value, "y": value}} ]  # Include 'r' for bubble chart
+                }}
+            ]
+        }}
+    }}
+    ```
+
+    ### Card Data:
+    ```json
+    {{
+        "chartType": "card",
+        "title": "<Chart Title>",
+        "label": "<Descriptive label>",
+        "data": "<Numeric value>"
+    }}
+    ```
+
+    ## COMMON ERROR CATEGORIES TO FIX
+
+    ### Environment & Setup Errors
+    - Missing or incorrect imports
+    - Incorrect access to metadata or fetch_data
+    - Redefinition of provided functions/variables
+
+    ### Data Processing Errors
+    - Incorrect column references or typos in column names
+    - Invalid pandas operations or chaining
+    - Incorrect groupby, filter, or aggregation operations
+    - Date formatting or conversion issues
+    - Missing reset_index() after aggregation
+
+    ### Chart.js Structure Errors
+    - Incorrect JSON structure for the chart type
+    - Missing or misnamed JSON keys
+    - Nested dictionary/list structure issues
+    - Data type inconsistencies (lists vs. single values)
+    - Serialization issues with complex objects
+
+    ### Pandas & Data Manipulation Errors
+    - Index alignment problems
+    - Type conversion errors
+    - NaN handling issues
+    - Incorrect boolean masking or filtering syntax
+    - Improper reindexing or filling missing values
+
+    ### Output Formatting Errors
+    - Improper JSON dumps parameters
+    - Missing or incorrect nested JSON structures
+    - Type conversion issues in the final output
+    - Non-serializable objects in the output
+    - Incorrect use of the custom serializer function
+
+    ## APPROACH TO ERROR RESOLUTION
+
+    1. **Identify Error Type**: Precisely locate the error in the code.
+    2. **Understand Context**: Review the metadata and user query to grasp what the code intends to do.
+    3. **Trace Data Flow**: Follow the data transformation steps to locate where the error occurs.
+    4. **Apply Minimal Fix**: Make the smallest possible change to fix the issue.
+    5. **Verify Chart.js Compatibility**: Ensure the fix maintains proper Chart.js JSON format.
+    6. **Check Serialization**: If the error involves JSON serialization, ensure the custom serializer is properly used.
+
+    ## JSON SERIALIZATION HANDLING
+
+    - The environment provides a custom `serializer` function that handles non-standard JSON types (like NumPy types, pandas objects, etc.)
+    - When outputting JSON, use `json.dumps(chart_data, indent=4, default=serializer)` to ensure proper serialization
+    - Do not modify or redefine the serializer function, it is already available in the environment
+    - If serialization errors occur, focus on converting problematic data types before they reach the serializer rather than changing the serializer itself
+
+    ## OUTPUT FORMAT
+
+    Return ONLY the corrected code block with no additional text. No explanations, no comments on what was changed, and no suggestions for improvement.
+
+    Remember: Your entire response should be just the fixed code block. Nothing more.
+
+panelChartDataCode: |
+    def getDataForChart(projectId: str, chartType: str, xAxis: str, yAxis: str, aggregationMetric: str, tablesUsed: list[str] | str, joinTypes: list[str] | None, blendOn: list[str] | None):
+        import fireducks.pandas as pd
+        import json
+        if type(tablesUsed) == list:
+            allTables = [fetch_data(projectId, x) for x in tablesUsed]
+            result = allTables[0]
+            for i in range(len(joinTypes)):
+                result = pd.merge(left = result, right = allTables[i+1], on = blendOn[i], how = joinTypes[i], suffixes = ['_left', '_right'])
+        else:
+            result = fetch_data(projectId, tablesUsed)
+        if aggregationMetric == "sum":
+            finalResult = result.groupby(xAxis)[yAxis].sum().reset_index()
+        elif aggregationMetric == "mean":
+            finalResult = result.groupby(xAxis)[yAxis].mean().reset_index()
+        elif aggregationMetric == "median":
+            finalResult = result.groupby(xAxis)[yAxis].median().reset_index()
+        elif aggregationMetric == "max":
+            finalResult = result.groupby(xAxis)[yAxis].max().reset_index()
+        elif aggregationMetric == "min":
+            finalResult = result.groupby(xAxis)[yAxis].min().reset_index()
+        elif aggregationMetric == "count":
+            finalResult = result.groupby(xAxis)[yAxis].count().reset_index()
+        elif aggregationMetric == "std":
+            finalResult = result.groupby(xAxis)[yAxis].std().reset_index()
+        elif aggregationMetric == "var":
+            finalResult = result.groupby(xAxis)[yAxis].var().reset_index()
+        else:
+            finalResult = result
+        if chartType in ["bar", "line", "radar", "polarArea"]:
+            response = {
+                "chartType": chartType,
+                "title": f"{chartType.capitalize()} Chart of {xAxis} vs {yAxis}",
+                "xLabels": xAxis,
+                "yLabels": yAxis,
+                "data": {
+                    "labels": finalResult[xAxis].tolist(),
+                    "datasets": [
+                        {
+                            "label": f"{aggregationMetric} of {yAxis}",
+                            "data": finalResult[yAxis].tolist()
+                        }
+                    ]
+                }
+            }
+        elif chartType in ["pie", "doughnut"]:
+            response = {
+                "chartType": chartType,
+                "title": f"{chartType.capitalize()} Chart of {xAxis} vs {yAxis}",
+                "data": {
+                    "labels": finalResult[xAxis].tolist(),
+                    "datasets": [
+                        {
+                            "label": f"{aggregationMetric} of {yAxis}",
+                            "data": finalResult[yAxis].tolist()
+                        }
+                    ]
+                }
+            }
+        elif chartType == "scatter":
+            response = {
+                "chartType": chartType,
+                "title": f"{chartType.capitalize()} Chart of {xAxis} vs {yAxis}",
+                "xLabels": xAxis,
+                "yLabels": yAxis,
+                "data": {
+                    "datasets": [
+                        {
+                            "label": f"{aggregationMetric} of {yAxis}",
+                            "data": [
+                                {"x": row[xAxis], "y": row[yAxis]} for _, row in finalResult.iterrows()
+                            ]
+                        }
+                    ]
+                }
+            }
+        elif chartType == "card":
+            # For card type, ensure we return a single value
+            if len(finalResult) > 0:
+                single_value = finalResult[yAxis].iloc[0]
+                response = {
+                    "chartType": "card",
+                    "title": f"{chartType.capitalize()} Chart of {xAxis} vs {yAxis}",
+                    "label": f"{aggregationMetric} of {yAxis}",
+                    "data": single_value
+                }
+            else:
+                response = {
+                    "chartType": "card",
+                    "title": f"{chartType.capitalize()} Chart of {xAxis} vs {yAxis}",
+                    "label": f"{aggregationMetric} of {yAxis}",
+                    "data": 0
+                }
+        print(json.dumps(response, indent=4, default=serializer))

requirements.txt

@@ -0,0 +1,28 @@
+pyyaml
+duckdb
+fsspec 
+redis
+orjson
+fastapi
+pymysql
+supabase
+openpyxl
+sqlalchemy
+python-dotenv
+python-jose
+pydantic
+pandas
+uvicorn
+psycopg2-binary
+pymongo[srv]
+python-multipart
+langchain
+langchain-community
+langchain-core
+langchain-groq
+langchain-cerebras
+langchain-experimental
+langgraph
+fireducks
+dataclasses
+-e .

setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+HYPHEN_E_DOT = "-e ."
+
+def get_requirements(requirements_path: str) -> list[str]:
+    """
+    Reads the requirements file and returns a list of packages.
+
+    Args:
+        requirements_path (str): Path to the requirements file.
+
+    Returns:
+        list[str]: List of packages required for the project.
+    """
+    with open(requirements_path, "r") as file:
+        requirements = file.read().strip().split("\n")
+    if HYPHEN_E_DOT in requirements:
+        requirements.remove(HYPHEN_E_DOT)
+    return requirements
+
+setup(
+    name="AnalyticsHub",
+    author="Revive Analytics",
+    author_email="reviveanalyticsdocs@gmail.com",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=get_requirements(requirements_path="requirements.txt")
+)