Ollama Support Added

.gitignore

@@ -0,0 +1 @@
+/python

requirements.txt

@@ -1,3 +1,10 @@
-altair
+matplotlib
+requests
+pytz
+lxml
 pandas
-streamlit
+streamlit
+numpy
+plotly
+langchain
+langchain-ollama

src/customAPI.py

@@ -0,0 +1,968 @@
+import requests
+import logging
+import urllib.parse
+import pytz
+import pandas as pd
+from datetime import datetime
+from urllib.parse import quote , urlencode
+from lxml import etree
+from io import BytesIO
+tz = pytz.timezone('Asia/Kolkata')
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class NSEAPIError(Exception):
+    """Custom exception for NSE API errors."""
+    pass
+
+class NSEAPI:
+    """API client for fetching data from www.nseindia.com."""
+
+    def __init__(self):
+        self.base_url_charting = "https://charting.nseindia.com"
+        self.base_url_market = "https://www.nseindia.com/api/"
+        self.session = requests.Session()
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
+            "Referer": "https://www.nseindia.com/",
+            "Origin": "https://www.nseindia.com",
+            "Sec-Fetch-Site": "same-origin",
+        }
+        self.initialize_session()
+    
+    def initialize_session(self):
+        """Fetch NSE homepage to initialize session and get cookies."""
+
+        try:
+            response = self.session.get('https://www.nseindia.com/report-detail/eq_security', headers=self.headers, timeout=10)
+            response.raise_for_status()
+            logger.info("Session initialized successfully.")
+        except requests.exceptions.RequestException as e:
+            raise NSEAPIError(f"Error initializing session: {e}")
+
+    def get_all_equities(self):
+        """
+        Retrieves the list of all equities available on NSE.
+
+        Returns:
+            list of dict: Each dictionary contains 'ScripCode', 'TradingSymbol', 
+                          'Description', and 'InstrumentType'.
+
+        Raises:
+            NSEAPIError: If there is an error fetching the data from the server.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> equities = api.get_all_equities()
+            >>> print(equities[0])
+            {
+                'ScripCode': '500209',
+                'TradingSymbol': 'INFY',
+                'Description': 'Infosys Limited',
+                'InstrumentType': 'EQ'
+            }
+        """
+        endpoint = "/Charts/GetEQMasters"
+        self.headers['Content-Type'] = "text/plain"
+        self.headers['Accept'] = "text/plain"
+        
+        # Fetch data
+        try:
+            response = self.session.get(urllib.parse.urljoin(self.base_url_charting,endpoint), headers=self.headers)
+            response.raise_for_status()  # Raises exception for HTTP errors (e.g., 404, 500)
+        except requests.exceptions.RequestException as e:
+            raise NSEAPIError(f"Error fetching data: {e}")
+
+        # Parse plain text response
+        lines = response.text.split('\n')
+        equities = []
+        
+        for line in lines:
+            if line.strip():  # Skip empty lines
+                fields = [field.strip() for field in line.split('|')]
+                if len(fields) == 4:  # Ensure correct number of fields
+                    equities.append({
+                        'ScripCode': fields[0],
+                        'TradingSymbol': fields[1],
+                        'Description': fields[2],
+                        'InstrumentType': fields[3]
+                    })
+                else:
+                    logger.warning(f"Malformed line skipped: {line}")
+
+        # Warn if no valid data is found
+        if not equities:
+            logger.warning("No valid equity data found in the response")
+
+        eqdf = pd.DataFrame(equities[1:])
+        eqdf.ScripCode = eqdf.ScripCode.apply(int)
+        # eqdf = eqdf.query('ScripCode<26000 and ScripCode<=27000')
+        eqdf = eqdf.reset_index(drop=True)
+        eqdf = eqdf.sort_index()
+        
+        return eqdf
+    
+    def get_all_currencies(self):
+        """
+        Retrieves the list of all currencies pairs.
+
+        Returns:
+            list of dict: Each dictionary contains 'ScripCode', 'TradingSymbol', 
+                          'Description', and 'InstrumentType'.
+
+        Raises:
+            NSEAPIError: If there is an error fetching the data from the server.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> crc = api.get_all_crc()
+            >>> print(crc[0])
+            {'
+                ScripCode': '1', 
+                'TradingSymbol': 'USDINR', 
+                'Description': 'USDINR', 
+                'InstrumentType': '8'
+            }
+        """
+        endpoint = "/Charts/GetCDMasters"
+        self.headers['Content-Type'] = "text/plain"
+        self.headers['Accept'] = "text/plain"
+        
+        # Fetch data
+        try:
+            response = self.session.get(urllib.parse.urljoin(self.base_url_charting,endpoint), headers=self.headers)
+            response.raise_for_status()  # Raises exception for HTTP errors (e.g., 404, 500)
+        except requests.exceptions.RequestException as e:
+            raise NSEAPIError(f"Error fetching data: {e}")
+
+        # Parse plain text response
+        lines = response.text.split('\n')
+        fnos = []
+        
+        for line in lines:
+            if line.strip():  # Skip empty lines
+                fields = [field.strip() for field in line.split('|')]
+                if len(fields) == 4:  # Ensure correct number of fields
+                    fnos.append({
+                        'ScripCode': fields[0],
+                        'TradingSymbol': fields[1],
+                        'Description': fields[2],
+                        'InstrumentType': fields[3]
+                    })
+                else:
+                    logger.warning(f"Malformed line skipped: {line}")
+
+        # Warn if no valid data is found
+        if not fnos:
+            logger.warning("No valid equity data found in the response")
+        
+        return fnos
+    
+    def get_all_fnos(self):
+        """
+        Retrieves the list of all fnos available on NSE.
+
+        Returns:
+            list of dict: Each dictionary contains 'ScripCode', 'TradingSymbol', 
+                          'Description', and 'InstrumentType'.
+
+        Raises:
+            NSEAPIError: If there is an error fetching the data from the server.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> fnos = api.get_all_fnos()
+            >>> print(fnos[0])
+            {'
+                ScripCode': '35000', 
+                'TradingSymbol': 'MIDCPNIFTY25MARFUT', 
+                'Description': 'MIDCPNIFTY 27 Mar 2025', 
+                'InstrumentType': '1'
+            }
+        """
+        endpoint = "/Charts/GetFOMasters"
+        self.headers['Content-Type'] = "text/plain"
+        self.headers['Accept'] = "text/plain"
+        
+        # Fetch data
+        try:
+            response = self.session.get(urllib.parse.urljoin(self.base_url_charting,endpoint), headers=self.headers)
+            response.raise_for_status()  # Raises exception for HTTP errors (e.g., 404, 500)
+        except requests.exceptions.RequestException as e:
+            raise NSEAPIError(f"Error fetching data: {e}")
+
+        # Parse plain text response
+        lines = response.text.split('\n')
+        fnos = []
+        
+        for line in lines:
+            if line.strip():  # Skip empty lines
+                fields = [field.strip() for field in line.split('|')]
+                if len(fields) == 4:  # Ensure correct number of fields
+                    fnos.append({
+                        'ScripCode': fields[0],
+                        'TradingSymbol': fields[1],
+                        'Description': fields[2],
+                        'InstrumentType': fields[3]
+                    })
+                else:
+                    logger.warning(f"Malformed line skipped: {line}")
+
+        # Warn if no valid data is found
+        if not fnos:
+            logger.warning("No valid equity data found in the response")
+        
+        return fnos
+    
+    def get_all_indices(self):
+        """
+        Retrieves the list of all indices available on NSE.
+
+        Returns:
+            list of dict: Each dictionary contains details of an index, such as 'index', 'last', 'variation', etc.
+
+        Raises:
+            NSEAPIError: If there is an error fetching the data from the server or if the response is invalid.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> indices = api.get_all_indices()
+            >>> print(indices[0]['index'])
+            NIFTY 50
+        """
+        endpoint = "allIndices"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+
+        try:
+            response = self.session.get(
+                urllib.parse.urljoin(self.base_url_market, endpoint),
+                headers=self.headers
+            )
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch data: {str(e)}")
+        except ValueError:
+            raise NSEAPIError("Received invalid JSON response")
+
+        if "data" not in data or not isinstance(data["data"], list):
+            raise NSEAPIError("Response does not contain a valid 'data' list")
+
+        return pd.DataFrame(data["data"])
+    
+    def get_index_data(self, index_name: str):
+        """
+        Retrieves detailed data for a selected index, including its constituents.
+
+        Args:
+            index_name (str): The name of the index (e.g., "NIFTY 50").
+
+        Returns:
+            dict: A dictionary with the following keys:
+                - 'index': dict with index details (e.g., lastPrice, change, pChange)
+                - 'constituents': list of dicts with stock details (e.g., symbol, lastPrice)
+                - 'timestamp': str, the data timestamp
+                - 'advance': dict with advances, declines, and unchanged counts
+
+        Raises:
+            NSEAPIError: If the API request fails or the response is invalid.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> data = api.get_index_data("NIFTY 50")
+            >>> print(data['index']['lastPrice'])
+            22552.5
+            >>> print(data['constituents'][0]['symbol'])
+            RELIANCE
+        """
+        # URL-encode the index name to handle spaces and special characters
+        encoded_index = quote(index_name)
+        url = f"https://www.nseindia.com/api/equity-stockIndices?index={encoded_index}"
+        
+        # Headers to mimic browser request
+        headers = {
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9"
+        }
+
+        # Fetch data
+        try:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch data for index '{index_name}': {str(e)}")
+
+        # Parse JSON response
+        try:
+            data = response.json()
+        except ValueError:
+            raise NSEAPIError(f"Invalid JSON response for index '{index_name}'")
+
+        # Validate required fields
+        if "data" not in data or not isinstance(data["data"], list) or not data["data"]:
+            raise NSEAPIError(f"No valid data found for index '{index_name}'")
+
+        # Extract index and constituents
+        index_data = None
+        constituents = []
+        for item in data["data"]:
+            if item.get("priority") == 1:
+                index_data = item
+            else:
+                constituents.append(item)
+
+        if not index_data:
+            raise NSEAPIError(f"Index data not found in response for '{index_name}'")
+
+        # Structure the response
+        result = {
+            "index": {
+                "name": index_data["symbol"],
+                "lastPrice": index_data["lastPrice"],
+                "change": index_data["change"],
+                "pChange": index_data["pChange"],
+                "open": index_data["open"],
+                "dayHigh": index_data["dayHigh"],
+                "dayLow": index_data["dayLow"],
+                "previousClose": index_data["previousClose"],
+                "yearHigh": index_data["yearHigh"],
+                "yearLow": index_data["yearLow"],
+                "totalTradedVolume": index_data["totalTradedVolume"],
+                "totalTradedValue": index_data["totalTradedValue"]
+            },
+            "constituents": [
+                {
+                    "symbol": stock["symbol"],
+                    "lastPrice": stock["lastPrice"],
+                    "change": stock["change"],
+                    "pChange": stock["pChange"],
+                    "open": stock["open"],
+                    "dayHigh": stock["dayHigh"],
+                    "dayLow": stock["dayLow"],
+                    "previousClose": stock["previousClose"],
+                    "yearHigh": stock["yearHigh"],
+                    "yearLow": stock["yearLow"],
+                    "totalTradedVolume": stock["totalTradedVolume"],
+                    "totalTradedValue": stock["totalTradedValue"]
+                }
+                for stock in constituents
+            ],
+            "timestamp": data.get("timestamp", ""),
+            "advance": data.get("advance", {})
+        }
+
+        return result
+    
+    def get_stock_metadata(self, symbol: str):
+        """
+        Retrieves all metadata for a specified stock symbol from the NSE India API.
+
+        Args:
+            symbol (str): The stock symbol (e.g., "RELIANCE").
+
+        Returns:
+            dict: A dictionary containing all metadata for the stock, including:
+                - info: Basic stock information (symbol, company name, industry, etc.).
+                - metadata: Additional details (series, status, listing date, etc.).
+                - securityInfo: Trading status and segment details.
+                - priceInfo: Price data (last price, change, VWAP, etc.).
+                - industryInfo: Industry classification.
+                - preOpenMarket: Pre-open market data.
+
+        Raises:
+            NSEAPIError: If the API request fails, the response is invalid, or required data is missing.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> metadata = api.get_stock_metadata("RELIANCE")
+            >>> print(metadata["info"]["companyName"])
+            Reliance Industries Limited
+            >>> print(metadata["priceInfo"]["lastPrice"])
+            1246.4
+        """
+        # URL-encode the symbol to handle special characters
+        encoded_symbol = quote(symbol.split('-')[0])
+        print(encoded_symbol)
+
+        endpoint = f"quote-equity?symbol={encoded_symbol}"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+        
+        # Fetch data
+        try:
+            response = self.session.get(urllib.parse.urljoin(self.base_url_market,endpoint), headers=self.headers)
+            response.raise_for_status()  # Raises an HTTPError for bad responses
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch metadata for symbol '{symbol}': {str(e)}")
+
+        # Parse JSON response
+        try:
+            data = response.json()
+        except ValueError:
+            raise NSEAPIError(f"Invalid JSON response for symbol '{symbol}'")
+
+        # Verify essential keys are present
+        expected_keys = ["info", "metadata", "securityInfo", "priceInfo"]
+        if not all(key in data for key in expected_keys):
+            raise NSEAPIError(f"Incomplete metadata for symbol '{symbol}'")
+
+        return data
+    
+    def get_stock_live_trade_info(self, symbol: str):
+        """
+        Retrieves all Traded Information for a specified stock symbol from the NSE India API.
+
+        Args:
+            symbol (str): The stock symbol (e.g., "RELIANCE").
+
+        Returns:
+            dict: A dictionary containing all traded info for the stock, including:
+                - marketDeptOrderBook: Top Sellers and Buyers positions, Traded Volume Details, Risk margins etc.
+                - securityWiseDP: Intraday and Delivery Trade Volume.
+
+        Raises:
+            NSEAPIError: If the API request fails, the response is invalid, or required data is missing.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> metadata = api.get_stock_trade_info("RELIANCE")
+            >>> print(metadata["tradeInfo"]["totalTradedVolume"])
+            161.62
+            >>> print(metadata["securityWiseDP"]["deliveryToTradedQuantity"])
+            70.19
+        """
+        # URL-encode the symbol to handle special characters
+        encoded_symbol = quote(symbol)
+
+        endpoint = f"quote-equity?symbol={encoded_symbol}&section=trade_info"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+        
+        # Fetch data
+        try:
+            response = self.session.get(urllib.parse.urljoin(self.base_url_market,endpoint), headers=self.headers)
+            response.raise_for_status()  # Raises an HTTPError for bad responses
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch metadata for symbol '{symbol}': {str(e)}")
+
+        # Parse JSON response
+        try:
+            data = response.json()
+        except ValueError:
+            raise NSEAPIError(f"Invalid JSON response for symbol '{symbol}'")
+
+        print(data.keys())
+
+        # Verify essential keys are present
+        expected_keys = ["marketDeptOrderBook", "securityWiseDP"]
+        if not all(key in data for key in expected_keys):
+            raise NSEAPIError(f"Incomplete metadata for symbol '{symbol}'")
+
+        return data
+    
+    def get_historical_data(self, code: str, from_date: datetime, to_date: datetime, time_interval: int = 1, period: str='I'):
+        """
+        Retrieves historical intraday data for a given scrip code within the specified date range.
+
+        Args:
+            code (str): The scrip code of the stock or index (e.g., "26000").
+            from_date (datetime): The start date and time in UTC.
+            to_date (datetime): The end date and time in UTC.
+            time_interval (int, optional): The interval (default is 1).
+            period (str, optional): (Minute: 'I', Day: 'D')
+
+        Returns:
+            list of dict: A list where each dictionary represents a candlestick with keys:
+                - timestamp (int): Unix timestamp in seconds
+                - open (float): Opening price
+                - high (float): Highest price
+                - low (float): Lowest price
+                - close (float): Closing price
+                - volume (int): Trading volume
+
+        Raises:
+            NSEAPIError: If the API request fails or the response is invalid.
+
+        Example:
+            >>> from datetime import datetime, timezone
+            >>> api = NSEAPI()
+            >>> code = "26000"
+            >>> from_date = datetime(2024, 10, 28, tzinfo=timezone.utc)
+            >>> to_date = datetime(2024, 10, 29, tzinfo=timezone.utc)
+            >>> data = api.get_historical_data(code, from_date, to_date)
+            >>> print(data[0])
+            {
+                'timestamp': 1740759239,
+                'open': 22124.7,
+                'high': 22124.7,
+                'low': 22124.7,
+                'close': 22124.7,
+                'volume': 1
+            }
+        """
+        # Define the API endpoint
+        endpoint = "/Charts/symbolhistoricaldata/"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+
+        # Prepare the JSON payload
+        payload = {
+            "exch": "N",
+            "instrType": "C",
+            "scripCode": code,
+            "ulToken": code,
+            "fromDate": int(from_date.timestamp()),
+            "toDate": int(to_date.timestamp()),
+            "timeInterval": time_interval,
+            "chartPeriod": period,
+            "chartStart": 0
+        }
+
+        # Send the POST request
+        try:
+            response = self.session.post(urllib.parse.urljoin(self.base_url_charting,endpoint), json=payload, headers=self.headers)
+            response.raise_for_status()  # Raises an exception for HTTP errors
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch data: {str(e)}")
+        except ValueError:
+            raise NSEAPIError("Received invalid JSON response")
+
+        # Check if the request was successful
+        if data.get("s") != "Ok":
+            raise NSEAPIError(f"API returned an error: {data}")
+
+        # Extract and validate the response arrays
+        try:
+            timestamps = data["t"]
+            opens = data["o"]
+            highs = data["h"]
+            lows = data["l"]
+            closes = data["c"]
+            volumes = data["v"]
+
+            # Ensure all are lists and of the same length
+            arrays = [timestamps, opens, highs, lows, closes, volumes]
+            if not all(isinstance(arr, list) for arr in arrays):
+                raise NSEAPIError("Response contains invalid data types")
+            length = len(timestamps)
+            if not all(len(arr) == length for arr in arrays):
+                raise NSEAPIError("Response arrays have mismatched lengths")
+
+            # Structure the data into a list of candlesticks
+            historical_data = [
+                {
+                    "timestamp": timestamps[i],
+                    "open": opens[i],
+                    "high": highs[i],
+                    "low": lows[i],
+                    "close": closes[i],
+                    "volume": volumes[i]
+                }
+                for i in range(length)
+            ]
+
+            return historical_data
+
+        except KeyError as e:
+            raise NSEAPIError(f"Missing expected field in response: {str(e)}")
+
+    def get_historical_data_v2(self, symbol: str, from_date: datetime, to_date: datetime, time_interval: int = 1, period: str = 'I'):
+        """
+        Retrieves historical intraday data using trading symbol from the newer ChartData endpoint.
+
+        Args:
+            symbol (str): The trading symbol of the stock (e.g., "YESBANK-EQ").
+            from_date (datetime): Start date in UTC.
+            to_date (datetime): End date in UTC.
+            time_interval (int, optional): Interval in minutes. Default is 1.
+            period (str, optional): Period type - 'I' for intraday, 'D' for daily. Default is 'I'.
+
+        Returns:
+            list of dict: Candlestick data with timestamp, open, high, low, close, volume.
+
+        Raises:
+            NSEAPIError: If the API request fails or the response is invalid.
+        """
+        endpoint = "/Charts/ChartData/"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "*/*"
+
+        payload = {
+            "exch": "N",
+            "tradingSymbol": symbol,
+            "fromDate": int(from_date.timestamp()),
+            "toDate": int(to_date.timestamp()),
+            "timeInterval": time_interval,
+            "chartPeriod": period,
+            "chartStart": 0
+        }
+
+        try:
+            response = self.session.post(
+                urllib.parse.urljoin(self.base_url_charting, endpoint),
+                json=payload,
+                headers=self.headers
+            )
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch data: {str(e)}")
+        except ValueError:
+            raise NSEAPIError("Received invalid JSON response")
+
+        if data.get("s") != "Ok":
+            raise NSEAPIError(f"API returned an error: {data}")
+
+        try:
+            timestamps = data["t"]
+            opens = data["o"]
+            highs = data["h"]
+            lows = data["l"]
+            closes = data["c"]
+            volumes = data["v"]
+
+            arrays = [timestamps, opens, highs, lows, closes, volumes]
+            if not all(isinstance(arr, list) for arr in arrays):
+                raise NSEAPIError("Response contains invalid data types")
+            length = len(timestamps)
+            if not all(len(arr) == length for arr in arrays):
+                raise NSEAPIError("Response arrays have mismatched lengths")
+
+            return [
+                {
+                    "timestamp": timestamps[i],
+                    "open": opens[i],
+                    "high": highs[i],
+                    "low": lows[i],
+                    "close": closes[i],
+                    "volume": volumes[i]
+                }
+                for i in range(length)
+            ]
+
+        except KeyError as e:
+            raise NSEAPIError(f"Missing expected field in response: {str(e)}")
+
+    def get_historical_trade_info(self, symbol: str, from_date: datetime, to_date: datetime, data_type: str = "priceVolumeDeliverable", series: str = "ALL"):
+        """
+        Retrieves historical trade data for a given symbol using the updated NSE API.
+
+        Args:
+            symbol (str): The stock symbol (e.g., "RELIANCE").
+            from_date (datetime): The start date.
+            to_date (datetime): The end date.
+            data_type (str, optional): The type of data to retrieve (default is "priceVolumeDeliverable").
+            series (str, optional): The series to retrieve (default is "ALL").
+
+        Returns:
+            list of dict: A list of daily records with historical trade data.
+
+        Raises:
+            NSEAPIError: If the API request fails or the response is invalid.
+
+        Example:
+            >>> from datetime import datetime
+            >>> api = NSEAPI()
+            >>> data = api.get_historical_trade_info("RELIANCE", datetime(2025, 5, 7), datetime(2025, 5, 8))
+            >>> print(data[0]["COP_DELIV_PERC"])
+            73.92
+        """
+        params = {
+            "from": from_date.strftime("%d-%m-%Y"),
+            "to": to_date.strftime("%d-%m-%Y"),
+            "symbol": symbol.split('-')[0],
+            "type": data_type,
+            "series": series
+        }
+
+        endpoint = f"historicalOR/generateSecurityWiseHistoricalData?{urlencode(params)}"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+
+        try:
+            response = self.session.get(
+                urllib.parse.urljoin(self.base_url_market, endpoint),
+                headers=self.headers
+            )
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch data: {str(e)}")
+        except ValueError:
+            raise NSEAPIError("Invalid JSON response")
+
+        if "data" not in data or not isinstance(data["data"], list):
+            raise NSEAPIError("Response does not contain a valid 'data' list")
+        print(data)
+        return data["data"]
+    
+    def get_all_large_deals(self):
+        """
+        Retrieves the list of all fnos available on NSE.
+
+        Returns:
+            dict: dictionary contains 'BLOCK_DEALS(count)', 'BLOCK_DEALS_DATA', 'BULK_DEALS(count)', 'BULK_DEALS_DATA', 'SHORT_DEALS(count)', 'SHORT_DEALS_DATA'.
+
+        Raises:
+            NSEAPIError: If there is an error fetching the data from the server.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> deals = api.get_all_large_deals()
+            >>> print(deals[0])
+            {
+                "as_on_date": "28-Feb-2025",
+                "BULK_DEALS": "1",
+                "BULK_DEALS_DATA": [
+                    {
+                        "date": "28-Feb-2025",
+                        "symbol": "BIRDYS",
+                        "name": "Grill Splendour Ser Ltd",
+                        "clientName": "AJAY KRISHNAKANT PARIKH",
+                        "buySell": "BUY",
+                        "qty": "36000",
+                        "watp": "84.57",
+                        "remarks": "-"
+                    }
+                ],
+                "SHORT_DEALS": "0",
+                "SHORT_DEALS_DATA": [],
+                "BLOCK_DEALS": "0",
+                "BLOCK_DEALS_DATA": []
+            }
+        """
+        endpoint = "snapshot-capital-market-largedeal"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+        
+        # Fetch data
+        try:
+            print(urllib.parse.urljoin(self.base_url_market,endpoint))
+            response = self.session.get(urllib.parse.urljoin(self.base_url_market,endpoint), headers=self.headers)
+            response.raise_for_status()  # Raises exception for HTTP errors (e.g., 404, 500)
+        except requests.exceptions.RequestException as e:
+            raise NSEAPIError(f"Error fetching data: {e}")
+
+        # Parse plain text response
+        deals = response.json()
+
+        # Warn if no valid data is found
+        if not deals:
+            logger.warning("No valid equity data found in the response")
+        
+        return deals
+    
+    def get_corporate_actions(self, symbol: str, index: str = "equities"):
+        """
+        Retrieves corporate actions (e.g., dividends, bonuses) for a given symbol and issuer.
+
+        Args:
+            symbol (str): Stock symbol (e.g., "RELIANCE").
+            issuer (str): Issuer name (e.g., "Reliance Industries Limited").
+            index (str, optional): Index type (default is "equities").
+
+        Returns:
+            list of dict: Corporate actions with details like exDate, subject, etc.
+
+        Raises:
+            NSEAPIError: If the API request fails or the response is invalid.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> data = api.get_corporate_actions("RELIANCE", "Reliance Industries Limited")
+            >>> print(data[0]["subject"])
+            Dividend - Rs 10 Per Share
+        """
+        params = {
+            "index": index,
+            "symbol": symbol.split('-')[0]
+        }
+
+        endpoint = f"corporates-corporateActions?{urlencode(params)}"
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+
+        self.headers['referer'] = "https://www.nseindia.com/report-detail/eq_security"
+
+        try:
+            print(urllib.parse.urljoin(self.base_url_market,endpoint))
+            response = self.session.get(urllib.parse.urljoin(self.base_url_market,endpoint), headers=self.headers)
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch corporate actions: {str(e)}")
+        except ValueError:
+            raise NSEAPIError("Invalid JSON response")
+
+        return data
+
+    def get_financial_results(self, symbol: str, period: str = "Quarterly", index: str = "equities"):
+        """
+        Retrieves corporate financial results for a given symbol and issuer over a date range.
+
+        Args:
+            symbol (str): Stock symbol (e.g., "RELIANCE").
+            period (str, optional): Financial period (e.g., "Quarterly" or "Annual"). Defaults to "Quarterly".
+            index (str, optional): Index type (e.g., "equities"). Defaults to "equities".
+
+        Returns:
+            list of dict: A list of financial result records, each containing details like
+                        symbol, companyName, period, filingDate, xbrl, consolidated, etc.
+
+        Raises:
+            NSEAPIError: If the API request fails, the response is invalid, or required data is missing.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> data = api.get_financial_results(
+            ...     symbol="RELIANCE",
+            ...     period="Quarterly"
+            ... )
+            >>> print(data[0]["symbol"])
+            RELIANCE
+            >>> print(data[0]["filingDate"])
+            16-Jan-2025 20:20
+        """
+        # Prepare query parameters
+        params = {
+            "index": index,
+            "symbol": symbol.split('-')[0],
+            "period": period
+        }
+        endpoint = f"corporates-financial-results?{urlencode(params)}"
+
+        # Set headers
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+        self.headers['referer'] = "https://www.nseindia.com/companies-listing/corporate-filings-financial-results"
+
+        # Fetch data
+        try:
+            response = self.session.get(
+                urllib.parse.urljoin(self.base_url_market, endpoint),
+                headers=self.headers
+            )
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Failed to fetch financial results for symbol '{symbol}': {str(e)}")
+        except ValueError:
+            raise NSEAPIError(f"Invalid JSON response for symbol '{symbol}'")
+
+        # Validate response
+        if not isinstance(data, list):
+            raise NSEAPIError(f"Response does not contain a valid list for symbol '{symbol}'")
+        if not data:
+            logger.warning(f"No financial results found for symbol '{symbol}'")
+
+        return data
+
+    def get_bulk_block_short_deals(self, from_date: str, to_date: str, option_type: str = "bulk_deals", symbol: str = None):
+        """
+        Retrieves bulk deals data for a specified date range and option type from NSE.
+
+        Args:
+            symbol (str): Stock symbol (e.g., "RELIANCE").
+            from_date (str): Start date in DD-MM-YYYY format (e.g., "07-05-2025").
+            to_date (str): End date in DD-MM-YYYY format (e.g., "08-05-2025").
+            option_type (str, optional): Type of deals to retrieve (e.g., "bulk_deals", "block_deals", "short_selling"). Defaults to "bulk_deals".
+
+        Returns:
+            list of dict: A list of deal records, each containing details like date, symbol, client name, buy/sell, quantity, weighted average trade price, and remarks.
+
+        Raises:
+            NSEAPIError: If the API request fails, the response is invalid, or required data is missing.
+
+        Example:
+            >>> api = NSEAPI()
+            >>> deals = api.get_bulk_deals(from_date="07-05-2025", to_date="08-05-2025", option_type="bulk_deals")
+            >>> print(deals[0])
+            {
+                'BD_DT_DATE': '07-MAY-2025',
+                'BD_DT_ORDER': '2025-05-06T18:30:00.000+00:00',
+                'BD_SYMBOL': 'AARTIDRUGS',
+                'BD_SCRIP_NAME': 'Aarti Drugs Ltd.',
+                'BD_CLIENT_NAME': 'GRAVITON RESEARCH CAPITAL LLP',
+                'BD_BUY_SELL': 'BUY',
+                'BD_QTY_TRD': 803477,
+                'BD_TP_WATP': 393.1,
+                'BD_REMARKS': '-'
+            }
+        """
+        # Prepare query parameters
+        params = {
+            "symbol": symbol.split('-')[0] if symbol else "",
+            "optionType": option_type,
+            "from": from_date,
+            "to": to_date
+        }
+        endpoint = f"historicalOR/bulk-block-short-deals?{urlencode(params)}"
+
+        # Set headers
+        self.headers['Content-Type'] = "application/json; charset=utf-8"
+        self.headers['Accept'] = "application/json; charset=utf-8"
+        self.headers['referer'] = "https://www.nseindia.com/report-detail/display-bulk-and-block-deals"
+
+        # Fetch data
+        try:
+            response = self.session.get(
+                urllib.parse.urljoin(self.base_url_market, endpoint),
+                headers=self.headers
+            )
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise NSEAPIError(f"Error fetching bulk deals data: {str(e)}")
+        except ValueError:
+            raise NSEAPIError("Invalid JSON response")
+
+        # Validate response
+        if "data" not in data or not isinstance(data["data"], list):
+            raise NSEAPIError("Response does not contain a valid 'data' list")
+        if not data["data"]:
+            logger.warning("No bulk deals data found in the response")
+
+        return data["data"]
+
+
+    def xbrl_to_dict(self, xml_url):
+        try:
+            response = self.session.get(xml_url, headers=self.headers)
+            response.raise_for_status()
+            xml_content = response.content
+
+            tree = etree.parse(BytesIO(xml_content))
+            root = tree.getroot()
+
+            ns = root.nsmap
+            if None in ns:
+                ns['default'] = ns.pop(None)  
+                
+            data_dict = {}
+            for elem in root.iter():
+                tag = etree.QName(elem).localname
+                value = elem.text.strip() if elem.text else None
+
+                if value:
+                    key = f"{tag} ({elem.get('contextRef')})" if elem.get('contextRef') else tag
+                    data_dict[key] = value
+
+            return data_dict
+
+        except requests.RequestException as e:
+            print(f"Error fetching XML: {e}")
+        except etree.XMLSyntaxError as e:
+            print(f"Error parsing XML: {e}")
+        return {}
+
+if __name__ == "__main__":
+    api = NSEAPI()
+    try:
+        # Test Code
+        pass
+    except NSEAPIError as e:
+        print(f"Failed to fetch deals: {e}")

src/streamlit_app.py

@@ -1,40 +1,817 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from datetime import datetime
+import pytz
+import pandas as pd
+import numpy as np
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+from customAPI import NSEAPI
+import plotly.express as px
+
+# Set page configuration
+st.set_page_config(page_title="Stock Market Application", layout="wide")
+
+# Initialize timezone and NSEAPI
+tz = pytz.timezone('Asia/Kolkata')
+api = NSEAPI()
+
+# Fetch all equities
+@st.cache_data
+def load_equities():
+    equities_df = api.get_all_equities()
+    return equities_df
+
+# Fetch all indices
+@st.cache_data
+def load_indices():
+    indices_df = api.get_all_indices()
+    return indices_df
+
+eq_list = load_equities()
+inx_list = load_indices()
+
+# Sidebar for equity selection and date range
+st.sidebar.header("Stock Selection")
+selected_stock = st.sidebar.selectbox("Select a Stock", eq_list.query('TradingSymbol.str.endswith(\'-EQ\')')['TradingSymbol'].tolist()) #.loc[eq_list['TradingSymbol'].str.endswith('-EQ')]
+
+st.sidebar.header("Date Range")
+default_end = datetime.now(tz=tz)
+default_start = datetime(2019, 12, 30, 9, 15, 0, tzinfo=tz)
+start_date = st.sidebar.date_input("Start Date", value=default_start, min_value=default_start, max_value=default_end)
+end_date = st.sidebar.date_input("End Date", value=default_end, min_value=default_start, max_value=default_end)
+
+# Convert date inputs to datetime with timezone
+start_date = tz.localize(datetime.combine(start_date, datetime.min.time()))
+end_date = tz.localize(datetime.combine(end_date, datetime.max.time()))
+
+# Cache historical data based on stock and date range
+@st.cache_data
+def fetch_historical_data(symbol, start, end):
+    return api.get_historical_data_v2(symbol, start, end, 1, "D")
+
+# Cache index data for comparative analysis
+@st.cache_data
+def fetch_index_data(index_name, start, end):
+    data = api.get_historical_data(index_name, start, end, 1, "D")
+    df = pd.DataFrame(data)
+    df['date'] = pd.to_datetime(df['timestamp'], unit='s').dt.tz_localize('UTC').dt.tz_convert(tz)
+    df.set_index('date', inplace=True)
+    df = df[['open', 'high', 'low', 'close', 'volume']]
+    df.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+    return df
+
+def predict_next_return(df, window_size=3, bin_size=0.5):
+    """
+    Predicts the most probable next return based on historical return patterns.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing 'Returns' column with daily returns.
+        window_size (int): Size of the sliding window for patterns (default=3).
+        bin_size (float): Size of return bins in percentage (default=0.5).
+
+    Returns:
+        dict: Contains the current pattern, historical occurrences, frequency of next returns,
+              and the most probable next return.
+    """
+    # Discretize returns into bins
+    returns = df['Returns'].dropna()
+    min_return = returns.min()
+    max_return = returns.max()
+    bins = np.arange(np.floor(min_return / bin_size) * bin_size, 
+                    np.ceil(max_return / bin_size) * bin_size + bin_size, 
+                    bin_size)
+    binned_returns = pd.cut(returns, bins=bins, include_lowest=True, labels=False)
+    binned_returns = binned_returns * bin_size  # Convert bin indices back to return values
+
+    # Create sliding window patterns
+    patterns = []
+    for i in range(len(binned_returns) - window_size):
+        pattern = tuple(binned_returns[i:i + window_size])
+        next_return = binned_returns[i + window_size] if i + window_size < len(binned_returns) else np.nan
+        patterns.append((pattern, next_return))
+
+    # Get current pattern (last window_size returns)
+    current_pattern = tuple(binned_returns[-window_size:]) if len(binned_returns) >= window_size else None
+
+    if not current_pattern:
+        return {
+            'current_pattern': None,
+            'occurrences': 0,
+            'next_return_frequencies': {},
+            'most_probable_return': None
+        }
+
+    # Find historical occurrences of the current pattern
+    matching_patterns = [(p, r) for p, r in patterns if p == current_pattern and not np.isnan(r)]
+    
+    # Count frequency of next returns
+    next_returns = [r for _, r in matching_patterns]
+    if not next_returns:
+        return {
+            'current_pattern': current_pattern,
+            'occurrences': 0,
+            'next_return_frequencies': {},
+            'most_probable_return': None
+        }
+
+    # Calculate frequency of each next return
+    freq = pd.Series(next_returns).value_counts().to_dict()
+    total_occurrences = len(next_returns)
+    freq_percentage = {k: (v / total_occurrences * 100) for k, v in freq.items()}
+
+    # Find the most probable next return
+    most_probable = max(freq.items(), key=lambda x: x[1])[0] if freq else None
+
+    return {
+        'current_pattern': current_pattern,
+        'occurrences': total_occurrences,
+        'next_return_frequencies': freq_percentage,
+        'most_probable_return': most_probable
+    }
+
+# Main content
+st.title("Stock Market Application")
+
+if selected_stock:
+    # Fetch historical data
+    data = fetch_historical_data(selected_stock, start_date, end_date)
+    df = pd.DataFrame(data)
+    df['date'] = pd.to_datetime(df['timestamp'], unit='s').dt.tz_localize('Asia/Kolkata')
+    df.set_index('date', inplace=True)
+    df = df[['open', 'high', 'low', 'close', 'volume']]
+    df.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+
+    # Calculate additional metrics
+    df['SMA5'] = df['Close'].ewm(span=5, adjust=False).mean()
+    df['SMA20'] = df['Close'].ewm(span=20, adjust=False).mean()
+    df['SMA50'] = df['Close'].rolling(window=50).mean()
+    df['SMA100'] = df['Close'].rolling(window=100).mean()
+    df['SMA200'] = df['Close'].rolling(window=200).mean()
+    df['Returns'] = ((df['Close'] - df['Open']) / df['Open']) * 100
+    df['LogReturns'] = np.log(df['Close'] / df['Close'].shift(1))
+    df['Volatility'] = df['Returns'].rolling(window=20).std()
+    df['Volume_Rank'] = df['Volume'].rank(pct=True)  # For volume-conditional analysis
+    df['DayOfWeek'] = df.index.dayofweek
+    df['Month'] = df.index.month
+    df['Year'] = df.index.year
+    df['Avg'] = ((df['High']-df['Low'])/2) + df['Low']
+    
+    # Calculate RSI for signal-based conditioning
+    delta = df['Close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+    rs = gain / loss
+    df['RSI'] = 100 - (100 / (1 + rs))
+
+    # Price bins for volume per price
+    price_bin_size = int((df['High'].max()-df['Low'].min())/20)
+    min_price = df['Close'].min()
+    max_price = df['Close'].max()
+    bins = pd.interval_range(start=int(min_price), end=int(max_price) + 1, freq=price_bin_size)
+    df['price_bin'] = pd.cut(df['Avg'], bins=bins)
+    volume_per_price = df.groupby('price_bin')['Volume'].sum()
+    volume_per_price = volume_per_price.reset_index()
+    volume_per_price['price_mid'] = volume_per_price['price_bin'].apply(lambda x: x.mid)
+
+    # Prepare return distributions
+    returns = df['Returns'].dropna()
+    log_returns = df['LogReturns'].dropna()
+    total_returns = len(returns)
+
+    # Create main figure
+    fig = make_subplots(
+        rows=8, cols=2,
+        shared_xaxes=False,
+        shared_yaxes=False,
+        vertical_spacing=0.05,
+        horizontal_spacing=0.1,
+        subplot_titles=(
+            f"{selected_stock} Daily Chart", "Volume per Price Bracket",
+            "Volume", "Volume Deviation per Price Bracket",
+            "Overall Return Distribution", "Returns in Fixed Ranges",
+            "Daily Return Probability by Day of Week", "",
+            "5-SMA vs 20-SMA", "5-20 SMA Deviation Distribution",
+            "20-SMA vs 50-SMA", "20-50 SMA Deviation Distribution",
+            "50-SMA vs 100-SMA", "50-100 SMA Deviation Distribution",
+            "100-SMA vs 200-SMA", "100-200 SMA Deviation Distribution",
+        ),
+        row_heights=[0.2, 0.1, 0.1, 0.1, 0.1, 0.12, 0.12, 0.12],
+        column_widths=[0.6, 0.4],
+        specs=[
+            [{"rowspan": 1}, {"rowspan": 1}],
+            [{"rowspan": 1}, {"rowspan": 1}],
+            [{"rowspan": 1}, {"rowspan": 1}],
+            [{"colspan": 2}, None],
+            [{"rowspan": 1}, {"rowspan": 1}],
+            [{"rowspan": 1}, {"rowspan": 1}],
+            [{"rowspan": 1}, {"rowspan": 1}],
+            [{"rowspan": 1}, {"rowspan": 1}]
+        ]
+    )
+
+    # Candlestick chart
+    fig.add_trace(
+        go.Candlestick(
+            x=df.index,
+            open=df['Open'],
+            high=df['High'],
+            low=df['Low'],
+            close=df['Close'],
+            name=selected_stock,
+            increasing_line_color='green',
+            decreasing_line_color='red'
+        ),
+        row=1, col=1
+    )
+
+    # Volume per price
+    fig.add_trace(
+        go.Bar(
+            y=volume_per_price['price_mid'],
+            x=volume_per_price['Volume'],
+            orientation='h',
+            name='Volume per Price',
+            marker_color='rgba(255, 165, 0, 0.6)'
+        ),
+        row=1, col=2
+    )
+
+
+    volume_per_price['price_volume_mean'] = volume_per_price['Volume'].mean()
+    volume_per_price['price_volume_above_mean'] = volume_per_price['Volume'].where(volume_per_price['Volume']>(0.5*volume_per_price['price_volume_mean']),0)
+
+    volume_per_price['ma_price_volume_above_mean'] = volume_per_price['price_volume_above_mean'].rolling(window=2).mean()
+    
+
+    fig.add_trace(
+        go.Bar(
+            y=volume_per_price['price_mid'],
+            x=volume_per_price['ma_price_volume_above_mean'],
+            orientation='h',
+            name='Volume MA per Price',
+            marker_color='rgba(255, 165, 0, 0.6)'
+        ),
+        row=2, col=2
+    )
+
+    # Volume subplot
+    fig.add_trace(
+        go.Bar(x=df.index, y=df['Volume'], name='Volume', marker_color='rgba(0, 0, 255, 0.5)'),
+        row=2, col=1
+    )
+
+    def get_return_color(x):
+        if x < 0:
+            intensity = min(255, int(abs(x) * 100))
+            return f'rgb({255},{255-intensity},{255-intensity})'
+        else:
+            intensity = min(255, int(x * 100))
+            return f'rgb({255-intensity},{255},{255-intensity})'
+
+    # Overall return distribution
+    combined_bin_edges = np.histogram_bin_edges(returns, bins=50)
+    hist_data_combined, _ = np.histogram(returns, bins=combined_bin_edges)
+    bin_centers_combined = 0.5 * (combined_bin_edges[:-1] + combined_bin_edges[1:])
+    customdata_combined = [
+        (f"{combined_bin_edges[i]:.2f} to {combined_bin_edges[i+1]:.2f}",
+         (hist_data_combined[i] / total_returns) * 100,
+         hist_data_combined[i],
+         total_returns)
+        for i in range(len(hist_data_combined))
+    ]
+    bar_colors = [get_return_color(x) for x in bin_centers_combined]
+
+    fig.add_trace(
+        go.Bar(
+            x=bin_centers_combined,
+            y=hist_data_combined,
+            name='Daily Returns Distribution',
+            marker_color=bar_colors,
+            marker_line=dict(color='black', width=1),
+            opacity=0.8,
+            customdata=customdata_combined,
+            hovertemplate='Return: %{customdata[0]}<br>Probability: %{customdata[1]:.2f}% %{customdata[2]}/%{customdata[3]}<extra></extra>'
+        ),
+        row=3, col=1
+    )
+    
+    # Return distribution (fixed bins)
+    bin_edges = list(range(-15, 18, 3))
+    bin_labels = [f"{bin_edges[i]}% to {bin_edges[i+1]}%" for i in range(len(bin_edges)-1)]
+    bin_centers = [(bin_edges[i] + bin_edges[i+1]) / 2 for i in range(len(bin_edges)-1)]
+    bin_counts = [((returns >= bin_edges[i]) & (returns < bin_edges[i+1])).sum() for i in range(len(bin_edges)-1)]
+    bin_probs = [count / total_returns * 100 for count in bin_counts]
+
+    bar_colors = [get_return_color(x) for x in bin_centers]
+
+    fig.add_trace(
+        go.Bar(
+            x=bin_probs,
+            y=bin_labels,
+            orientation='h',
+            name='Fixed Return Ranges',
+            marker_color=bar_colors,
+            hovertemplate='Range: %{y}<br>Probability: %{x:.2f}%<extra></extra>'
+        ),
+        row=3, col=2
+    )
+
+    # Day of Week Returns - Probability Distributions
+    dow_returns = df.groupby('DayOfWeek')['Returns'].apply(list)
+    dow_labels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']
+    dow_data = [dow_returns.get(i, []) for i in range(5)]
+    colors = ['rgba(0, 128, 128, 0.6)', 'rgba(255, 165, 0, 0.6)', 'rgba(0, 0, 255, 0.6)', 
+              'rgba(255, 0, 0, 0.6)', 'rgba(128, 0, 128, 0.6)']
+    
+    for i, (day_data, label, color) in enumerate(zip(dow_data, dow_labels, colors)):
+        if day_data:  # Only plot if there is data for the day
+            hist_data, _ = np.histogram(day_data, bins=combined_bin_edges)
+            hist_probs = hist_data / np.sum(hist_data) * 100 if np.sum(hist_data) > 0 else hist_data
+            fig.add_trace(
+                go.Bar(
+                    x=bin_centers_combined,
+                    y=hist_probs,
+                    name=f'{label} Returns',
+                    marker_color=color,
+                    opacity=0.6,
+                    hovertemplate=f'{label} Return: %{{x:.2f}}%<br>Probability: %{{y:.2f}}%<extra></extra>'
+                ),
+                row=4, col=1
+            )
+
+    df_recent1 = df.iloc[-1000:]
+    df_recent2 = df.iloc[-1000:]
+    df_recent3 = df.iloc[-1000:]
+    df_recent4 = df.iloc[-1000:]
+
+    # Calculate normalized deviations for SMA subplots
+    # 5-SMA vs 20-SMA
+    deviation_5_20 = (df_recent1['SMA5'] - df_recent1['SMA20']) / df_recent1['SMA20']
+    max_abs_deviation_5_20 = np.abs(deviation_5_20).max()
+    normalized_deviation_5_20 = deviation_5_20 / max_abs_deviation_5_20 if max_abs_deviation_5_20 != 0 else deviation_5_20
+
+    # 20-SMA vs 50-SMA
+    deviation_20_50 = (df_recent2['SMA20'] - df_recent2['SMA50']) / df_recent2['SMA50']
+    max_abs_deviation_20_50 = np.abs(deviation_20_50).max()
+    normalized_deviation_20_50 = deviation_20_50 / max_abs_deviation_20_50 if max_abs_deviation_20_50 != 0 else deviation_20_50
+
+    # 50-SMA vs 100-SMA
+    deviation_50_100 = (df_recent3['SMA50'] - df_recent3['SMA100']) / df_recent3['SMA100']
+    max_abs_deviation_50_100 = np.abs(deviation_50_100).max()
+    normalized_deviation_50_100 = deviation_50_100 / max_abs_deviation_50_100 if max_abs_deviation_50_100 != 0 else deviation_50_100
+
+    # 100-SMA vs 200-SMA
+    deviation_100_200 = (df_recent4['SMA100'] - df_recent4['SMA200']) / df_recent4['SMA200']
+    max_abs_deviation_100_200 = np.abs(deviation_100_200).max()
+    normalized_deviation_100_200 = deviation_100_200 / max_abs_deviation_100_200 if max_abs_deviation_100_200 != 0 else deviation_100_200
+
+    # Define histogram bins for normalized deviations
+    hist_bins = np.linspace(-1, 1, 21)  # 20 bins from -1 to 1
+    bin_centers = 0.5 * (hist_bins[:-1] + hist_bins[1:])
+
+    # 5-SMA vs 20-SMA
+    if not normalized_deviation_5_20.empty:
+        mean_5_20 = normalized_deviation_5_20.mean()
+        std_5_20 = normalized_deviation_5_20.std() if normalized_deviation_5_20.std() != 0 else 1e-10
+        # Add mean and ±1σ, ±2σ, ±3σ lines
+        for level, label, color, dash in [
+            (mean_5_20, 'Mean', 'rgba(128, 0, 128, 1)', 'solid'),
+            (mean_5_20 + std_5_20, '+1σ', 'rgba(128, 0, 128, 0.8)', 'dash'),
+            (mean_5_20 - std_5_20, '-1σ', 'rgba(128, 0, 128, 0.8)', 'dash'),
+            (mean_5_20 + 2 * std_5_20, '+2σ', 'rgba(128, 0, 128, 0.6)', 'dot'),
+            (mean_5_20 - 2 * std_5_20, '-2σ', 'rgba(128, 0, 128, 0.6)', 'dot'),
+            (mean_5_20 + 3 * std_5_20, '+3σ', 'rgba(128, 0, 128, 0.4)', 'dashdot'),
+            (mean_5_20 - 3 * std_5_20, '-3σ', 'rgba(128, 0, 128, 0.4)', 'dashdot')
+        ]:
+            if -1 <= level <= 1:  # Only plot within y-axis range
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_recent1.index,
+                        y=[level] * len(df_recent1),
+                        mode='lines',
+                        name=f'5-20 {label}',
+                        line=dict(color=color, width=1, dash=dash),
+                        showlegend=False
+                    ),
+                    row=5, col=1
+                )
+        # Add histogram in next column
+        hist_data_5_20, _ = np.histogram(normalized_deviation_5_20.dropna(), bins=hist_bins)
+        hist_probs_5_20 = hist_data_5_20 / np.sum(hist_data_5_20) * 100 if np.sum(hist_data_5_20) > 0 else hist_data_5_20
+        fig.add_trace(
+            go.Bar(
+                y=bin_centers,
+                x=hist_probs_5_20,
+                orientation='h',
+                name='5-20 Distribution',
+                marker_color='rgba(128, 0, 128, 0.6)',
+                width=(hist_bins[1] - hist_bins[0]),
+                showlegend=False
+            ),
+            row=5, col=2
+        )
+        fig.add_trace(
+            go.Scatter(
+                y=[-1, 1],
+                x=[mean_5_20, mean_5_20],
+                mode='lines',
+                name='5-20 Mean',
+                line=dict(color='rgba(128, 0, 128, 1)', width=2, dash='solid'),
+                showlegend=False
+            ),
+            row=5, col=2
+        )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent1.index, 
+            y=normalized_deviation_5_20, 
+            line=dict(color='purple', width=1), 
+            name='5-SMA Deviation'
+        ),
+        row=5, col=1
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent1.index, 
+            y=[0] * len(df_recent1), 
+            line=dict(color='blue', width=1, dash='dash'), 
+            name='20-SMA Baseline'
+        ),
+        row=5, col=1
+    )
+
+    # 20-SMA vs 50-SMA
+    if not normalized_deviation_20_50.empty:
+        mean_20_50 = normalized_deviation_20_50.mean()
+        std_20_50 = normalized_deviation_20_50.std() if normalized_deviation_20_50.std() != 0 else 1e-10
+        for level, label, color, dash in [
+            (mean_20_50, 'Mean', 'rgba(0, 0, 255, 1)', 'solid'),
+            (mean_20_50 + std_20_50, '+1σ', 'rgba(0, 0, 255, 0.8)', 'dash'),
+            (mean_20_50 - std_20_50, '-1σ', 'rgba(0, 0, 255, 0.8)', 'dash'),
+            (mean_20_50 + 2 * std_20_50, '+2σ', 'rgba(0, 0, 255, 0.6)', 'dot'),
+            (mean_20_50 - 2 * std_20_50, '-2σ', 'rgba(0, 0, 255, 0.6)', 'dot'),
+            (mean_20_50 + 3 * std_20_50, '+3σ', 'rgba(0, 0, 255, 0.4)', 'dashdot'),
+            (mean_20_50 - 3 * std_20_50, '-3σ', 'rgba(0, 0, 255, 0.4)', 'dashdot')
+        ]:
+            if -1 <= level <= 1:
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_recent2.index,
+                        y=[level] * len(df_recent2),
+                        mode='lines',
+                        name=f'20-50 {label}',
+                        line=dict(color=color, width=1, dash=dash),
+                        showlegend=False
+                    ),
+                    row=6, col=1
+                )
+        hist_data_20_50, _ = np.histogram(normalized_deviation_20_50.dropna(), bins=hist_bins)
+        hist_probs_20_50 = hist_data_20_50 / np.sum(hist_data_20_50) * 100 if np.sum(hist_data_20_50) > 0 else hist_data_20_50
+        fig.add_trace(
+            go.Bar(
+                y=bin_centers,
+                x=hist_probs_20_50,
+                orientation='h',
+                name='20-50 Distribution',
+                marker_color='rgba(0, 0, 255, 0.6)',
+                width=(hist_bins[1] - hist_bins[0]),
+                showlegend=False
+            ),
+            row=6, col=2
+        )
+        fig.add_trace(
+            go.Scatter(
+                y=[-1, 1],
+                x=[mean_20_50, mean_20_50],
+                mode='lines',
+                name='20-50 Mean',
+                line=dict(color='rgba(0, 0, 255, 1)', width=2, dash='solid'),
+                showlegend=False
+            ),
+            row=6, col=2
+        )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent2.index, 
+            y=normalized_deviation_20_50, 
+            line=dict(color='blue', width=1), 
+            name='20-SMA Deviation'
+        ),
+        row=6, col=1
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent2.index, 
+            y=[0] * len(df_recent2), 
+            line=dict(color='green', width=1, dash='dash'), 
+            name='50-SMA Baseline'
+        ),
+        row=6, col=1
+    )
+
+    # 50-SMA vs 100-SMA
+    if not normalized_deviation_50_100.empty:
+        mean_50_100 = normalized_deviation_50_100.mean()
+        std_50_100 = normalized_deviation_50_100.std() if normalized_deviation_50_100.std() != 0 else 1e-10
+        for level, label, color, dash in [
+            (mean_50_100, 'Mean', 'rgba(0, 128, 0, 1)', 'solid'),
+            (mean_50_100 + std_50_100, '+1σ', 'rgba(0, 128, 0, 0.8)', 'dash'),
+            (mean_50_100 - std_50_100, '-1σ', 'rgba(0, 128, 0, 0.8)', 'dash'),
+            (mean_50_100 + 2 * std_50_100, '+2σ', 'rgba(0, 128, 0, 0.6)', 'dot'),
+            (mean_50_100 - 2 * std_50_100, '-2σ', 'rgba(0, 128, 0, 0.6)', 'dot'),
+            (mean_50_100 + 3 * std_50_100, '+3σ', 'rgba(0, 128, 0, 0.4)', 'dashdot'),
+            (mean_50_100 - 3 * std_50_100, '-3σ', 'rgba(0, 128, 0, 0.4)', 'dashdot')
+        ]:
+            if -1 <= level <= 1:
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_recent3.index,
+                        y=[level] * len(df_recent3),
+                        mode='lines',
+                        name=f'50-100 {label}',
+                        line=dict(color=color, width=1, dash=dash),
+                        showlegend=False
+                    ),
+                    row=7, col=1
+                )
+        hist_data_50_100, _ = np.histogram(normalized_deviation_50_100.dropna(), bins=hist_bins)
+        hist_probs_50_100 = hist_data_50_100 / np.sum(hist_data_50_100) * 100 if np.sum(hist_data_50_100) > 0 else hist_data_50_100
+        fig.add_trace(
+            go.Bar(
+                y=bin_centers,
+                x=hist_probs_50_100,
+                orientation='h',
+                name='50-100 Distribution',
+                marker_color='rgba(0, 128, 0, 0.6)',
+                width=(hist_bins[1] - hist_bins[0]),
+                showlegend=False
+            ),
+            row=7, col=2
+        )
+        fig.add_trace(
+            go.Scatter(
+                y=[-1, 1],
+                x=[mean_50_100, mean_50_100],
+                mode='lines',
+                name='50-100 Mean',
+                line=dict(color='rgba(0, 128, 0, 1)', width=2, dash='solid'),
+                showlegend=False
+        ),
+            row=7, col=2
+        )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent3.index, 
+            y=normalized_deviation_50_100, 
+            line=dict(color='green', width=1), 
+            name='50-SMA Deviation'
+        ),
+        row=7, col=1
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent3.index, 
+            y=[0] * len(df_recent3), 
+            line=dict(color='orange', width=1, dash='dash'), 
+            name='100-SMA Baseline'
+        ),
+        row=7, col=1
+    )
+
+    # 100-SMA vs 200-SMA
+    if not normalized_deviation_100_200.empty:
+        mean_100_200 = normalized_deviation_100_200.mean()
+        std_100_200 = normalized_deviation_100_200.std() if normalized_deviation_100_200.std() != 0 else 1e-10
+        for level, label, color, dash in [
+            (mean_100_200, 'Mean', 'rgba(255, 165, 0, 1)', 'solid'),
+            (mean_100_200 + std_100_200, '+1σ', 'rgba(255, 165, 0, 0.8)', 'dash'),
+            (mean_100_200 - std_100_200, '-1σ', 'rgba(255, 165, 0, 0.8)', 'dash'),
+            (mean_100_200 + 2 * std_100_200, '+2σ', 'rgba(255, 165, 0, 0.6)', 'dot'),
+            (mean_100_200 - 2 * std_100_200, '-2σ', 'rgba(255, 165, 0, 0.6)', 'dot'),
+            (mean_100_200 + 3 * std_100_200, '+3σ', 'rgba(255, 165, 0, 0.4)', 'dashdot'),
+            (mean_100_200 - 3 * std_100_200, '-3σ', 'rgba(255, 165, 0, 0.4)', 'dashdot')
+        ]:
+            if -1 <= level <= 1:
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_recent4.index,
+                        y=[level] * len(df_recent4),
+                        mode='lines',
+                        name=f'100-200 {label}',
+                        line=dict(color=color, width=1, dash=dash),
+                        showlegend=False
+                    ),
+                    row=8, col=1
+                )
+        hist_data_100_200, _ = np.histogram(normalized_deviation_100_200.dropna(), bins=hist_bins)
+        hist_probs_100_200 = hist_data_100_200 / np.sum(hist_data_100_200) * 100 if np.sum(hist_data_100_200) > 0 else hist_data_100_200
+        fig.add_trace(
+            go.Bar(
+                y=bin_centers,
+                x=hist_probs_100_200,
+                orientation='h',
+                name='100-200 Distribution',
+                marker_color='rgba(255, 165, 0, 0.6)',
+                width=(hist_bins[1] - hist_bins[0]),
+                showlegend=False
+            ),
+            row=8, col=2
+        )
+        fig.add_trace(
+            go.Scatter(
+                y=[-1, 1],
+                x=[mean_100_200, mean_100_200],
+                mode='lines',
+                name='100-200 Mean',
+                line=dict(color='rgba(255, 165, 0, 1)', width=2, dash='solid'),
+                showlegend=False
+            ),
+            row=8, col=2
+        )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent4.index, 
+            y=normalized_deviation_100_200, 
+            line=dict(color='orange', width=1), 
+            name='100-SMA Deviation'
+        ),
+        row=8, col=1
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=df_recent4.index, 
+            y=[0] * len(df_recent4), 
+            line=dict(color='red', width=1, dash='dash'), 
+            name='200-SMA Baseline'
+        ),
+        row=8, col=1
+    )
+
+    # Update layout
+    fig.update_layout(
+        yaxis_title="Price (INR)", xaxis_title="Date",
+        yaxis2_title="Price (INR)", xaxis2_title="Volume",
+        yaxis3_title="Volume", xaxis3_title="Date",
+        yaxis4_title="Frequency", xaxis4_title="Returns (%)",
+        yaxis5_title="Probability (%)", xaxis5_title="Returns (%)",
+        yaxis6_title="Returns (%)", xaxis6_title="Probability (%)",
+        yaxis7_title="Returns (%)", xaxis7_title="Day of the week",
+        yaxis8_title="Normalized Deviation", xaxis8_title="Date",
+        yaxis8=dict(range=[-1, 1]),
+        yaxis9_title="Probability (%)", xaxis9_title="",
+        yaxis9=dict(range=[-1, 1]),
+        yaxis10_title="Normalized Deviation", xaxis10_title="Date",
+        yaxis10=dict(range=[-1, 1]),
+        yaxis11_title="Probability (%)", xaxis11_title="",
+        yaxis11=dict(range=[-1, 1]),
+        yaxis12_title="Normalized Deviation", xaxis12_title="Date",
+        yaxis12=dict(range=[-1, 1]),
+        yaxis13_title="Probability (%)", xaxis13_title="",
+        yaxis13=dict(range=[-1, 1]),
+        yaxis14_title="Normalized Deviation", xaxis14_title="Date",
+        yaxis14=dict(range=[-1, 1]),
+        yaxis15_title="Probability (%)", xaxis15_title="",
+        yaxis15=dict(range=[-1, 1]),
+        template="plotly_white", xaxis_rangeslider_visible=False,
+        height=2000, showlegend=True,
+        dragmode='zoom', hovermode='x unified', uirevision='dataset'
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Additional Visualizations
+    st.subheader("Advanced Analysis")
+
+    # Transition Matrix
+    st.subheader("Return Transition Matrix")
+    bins = [-np.inf, -2, 0, 2, np.inf]
+    labels = ['<-2%', '-2% to 0%', '0% to 2%', '>2%']
+    df['Return_Bin'] = pd.cut(df['Returns'], bins=bins, labels=labels)
+    df['Next_Return_Bin'] = df['Return_Bin'].shift(-1)
+    transition_matrix = pd.crosstab(df['Return_Bin'], df['Next_Return_Bin'], normalize='index') * 100
+    fig_tm = px.imshow(
+        transition_matrix,
+        labels=dict(x="Next Day Return Bin", y="Current Day Return Bin", color="Probability (%)"),
+        x=labels, y=labels, color_continuous_scale='Blues'
+    )
+    fig_tm.update_layout(title="Transition Matrix of Returns")
+    st.plotly_chart(fig_tm, use_container_width=True)
+
+    # Comparative Analysis with NIFTY 50
+    st.subheader("Comparative Analysis with NIFTY 50")
+    nifty_data = fetch_index_data("26003", start_date, end_date)
+    nifty_data['Returns'] = ((nifty_data['Close'] - nifty_data['Open']) / nifty_data['Open']) * 100
+    merged_df = pd.merge(df[['Returns']], nifty_data[['Returns']], left_index=True, right_index=True, suffixes=('_Stock', '_Nifty'))
+    merged_df['Return_Diff'] = merged_df['Returns_Stock'] - merged_df['Returns_Nifty']
+    fig_diff = go.Figure()
+    fig_diff.add_trace(
+        go.Histogram(
+            x=merged_df['Return_Diff'],
+            nbinsx=50,
+            name='Return Difference (Stock - Nifty)',
+            marker_color='rgba(255, 69, 0, 0.6)',
+            opacity=0.8
+        )
+    )
+    fig_diff.update_layout(
+        title="Histogram of Return Differences (Stock - NIFTY 50)",
+        xaxis_title="Return Difference (%)",
+        yaxis_title="Frequency",
+        template="plotly_white"
+    )
+    st.plotly_chart(fig_diff, use_container_width=True)
+
+    # Heatmap of Returns by Day of Week and Month
+    st.subheader("Returns by Day of Week and Month")
+    heatmap_data = df.pivot_table(values='Returns', index='DayOfWeek', columns='Month', aggfunc='mean')
+    heatmap_data.index = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+    heatmap_data.columns = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+    fig_heatmap = px.imshow(
+        heatmap_data,
+        labels=dict(x="Month", y="Day of Week", color="Average Return (%)"),
+        color_continuous_scale='RdYlGn'
+    )
+    fig_heatmap.update_layout(title="Heatmap of Average Returns by Day of Week and Month")
+    st.plotly_chart(fig_heatmap, use_container_width=True)
+
+    # Pattern-based Return Prediction
+    st.subheader("Pattern-based Return Prediction")
+    prediction = predict_next_return(df, window_size=3, bin_size=0.5)
+    if prediction['current_pattern']:
+        st.write(f"**Current Pattern (Last 3 Days' Returns)**: {list(prediction['current_pattern'])}%")
+        st.write(f"**Number of Historical Occurrences**: {prediction['occurrences']}")
+        if prediction['most_probable_return'] is not None:
+            st.write(f"**Most Probable Next Return**: {prediction['most_probable_return']}%")
+            st.write("**Frequency of Next Returns**:")
+            for return_val, freq in prediction['next_return_frequencies'].items():
+                st.write(f"Return {return_val}%: {freq:.2f}%")
+            
+            # Visualize frequency of next returns
+            fig_pred = go.Figure()
+            fig_pred.add_trace(
+                go.Bar(
+                    x=list(prediction['next_return_frequencies'].keys()),
+                    y=list(prediction['next_return_frequencies'].values()),
+                    name='Next Return Probability',
+                    marker_color='rgba(0, 128, 255, 0.6)'
+                )
+            )
+            fig_pred.update_layout(
+                title="Probability Distribution of Next Return",
+                xaxis_title="Next Return (%)",
+                yaxis_title="Probability (%)",
+                template="plotly_white"
+            )
+            st.plotly_chart(fig_pred, use_container_width=True)
+        else:
+            st.write("No historical matches found for the current pattern.")
+    else:
+        st.write("Insufficient data to form a pattern for prediction.")
+
+    # Stock Information
+    selected_stock_meta = eq_list.loc[eq_list['TradingSymbol']==selected_stock]
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+    if(selected_stock_meta.iloc[0]['TradingSymbol'].endswith('EQ')):
+        metadata = api.get_stock_metadata(selected_stock)
+        enriched = {
+            'ScripCode': selected_stock_meta['ScripCode'],
+            'TradingSymbol': selected_stock,
+            'Description': selected_stock_meta['Description'],
+            'InstrumentType': selected_stock_meta['InstrumentType'],
+            'CompanyName': metadata['info'].get('companyName'),
+            'ISIN': metadata['info'].get('isin'),
+            'MarketCapital': int((float(metadata['priceInfo'].get('lastPrice'))*float(metadata['securityInfo'].get('issuedSize')))/pow(10,7)),
+            'ListingDate': metadata['info'].get('listingDate'),
+            'LastPrice': metadata['priceInfo'].get('lastPrice'),
+            'PreviousClose': metadata['priceInfo'].get('previousClose'),
+            'Open': metadata['priceInfo'].get('open'),
+            'High': metadata['priceInfo']['intraDayHighLow'].get('max'),
+            'Low': metadata['priceInfo']['intraDayHighLow'].get('min'),
+            'VWAP': metadata['priceInfo'].get('vwap'),
+            '52WeekHigh': metadata['priceInfo']['weekHighLow'].get('max'),
+            '52WeekLow': metadata['priceInfo']['weekHighLow'].get('min'),
+            'SectorPE': metadata['metadata'].get('pdSectorPe'),
+            'PE': metadata['metadata'].get('pdSymbolPe'),
+            'Sector': metadata['industryInfo'].get('sector'),
+            'Macro': metadata['industryInfo'].get('macro'),
+            'Industry': metadata['industryInfo'].get('industry'),
+            'BasicIndustry': metadata['industryInfo'].get('basicIndustry'),
+        }
+        
+        st.subheader("Stock Information")
+        st.write(f"**Company Name**: {enriched['CompanyName']}")
+        st.write(f"**Sector**: {enriched['Sector']}")
+        st.write(f"**Industry**: {enriched['BasicIndustry']}")
+        st.write(f"**Market Capital(CR)**: ₹{enriched['MarketCapital']}")
+        st.write(f"**PE**: {enriched['PE']}")
+        st.write(f"**Sector PE**: {enriched['SectorPE']}")
+        st.write(f"**52WeekHigh**: ₹{enriched['52WeekHigh']}")
+        st.write(f"**52WeekLow**: ₹{enriched['52WeekLow']}")
+        st.write(f"**VWAP**: ₹{enriched['VWAP']}")
+    else:
+        selected_index_meta = inx_list.loc[inx_list['index']==selected_stock.upper()]
+        if len(selected_index_meta)>0:
+            st.subheader("Index Information")
+            st.write(selected_index_meta.iloc[0])
+else:
+    st.write("Select a stock from the sidebar to view the chart.")