mftool 3.4__py3-none-any.whl

mftool/mftool.py

@@ -0,0 +1,935 @@
+"""
+    The MIT License (MIT)
+    Copyright (c) 2026 Sujit Nayakwadi
+    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.
+"""
+# -*- coding: UTF-8 -*-
+import requests
+import httpx
+from bs4 import BeautifulSoup
+import yfinance as yf
+import datetime
+from deprecated import deprecated
+from matplotlib import pyplot as plt
+from .utils import Utilities, is_holiday, get_today, get_friday, render_response, get_52_week_high_low
+from .cache import CacheManager
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Dict, Union
+
+
+class Mftool:
+    """
+    class which implements all the functionality for
+    Mutual Funds in India
+    """
+    def __init__(self):
+        self._session = requests.session()
+        self._const = Utilities().values
+        # URL list
+        self._get_quote_url = self._const['get_quote_url']
+        self._get_scheme_url = self._const['get_scheme_url']
+        self._get_amc_details_url = self._const['get_amc_details_url']
+        self._get_open_ended_equity_scheme_url = self._const['get_open_ended_equity_scheme_url']
+        self._get_avg_aum = self._const['get_avg_aum_url']
+        self._open_ended_equity_category = self._const['open_ended_equity_category']
+        self._open_ended_debt_category = self._const['open_ended_debt_category']
+        self._open_ended_hybrid_category = self._const['open_ended_hybrid_category']
+        self._open_ended_solution_category = self._const['open_ended_solution_category']
+        self._open_ended_other_category = self._const['open_ended_other_category']
+        self._amc=self._const['amc']
+        self._user_agent = self._const['user_agent']
+        self._codes = self._const['codes']
+
+        # Initialize caching layer
+        # NAV data: 24 hours TTL (86400 seconds) - updates once daily
+        self._cache = CacheManager(default_ttl=86400)
+        # Scheme codes: 7 days TTL - rarely changes
+        self._scheme_codes_cache = CacheManager(default_ttl=604800)
+
+        self._scheme_codes = self.get_scheme_codes().keys()
+
+    def set_proxy(self, proxy):
+        """
+        This is optional method to work with proxy server before getting any data.
+        :param proxy: provide dictionary for proxies setup as
+                proxy = { 'http': 'http://user:pass@10.10.1.0:1080',
+                          'https': 'http://user:pass@10.10.1.0:1090'}
+        :return: None
+        """
+        self._session.proxies = proxy
+
+    def get_scheme_codes(self, as_json=False):
+        """
+        returns a dictionary with key as scheme code and value as scheme name.
+        cache handled internally
+        :return: dict / json
+        """
+        # Try to get from cache first
+        cache_key = f"scheme_codes:{as_json}"
+        cached_result = self._scheme_codes_cache.get(cache_key)
+        if cached_result is not None:
+            return cached_result
+
+        scheme_info = {}
+        url = self._get_quote_url
+        response = self._session.get(url)
+        data = response.text.split("\n")
+        for scheme_data in data:
+            if ";" in scheme_data:
+                scheme = scheme_data.split(";")
+                scheme_info[scheme[0]] = f"{scheme[3]} - {scheme[5]}" if len(scheme) > 5 else scheme[3]
+
+        result = render_response(scheme_info, as_json)
+        # Cache the result
+        self._scheme_codes_cache.set(cache_key, result)
+        return result
+
+    def get_available_schemes(self, amc_name):
+        """
+        returns a dictionary with key as scheme code and value as scheme name for given amc.
+        :param amc_name: a string name of amc eg- Axis, ICICI, Reliance
+        :return: dict / json
+        """
+        all_schemes = self.get_scheme_codes(as_json=False)
+        return {k: v for (k, v) in all_schemes.items() if amc_name.lower() in v.lower()}
+
+    def is_valid_code(self, code):
+        """
+        check whether a given scheme code is correct or NOT
+        :param code: a string scheme code
+        :return: Boolean
+        """
+        if code:
+            # Performance improvement
+            return True if code in self._scheme_codes else False
+        else:
+            return False
+
+    def is_code(self, code):
+        """
+        check whether a New scheme code is correct or NOT, only used with mf.history()
+        :param code: a string scheme code
+        :return: Boolean
+        """
+        if code:
+            return any(code in cd for cd in self._codes)
+        else:
+            return False
+
+    def get_scheme_quote(self, code, as_json=False):
+        """
+        gets the quote for a given scheme code
+        :param code: scheme code
+        :param as_json: default false
+        :return: dict or None
+        :raises: HTTPError, URLError
+        """
+        code = str(code)
+        if self.is_valid_code(code):
+            # Try to get from cache first
+            cache_key = f"quote:{code}:{as_json}"
+            cached_result = self._cache.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+
+            scheme_info = {}
+            url = self._get_quote_url
+            response = self._session.get(url)
+            data = response.text.split("\n")
+            for scheme_data in data:
+                if code in scheme_data:
+                    scheme = scheme_data.split(";")
+                    scheme_info['scheme_code'] = scheme[0]
+                    scheme_info['scheme_name'] = scheme[3]
+                    scheme_info['plan'] = scheme[4]
+                    scheme_info['option'] = scheme[5]
+                    scheme_info['last_updated'] = scheme[7].replace("\r", "")
+                    scheme_info['nav'] = scheme[6]
+                    break
+
+            result = render_response(scheme_info, as_json)
+            # Cache the result
+            self._cache.set(cache_key, result)
+            return result
+        else:
+            return None
+
+    def get_bulk_quotes(self, scheme_codes: List[Union[str, int]], as_json=False,
+                       max_workers=10, show_progress=False) -> Dict[str, Union[dict, None]]:
+        """
+        Fetch quotes for multiple schemes concurrently for better performance.
+        Perfect for portfolio-level operations.
+
+        :param scheme_codes: List of scheme codes to fetch
+        :param as_json: Return data in JSON format (default: False)
+        :param max_workers: Maximum number of concurrent threads (default: 10)
+        :param show_progress: Print progress during fetching (default: False)
+        :return: Dictionary with scheme codes as keys and quote data as values
+        :raises: HTTPError, URLError
+
+        Example:
+            >>> mf = Mftool()
+            >>> codes = ['119597', '119062', '119061']
+            >>> quotes = mf.get_bulk_quotes(codes)
+            >>> print(quotes['119597']['nav'])
+        """
+        # Validate all codes first
+        valid_codes = []
+        invalid_codes = []
+
+        for code in scheme_codes:
+            code = str(code)
+            if self.is_valid_code(code):
+                valid_codes.append(code)
+            else:
+                invalid_codes.append(code)
+
+        if invalid_codes and show_progress:
+            print(f"Warning: {len(invalid_codes)} invalid scheme codes found: {invalid_codes[:5]}")
+
+        results = {}
+
+        # Check cache first for all codes
+        uncached_codes = []
+        for code in valid_codes:
+            cache_key = f"quote:{code}:{as_json}"
+            cached_result = self._cache.get(cache_key)
+            if cached_result is not None:
+                results[code] = cached_result
+            else:
+                uncached_codes.append(code)
+
+        if show_progress:
+            print(f"Fetching {len(uncached_codes)} quotes ({len(results)} from cache)...")
+
+        # Fetch uncached quotes concurrently
+        if uncached_codes:
+            def fetch_single_quote(code):
+                try:
+                    quote = self.get_scheme_quote(code, as_json=as_json)
+                    return code, quote
+                except Exception as e:
+                    if show_progress:
+                        print(f"Error fetching {code}: {str(e)[:50]}")
+                    return code, None
+
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = {executor.submit(fetch_single_quote, code): code for code in uncached_codes}
+
+                completed = 0
+                for future in as_completed(futures):
+                    code, quote = future.result()
+                    results[code] = quote
+                    completed += 1
+
+                    if show_progress and completed % 10 == 0:
+                        print(f"Progress: {completed}/{len(uncached_codes)} completed")
+
+        if show_progress:
+            print(f"✓ Fetched {len(results)} quotes successfully")
+
+        return results
+
+    def search_schemes(self, search_term: str, limit: int = 10, as_json=False) -> Union[List[Dict[str, str]], str]:
+        """
+        Search for mutual fund schemes by name using fuzzy matching.
+        Makes it easy to find schemes without knowing exact codes.
+
+        :param search_term: Name or partial name to search for (case-insensitive)
+        :param limit: Maximum number of results to return (default: 10, use 0 for all)
+        :param as_json: Return data in JSON format (default: False)
+        :return: List of matching schemes with code and name
+
+        Example:
+            >>> mf = Mftool()
+            >>> results = mf.search_schemes("HDFC midcap")
+            >>> for scheme in results:
+            ...     print(f"{scheme['code']}: {scheme['name']}")
+
+            >>> # Get scheme code for first match
+            >>> matches = mf.search_schemes("Axis bluechip", limit=1)
+            >>> code = matches[0]['code'] if matches else None
+        """
+        search_term = search_term.lower().strip()
+
+        if not search_term:
+            return render_response([], as_json)
+
+        # Get all scheme codes and names
+        all_schemes = self.get_scheme_codes(as_json=False)
+
+        # Search for matches
+        matches = []
+        for code, name in all_schemes.items():
+            name_lower = name.lower()
+
+            # Check if search term is in the scheme name
+            if search_term in name_lower:
+                # Calculate relevance score (lower is better)
+                # Exact matches get highest priority
+                if name_lower == search_term:
+                    score = 0
+                # Matches at the start of the name get high priority
+                elif name_lower.startswith(search_term):
+                    score = 1
+                # Matches of whole words get medium priority
+                elif f" {search_term} " in f" {name_lower} ":
+                    score = 2
+                # Partial matches get lower priority
+                else:
+                    score = 3
+
+                matches.append({
+                    'code': code,
+                    'name': name,
+                    'score': score
+                })
+
+        # Sort by relevance (score) and then alphabetically by name
+        matches.sort(key=lambda x: (x['score'], x['name']))
+
+        # Remove score from results
+        results = [{'code': m['code'], 'name': m['name']} for m in matches]
+
+        # Apply limit if specified
+        if limit > 0:
+            results = results[:limit]
+
+        return render_response(results, as_json)
+
+    def search_schemes_by_amc(self, amc_name: str, search_term: str = "",
+                             limit: int = 10, as_json=False) -> Union[List[Dict[str, str]], str]:
+        """
+        Search for schemes within a specific AMC (fund house).
+
+        :param amc_name: Name of AMC (e.g., "HDFC", "ICICI", "Axis")
+        :param search_term: Optional search term to filter schemes within the AMC
+        :param limit: Maximum number of results to return (default: 10, use 0 for all)
+        :param as_json: Return data in JSON format (default: False)
+        :return: List of matching schemes with code and name
+
+        Example:
+            >>> mf = Mftool()
+            >>> # Get all HDFC schemes
+            >>> hdfc_schemes = mf.search_schemes_by_amc("HDFC")
+            >>>
+            >>> # Get HDFC midcap schemes
+            >>> hdfc_midcap = mf.search_schemes_by_amc("HDFC", "midcap")
+        """
+        # Get all schemes from the AMC
+        amc_schemes = self.get_available_schemes(amc_name)
+
+        # If no search term, return AMC schemes
+        if not search_term:
+            results = [{'code': code, 'name': name} for code, name in amc_schemes.items()]
+            if limit > 0:
+                results = results[:limit]
+            return render_response(results, as_json)
+
+        # Filter by search term
+        search_term = search_term.lower().strip()
+        matches = []
+
+        for code, name in amc_schemes.items():
+            name_lower = name.lower()
+            if search_term in name_lower:
+                # Calculate relevance score
+                if name_lower == search_term:
+                    score = 0
+                elif name_lower.startswith(search_term):
+                    score = 1
+                elif f" {search_term} " in f" {name_lower} ":
+                    score = 2
+                else:
+                    score = 3
+
+                matches.append({
+                    'code': code,
+                    'name': name,
+                    'score': score
+                })
+
+        # Sort by relevance
+        matches.sort(key=lambda x: (x['score'], x['name']))
+
+        # Remove score and apply limit
+        results = [{'code': m['code'], 'name': m['name']} for m in matches]
+        if limit > 0:
+            results = results[:limit]
+
+        return render_response(results, as_json)
+
+    def search_schemes_by_type(self, scheme_type: str, search_term: str = "",
+                               limit: int = 10, as_json=False) -> Union[List[Dict[str, str]], str]:
+        """
+        Search for schemes by type/category (Equity, Debt, Hybrid, etc.).
+
+        :param scheme_type: Type keywords like "equity", "debt", "hybrid", "elss", "index", "liquid"
+        :param search_term: Optional additional search term
+        :param limit: Maximum number of results (default: 10, use 0 for all)
+        :param as_json: Return data in JSON format (default: False)
+        :return: List of matching schemes with code and name
+
+        Example:
+            >>> mf = Mftool()
+            >>> # Find all ELSS schemes
+            >>> elss = mf.search_schemes_by_type("elss")
+            >>>
+            >>> # Find HDFC ELSS schemes
+            >>> hdfc_elss = mf.search_schemes_by_type("elss", "hdfc")
+        """
+        all_schemes = self.get_scheme_codes(as_json=False)
+        scheme_type = scheme_type.lower().strip()
+        search_term = search_term.lower().strip() if search_term else ""
+
+        matches = []
+        for code, name in all_schemes.items():
+            name_lower = name.lower()
+
+            # Check if scheme type is in the name
+            if scheme_type in name_lower:
+                # If search term provided, check if it's also in the name
+                if search_term and search_term not in name_lower:
+                    continue
+
+                # Calculate relevance score
+                score = 0
+                if search_term:
+                    # Both type and search term match
+                    if scheme_type in name_lower and search_term in name_lower:
+                        score = 1
+                else:
+                    # Only type matches
+                    if name_lower.startswith(scheme_type):
+                        score = 2
+                    else:
+                        score = 3
+
+                matches.append({
+                    'code': code,
+                    'name': name,
+                    'score': score
+                })
+
+        # Sort by relevance
+        matches.sort(key=lambda x: (x['score'], x['name']))
+
+        # Remove score and apply limit
+        results = [{'code': m['code'], 'name': m['name']} for m in matches]
+        if limit > 0:
+            results = results[:limit]
+
+        return render_response(results, as_json)
+
+    def get_scheme_details(self, code, as_json=False):
+        """
+        gets the scheme info for a given scheme code
+        :param code: scheme code
+        :param as_json: default false
+        :return: dict or None
+        :raises: HTTPError, URLError
+        """
+        code = str(code)
+        if self.is_valid_code(code):
+            # Try to get from cache first
+            cache_key = f"details:{code}:{as_json}"
+            cached_result = self._cache.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+
+            try:
+                scheme_info = {}
+                url = self._get_scheme_url + code
+                response = self._session.get(url)
+                response.raise_for_status()  # Raise exception for bad status codes
+                response_data = response.json()
+
+                scheme_data = response_data['meta']
+                scheme_info['fund_house'] = scheme_data['fund_house']
+                scheme_info['scheme_type'] = scheme_data['scheme_type']
+                scheme_info['scheme_category'] = scheme_data['scheme_category']
+                scheme_info['scheme_code'] = scheme_data['scheme_code']
+                scheme_info['scheme_name'] = scheme_data['scheme_name']
+                scheme_info['scheme_start_date'] = response_data['data'][int(len(response_data['data']) -1)]
+
+                result = render_response(scheme_info, as_json)
+                # Cache the result
+                self._cache.set(cache_key, result)
+                return result
+            except Exception as e:
+                # Return None on error, don't cache errors
+                return None
+        else:
+            return None
+
+    def get_scheme_historical_nav(self, code, as_json=False, as_Dataframe=False):
+        """
+        gets the scheme historical data till last updated for a given scheme code
+        :param code: scheme-code
+        :param as_json: default false
+        :param as_Dataframe: default false
+        :return: dict or json or Dataframe or None
+        :raises: HTTPError, URLError
+        """
+        code = str(code)
+        if self.is_valid_code(code):
+            # Try to get from cache first
+            cache_key = f"historical:{code}:{as_json}:{as_Dataframe}"
+            cached_result = self._cache.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+
+            try:
+                scheme_info = {}
+                url = self._get_scheme_url + code
+                response = self._session.get(url)
+                response.raise_for_status()  # Raise exception for bad status codes
+                response_data = response.json()
+
+                scheme_data = response_data['meta']
+                scheme_info['fund_house'] = scheme_data['fund_house']
+                scheme_info['scheme_type'] = scheme_data['scheme_type']
+                scheme_info['scheme_category'] = scheme_data['scheme_category']
+                scheme_info['scheme_code'] = scheme_data['scheme_code']
+                scheme_info['scheme_name'] = scheme_data['scheme_name']
+                scheme_info['scheme_start_date'] = response_data['data'][int(len(response_data['data']) - 1)]
+                result = get_52_week_high_low(response_data['data'])
+                scheme_info['52_week_high'] = result['52_week_high']
+                scheme_info['52_week_low'] = result['52_week_low']
+                if response_data['data']:
+                    scheme_info['data'] = response_data['data']
+                else:
+                    scheme_info['data'] = "Underlying data not available"
+
+                final_result = render_response(scheme_info, as_json, as_Dataframe)
+                # Cache the result
+                self._cache.set(cache_key, final_result)
+                return final_result
+            except Exception as e:
+                # Return None on error, don't cache errors
+                return None
+        else:
+            return None
+
+
+
+    def calculate_balance_units_value(self, code, balance_units, as_json=False):
+        """
+        gets the market value of your balance units for a given scheme code
+        :param code: scheme code, balance_units : current balance units
+        :param balance_units: balance units
+        :param as_json: default false
+        :return: dict or None
+        """
+        code = str(code)
+        if self.is_valid_code(code):
+            scheme_info = {}
+            scheme_info = self.get_scheme_quote(code)
+            market_value = float(balance_units)*float(scheme_info['nav'])
+            scheme_info.update(balance_units_value= "{0:.2f}".format(market_value))
+            return render_response(scheme_info, as_json)
+        else:
+            return None
+
+    def calculate_returns(self, code, balanced_units, monthly_sip, investment_in_months, as_json=False):
+        """
+        gets the market value of your balance units for a given scheme code
+        :param code: scheme-code,
+        :param balanced_units : current balance units
+        :param monthly_sip: monthly investment in scheme
+        :param investment_in_months: months
+        :param as_json: default false
+        :return: dict or None
+        :example: calculate_returns(119062,1718.925, 2000, 51)
+        """
+        code = str(code)
+        if self.is_valid_code(code):
+            scheme_info = {}
+            scheme_info = self.get_scheme_quote(code)
+            initial_investment = int(investment_in_months) * float(monthly_sip)
+            years = investment_in_months / 12
+            market_value = float(float(balanced_units) * float(scheme_info['nav']))
+            total_return = market_value - initial_investment
+            absolute_return = ((market_value - initial_investment)/initial_investment) * 100
+            annualised_return = ((market_value / initial_investment) ** (1/years) - 1)*100
+
+            scheme_info.update(final_investment_value="{0:.2f}".format(market_value))
+            scheme_info.update(absolute_return="%.2f %%" %(absolute_return))
+            scheme_info.update(IRR_annualised_return="%.2f %%" %(annualised_return))
+            return render_response(scheme_info, as_json)
+        else:
+            return None
+
+    @deprecated(version='3.1',
+                reason="This function will be in deprecated from next release, use mf.history() to get data")
+    def get_scheme_historical_nav_for_dates(self, code, start_date, end_date, as_json=False, as_dataframe=False):
+        """
+        gets the scheme historical data between start_date and end_date for a given scheme code
+        :param start_date: string '%Y-%m-%d'
+        :param end_date: string '%Y-%m-%d'
+        :param code: scheme code
+        :param as_json: default false
+        :param as_dataframe: default false
+        :return: dict or None
+        :raises: HTTPError, URLError
+        """
+        code = str(code)
+        if self.is_valid_code(code):
+            # scheme_info = {}
+            data = []
+            start_date = datetime.datetime.strptime(start_date, '%d-%m-%Y').date()
+            end_date = datetime.datetime.strptime(end_date, '%d-%m-%Y').date()
+            nav = self.get_scheme_historical_nav(code)
+            scheme_info = self.get_scheme_details(code)
+            for dat in nav['data']:
+                navDate = dat['date']
+                d = datetime.datetime.strptime(navDate, '%d-%m-%Y')
+                if end_date >= d.date() >= start_date:
+                    data.append(dat)
+            if len(data) == 0:
+                data.append({'Data is NOT available for selected range'})
+
+            scheme_info.update(data=data)
+            return render_response(scheme_info, as_json, as_dataframe)
+        else:
+            return None
+
+    def get_open_ended_equity_scheme_performance(self, report_date=None,as_json=False):
+        """
+        gets the daily performance of open-ended equity schemes for all AMCs
+        :param report_date: date in 'DD-MMM-YYYY' format, if None then it will take last working day
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        scheme_performance = {}
+        subCategory = self._open_ended_equity_category
+        for key in subCategory:
+            scheme_performance[subCategory[key]] = self._get_daily_scheme_performance(self._get_open_ended_equity_scheme_url,report_date,1, key)
+        return render_response(scheme_performance, as_json)
+
+    def get_open_ended_debt_scheme_performance(self, report_date=None, as_json=False):
+        """
+        gets the daily performance of open-ended debt schemes for all AMCs
+        :param report_date: date in 'DD-MMM-YYYY' format, if None then it will take last working day
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        subCategory = self._open_ended_debt_category
+        scheme_performance = {}
+        for key in subCategory:
+            scheme_performance[subCategory[key]] = self._get_daily_scheme_performance(self._get_open_ended_equity_scheme_url,report_date,2,key)
+        return render_response(scheme_performance, as_json)
+
+    def get_open_ended_hybrid_scheme_performance(self, report_date=None, as_json=False):
+        """
+        gets the daily performance of open-ended hybrid schemes for all AMCs
+        :param report_date: date in 'DD-MMM-YYYY' format, if None then it will take last working day
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        subCategory = self._open_ended_hybrid_category
+        scheme_performance = {}
+        for key in subCategory:
+            scheme_performance[subCategory[key]] = self._get_daily_scheme_performance(
+                self._get_open_ended_equity_scheme_url,report_date, 3, key)
+        return render_response(scheme_performance, as_json)
+
+    def get_open_ended_solution_scheme_performance(self, report_date=None, as_json=False):
+        """
+        gets the daily performance of open-ended Solution-Oriented schemes for all AMCs
+        :param report_date: date in 'DD-MMM-YYYY' format, if None then it will take last working day
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        subCategory = self._open_ended_solution_category
+        scheme_performance = {}
+        for key in subCategory:
+            scheme_performance[subCategory[key]] = self._get_daily_scheme_performance(
+                self._get_open_ended_equity_scheme_url, report_date,4, key)
+        return render_response(scheme_performance, as_json)
+
+    def get_open_ended_other_scheme_performance(self, report_date=None, as_json=False):
+        """
+        gets the daily performance of open-ended index and FoF schemes for all AMCs
+        :param report_date: date in 'DD-MMM-YYYY' format, if None then it will take last working day
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        subCategory = self._open_ended_other_category
+        scheme_performance = {}
+        for key in subCategory:
+            scheme_performance[subCategory[key]] = self._get_daily_scheme_performance(
+                self._get_open_ended_equity_scheme_url, report_date,5, key)
+        return render_response(scheme_performance, as_json)
+
+    def _get_daily_scheme_performance(self, performance_url,report_date, category,key, as_json=False):
+        fund_performance = []
+        if not report_date:
+            if is_holiday():
+                report_date = get_friday()
+            else:
+                report_date = get_today()
+        try:
+            data = {"maturityType": 1,"category": category,"subCategory": int(key),"mfid": 0,"reportDate": report_date}
+            html = httpx.post(performance_url,headers={"User-Agent":"Mozilla/5.0"},timeout=25, json=data)
+            for result in html.json()['data']:
+                scheme_details = {}
+                scheme_details['scheme_name'] = result['schemeName']
+                scheme_details['benchmark'] = result['benchmark']
+                scheme_details['latest NAV- Regular'] = result['navRegular']
+                scheme_details['latest NAV- Direct'] = result['navDirect']
+                scheme_details['1-Year Return(%)- Regular'] = result['return1YearRegular']
+                scheme_details['1-Year Return(%)- Direct'] = result['return1YearDirect']
+                scheme_details['3-Year Return(%)- Regular'] = result['return3YearRegular']
+                scheme_details['3-Year Return(%)- Direct'] = result['return3YearDirect']
+                scheme_details['5-Year Return(%)- Regular'] = result['return5YearRegular']
+                scheme_details['5-Year Return(%)- Direct'] = result['return5YearDirect']
+                fund_performance.append(scheme_details)
+        except Exception:
+            return render_response(['The underlying data is unavailable for Today'], as_json)
+        return render_response(fund_performance, as_json)
+
+    @deprecated(version='3.1',
+                reason="This function will be in deprecated from next release, use mf.history() to get data")
+    def get_all_amc_profiles(self, as_json=True):
+        """
+        gets profiles for all Fund houses
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        url = self._get_amc_details_url
+        amc_profiles = []
+        for amc in self._amc:
+            html = requests.post(url,{'Id':amc})
+            soup = BeautifulSoup(html.text, 'html.parser')
+            rows = soup.select("table tbody tr")
+            amc_details = {}
+            for row in rows:
+                if len(row.findAll('td')) > 1:
+                    amc_details[row.select("td")[0].get_text()] = row.select("td")[1].get_text().strip()
+            amc_profiles.append(amc_details)
+            amc_details = None
+        return render_response(amc_profiles, as_json)
+
+    def get_average_aum(self, year_quarter, as_json=True):
+        """
+        gets the Avearage AUM data for all Fund houses
+        :param as_json: True / False
+        :param year_quarter: string 'July - September 2020'
+        #quarter format should like - 'April - June 2020'
+        :return: json format
+        :raises: HTTPError, URLError
+        """
+        all_funds_aum = []
+        url = self._get_avg_aum
+        html = requests.post(url,headers=self._user_agent,data={"AUmType":'F',"Year_Quarter":year_quarter})
+        soup = BeautifulSoup(html.text, 'html.parser')
+        rows = soup.select("table tbody tr")
+        for row in rows:
+            aum_fund = {}
+            if len(row.findAll('td')) > 1:
+                aum_fund['Fund Name']= row.select("td")[1].get_text().strip()
+                aum_fund['AAUM Overseas']= row.select("td")[2].get_text().strip()
+                aum_fund['AAUM Domestic'] = row.select("td")[3].get_text().strip()
+                all_funds_aum.append(aum_fund)
+                aum_fund = None
+        return render_response(all_funds_aum, as_json)
+
+    def history(self, code, start=None, end=None, period='5d', as_dataframe=True):
+        """
+        gets the scheme historical data in DataFrame or json for a given scheme code, only use NEW codes
+        :Parameters:
+            code : str, list
+                Scheme code to download
+            period : str
+                Valid periods: 1d,5d,1mo,3mo,6mo,1y,2y,5y,10y,max
+                Either Use period parameter or use start and end
+            start: str
+                Download start date string (YYYY-MM-DD) or _datetime.
+                Default is None
+            end: str
+                Download end date string (YYYY-MM-DD) or _datetime.
+                Default is None
+            as_dataframe: boolen
+                download data format,
+                True : DataFrame, False : JSON
+                Default is True
+        :return: Dataframe or JSON or None
+        :raises: HTTPError, URLError
+        """
+        code = str(code)
+        if self.is_code(code):
+            def get_Dataframe(df, as_dataframe):
+                df = df.drop(columns=['Open', 'High', 'Low','Volume'])
+                df = df.rename(columns={'Close': 'nav'})
+                df['dayChange'] = df['nav'].diff()
+                df = df.rename_axis('date')
+                df.index = df.index.strftime('%d-%m-%Y')
+                if not as_dataframe:                    # To get json format
+                    df.reset_index(inplace=True)
+                    return df.astype(str).to_json(orient = "index", date_format = "iso")
+                else:
+                    return df
+            code = code + ".BO"
+            if start and end is not None:
+                response = yf.download(code,start=start,end=end)
+            elif period is not None:
+                response = yf.download(code,period=period)
+            return get_Dataframe(response, as_dataframe)
+
+    def get_scheme_info(self, code, as_json=True):
+        """
+        gets the complete information for a given scheme code, only use NEW scheme codes
+        :Parameters:
+            code : str
+                Scheme code to download
+            as_json: True / False
+                Default is True
+        :return: JSON or None
+        :raises: HTTPError, URLError
+        """
+        code = str(code)
+        if self.is_code(code):
+            code = code + ".BO"
+            mf = yf.Ticker(code)
+            response = mf.info
+            return render_response(response, as_json)
+
+    def compare_trend(self, codes, start_date, end_date):
+        """
+        plot and Compare trend of mutual funds
+        :param start_date: string '%Y-%m-%d'
+        :param end_date: string '%Y-%m-%d'
+        :param code: scheme code
+        :param as_json: default false
+        :param as_dataframe: default false
+        :return: dict or None
+        :raises: HTTPError, URLError
+        """
+        all_mf = pd.DataFrame()
+        for code in codes:
+            mf_data = self.get_scheme_historical_nav_for_dates(code, start_date, end_date, as_dataframe=True)
+            mf_data = mf_data.drop(columns=['dayChange'])
+            mf_name = self.get_scheme_details(code)['scheme_name']
+            mf_data[mf_name] = mf_data['nav'].astype(float)
+            mf_data['date'] = mf_data.index
+            all_mf[mf_name] = mf_data[mf_name]
+            all_mf['date'] = mf_data['date']
+
+        all_mf = all_mf[::-1]
+        all_mf.plot(x='date')
+        plt.title("Compare mutual funds")
+        plt.xlabel("Date")
+        plt.ylabel("NAV")
+        plt.show()
+
+    def clear_cache(self):
+        """
+        Clear all cached data
+        :return: None
+        """
+        self._cache.clear()
+        self._scheme_codes_cache.clear()
+
+    def get_cache_stats(self):
+        """
+        Get cache statistics
+        :return: dict with cache stats
+        """
+        return {
+            'nav_cache': self._cache.get_stats(),
+            'scheme_codes_cache': self._scheme_codes_cache.get_stats()
+        }
+
+    def disable_cache(self):
+        """
+        Disable caching globally
+        :return: None
+        """
+        self._cache.disable()
+        self._scheme_codes_cache.disable()
+
+    def enable_cache(self):
+        """
+        Enable caching globally
+        :return: None
+        """
+        self._cache.enable()
+        self._scheme_codes_cache.enable()
+
+    def calculate_portfolio_value(self, holdings: List[Dict[str, Union[str, float]]],
+                                  as_json=False) -> Dict[str, Union[float, dict]]:
+        """
+        Calculate total portfolio value for multiple holdings concurrently.
+
+        :param holdings: List of dicts with 'scheme_code' and 'units' keys
+        :param as_json: Return data in JSON format (default: False)
+        :return: Dictionary with portfolio summary
+
+        Example:
+            >>> holdings = [
+            ...     {'scheme_code': '119597', 'units': 100},
+            ...     {'scheme_code': '119062', 'units': 50}
+            ... ]
+            >>> portfolio = mf.calculate_portfolio_value(holdings)
+            >>> print(f"Total value: {portfolio['total_value']}")
+        """
+        scheme_codes = [str(h['scheme_code']) for h in holdings]
+
+        # Fetch all quotes concurrently
+        quotes = self.get_bulk_quotes(scheme_codes, as_json=False)
+
+        portfolio_data = []
+        total_value = 0.0
+
+        for holding in holdings:
+            code = str(holding['scheme_code'])
+            units = float(holding['units'])
+
+            quote = quotes.get(code)
+            if quote and 'nav' in quote:
+                nav = float(quote['nav'])
+                value = units * nav
+                total_value += value
+
+                portfolio_data.append({
+                    'scheme_code': code,
+                    'scheme_name': quote.get('scheme_name', 'N/A'),
+                    'units': units,
+                    'nav': nav,
+                    'current_value': round(value, 2),
+                    'last_updated': quote.get('last_updated', 'N/A')
+                })
+            else:
+                portfolio_data.append({
+                    'scheme_code': code,
+                    'scheme_name': 'Error fetching data',
+                    'units': units,
+                    'nav': 0,
+                    'current_value': 0,
+                    'last_updated': 'N/A'
+                })
+
+        result = {
+            'total_value': round(total_value, 2),
+            'total_schemes': len(holdings),
+            'holdings': portfolio_data,
+            'currency': 'INR'
+        }
+
+        return render_response(result, as_json)