Text2SQL app

.gitignore

@@ -0,0 +1,61 @@
+# These are some examples of commonly ignored file patterns.
+# You should customize this list as applicable to your project.
+# Learn more about .gitignore:
+#     https://www.atlassian.com/git/tutorials/saving-changes/gitignore
+
+# Node artifact files
+node_modules/
+dist/
+
+# Compiled Java class files
+*.class
+
+# Compiled Python bytecode
+*.py[cod]
+
+# Log files
+*.log
+
+# Package files
+*.jar
+
+# Maven
+target/
+dist/
+
+# JetBrains IDE
+.idea/
+
+# Unit test reports
+TEST*.xml
+
+# Generated by MacOS
+.DS_Store
+
+# Generated by Windows
+Thumbs.db
+
+# Applications
+*.app
+*.exe
+*.war
+
+# Large media files
+*.mp4
+*.tiff
+*.avi
+*.flv
+*.mov
+*.wmv
+# These are some examples of commonly ignored file patterns.
+# You should customize this list as applicable to your project.
+# Learn more about .gitignore:
+#     https://www.atlassian.com/git/tutorials/saving-changes/gitignore
+
+venv/
+.venv/
+
+**/__pycache__/
+data/*
+env.sh
+db.sqlite3

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

core/admin.py

@@ -0,0 +1,16 @@
+"""
+This file is used to register the models in the admin panel.
+"""
+
+from django.contrib import admin
+from core.models import MutualFund, Stock
+
+
+@admin.register(MutualFund)
+class MutualFundAdmin(admin.ModelAdmin):
+    list_display = ("id", "rank", "fund_name", "isin_number", "security_id")
+
+
+@admin.register(Stock)
+class StockAdmin(admin.ModelAdmin):
+    pass

core/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class CoreConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "core"

core/clients/mutual_fund.py

@@ -0,0 +1,267 @@
+"""
+
+"""
+import logging
+
+from django.conf import settings
+
+import requests
+from bs4 import BeautifulSoup
+from core.models import MutualFund
+from core.constants import MONEYCONTROL_TOPFUNDS_URL
+from data_pipeline.interfaces.api_client import DataClient
+
+
+logger = logging.getLogger(__name__)
+
+
+settings.MORNINGSTAR_API_HEADERS = {
+    "X-RapidAPI-Key": settings.MORNINGSTAR_KEY,
+    "X-RapidAPI-Host": settings.MORNINGSTAR_HOST,
+}
+
+
+class MFList(DataClient):
+    model = MutualFund
+
+    # Monring Star List MF url
+    api_url = "https://lt.morningstar.com/api/rest.svc/g9vi2nsqjb/security/screener?page=1&pageSize=15000&sortOrder=name%20asc&outputType=json&version=1&languageId=en&currencyId=INR&universeIds=FOIND%24%24ALL%7CFCIND%24%24ALL&securityDataPoints=secId%2ClegalName%2CclosePrice%2CclosePriceDate%2Cyield_M12%2CongoingCharge%2CcategoryName%2CMedalist_RatingNumber%2CstarRatingM255%2CreturnD1%2CreturnW1%2CreturnM1%2CreturnM3%2CreturnM6%2CreturnM0%2CreturnM12%2CreturnM36%2CreturnM60%2CreturnM120%2CmaxFrontEndLoad%2CmanagerTenure%2CmaxDeferredLoad%2CexpenseRatio%2Cisin%2CinitialPurchase%2CfundTnav%2CequityStyleBox%2CbondStyleBox%2CaverageMarketCapital%2CaverageCreditQualityCode%2CeffectiveDuration%2CmorningstarRiskM255%2CalphaM36%2CbetaM36%2Cr2M36%2CstandardDeviationM36%2CsharpeM36%2CtrackRecordExtension&filters=&term="
+
+    def __init__(self) -> None:
+        self.api_response = None
+        self.transformed_data = None
+
+    def extract(self):
+
+        super().extract()
+
+        logger.info("Calling Morningstar API")
+        response = requests.get(self.api_url)
+
+        # Check if the request was successful (status code 200)
+        if response.status_code == 200:
+
+            # Parse JSON response
+            self.api_response = response.json()
+            logger.info(
+                f'Morningstar API response received {len(self.api_response["rows"])} funds'
+            )
+
+        else:
+            logger.info("Received status code: {response.status_code}")
+            logger.info(response.json())
+
+    def transform(self):
+        """
+        Transform the data to the format required by the model
+        """
+
+        super().transform()
+
+        self.transformed_data = [
+            {
+                "fund_name": fund["legalName"],
+                "isin_number": fund.get("isin"),
+                "security_id": fund["secId"],
+                "data": {"list_info": fund},
+            }
+            for fund in self.api_response["rows"]
+        ]
+
+    def load(self):
+        """
+        Load the data into the database
+        """
+
+        create_count = 0
+        update_count = 0
+        for data_dict in self.transformed_data:
+            try:
+                mf = self.model.objects.get(isin_number=data_dict["isin_number"])
+                mf.data.update(data_dict["data"])
+                mf.save()
+                update_count += 1
+            except self.model.DoesNotExist:
+                mf = self.model(**data_dict)
+                mf.save()
+                create_count += 1
+
+        logger.info(
+            "Created %s records; Updated %s records", create_count, update_count
+        )
+
+
+class MFQuote(DataClient):
+    model = MutualFund
+
+    # Monring Star get quote url
+    api_url = f"https://{settings.MORNINGSTAR_HOST}/etf/get-quote"
+
+    def __init__(self, isin) -> None:
+        self.api_response = None  # {"quotes": None, "holdings": None}
+        self.transformed_data = None
+        self.isin = isin
+        self.mf = self.model.objects.get(isin_number=self.isin)
+
+    def extract(self):
+
+        logger.info(f"Calling Morningstar Quote API for quotes with isin {self.isin}")
+        querystring = {"securityId": self.mf.security_id}
+
+        response = requests.get(
+            self.api_url, headers=settings.MORNINGSTAR_API_HEADERS, params=querystring
+        )
+
+        # Check if the request was successful (status code 200)
+        if response.status_code == 200:
+            # Parse JSON response
+            self.api_response = response.json()
+        else:
+            logger.info(f"API response: %s", response.status_code)
+            response.raise_for_status()
+
+    def load(self):
+        self.mf.data.update({"quotes": self.transformed_data})
+        self.mf.save()
+        logger.info(f"Successfully stored data of quotes for {self.mf.fund_name}")
+
+
+class MFHoldings(DataClient):
+    model = MutualFund
+    api_url = f"https://{settings.MORNINGSTAR_HOST}/etf/portfolio/get-holdings"
+
+    def __init__(self, isin) -> None:
+        self.api_response = None
+        self.transformed_data = None
+        self.isin = isin
+        self.mf = self.model.objects.get(isin_number=self.isin)
+
+    def extract(self):
+
+        querystring = {"securityId": self.mf.security_id}
+
+        response = requests.get(
+            self.api_url, headers=settings.MORNINGSTAR_API_HEADERS, params=querystring
+        )
+
+        # Check if the request was successful (status code 200)
+        if response.status_code == 200:
+            # Parse JSON response
+            self.api_response = response.json()
+        else:
+            logger.info(f"received status code {response.status_code} for {self.isin}")
+            logger.debug(response.content)
+            response.raise_for_status()
+
+    def load(self):
+        self.mf.data.update({"holdings": self.transformed_data})
+        self.mf.save()
+        logger.info(f"Successfully stored data of holdings for {self.mf.fund_name}")
+
+
+class MFRiskMeasures(DataClient):
+    model = MutualFund
+    api_url = (
+        f"https://{settings.MORNINGSTAR_HOST}/etf/risk/get-risk-volatility-measures"
+    )
+
+    def __init__(self, isin) -> None:
+        self.api_response = None
+        self.isin = isin
+        self.mf = self.model.objects.get(isin_number=self.isin)
+
+    def extract(self):
+
+        querystring = {"securityId": self.mf.security_id}
+
+        response = requests.get(
+            self.api_url, headers=settings.MORNINGSTAR_API_HEADERS, params=querystring
+        )
+
+        # Check if the request was successful (status code 200)
+        if response.status_code == 200:
+            # Parse JSON response
+            self.api_response = response.json()
+        else:
+            logger.info(response.json())
+            response.raise_for_status()
+
+    def load(self):
+        self.mf.data.update({"risk_measures": self.transformed_data})
+        self.mf.save()
+        logger.info(
+            f"Successfully stored data of risk measures for {self.mf.fund_name}"
+        )
+
+
+class MFRanking(DataClient):
+
+    api_url = MONEYCONTROL_TOPFUNDS_URL
+    model = MutualFund
+
+    def __init__(self) -> None:
+        self.api_response = None
+        self.transformed_data = None
+
+    def extract(self) -> None:
+        """
+        Fetches the top mutual funds from MoneyControl website based on their returns and
+        returns a tuple containing lists of fund names, fund types, CRISIL ranks,
+        INF numbers, and AUM data of top mutual funds.
+        """
+        super().extract()
+
+        logger.info("Fetching top mutual funds from MoneyControl website")
+        response = requests.get(self.api_url)
+
+        # Check if the request was successful (status code 200)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Find all rows containing fund information
+        fund_rows = soup.find_all("tr", class_=lambda x: x and "INF" in x)
+        logger.info("Found %s rows", len(fund_rows))
+
+        fund_details = []
+
+        # Extract fund name from each row of sponsored funds
+        for row in fund_rows:
+            columns = row.find_all("td")
+            fund_name = columns[0].text.strip()
+            fund_type = columns[2].text.strip()
+            crisil_rank = columns[3].text.strip()
+            aum = columns[4].text.strip()
+            isin_number = row["class"][0]
+
+            fund_details.append(
+                {
+                    "fund_name": fund_name,
+                    "fund_type": fund_type,
+                    "crisil_rank": crisil_rank,
+                    "isin_number": isin_number,
+                    "aum": aum,
+                }
+            )
+
+        self.api_response = fund_details
+
+    def load(self) -> None:
+        """
+        Load the data into the database
+        """
+
+        # clear the rank field
+        MutualFund.objects.exclude(rank=None).update(rank=None)
+
+        for rank, fund_details in enumerate(self.transformed_data, 1):
+            mf = MutualFund.objects.get(isin_number=fund_details["isin_number"])
+            mf.crisil_rank = (
+                fund_details["crisil_rank"] if fund_details["crisil_rank"] != "-" else 0
+            )
+            mf.rank = rank
+            mf.aum = float(fund_details["aum"].replace(",", ""))
+            mf.save()
+            logger.info(
+                f"Updated {rank=} {mf.fund_name} | {fund_details=} {fund_details['crisil_rank']=} {fund_details['aum']=}"
+            )

core/clients/stock.py

@@ -0,0 +1,206 @@
+"""
+This module contains the client classes for retrieving stock data from various sources.
+"""
+
+import time
+import logging
+
+import requests
+from bs4 import BeautifulSoup
+
+from django.conf import settings
+from core.models import Stock
+from data_pipeline.interfaces.api_client import DataClient
+from core.constants import MONEYCONTROL_TOPSTOCKS_URL
+
+logger = logging.getLogger(__name__)
+
+
+class StockRankings(DataClient):
+    """ """
+
+    model = Stock
+    api_url = MONEYCONTROL_TOPSTOCKS_URL
+
+    def __init__(self) -> None:
+        self.api_response = None
+        self.transformed_data = None
+
+    def extract(self) -> None:
+
+        logger.info("Fetching data from %s", self.api_url)
+        with requests.Session() as session:
+            try:
+                response = session.get(self.api_url)
+                response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Error fetching data from {self.api_url}: {e}")
+                return
+
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            # Find the table containing stock information
+            table = soup.find("table", {"id": "indicesTable"})
+            if not table:
+                logger.warning(
+                    "Table with id 'indicesTable' not found for stock during scraping ranks."
+                )
+                raise Exception(
+                    "Table with id 'indicesTable' not found for stock during scraping ranks."
+                )
+
+            data = []
+            rows = table.find_all("tr")
+            logger.info(f"Found {len(rows)} rows in the table")
+            isin_fails = 0
+            # Extract data from each row
+            for idx, row in enumerate(rows, start=1):
+                columns = row.find_all("td")
+                isin_number = None
+                if columns:
+                    link = columns[0].find("a").get("href") if columns[0] else None
+                    if link is not None:
+                        try:
+                            logger.info(f"Fetching stock details from link {link}")
+                            response = session.get(link)
+                            time.sleep(2)
+                            response.raise_for_status()
+                            soup = BeautifulSoup(response.text, "html.parser")
+                            isin_element = soup.select_one(
+                                'li.clearfix span:contains("ISIN") + p'
+                            )
+                            if isin_element:
+                                isin_number = isin_element.get_text(strip=True)
+                            else:
+                                isin_fails += 1
+                                logger.warning(f"ISIN not found for link {link}")
+                        except requests.exceptions.RequestException as e:
+                            logger.exception(
+                                f"Error fetching ISIN from link {link}: {e}"
+                            )
+                    data.append(
+                        {
+                            "name": columns[0].get_text(strip=True),
+                            "ltp": columns[1].get_text(strip=True),
+                            "link": link,
+                            "volume": columns[4].get_text(strip=True),
+                            "percentage_change": columns[2].get_text(strip=True),
+                            "price_change": columns[3].get_text(strip=True),
+                            "rank": idx,
+                            "isin_number": isin_number,
+                        }
+                    )
+            logger.info(f"ISIN not found for {isin_fails} stocks out of {len(rows)}")
+
+        self.api_response = data
+
+    def load(self) -> None:
+        """
+        Load the data into the database
+        """
+        logger.info("Loading ranking data into the database...")
+        # clear the rank field
+        Stock.objects.exclude(rank=None).update(rank=None)
+
+        for rank, stock_details in enumerate(self.transformed_data, 1):
+            try:
+                stock = Stock.objects.get(isin_number=stock_details["isin_number"])
+            except Stock.DoesNotExist:
+                logger.warning(
+                    f"No matching stock found for ISIN: {stock_details['isin_number']} creating new object..."
+                )
+                stock = Stock.objects.create(data={"stock_rank": stock_details})
+
+            else:
+                stock.data.update({"stock_rank": stock_details})
+
+            stock.name = stock_details["name"]
+            stock.ltp = stock_details["ltp"]
+            stock.percentage_change = stock_details["percentage_change"]
+            stock.price_change = stock_details["price_change"]
+            stock.link = stock_details["link"]
+            stock.volume = stock_details["volume"]
+            stock.isin_number = stock_details["isin_number"]
+            stock.rank = stock_details["rank"]
+            stock.save()
+
+            logger.info(
+                f"Saved {rank=} {stock.name} | {stock_details=} {stock_details['isin_number']=}"
+            )
+
+
+class StockDetails(DataClient):
+    """
+    Retrieves and updates stock details from the Morningstar API.
+    """
+
+    model = Stock
+    api_url = f"https://{settings.MORNINGSTAR_HOST}/stock/get-detail"
+
+    def __init__(self, perf_id: str, isin_number: str) -> None:
+        """
+        Initializes the StockDetails object.
+
+        Args:
+            perf_id (str): Performance ID of the stock.
+            isin_number (str): ISIN number of the stock.
+        """
+        if not perf_id:
+            raise ValueError("Performance ID cannot be empty.")
+        if not isin_number:
+            raise ValueError("ISIN number cannot be empty.")
+
+        self.api_response = {"details": None}
+        self.perf_id = perf_id
+        self.isin_number = isin_number
+
+    def _request(self) -> requests.Response:
+
+        querystring = {"PerformanceId": self.perf_id}
+        return requests.get(
+            self.api_url,
+            headers=settings.MORNINGSTAR_API_HEADERS,
+            params=querystring,
+        )
+
+    def extract(self) -> None:
+        """
+        Extracts stock details from the Morningstar API.
+        """
+
+        response = self._request()
+
+        requests_count = 1
+        while response.status_code != 200:
+            if response.status_code == 429:
+
+                logger.info(
+                    f"API response: %s. Waiting for %s secs",
+                    response.status_code,
+                    30 * requests_count,
+                )
+                time.sleep(30 * requests_count)
+                response = self._request()
+                if requests_count > 3:
+                    logger.warning(
+                        f"API response: %s. Max retries reached", response.status_code
+                    )
+                    break
+                requests_count += 1
+
+        else:
+            self.api_response["details"] = response.json()
+            logger.info(f"API response: %s", response.status_code)
+
+    def load(self) -> None:
+        """
+        Loads the retrieved stock details into the database.
+        """
+
+        stock = Stock.objects.filter(isin_number=self.isin_number).first()
+        if stock is None:
+            logger.warning(f"No matching stock found for ISIN: {self.isin_number}")
+            return
+        stock.data = self.transformed_data
+        stock.save()
+        logger.info(f"Successfully stored data for {stock.isin_number}.")

core/constants.py

@@ -0,0 +1,4 @@
+MONEYCONTROL_TOPFUNDS_URL = "https://www.moneycontrol.com/mutual-funds/performance-tracker/returns/large-cap-fund.html"
+MONEYCONTROL_TOPSTOCKS_URL = "https://www.moneycontrol.com/markets/indian-indices/changeTableData?deviceType=web&exName=N&indicesID=49&selTab=o&subTabOT=d&subTabOPL=cl&selPage=marketTerminal&classic=true"
+TOPFUNDS_COUNT = 30
+STOCKS_MAX_RANK = 1000

core/cron.py

@@ -0,0 +1,9 @@
+from data_pipeline import MFList
+
+
+def store_mutual_funds():
+    mf_list = MFList()
+    mf_list.extract()
+    mf_list.transform()
+    mf_list.load()
+    print("Stored successfully")

core/management/commands/text2sql_eval.py

@@ -0,0 +1,50 @@
+import logging
+import time
+import csv
+from django.core.management.base import BaseCommand
+from core.text2sql.handler import QueryDataHandler
+from core.text2sql.prompt import get_prompt
+from core.text2sql.eval_queries import queries
+
+logger = logging.getLogger(__name__)
+
+class Command(BaseCommand):
+    help = "Morningstar API to save the JSON response to a file which contains secIds with other details"
+
+    def handle(self, *args, **options) -> None:
+        t1 = time.perf_counter()
+        q=[]
+        count =1
+        for query in queries[26:]:
+            print("count: ", query["Query Number"])
+            prompt = get_prompt(query["Query Description"])
+            logger.info(f"Prompt: {prompt}")
+            generated_query, data = QueryDataHandler().get_data_from_query(prompt)
+            print(f"Description: {query['Query Description']}, Query: {query.get('SQL Statement')}, Generated: {generated_query} ")
+            q.append({
+                "Query Number": query["Query Number"],
+                "Complexity Level": query["Complexity Level"],
+                "Description": query["Query Description"],
+                "Query": query.get("SQL Statement", "-"),
+                "Generated": generated_query,
+            })
+            count+=1
+            time.sleep(1)
+        csv_file_path = 'queries_data.csv'
+
+        # Writing data to CSV
+        with open(csv_file_path, 'w', newline='', encoding='utf-8') as csv_file:
+            fieldnames = q[0].keys()
+            print(fieldnames)
+            writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
+
+            # Write the header
+            writer.writeheader()
+
+            # Write the data
+            writer.writerows(q)
+
+        print(f'Data has been written to {csv_file_path}.')
+        self.stdout.write(f"Time taken for evaluation: {time.perf_counter() - t1}")
+    
+

core/management/commands/update_mf.py

@@ -0,0 +1,92 @@
+"""
+This command is used to fetch all the data relating to mutual funds and save it to the database.
+"""
+
+import logging
+import time
+
+from django.core.management.base import BaseCommand
+from core.constants import MONEYCONTROL_TOPSTOCKS_URL
+from core.models import MutualFund
+from core.clients.mutual_fund import (
+    MFList,
+    MFQuote,
+    MFHoldings,
+    MFRiskMeasures,
+    MFRanking,
+)
+from core.clients.stock import StockDetails, StockRankings
+
+logger = logging.getLogger(__name__)
+
+
+def get_funds_details() -> None:
+    """
+    Get the details of the top 30 mutual funds and store them in the database.
+    """
+
+    t1 = time.perf_counter()
+    mutual_funds = MutualFund.objects.exclude(rank=None).order_by("rank")[:30]
+    logger.info(f"{mutual_funds=}")
+    for mf in mutual_funds:
+        # fetching the quotes data from the morningstar api and storing it in the database
+        MFQuote(mf.isin_number).run()
+        time.sleep(2)
+        # fetching the holdings data from the morningstar api and storing it in the database
+        MFHoldings(mf.isin_number).run()
+        time.sleep(2)
+
+        # fetching the risk measures data from the morningstar api and storing it in the database
+        MFRiskMeasures(mf.isin_number).run()
+        time.sleep(2)
+
+    logger.info("Time taken: %s", time.perf_counter() - t1)
+
+
+def get_stock_details() -> None:
+    """
+    Retrieves stock details for the top 30 mutual funds and updates the database.
+    """
+    count = 0
+    t1 = time.perf_counter()
+    mutual_funds = MutualFund.objects.exclude(rank=None).order_by("rank")[:30]
+
+    for mf in mutual_funds:
+
+        try:
+            holdings = (
+                mf.data["holdings"].get("equityHoldingPage", {}).get("holdingList", [])
+            )
+        except KeyError:
+            logger.warning("KeyError for holdings on Mutual Fund %s", mf.isin_number)
+
+        for holding in holdings:
+            performance_id = holding.get("performanceId")
+            isin = holding.get("isin")
+
+            if not performance_id or not isin:
+                logger.warning("Missing performanceId or isin for Mutual Fund %s", isin)
+                MFHoldings(mf.isin_number).run()
+
+            stock_details = StockDetails(performance_id, isin)
+            stock_details.run()
+            count += 1
+
+    logger.info("Processed count: %s", count)
+    logger.info("Time taken by stock details: %s", time.perf_counter() - t1)
+
+
+class Command(BaseCommand):
+    help = "Morningstar API to save the JSON response to a file which contains secIds with other details"
+
+    def handle(self, *args, **options) -> None:
+        t1 = time.perf_counter()
+        try:
+            MFList().run()
+            MFRanking().run()
+            get_funds_details()
+            StockRankings().run()
+            get_stock_details()
+        except Exception as e:
+            logger.exception(e)
+        self.stdout.write(f"Time taken by: {time.perf_counter() - t1}")

core/mfrating/score_calculator.py

@@ -0,0 +1,235 @@
+"""
+This module defines a class, MFRating, which provides methods for calculating
+the weighted rating and overall score for mutual funds based on various parameters.
+  
+"""
+import logging
+from typing import List, Dict, Any
+import numpy as np
+from django.db.models import Max, Min
+from core.models import MutualFund, Stock
+
+
+logger = logging.getLogger(__name__)
+
+
+class MFRating:
+    """
+    This class provides methods for calculating the weighted stock rank rating and overall score for mutual funds based on various parameters.
+    """
+
+    def __init__(self, max_rank: int = 1000) -> None:
+        self.max_rank = max_rank
+        self.scores = {
+            "stock_ranking_score": [10],
+            "crisil_rank_score": [10],
+            "churn_score": [10],
+            "sharperatio_score": [10],
+            "expenseratio_score": [10],
+            "aum_score": [10],
+            "alpha_score": [10],
+            "beta_score": [10],
+        }
+
+    def get_weighted_score(self, values: List[float]) -> float:
+        """
+        Calculates the weighted rating based on the weights and values provided.
+        """
+        weights = []
+        values = []
+        for _, (weight, score) in self.scores.items():
+            weights.append(weight)
+            values.append(score)
+
+        return np.average(values, weights=weights)
+
+    def get_rank_rating(self, stock_ranks: List[int]) -> List[float]:
+        """
+        Calculates the rank rating based on the stock ranks and the maximum rank.
+        """
+        return [
+            (self.max_rank - (rank if rank else self.max_rank)) / self.max_rank
+            for rank in stock_ranks
+        ]
+
+    def get_overall_score(self, **kwargs) -> float:
+        """
+        It returns the overall weighted score for mutual funds based on various parameters.
+
+        """
+
+        stock_rankings = self.get_rank_rating(kwargs.get("stock_rankings"))
+        # what np.average do?
+        # Multiply each element in the stock_rankings array by its corresponding weights, then Sum up the results, then divide by the sum of the weights.
+        # data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        # weights = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+        #
+        # Multiply each element in the data array by its corresponding weight:
+        # [1*10, 2*9, 3*8, 4*7, 5*6, 6*5, 7*4, 8*3, 9*2, 10*1]
+        # [10, 18, 24, 28, 30, 30, 28, 24, 18, 10]
+        #
+        # Sum up the results:
+        # 10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18 + 10 = 220
+        #
+        # Sum up the weights:
+        # 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 55
+        #
+        # Divide the sum of the weighted elements by the sum of the weights:
+        # 220 / 55 = 4.0
+        self.scores["stock_ranking_score"].append(
+            np.average(stock_rankings, weights=kwargs.get("stock_weights"))
+        )
+        self.scores["alpha_score"].append(kwargs.get("alpha", 0) / 100)
+        self.scores["beta_score"].append((2 - kwargs.get("beta", 2)) / 2)
+        self.scores["crisil_rank_score"].append(
+            (kwargs.get("crisil_rank_score", 0)) / 5
+        )
+        self.scores["churn_score"].append(kwargs.get("churn_rate", 0) / 100)
+        self.scores["sharperatio_score"].append(kwargs.get("sharpe_ratio", 0) / 100)
+        self.scores["expenseratio_score"].append(kwargs.get("expense_ratio", 0) / 100)
+        max_aum, min_aum, aum = kwargs.get("aum_score", (1, 0, 0))
+        self.scores["aum_score"].append((aum - min_aum) / (max_aum - min_aum))
+        # Calculate the overall rating using weighted sum
+
+        return self.get_weighted_score(self.scores)
+
+
+class MutualFundScorer:
+    def __init__(self) -> None:
+        self.mf_scores = []
+
+    def _get_stock_ranks(self, isin_ids: List[str]) -> List[int]:
+        """Get stock ranks based on ISIN ids."""
+
+        return list(
+            Stock.objects.filter(isin_number__in=isin_ids)
+            .order_by("rank")
+            .values_list("rank", "isin_number")
+        )
+
+    def _get_mutual_funds(self) -> List[MutualFund]:
+        """Get a list of top 30 mutual funds based on rank."""
+
+        return MutualFund.objects.exclude(rank=None).order_by("rank")[:30]
+
+    def _get_risk_measure(
+        self, risk_measures: Dict[str, Any], key: str, year: str
+    ) -> float:
+        """
+        Get value of the specified key from the risk_measures dictionary for the given year.
+        """
+        try:
+            value = risk_measures.get(year, {}).get(key, 0)
+            return float(value)
+        except (TypeError, ValueError):
+            return 0
+
+    def _get_most_non_null_key(self, key, mutual_funds):
+        """
+        Get the year with the maximum number of non-None values for the specified key
+        within the given mutual funds.
+        """
+        year_counts = {
+            "for15Year": 0,
+            "for10Year": 0,
+            "for5Year": 0,
+            "for3Year": 0,
+            "for1Year": 0,
+        }
+
+        for mf in mutual_funds:
+            risk_measures = mf.data["risk_measures"].get("fundRiskVolatility", {})
+
+            for year in year_counts:
+                if risk_measures.get(year, {}).get(key) is not None:
+                    year_counts[year] += 1
+
+        most_non_null_year = max(year_counts, key=year_counts.get)
+        return most_non_null_year
+
+    def get_scores(self) -> List[Dict[str, Any]]:
+        """Calculate scores for mutual funds and return the results."""
+
+        logger.info("Calculating scores for mutual funds...")
+        max_aum = MutualFund.objects.exclude(rank=None).aggregate(max_price=Max("aum"))[
+            "max_price"
+        ]
+        min_aum = MutualFund.objects.exclude(rank=None).aggregate(min_price=Min("aum"))[
+            "min_price"
+        ]
+        mutual_funds = self._get_mutual_funds()
+
+        # Get the year with the maximum number of non-None values for sharpeRatio, alpha and beta
+        sharpe_ratio_year = self._get_most_non_null_key("sharpeRatio", mutual_funds)
+        alpha_year = self._get_most_non_null_key("alpha", mutual_funds)
+        beta_year = self._get_most_non_null_key("beta", mutual_funds)
+        for mf in mutual_funds:
+            mf_rating = MFRating(
+                max_rank=1000,
+            )
+            logger.info(f"Processing mutual fund: %s", mf.fund_name)
+            holdings = (
+                mf.data.get("holdings", {})
+                .get("equityHoldingPage", {})
+                .get("holdingList", [])
+            )
+            portfolio_holding_weights = {
+                holding.get("isin"): (
+                    holding.get("weighting") if holding.get("weighting") else 0
+                )
+                for holding in holdings
+                if holding.get("isin")
+            }
+            stock_ranks_and_weights = [
+                (rank, portfolio_holding_weights[isin])
+                for rank, isin in self._get_stock_ranks(
+                    portfolio_holding_weights.keys()
+                )
+            ]
+            stock_ranks, stock_weights = zip(*stock_ranks_and_weights)
+            sharpe_ratio = self._get_risk_measure(
+                mf.data["risk_measures"].get("fundRiskVolatility", {}),
+                "sharpeRatio",
+                sharpe_ratio_year,
+            )
+            alpha = self._get_risk_measure(
+                mf.data["risk_measures"].get("fundRiskVolatility", {}),
+                "alpha",
+                alpha_year,
+            )
+            beta = self._get_risk_measure(
+                mf.data["risk_measures"].get("fundRiskVolatility", {}),
+                "beta",
+                beta_year,
+            )
+            overall_score = mf_rating.get_overall_score(
+                stock_rankings=stock_ranks,
+                stock_weights=stock_weights,
+                churn_rate=mf.data["quotes"]["lastTurnoverRatio"]
+                if mf.data["quotes"].get("lastTurnoverRatio")
+                else 0,
+                sharpe_ratio=sharpe_ratio,
+                expense_ratio=mf.data["quotes"]["expenseRatio"],
+                crisil_rank_score=mf.crisil_rank,
+                aum_score=(max_aum, min_aum, mf.aum),
+                alpha=alpha,
+                beta=beta,
+            )
+
+            self.mf_scores.append(
+                {
+                    "isin": mf.isin_number,
+                    "name": mf.fund_name,
+                    "rank": mf.rank,
+                    "sharpe_ratio": round(sharpe_ratio, 4),
+                    "churn_rate": mf.data["quotes"].get("lastTurnoverRatio", 0),
+                    "expense_ratio": mf.data["quotes"].get("expenseRatio", 0),
+                    "aum": mf.aum,
+                    "alpha": round(alpha, 4),
+                    "beta": round(beta, 4),
+                    "crisil_rank": mf.crisil_rank,
+                    "overall_score": round(overall_score, 4),
+                }
+            )
+        logger.info("Finished calculating scores.")
+        return sorted(self.mf_scores, key=lambda d: d["overall_score"], reverse=True)

core/middleware.py

@@ -0,0 +1,55 @@
+import logging
+import traceback
+
+from django.http import JsonResponse
+
+
+logger = logging.getLogger(__name__)
+
+
+class ExceptionMiddleware:
+    """
+    Middleware to catch exceptions and handle them with appropriate logging and JSON response.
+    """
+
+    def __init__(self, get_response):
+        """
+        Initializes the ExceptionMiddleware with the provided get_response function.
+        """
+        self.get_response = get_response
+
+    def __call__(self, request):
+        """
+        Process the request and call the next middleware or view function in the chain.
+        """
+        response = self.get_response(request)
+        return response
+
+    def process_exception(self, request, exception):
+        """
+        Called when a view function raises an exception.
+        """
+        error_type = exception.__class__.__name__
+        error_message = exception.args
+        logger.info(f"Error Type: {error_type} | Error Message: {error_message}")
+        logger.debug("Request Details: %s", request.__dict__)
+        logger.exception(traceback.format_exc())
+
+        if isinstance(exception, KeyError):
+            status_code = 400
+            message = f"Please Add Valid Data For {error_message[0]}"
+            error = "BAD_REQUEST"
+        elif isinstance(exception, AttributeError):
+            status_code = 500
+            message = "Something Went Wrong. Please try again."
+            error = "SOMETHING_WENT_WRONG"
+        elif isinstance(exception, TypeError):
+            status_code = 500
+            message = "Something Went Wrong. Please try again."
+            error = "SOMETHING_WENT_WRONG"
+        else:
+            status_code = 500
+            message = "Something Went Wrong. Please try again."
+            error = "SOMETHING_WENT_WRONG"
+
+        return JsonResponse({"message": message, "error": error}, status=status_code)

core/migrations/0001_initial.py

@@ -0,0 +1,41 @@
+# Generated by Django 4.2 on 2023-12-05 10:58
+
+from django.db import migrations, models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="MutualFund",
+            fields=[
+                ("created_at", models.DateTimeField(auto_now_add=True, null=True)),
+                ("updated_at", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                ("fund_house", models.CharField(max_length=200)),
+                (
+                    "isin_number",
+                    models.CharField(max_length=50, null=True, unique=True),
+                ),
+                ("security_id", models.CharField(max_length=50, unique=True)),
+                ("data", models.JSONField(null=True)),
+                ("rank", models.IntegerField(null=True, unique=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+    ]

core/migrations/0002_rename_fund_house_mutualfund_fund_name.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2023-12-06 05:44
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="mutualfund",
+            old_name="fund_house",
+            new_name="fund_name",
+        ),
+    ]

core/migrations/0002_stock.py

@@ -0,0 +1,41 @@
+# Generated by Django 4.2 on 2023-12-06 13:59
+
+from django.db import migrations, models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Stock",
+            fields=[
+                ("created_at", models.DateTimeField(auto_now_add=True, null=True)),
+                ("updated_at", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                ("name", models.CharField(max_length=200)),
+                ("ltp", models.CharField(max_length=50, null=True)),
+                ("percentage_change", models.CharField(max_length=50, null=True)),
+                ("price_change", models.CharField(max_length=50, null=True)),
+                ("link", models.URLField(max_length=50, null=True)),
+                ("volume", models.CharField(max_length=50, null=True)),
+                ("data", models.JSONField(null=True)),
+                ("rank", models.IntegerField(null=True, unique=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+    ]

core/migrations/0003_alter_mutualfund_fund_name.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2023-12-12 11:29
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0002_rename_fund_house_mutualfund_fund_name"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="mutualfund",
+            name="fund_name",
+            field=models.CharField(max_length=200, unique=True),
+        ),
+    ]

core/migrations/0003_alter_stock_link.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2023-12-06 14:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0002_stock"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="stock",
+            name="link",
+            field=models.URLField(null=True),
+        ),
+    ]

core/migrations/0004_stock_isin_number.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2023-12-07 06:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0003_alter_stock_link"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="stock",
+            name="isin_number",
+            field=models.CharField(max_length=50, null=True, unique=True),
+        ),
+    ]

core/migrations/0005_merge_20231211_0610.py

@@ -0,0 +1,13 @@
+# Generated by Django 4.2 on 2023-12-11 06:10
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0002_rename_fund_house_mutualfund_fund_name"),
+        ("core", "0004_stock_isin_number"),
+    ]
+
+    operations = []

core/migrations/0006_mutualfund_crisil_rank.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2023-12-14 12:15
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0005_merge_20231211_0610"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="mutualfund",
+            name="crisil_rank",
+            field=models.IntegerField(null=True),
+        )
+    ]

core/migrations/0007_merge_20231214_1924.py

@@ -0,0 +1,13 @@
+# Generated by Django 4.2 on 2023-12-14 19:24
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0003_alter_mutualfund_fund_name"),
+        ("core", "0006_mutualfund_crisil_rank"),
+    ]
+
+    operations = []

core/migrations/0008_mutualfund_aum.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2023-12-14 19:24
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0007_merge_20231214_1924"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="mutualfund",
+            name="aum",
+            field=models.FloatField(null=True),
+        ),
+    ]

core/migrations/0009_mutualfund_expense_ratio_mutualfund_return_m12_and_more.py

@@ -0,0 +1,106 @@
+# Generated by Django 4.2 on 2024-01-09 12:19
+
+from django.db import migrations, models
+import django.db.models.deletion
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0008_mutualfund_aum"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="mutualfund",
+            name="expense_ratio",
+            field=models.FloatField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="mutualfund",
+            name="return_m12",
+            field=models.FloatField(blank=True, null=True),
+        ),
+        migrations.CreateModel(
+            name="MFVolatility",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                (
+                    "year",
+                    models.CharField(
+                        choices=[
+                            (1, "for1Year"),
+                            (3, "for3Year"),
+                            (5, "for5Year"),
+                            (10, "for10Year"),
+                            (15, "for15Year"),
+                        ],
+                        max_length=100,
+                    ),
+                ),
+                ("alpha", models.FloatField(blank=True, null=True)),
+                ("beta", models.FloatField(blank=True, null=True)),
+                ("sharpe_ratio", models.FloatField(blank=True, null=True)),
+                ("standard_deviation", models.FloatField(blank=True, null=True)),
+                (
+                    "mutual_fund",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="core.mutualfund",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="MFHoldings",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                ("isin_number", models.CharField(max_length=20)),
+                ("security_id", models.CharField(max_length=20)),
+                ("sector", models.CharField(max_length=50)),
+                ("country", models.CharField(max_length=50)),
+                ("currency", models.CharField(max_length=20)),
+                ("weighting", models.FloatField(blank=True, null=True)),
+                ("sector_code", models.CharField(max_length=20)),
+                ("holding_type", models.CharField(max_length=20)),
+                ("market_value", models.FloatField(blank=True, null=True)),
+                (
+                    "stock_rating",
+                    models.CharField(blank=True, max_length=10, null=True),
+                ),
+                ("total_assets", models.FloatField(blank=True, null=True)),
+                ("currency_name", models.CharField(max_length=50)),
+                ("maturity_date", models.DateField(blank=True, null=True)),
+                ("security_name", models.CharField(max_length=100)),
+                ("security_type", models.CharField(max_length=10)),
+                ("holding_type_id", models.CharField(max_length=1)),
+                ("number_of_shares", models.FloatField(blank=True, null=True)),
+                ("one_year_return", models.FloatField(blank=True, null=True)),
+                ("nav", models.FloatField(blank=True, null=True)),
+                (
+                    "mutual_fund",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="core.mutualfund",
+                    ),
+                ),
+            ],
+        ),
+    ]

core/migrations/0010_remove_mfholdings_nav_mutualfund_nav.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2 on 2024-01-09 12:24
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0009_mutualfund_expense_ratio_mutualfund_return_m12_and_more"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="mfholdings",
+            name="nav",
+        ),
+        migrations.AddField(
+            model_name="mutualfund",
+            name="nav",
+            field=models.FloatField(blank=True, null=True),
+        ),
+    ]

core/migrations/0011_remove_mfholdings_maturity_date_and_more.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2 on 2024-01-09 12:49
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0010_remove_mfholdings_nav_mutualfund_nav"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="mfholdings",
+            name="maturity_date",
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="holding_type_id",
+            field=models.CharField(max_length=10),
+        ),
+    ]

core/migrations/0012_alter_mfholdings_isin_number.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2024-01-09 13:06
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0011_remove_mfholdings_maturity_date_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="isin_number",
+            field=models.CharField(blank=True, max_length=20, null=True),
+        ),
+    ]

core/migrations/0013_alter_mfholdings_country_alter_mfholdings_currency_and_more.py

@@ -0,0 +1,63 @@
+# Generated by Django 4.2 on 2024-01-09 13:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0012_alter_mfholdings_isin_number"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="country",
+            field=models.CharField(blank=True, max_length=50, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="currency",
+            field=models.CharField(blank=True, max_length=20, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="currency_name",
+            field=models.CharField(blank=True, max_length=50, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="holding_type",
+            field=models.CharField(blank=True, max_length=20, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="holding_type_id",
+            field=models.CharField(blank=True, max_length=10, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="sector",
+            field=models.CharField(blank=True, max_length=50, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="sector_code",
+            field=models.CharField(blank=True, max_length=20, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="security_id",
+            field=models.CharField(blank=True, max_length=20, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="security_name",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="security_type",
+            field=models.CharField(blank=True, max_length=10, null=True),
+        ),
+    ]

core/migrations/0014_alter_mfholdings_currency_and_more.py

@@ -0,0 +1,48 @@
+# Generated by Django 4.2 on 2024-01-09 13:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0013_alter_mfholdings_country_alter_mfholdings_currency_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="currency",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="currency_name",
+            field=models.CharField(blank=True, max_length=150, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="holding_type",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="holding_type_id",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="sector_code",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="security_type",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AlterField(
+            model_name="mfholdings",
+            name="stock_rating",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+    ]

core/migrations/0015_rename_security_name_mfholdings_holding_name_and_more.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2 on 2024-01-09 14:10
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0014_alter_mfholdings_currency_and_more"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="mfholdings",
+            old_name="security_name",
+            new_name="holding_name",
+        ),
+        migrations.RemoveField(
+            model_name="mfholdings",
+            name="security_type",
+        ),
+    ]

core/models.py

@@ -0,0 +1,100 @@
+import uuid
+from django.db import models, connection
+
+
+class BaseModel(models.Model):
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    created_at = models.DateTimeField(auto_now_add=True, null=True, blank=True)
+    updated_at = models.DateTimeField(auto_now=True, null=True, blank=True)
+
+    class Meta:
+        abstract = True
+
+
+class MutualFund(BaseModel):
+    """
+    This model will store the mutual fund data
+    """
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    fund_name = models.CharField(max_length=200, unique=True)
+    isin_number = models.CharField(max_length=50, unique=True, null=True)
+    security_id = models.CharField(max_length=50, unique=True)
+    data = models.JSONField(null=True)
+    rank = models.IntegerField(unique=True, null=True)
+    crisil_rank = models.IntegerField(null=True)
+    aum = models.FloatField(null=True)
+    expense_ratio = models.FloatField(null=True, blank=True)
+    return_m12 = models.FloatField(null=True, blank=True)
+    nav = models.FloatField(null=True, blank=True)
+
+    @staticmethod
+    def execute_raw_sql_query(sql_query):
+        with connection.cursor() as cursor:
+            cursor.execute(sql_query)
+            columns = [col[0] for col in cursor.description]
+            results = [dict(zip(columns, row)) for row in cursor.fetchall()]
+
+        return results
+
+    @classmethod
+    def execute_query(cls, query):
+        try:
+            return cls.execute_raw_sql_query(query)
+        except Exception as e:
+            return []
+
+class Stock(BaseModel):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=200)
+    ltp = models.CharField(max_length=50, null=True)
+    percentage_change = models.CharField(max_length=50, null=True)
+    price_change = models.CharField(max_length=50, null=True)
+    link = models.URLField(max_length=200, null=True)
+    volume = models.CharField(max_length=50, null=True)
+    data = models.JSONField(null=True)
+    isin_number = models.CharField(max_length=50, unique=True, null=True)
+    rank = models.IntegerField(unique=True, null=True)
+
+
+class MFHoldings(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    isin_number = models.CharField(max_length=20, null=True, blank=True)
+    security_id = models.CharField(max_length=20, null=True, blank=True)
+    sector = models.CharField(max_length=50, null=True, blank=True)
+    country = models.CharField(max_length=50, null=True, blank=True)
+    currency = models.CharField(max_length=100, null=True, blank=True)
+    weighting = models.FloatField(null=True, blank=True)
+    sector_code = models.CharField(max_length=100, null=True, blank=True)
+    holding_type = models.CharField(max_length=100, null=True, blank=True)
+    market_value = models.FloatField(null=True, blank=True)
+    stock_rating = models.CharField(max_length=100, null=True, blank=True)
+    total_assets = models.FloatField(null=True, blank=True)
+    currency_name = models.CharField(max_length=150, null=True, blank=True)
+    holding_name = models.CharField(max_length=100, null=True, blank=True)
+    holding_type = models.CharField(max_length=100, null=True, blank=True)
+    holding_type_id = models.CharField(max_length=100, null=True, blank=True)
+    number_of_shares = models.FloatField(null=True, blank=True)
+    one_year_return = models.FloatField(null=True, blank=True)
+    mutual_fund = models.ForeignKey(MutualFund, on_delete=models.CASCADE)
+
+    def __str__(self):
+        return f"{self.ticker} - {self.securityName}"
+
+
+class MFVolatility(models.Model):
+    VOLATILITY_CHOICES = (
+        (1, "for1Year"),
+        (3, "for3Year"),
+        (5, "for5Year"),
+        (10, "for10Year"),
+        (15, "for15Year"),
+    )
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    mutual_fund = models.ForeignKey(MutualFund, on_delete=models.CASCADE)
+    year = models.CharField(max_length=100, choices=VOLATILITY_CHOICES)
+    alpha = models.FloatField(null=True, blank=True)
+    beta = models.FloatField(null=True, blank=True)
+    sharpe_ratio = models.FloatField(null=True, blank=True)
+    standard_deviation = models.FloatField(null=True, blank=True)

core/test_models.py

@@ -0,0 +1,42 @@
+from django.test import TestCase
+from core.models import MutualFund
+
+
+class TestMutualFund(TestCase):
+    def test_model_creation(self):
+        # Create a new MutualFund instance
+        mutual_fund1 = MutualFund(
+            fund_name="Test Fund 1",
+            isin_number="123456789012",
+            security_id="MST01234",
+            data={
+                "details": {
+                    "legalName": "Test Fund 1",
+                    "isin": "123456789012",
+                    "secId": "MST01234",
+                }
+            },
+        )
+
+        # Save the MutualFund instance to the database
+        mutual_fund1.save()
+
+        # Check if the MutualFund instance was saved successfully
+        self.assertEqual(MutualFund.objects.count(), 1)
+
+        mutual_fund2 = MutualFund(
+            fund_name="Test Fund 2",
+            isin_number="9876543210",
+            security_id="MST56789",
+            data={
+                "details": {
+                    "legalName": "Test Fund 2",
+                    "isin": "9876543210",
+                    "secId": "MST56789",
+                }
+            },
+        )
+        mutual_fund2.save()
+
+        self.assertNotEqual(mutual_fund1.id, mutual_fund2.id)
+        self.assertEqual(MutualFund.objects.count(), 2)

core/tests/data.py

@@ -0,0 +1,339 @@
+test_data = {
+    1: {
+        "quotes": {"expenseRatio": 0.023399999999999997, "lastTurnoverRatio": 0.1568},
+        "holdings": {
+            "equityHoldingPage": {
+                "pageSize": 100,
+                "totalPage": 1,
+                "pageNumber": 1,
+                "holdingList": [
+                    {
+                        "isin": "INE280A01028",
+                        "weighting": 9.3,
+                    },
+                    {
+                        "isin": "INE002A01018",
+                        "weighting": 7.1,
+                    },
+                    {"isin": "INE090A01021", "weighting": 2.4},
+                    {"isin": "INE040A01034", "weighting": 1.1},
+                ],
+            },
+        },
+        "list_info": {"isin": "MF123"},
+        "risk_measures": {
+            "cur": "INR",
+            "fundName": "Testing fund 2",
+            "indexName": "Morningstar India GR INR",
+            "categoryName": "Large-Cap",
+            "fundRiskVolatility": {
+                "endDate": "2023-11-30T06:00:00.000",
+                "for1Year": {
+                    "beta": 1.002,
+                    "alpha": 4.464,
+                    "rSquared": 98.8,
+                    "sharpeRatio": 0.877,
+                    "standardDeviation": 11.355,
+                },
+                "for3Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for5Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for10Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for15Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "bestFitIndexName": None,
+                "forLongestTenure": None,
+                "bestFitBetaFor3Year": None,
+                "primaryIndexNameNew": "S&P BSE 100 India TR INR",
+                "bestFitAlphaFor3Year": None,
+                "bestFitRSquaredFor3Year": None,
+            },
+        },
+    },
+    2: {
+        "quotes": {"expenseRatio": 0.023399999999999997, "lastTurnoverRatio": 0.5158},
+        "holdings": {
+            "equityHoldingPage": {
+                "pageSize": 100,
+                "totalPage": 1,
+                "pageNumber": 1,
+                "holdingList": [
+                    {"isin": "INE040A01034", "weighting": 7.6},
+                    {"isin": "INE154A01025", "weighting": 1.1},
+                    {"isin": "INE018A01030", "weighting": 3.2},
+                    {"isin": "INE154A01025", "weighting": 3.1},
+                ],
+            },
+        },
+        "list_info": {"isin": "MF123"},
+        "risk_measures": {
+            "cur": "INR",
+            "fundName": "Testing fund 2",
+            "indexName": "Morningstar India GR INR",
+            "categoryName": "Large-Cap",
+            "fundRiskVolatility": {
+                "endDate": "2023-11-30T06:00:00.000",
+                "for1Year": {
+                    "beta": 0.994,
+                    "alpha": 0.337,
+                    "rSquared": 98.8,
+                    "sharpeRatio": 0.341,
+                    "standardDeviation": 11.355,
+                },
+                "for3Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for5Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for10Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for15Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "bestFitIndexName": None,
+                "forLongestTenure": None,
+                "bestFitBetaFor3Year": None,
+                "primaryIndexNameNew": "S&P BSE 100 India TR INR",
+                "bestFitAlphaFor3Year": None,
+                "bestFitRSquaredFor3Year": None,
+            },
+        },
+    },
+    3: {
+        "quotes": {"expenseRatio": 0.0106, "lastTurnoverRatio": 0.3109},
+        "holdings": {
+            "equityHoldingPage": {
+                "pageSize": 100,
+                "totalPage": 1,
+                "pageNumber": 1,
+                "holdingList": [
+                    {"isin": "INE280A01028", "weighting": 11.2},
+                    {"isin": "INE090A01021", "weighting": 7.1},
+                    {"isin": "INE040A01034", "weighting": 2.4},
+                ],
+            },
+        },
+        "list_info": {"isin": "MF123"},
+        "risk_measures": {
+            "cur": "INR",
+            "fundName": "Testing fund 2",
+            "indexName": "Morningstar India GR INR",
+            "categoryName": "Large-Cap",
+            "fundRiskVolatility": {
+                "endDate": "2023-11-30T06:00:00.000",
+                "for1Year": {
+                    "beta": 0.954,
+                    "alpha": -0.645,
+                    "rSquared": 98.8,
+                    "sharpeRatio": 0.251,
+                    "standardDeviation": 11.355,
+                },
+                "for3Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for5Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for10Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for15Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "bestFitIndexName": None,
+                "forLongestTenure": None,
+                "bestFitBetaFor3Year": None,
+                "primaryIndexNameNew": "S&P BSE 100 India TR INR",
+                "bestFitAlphaFor3Year": None,
+                "bestFitRSquaredFor3Year": None,
+            },
+        },
+    },
+    4: {
+        "quotes": {"expenseRatio": 0.0158, "lastTurnoverRatio": 0.5451},
+        "holdings": {
+            "equityHoldingPage": {
+                "pageSize": 100,
+                "totalPage": 1,
+                "pageNumber": 1,
+                "holdingList": [
+                    {"isin": "INE280A01028", "weighting": 10.2},
+                    {"isin": "INE002A01018", "weighting": 9.2},
+                ],
+            },
+        },
+        "list_info": {"isin": "MF123"},
+        "risk_measures": {
+            "cur": "INR",
+            "fundName": "Testing fund 2",
+            "indexName": "Morningstar India GR INR",
+            "categoryName": "Large-Cap",
+            "fundRiskVolatility": {
+                "endDate": "2023-11-30T06:00:00.000",
+                "for1Year": {
+                    "beta": 1.137,
+                    "alpha": 5.675,
+                    "rSquared": 98.8,
+                    "sharpeRatio": 0.735,
+                    "standardDeviation": 11.355,
+                },
+                "for3Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for5Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for10Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for15Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "bestFitIndexName": None,
+                "forLongestTenure": None,
+                "bestFitBetaFor3Year": None,
+                "primaryIndexNameNew": "S&P BSE 100 India TR INR",
+                "bestFitAlphaFor3Year": None,
+                "bestFitRSquaredFor3Year": None,
+            },
+        },
+    },
+    5: {
+        "quotes": {"expenseRatio": 0.0216, "lastTurnoverRatio": 0.2025},
+        "holdings": {
+            "equityHoldingPage": {
+                "pageSize": 100,
+                "totalPage": 1,
+                "pageNumber": 1,
+                "holdingList": [
+                    {"isin": "INE002A01018", "weighting": 13.2},
+                    {"isin": "INE090A01021", "weighting": 7.4},
+                    {"isin": "INE040A01034", "weighting": 3.4},
+                ],
+            },
+        },
+        "list_info": {"isin": "MF123"},
+        "risk_measures": {
+            "cur": "INR",
+            "fundName": "Testing fund 2",
+            "indexName": "Morningstar India GR INR",
+            "categoryName": "Large-Cap",
+            "fundRiskVolatility": {
+                "endDate": "2023-11-30T06:00:00.000",
+                "for1Year": {
+                    "beta": 1.041,
+                    "alpha": 0.521,
+                    "rSquared": 98.8,
+                    "sharpeRatio": 0.354,
+                    "standardDeviation": 11.355,
+                },
+                "for3Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for5Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for10Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "for15Year": {
+                    "beta": None,
+                    "alpha": None,
+                    "rSquared": None,
+                    "sharpeRatio": None,
+                    "standardDeviation": None,
+                },
+                "bestFitIndexName": None,
+                "forLongestTenure": None,
+                "bestFitBetaFor3Year": None,
+                "primaryIndexNameNew": "S&P BSE 100 India TR INR",
+                "bestFitAlphaFor3Year": None,
+                "bestFitRSquaredFor3Year": None,
+            },
+        },
+    },
+}

core/tests/test_scores.py

@@ -0,0 +1,101 @@
+from django.test import TestCase
+from core.models import MutualFund, Stock
+from core.mfrating.score_calculator import MutualFundScorer, MFRating
+from core.tests.data import test_data
+
+
+class MutualFundScorerTestCase(TestCase):
+    """
+    Test case for the MutualFundScorer class to test scores.
+    """
+
+    def setUp(self):
+        self.stock_data = [
+            {"isin_number": "INE040A01034", "rank": 10},
+            {"isin_number": "INE090A01021", "rank": 21},
+            {"isin_number": "INE002A01018", "rank": 131},
+            {"isin_number": "INE154A01025", "rank": 99},
+            {"isin_number": "INE018A01030", "rank": 31},
+            {"isin_number": "INE280A01028", "rank": 2},
+        ]
+
+        self.mutual_fund_data = [
+            {
+                "isin_number": "ISIN1",
+                "fund_name": "Testing Fund 1",
+                "rank": 1,
+                "aum": 837.3,
+                "crisil_rank": 4,
+                "security_id": "SEC1",
+                "data": test_data[1],
+            },
+            {
+                "isin_number": "ISIN2",
+                "fund_name": "Testing Fund 2",
+                "rank": 2,
+                "aum": 210.3,
+                "crisil_rank": 1,
+                "security_id": "SEC2",
+                "data": test_data[2],
+            },
+            {
+                "isin_number": "ISIN3",
+                "fund_name": "Testing Fund 3",
+                "rank": 3,
+                "aum": 639.3,
+                "crisil_rank": 3,
+                "security_id": "SEC3",
+                "data": test_data[3],
+            },
+            {
+                "isin_number": "ISIN4",
+                "fund_name": "Testing Fund 4",
+                "rank": 4,
+                "aum": 410.3,
+                "crisil_rank": 2,
+                "security_id": "SEC4",
+                "data": test_data[4],
+            },
+            {
+                "isin_number": "ISIN5",
+                "fund_name": "Testing Fund 5",
+                "rank": 5,
+                "aum": 1881.3,
+                "crisil_rank": 5,
+                "security_id": "SEC5",
+                "data": test_data[5],
+            },
+        ]
+
+        self.create_stock_objects()
+        self.create_mutual_fund_objects()
+        self.mf_scorer = MutualFundScorer()
+
+    def create_stock_objects(self):
+        """
+        Create stock objects using the predefined stock data.
+        """
+        self.stock_objects = [Stock.objects.create(**data) for data in self.stock_data]
+
+    def create_mutual_fund_objects(self):
+        """
+        Create mutual fund objects using the predefined mutual fund data.
+        """
+        self.mutual_fund_objects = [
+            MutualFund.objects.create(**data) for data in self.mutual_fund_data
+        ]
+
+    def test_get_scores_returns_sorted_list(self):
+        """
+        Test whether the get_scores method returns a sorted list of scores.
+        """
+        scores = self.mf_scorer.get_scores()
+        self.assertEqual(len(scores), 5)
+        self.assertEqual(
+            scores, sorted(scores, key=lambda x: x["overall_score"], reverse=True)
+        )
+        expected_scores = [0.4263, 0.3348, 0.2962, 0.2447, 0.2101]
+        for i, expected_score in enumerate(expected_scores):
+            self.assertAlmostEqual(
+                scores[i]["overall_score"], expected_score, delta=1e-4
+            )

core/text2sql/eval_queries.py

@@ -0,0 +1,86 @@
+queries = [
+    {"Query Number": 1, "Complexity Level": "Simple", "Query Description": "Retrieve all mutual funds and their names",
+        "SQL Statement": "SELECT id, fund_name FROM core_mutualfund;"},
+    {"Query Number": 2, "Complexity Level": "Simple", "Query Description": "Get the total number of mutual funds",
+        "SQL Statement": "SELECT COUNT(*) FROM core_mutualfund;"},
+    {"Query Number": 3, "Complexity Level": "Simple", "Query Description": "List all unique ISIN numbers in the mutual fund holdings",
+        "SQL Statement": "SELECT DISTINCT isin_number FROM core_mfholdings;"},
+    {"Query Number": 4, "Complexity Level": "Simple", "Query Description":
+        "Find the mutual fund with the highest AUM (Assets Under Management)", "SQL Statement": "SELECT * FROM core_mutualfund ORDER BY aum DESC LIMIT 1;"},
+    {"Query Number": 5, "Complexity Level": "Simple", "Query Description": "Retrieve the top 5 mutual funds with the highest one-year return",
+        "SQL Statement": "SELECT * FROM core_mutualfund ORDER BY return_m12 DESC LIMIT 5;"},
+    {"Query Number": 6, "Complexity Level": "Medium", "Query Description": "List mutual funds with their holdings and respective sector codes",
+        "SQL Statement": "SELECT m.fund_name, h.sector, h.sector_code FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id;"},
+    {"Query Number": 7, "Complexity Level": "Medium", "Query Description": "Find the average expense ratio for all mutual funds",
+        "SQL Statement": "SELECT AVG(expense_ratio) FROM core_mutualfund;"},
+    {"Query Number": 8, "Complexity Level": "Medium", "Query Description": "Retrieve mutual funds with a specific country in their holdings",
+        "SQL Statement": "SELECT m.fund_name, h.country FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id WHERE h.country = 'USA';"},
+    {"Query Number": 9, "Complexity Level": "Medium", "Query Description":
+        "List mutual funds with volatility metrics (alpha, beta, sharpe_ratio)", "SQL Statement": "SELECT m.fund_name, v.alpha, v.beta, v.sharpe_ratio FROM core_mutualfund m JOIN core_mfvolatility v ON m.id = v.mutual_fund_id;"},
+    {"Query Number": 10, "Complexity Level": "Medium", "Query Description":
+        "Retrieve mutual funds with a NAV (Net Asset Value) greater than a specific value", "SQL Statement": "SELECT * FROM core_mutualfund WHERE nav > 100;"},
+    {"Query Number": 11, "Complexity Level": "High", "Query Description": "Find the mutual fund with the highest total market value of holdings",
+        "SQL Statement": "SELECT m.fund_name, MAX(h.market_value) AS max_market_value FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id;"},
+    {"Query Number": 12, "Complexity Level": "High", "Query Description": "List mutual funds with their average one-year return grouped by sector",
+        "SQL Statement": "SELECT h.sector, AVG(m.return_m12) AS avg_one_year_return FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id GROUP BY h.sector;"},
+    {"Query Number": 13, "Complexity Level": "High", "Query Description": "Retrieve mutual funds with a specific stock rating in their holdings",
+        "SQL Statement": "SELECT m.fund_name, h.stock_rating FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id WHERE h.stock_rating = 'A';"},
+    {"Query Number": 14, "Complexity Level": "High", "Query Description": "Find the mutual fund with the lowest standard deviation of volatility",
+        "SQL Statement": "SELECT m.fund_name, MIN(v.standard_deviation) AS min_standard_deviation FROM core_mutualfund m JOIN core_mfvolatility v ON m.id = v.mutual_fund_id;"},
+    {"Query Number": 15, "Complexity Level": "High", "Query Description": "List mutual funds with the highest number of shares in their holdings",
+        "SQL Statement": "SELECT m.fund_name, MAX(h.number_of_shares) AS max_number_of_shares FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id;"},
+    {"Query Number": 16, "Complexity Level": "More Complex", "Query Description": "Retrieve mutual funds and their holdings with a specific currency",
+        "SQL Statement": "SELECT m.fund_name, h.currency FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id WHERE h.currency = 'USD';"},
+    {"Query Number": 17, "Complexity Level": "More Complex", "Query Description": "Find the mutual fund with the highest total market value across all holdings",
+        "SQL Statement": "SELECT m.fund_name, SUM(h.market_value) AS total_market_value FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id GROUP BY m.fund_name ORDER BY total_market_value DESC LIMIT 1;"},
+    {"Query Number": 18, "Complexity Level": "More Complex", "Query Description": "List mutual funds with their average alpha and beta values for a specific year",
+        "SQL Statement": "SELECT m.fund_name, AVG(v.alpha) AS avg_alpha, AVG(v.beta) AS avg_beta FROM core_mutualfund m JOIN core_mfvolatility v ON m.id = v.mutual_fund_id WHERE v.year = '2023' GROUP BY m.fund_name;"},
+    {"Query Number": 19, "Complexity Level": "More Complex", "Query Description": "Retrieve mutual funds with a specific holding type and its market value",
+        "SQL Statement": "SELECT m.fund_name, h.holding_type, h.market_value FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id WHERE h.holding_type = 'Equity';"},
+    {"Query Number": 20, "Complexity Level": "More Complex", "Query Description": "List mutual funds with their rankings and corresponding CRISIL rankings",
+        "SQL Statement": "SELECT m.fund_name, m.rank, m.crisil_rank FROM core_mutualfund m;"},
+    {"Query Number": 21, "Complexity Level": "More Complex", "Query Description": "Find the mutual fund with the highest average one-year return across all years",
+        "SQL Statement": "SELECT m.fund_name, AVG(m.return_m12) AS avg_one_year_return FROM core_mutualfund m GROUP BY m.fund_name ORDER BY avg_one_year_return DESC LIMIT 1;"},
+    {"Query Number": 22, "Complexity Level": "More Complex", "Query Description": "Retrieve mutual funds with their top 3 holdings based on market value",
+        "SQL Statement": "SELECT m.fund_name, h.holding_name, h.market_value FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id ORDER BY h.market_value DESC LIMIT 3;"},
+    {"Query Number": 23, "Complexity Level": "More Complex", "Query Description": "List mutual funds with their volatility metrics for a specific year",
+        "SQL Statement": "SELECT m.fund_name, v.year, v.alpha, v.beta, v.sharpe_ratio, v.standard_deviation FROM core_mutualfund m JOIN core_mfvolatility v ON m.id = v.mutual_fund_id WHERE v.year = '2022';"},
+    {"Query Number": 24, "Complexity Level": "More Complex", "Query Description": "Find the mutual fund with the highest average market value per holding",
+        "SQL Statement": "SELECT m.fund_name, AVG(h.market_value) AS avg_market_value_per_holding FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id GROUP BY m.fund_name ORDER BY avg_market_value_per_holding DESC LIMIT 1;"},
+    {
+        "Query Number": 25,
+        "Complexity Level": "More Complex",
+        "Query Description": "Retrieve mutual funds with their total assets and the corresponding volatility metrics",
+        "SQL Statement": "SELECT m.fund_name, h.total_assets, v.alpha, v.beta, v.sharpe_ratio, v.standard_deviation FROM core_mutualfund m JOIN core_mfholdings h ON m.id = h.mutual_fund_id JOIN core_mfvolatility v ON m.id = v.mutual_fund_id;"
+    },
+    {
+        "Query Number": 26,
+        "Complexity Level": "More Complex",
+        "Query Description":"Retrieve mutual funds that have holdings in both technology and healthcare sectors, and provide a breakdown of their allocation percentages in each sector.",
+        "SQL Statement":"-"
+    },
+    {
+        "Query Number": 27,
+        "Complexity Level": "More Complex",
+        "Query Description": "Retrieve Mutual Funds with Highest Average Return and Lowest Expense Ratio",
+        "SQL Statement":"-"
+    },
+    {
+        "Query Number": 28,
+        "Complexity Level": "More Complex",
+        "Query Description":"Find Mutual Funds with Diversified Holdings",
+        "SQL Statement":"-"
+    },
+    {
+        "Query Number": 29,
+        "Complexity Level": "More Complex",
+        "Query Description": "Identify Mutual Funds with Consistent Performance and High AUM",
+        "SQL Statement":"-"
+    },
+    {
+        "Query Number": 30,
+        "Complexity Level": "More Complex",
+        "Query Description": "Calculate Weighted Average Return for Mutual Funds in a Specific Sector",
+        "SQL Statement":"-"
+    }
+]

core/text2sql/handler.py

@@ -0,0 +1,26 @@
+import logging
+from core.models import MutualFund
+from core.text2sql.ml_models import Text2SQLModel
+
+logger = logging.getLogger(__name__)
+
+
+class QueryDataHandler:
+    """
+    A class for handling queries and fetching data using a Text2SQL model and Django models.
+    """
+
+    def __init__(self):
+        self.mutual_fund = MutualFund()
+        self.text2sql_model = Text2SQLModel()
+
+    def get_data_from_query(self, prompt):
+        """
+        Generates a PostgreSQL query using the Text2SQL model based on the input prompt
+        and retrieves data using Django models.
+        """
+        # Use Text2SQL ML model to generate a PostgreSQL query
+        sql_query = self.text2sql_model.generate_query(prompt)
+        logger.info(f"SQL Query: {sql_query}")
+        # Use Django models to fetch data
+        return sql_query, self.mutual_fund.execute_query(sql_query)

core/text2sql/ml_models.py

@@ -0,0 +1,24 @@
+import replicate
+
+
+class Text2SQLModel:
+    """
+    A class representing a Text-to-SQL model for generating SQL queries from LLM.
+    """
+
+    def __init__(self):
+        pass
+
+    def load_model(self):
+        """Loads the machine learning model for Text-to-SQL processing."""
+        pass
+
+    def generate_query(self, prompt):
+        output = replicate.run(
+            "ns-dev-sentience/sqlcoder:18bcabd866a64547daf3c6044cdebbd47a1f489571110087b80722848eb09398",
+            input={"prompt": prompt},
+        )
+        return (
+            output.split("```PostgresSQL")[-1].split("```")[0].split(";")[0].strip()
+            + ";"
+        )

core/text2sql/prompt.py

@@ -0,0 +1,69 @@
+def get_prompt(question):
+    database_schema = """
+CREATE TABLE core_mutualfund (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    fund_name VARCHAR(200) UNIQUE,
+    isin_number VARCHAR(50) UNIQUE,
+    security_id VARCHAR(50) UNIQUE,
+    data JSONB,
+    rank INTEGER UNIQUE,
+    crisil_rank INTEGER,
+    aum DOUBLE PRECISION,
+    expense_ratio DOUBLE PRECISION,
+    nav DOUBLE PRECISION,
+    return_m12 DOUBLE PRECISION
+);
+
+CREATE TABLE core_mfholdings (
+    "id" uuid NOT NULL PRIMARY KEY,
+    "isin_number" varchar(20) NULL,
+    "security_id" varchar(20) NULL,
+    "sector" varchar(50) NULL,
+    "country" varchar(50) NULL,
+    "currency" varchar(100) NULL,
+    "weighting" double precision NULL,
+    "sector_code" varchar(100) NULL,
+    "holding_type" varchar(100) NULL,
+    "market_value" double precision NULL,
+    "stock_rating" varchar(100) NULL,
+    "total_assets" double precision NULL,
+    "currency_name" varchar(150) NULL,
+    "holding_name" varchar(100) NULL,
+    "holding_type" varchar(100) NULL,
+    "holding_type_id" varchar(100) NULL,
+    "number_of_shares" double precision NULL,
+    "one_year_return" double precision NULL,
+    "mutual_fund_id" uuid NOT NULL REFERENCES "core_mutualfund" ("id") DEFERRABLE INITIALLY DEFERRED
+);
+
+CREATE TABLE core_mfvolatility (
+    "id" uuid NOT NULL PRIMARY KEY,
+    "mutual_fund_id" uuid NOT NULL REFERENCES "core_mutualfund" ("id") DEFERRABLE INITIALLY DEFERRED,
+    "year" varchar(100) NOT NULL,
+    "alpha" double precision NULL,
+    "beta" double precision NULL,
+    "sharpe_ratio" double precision NULL,
+    "standard_deviation" double precision NULL
+);
+
+-- core_mfvolatility.mutual_fund_id can be joined with core_mutualfund.id
+-- core_mfholdings.mutual_fund_id can be joined with core_mutualfund.id
+    """
+
+    sql_prompt = f"""
+Your task is to convert a question into a PostgresSQL query, given a database schema.
+
+###Task:
+Generate a SQL query that answers the question `{question}`.
+
+### Database Schema:
+This query will run on a database whose schema is represented below:
+{database_schema}
+
+### Response:
+Based on your instructions, here is the PostgresSQL query I have generated to answer the question `{question}`:
+```PostgresSQL
+    """
+    return sql_prompt

core/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+from core.views import get_scores, get_mf_data
+
+urlpatterns = [
+    path("mutual-fund-details/", get_scores, name="mutual-fund-details"),
+    path("get-mf-data/", get_mf_data, name="get-mf-data"),
+]

core/views.py

@@ -0,0 +1,30 @@
+"""
+
+"""
+import logging
+from django.http import JsonResponse
+from core.mfrating.score_calculator import MutualFundScorer
+from core.text2sql.handler import QueryDataHandler
+from core.text2sql.prompt import get_prompt
+
+logger = logging.getLogger(__name__)
+
+
+def get_scores(request):
+    """
+    Retrieves scores for mutual funds based on various factors.
+    """
+    data = MutualFundScorer().get_scores()
+    return JsonResponse({"status": "success", "data": data}, status=200)
+
+
+def get_mf_data(request):
+    """
+    Retrieves mutual fund data based on user query.
+    """
+    query = request.GET.get("query", "")
+    logger.info(f"Query: {query}")
+    prompt = get_prompt(query)
+    logger.info(f"Prompt: {prompt}")
+    query, data = QueryDataHandler().get_data_from_query(prompt)
+    return JsonResponse({"status": "success", "query": query, "data": data}, status=200)

data_pipeline/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

data_pipeline/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DataPipelineConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "data_pipeline"

data_pipeline/interfaces/api_client.py

@@ -0,0 +1,36 @@
+"""
+Interface for API clients
+"""
+from abc import ABC, abstractmethod
+
+
+class DataClient(ABC):
+    """
+    Abstract class for API clients
+    """
+
+    @abstractmethod
+    def extract(self):
+        """
+        Extract data from API
+        """
+        if self.api_url is None:
+            raise Exception("No API URL provided")
+
+    def transform(self):
+        """
+        Placeholder method for future transformation logic.
+        """
+        self.transformed_data = self.api_response
+
+    @abstractmethod
+    def load(self):
+        """
+        Load data into target model
+        """
+        raise Exception("No model to transform")
+
+    def run(self) -> None:
+        self.extract()
+        self.transform()
+        self.load()

data_pipeline/interfaces/test_api_client.py

@@ -0,0 +1,35 @@
+"""
+
+"""
+from django.test import TestCase
+from data_pipeline.interfaces.api_client import DataClient
+
+
+class TestDataClient(TestCase):
+    def test_extract_raises_exception_on_instantiation(self):
+        with self.assertRaises(TypeError):
+            data_client = DataClient()
+
+    def test_extract_raises_exception_without_api_url(self):
+        class NewDataClientWithoutFunctionOverride(DataClient):
+            def __init__(self) -> None:
+                pass
+
+        with self.assertRaises(TypeError):
+            data_client = NewDataClientWithoutFunctionOverride()
+
+    def test_inherited_class(self):
+        class NewDataClientWith3FunctionOverride(DataClient):
+            def __init__(self) -> None:
+                pass
+
+            def extract(self):
+                pass
+
+            def transform(self):
+                pass
+
+            def load(self):
+                pass
+
+        data_client = NewDataClientWith3FunctionOverride()