wiz-trader 0.37.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

wiz_trader/apis/client.py

@@ -226,7 +226,68 @@ class WizzerClient:
     "kv.delete": "/kv/{strategy_id}/{key}",
     "kv.list": "/kv/{strategy_id}",
     "kv.keys": "/kv/{strategy_id}/keys",
-    "kv.delete_all": "/kv/{strategy_id}/all"
+    "kv.delete_all": "/kv/{strategy_id}/all",
+    
+    # Analytics API endpoints - Fundamentals
+    "analytics.fundamentals.net_profit_margin": "/analytics/fundamentals/margins/netProfit",
+    "analytics.fundamentals.roe": "/analytics/fundamentals/roe",
+    "analytics.fundamentals.roa": "/analytics/fundamentals/roa",
+    "analytics.fundamentals.ebit_margin": "/analytics/fundamentals/ebit-margin",
+    "analytics.fundamentals.ocf_netprofit_ratio": "/analytics/fundamentals/ocf-netprofit-ratio",
+    "analytics.fundamentals.eps_cagr": "/analytics/fundamentals/eps-cagr",
+    "analytics.fundamentals.book_to_market": "/analytics/fundamentals/valuation/book-to-market",
+    "analytics.fundamentals.marketcap_to_sales": "/analytics/fundamentals/valuation/marketcap-to-sales",
+    "analytics.fundamentals.cash_to_marketcap": "/analytics/fundamentals/liquidity/cash-to-marketcap",
+    
+    # Analytics API endpoints - Valuation
+    "analytics.valuation.pe_ratio": "/analytics/valuation/pe-ratio",
+    "analytics.valuation.pb_ratio": "/analytics/valuation/pb-ratio",
+    "analytics.valuation.ev_ebitda": "/analytics/valuation/ev-ebitda",
+    "analytics.valuation.fcf_yield": "/analytics/valuation/fcf-yield",
+    
+    # Analytics API endpoints - Returns
+    "analytics.returns.quarterly": "/analytics/returns/quarterly",
+    "analytics.returns.monthly": "/analytics/returns/monthly",
+    "analytics.returns.cagr": "/analytics/returns/cagr",
+    
+    # Analytics API endpoints - Market Data
+    "analytics.marketdata.ohlcv_daily": "/analytics/marketdata/ohlcv-daily",
+    "analytics.marketdata.historical_prices": "/analytics/marketdata/historical-prices",
+    "analytics.marketdata.free_float_market_cap": "/analytics/marketdata/free-float-market-cap",
+    "analytics.marketdata.index_ohlc_daily": "/analytics/marketdata/index-ohlc-daily",
+    
+    # Analytics API endpoints - Ownership
+    "analytics.ownership.fii_dii": "/analytics/ownership/fii-dii",
+    "analytics.ownership.fii_change": "/analytics/ownership/fii-change",
+    "analytics.ownership.dii_change": "/analytics/ownership/dii-change",
+    
+    # Analytics API endpoints - Metrics
+    "analytics.metrics.sortino_ratio": "/analytics/metrics/sortino-ratio",
+    "analytics.metrics.upside_capture": "/analytics/metrics/upside-capture",
+    
+    # Analytics API endpoints - Macro
+    "analytics.macro.risk_free_rate": "/analytics/macro/rates/risk-free",
+    
+    # Analytics API endpoints - Risk
+    "analytics.risk.max_drawdown": "/analytics/risk/maxDrawdown",
+    "analytics.risk.returns_volatility": "/analytics/risk/returnsVolatility",
+    
+    # Analytics API endpoints - Metadata
+    "analytics.metadata.sector": "/analytics/metadata/sector",
+    
+    # Analytics API endpoints - Leverage
+    "analytics.leverage.debt_equity_ratio": "/analytics/leverage/debtEquityRatio",
+    
+    # Analytics API endpoints - New Additions
+    "analytics.marketdata.average_volume": "/analytics/marketdata/averageVolume",
+    "analytics.index.max_drawdown": "/analytics/index/metrics/maxDrawdown",
+    "analytics.instrument.drawdown_duration": "/analytics/instrument/metrics/drawdownDuration",
+    "analytics.price.rolling_peak": "/analytics/analytics/price/rollingPeak",
+    "analytics.price.rolling_mean": "/analytics/analytics/price/rollingMean",
+    "analytics.volatility.realized": "/analytics/analytics/volatility/realized",
+    "analytics.risk.beta_90d": "/analytics/risk/beta90d",
+    "analytics.risk.beta_custom": "/analytics/risk/beta",
+    
   }
   
   def __init__(
@@ -1768,11 +1829,37 @@ class WizzerClient:
     logger.debug("Fetching screener fields.")
     return self._make_request("GET", endpoint)
 
+  def _normalize_params(self, params: Optional[Dict[str, Any]]) -> Optional[Dict[str, str]]:
+    """
+    Normalize parameters for HTTP requests, converting booleans to lowercase strings.
+    Preserves spaces in string values to prevent automatic URL encoding by requests library.
+    
+    Args:
+      params (Optional[Dict[str, Any]]): Raw parameters dictionary.
+      
+    Returns:
+      Optional[Dict[str, str]]: Normalized parameters with proper string formatting.
+    """
+    if not params:
+      return None
+    
+    normalized = {}
+    for key, value in params.items():
+      if isinstance(value, bool):
+        # Convert Python boolean to lowercase string for API compatibility
+        normalized[key] = "true" if value else "false"
+      elif value is not None:
+        # Convert other values to strings, preserving spaces
+        # This prevents requests library from automatically URL-encoding spaces to '+'
+        normalized[key] = str(value)
+    
+    return normalized
+
   def _make_request(
     self,
     method: str,
     endpoint: str, 
-    params: Optional[Dict[str, str]] = None, 
+    params: Optional[Dict[str, Any]] = None, 
     json: Optional[Dict[str, Any]] = None,
     headers: Optional[Dict[str, str]] = None
   ) -> Any:
@@ -1782,7 +1869,7 @@ class WizzerClient:
     Args:
       method (str): HTTP method (GET, POST, etc.)
       endpoint (str): API endpoint path.
-      params (Optional[Dict[str, str]]): Query parameters for GET requests.
+      params (Optional[Dict[str, Any]]): Query parameters for GET requests.
       json (Optional[Dict[str, Any]]): JSON payload for POST requests.
       headers (Optional[Dict[str, str]]): Custom headers to override the defaults.
 
@@ -1792,16 +1879,35 @@ class WizzerClient:
     Raises:
       requests.RequestException: If the request fails.
     """
+    import urllib.parse
+    
     url = f"{self.base_url}{endpoint}"
     request_headers = headers if headers else self.headers
     
+    # Normalize parameters to handle booleans correctly
+    normalized_params = self._normalize_params(params)
+    
+    # Handle URL construction manually to encode spaces as %20 instead of +
+    if normalized_params and method.upper() == 'GET':
+      # Construct query string manually to control encoding
+      query_parts = []
+      for key, value in normalized_params.items():
+        # Use urllib.parse.quote to encode values, spaces become %20 instead of +
+        encoded_key = urllib.parse.quote(str(key), safe='')
+        encoded_value = urllib.parse.quote(str(value), safe='')  # Properly encode all special chars
+        query_parts.append(f"{encoded_key}={encoded_value}")
+      
+      if query_parts:
+        url = f"{url}?{'&'.join(query_parts)}"
+      normalized_params = None  # Don't pass params to requests since we built the URL manually
+    
     try:
       logger.debug("%s request to %s", method, url)
       response = requests.request(
         method=method,
         url=url,
         headers=request_headers,
-        params=params,
+        params=normalized_params,
         json=json
       )
       response.raise_for_status()
@@ -2234,3 +2340,1538 @@ class WizzerClient:
     
     logger.debug("Deleting all KV pairs for strategy: %s", strategy_info["id"])
     return self._make_request("DELETE", endpoint)
+  
+  # ===== ANALYTICS API METHODS =====
+  
+  # --- Fundamentals Methods ---
+  
+  def get_net_profit_margin(
+    self, 
+    symbol: str, 
+    period: str = "quarterly", 
+    fiscal_year: Optional[str] = None,
+    quarter: Optional[str] = None
+  ) -> Dict[str, Any]:
+    """
+    Get net profit margin for a stock.
+    
+    Args:
+      symbol (str): Stock symbol (e.g., "INFY").
+      period (str, optional): "quarterly" or "annual". Defaults to "quarterly".
+      fiscal_year (str, optional): For annual reports (e.g., "2023").
+      quarter (str, optional): For quarterly reports (e.g., "Q1FY24").
+      
+    Returns:
+      Dict[str, Any]: Net profit margin data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "period": "quarterly",
+        "quarter": "Q1FY24",
+        "fiscalYear": null,
+        "netProfitMargin": 16.8,
+        "unit": "%"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "period": period
+    })
+    
+    if fiscal_year:
+      params["fiscalYear"] = fiscal_year
+    if quarter:
+      params["quarter"] = quarter
+    
+    logger.debug("Fetching net profit margin for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.net_profit_margin"], params=params)
+  
+  def get_roe(
+    self, 
+    symbol: str, 
+    period: str = "annual", 
+    consolidated: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get Return on Equity (ROE) for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      period (str, optional): "quarterly" or "annual". Defaults to "annual".
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: ROE data.
+      
+    Example Response:
+      {
+        "symbol": "TCS",
+        "period": "annual",
+        "roe": 42.5,
+        "unit": "%"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "period": period,
+      "consolidated": consolidated
+    }
+    
+    logger.debug("Fetching ROE for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.roe"], params=params)
+  
+  def get_roa(
+    self, 
+    symbol: str, 
+    period: str = "annual", 
+    consolidated: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get Return on Assets (ROA) for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      period (str, optional): "quarterly" or "annual". Defaults to "annual".
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: ROA data.
+      
+    Example Response:
+      {
+        "symbol": "WIPRO",
+        "period": "annual",
+        "roa": 14.3,
+        "unit": "%"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "period": period,
+      "consolidated": consolidated
+    }
+    
+    logger.debug("Fetching ROA for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.roa"], params=params)
+  
+  def get_ebit_margin(
+    self, 
+    symbol: str, 
+    period: str = "annual", 
+    consolidated: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get EBIT margin for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      period (str, optional): "quarterly" or "annual". Defaults to "annual".
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: EBIT margin data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "period": "annual",
+        "ebit_margin": 24.1,
+        "unit": "%"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "period": period,
+      "consolidated": consolidated
+    }
+    
+    logger.debug("Fetching EBIT margin for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.ebit_margin"], params=params)
+  
+  def get_ocf_netprofit_ratio(
+    self, 
+    symbol: str, 
+    period: str = "annual"
+  ) -> Dict[str, Any]:
+    """
+    Get Operating Cash Flow to Net Profit ratio.
+    
+    Args:
+      symbol (str): Stock symbol.
+      period (str, optional): "annual" or "ttm". Defaults to "annual".
+      
+    Returns:
+      Dict[str, Any]: OCF/Net Profit ratio data.
+      
+    Example Response:
+      {
+        "symbol": "TCS",
+        "period": "annual",
+        "ocf_netprofit_ratio": 1.15,
+        "unit": "ratio"
+      }
+      
+    Note: Ratio > 1 indicates strong cash generation.
+    """
+    params = {
+      "symbol": symbol,
+      "period": period
+    }
+    
+    logger.debug("Fetching OCF/Net Profit ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.ocf_netprofit_ratio"], params=params)
+  
+  def get_eps_cagr(
+    self, 
+    symbol: str, 
+    start_year: int,
+    end_year: int
+  ) -> Dict[str, Any]:
+    """
+    Get EPS Compound Annual Growth Rate (CAGR).
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_year (int): Starting year (e.g., 2019).
+      end_year (int): Ending year (e.g., 2023).
+      
+    Returns:
+      Dict[str, Any]: EPS CAGR data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "startYear": 2019,
+        "endYear": 2023,
+        "epsCagr": 8.5,
+        "epsStart": 35.2,
+        "epsEnd": 48.7,
+        "years": 4,
+        "unit": "%"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startYear": start_year,
+      "endYear": end_year
+    })
+    
+    logger.debug("Fetching EPS CAGR for %s from %s to %s", symbol, start_year, end_year)
+    return self._make_request("GET", self._routes["analytics.fundamentals.eps_cagr"], params=params)
+  
+  def get_book_to_market(
+    self,
+    symbol: str,
+    as_of: str,
+    price_source: str = "avgQuarter",
+    custom_price: Optional[float] = None,
+    standalone: bool = False,
+    currency: str = "INR"
+  ) -> Dict[str, Any]:
+    """
+    Get book-to-market ratio for a stock.
+    
+    Args:
+      symbol (str): Stock symbol (e.g., "NSE:INFY").
+      as_of (str): Reference date (YYYY-MM-DD).
+      price_source (str, optional): Price source: spot, avgQuarter, custom. Defaults to "avgQuarter".
+      custom_price (float, optional): Required if price_source=custom.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      currency (str, optional): Output currency. Defaults to "INR".
+      
+    Returns:
+      Dict[str, Any]: Book-to-market ratio data.
+      
+    Example Response:
+      {
+        "symbol": "NSE:INFY",
+        "asOf": "2023-03-31",
+        "bookToMarket": 0.1234,
+        "bookValuePerShare": 184.50,
+        "marketPricePerShare": 1495.75,
+        "sourcePriceType": "avgQuarter",
+        "quarterRef": "Q4FY23",
+        "standalone": false,
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "asOf": as_of,
+      "priceSource": price_source,
+      "standalone": standalone,
+      "currency": currency
+    })
+    
+    if custom_price is not None:
+      params["customPrice"] = str(custom_price)
+    
+    logger.debug("Fetching book-to-market ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.book_to_market"], params=params)
+  
+  def get_marketcap_to_sales(
+    self,
+    symbol: str,
+    as_of: str,
+    price_source: str = "avgQuarter",
+    custom_price: Optional[float] = None,
+    standalone: bool = False
+  ) -> Dict[str, Any]:
+    """
+    Get market cap to sales ratio for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      as_of (str): Reference date (YYYY-MM-DD).
+      price_source (str, optional): Price source. Defaults to "avgQuarter".
+      custom_price (float, optional): Custom price if price_source=custom.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      
+    Returns:
+      Dict[str, Any]: Market cap to sales ratio data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "asOf": "2023-03-31",
+        "marketcapToSales": 5.67,
+        "marketCap": 615000,
+        "sales": 108500,
+        "pricePerShare": 1495.75,
+        "sharesOutstanding": 4112000000,
+        "revenueQuarter": "Q1",
+        "standalone": false,
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "asOf": as_of,
+      "priceSource": price_source,
+      "standalone": standalone
+    })
+    
+    if custom_price is not None:
+      params["customPrice"] = str(custom_price)
+    
+    logger.debug("Fetching market cap to sales ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.marketcap_to_sales"], params=params)
+  
+  def get_cash_to_marketcap(
+    self,
+    symbol: str,
+    as_of: str,
+    price_source: str = "avgQuarter",
+    custom_price: Optional[float] = None,
+    standalone: bool = False
+  ) -> Dict[str, Any]:
+    """
+    Get cash to market cap ratio for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      as_of (str): Reference date (YYYY-MM-DD).
+      price_source (str, optional): Price source. Defaults to "avgQuarter".
+      custom_price (float, optional): Custom price if price_source=custom.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      
+    Returns:
+      Dict[str, Any]: Cash to market cap ratio data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "asOf": "2023-03-31",
+        "cashToMarketcap": 0.0456,
+        "cashAndEquivalents": 28050,
+        "marketCap": 615000,
+        "pricePerShare": 1495.75,
+        "sharesOutstanding": 4112000000,
+        "reportingQuarter": "Q1",
+        "standalone": false,
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "asOf": as_of,
+      "priceSource": price_source,
+      "standalone": standalone
+    })
+    
+    if custom_price is not None:
+      params["customPrice"] = str(custom_price)
+    
+    logger.debug("Fetching cash to market cap ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.fundamentals.cash_to_marketcap"], params=params)
+  
+  # --- Valuation Methods ---
+  
+  def get_pe_ratio(
+    self, 
+    symbol: str, 
+    date: Optional[str] = None,
+    ttm: bool = False,
+    consolidated: bool = True,
+    standalone: bool = False
+  ) -> Dict[str, Any]:
+    """
+    Get Price to Earnings (P/E) ratio.
+    
+    Args:
+      symbol (str): Stock symbol.
+      date (str, optional): Date in "YYYY-MM-DD" format.
+      ttm (bool, optional): Use trailing twelve months. Defaults to False.
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      
+    Returns:
+      Dict[str, Any]: P/E ratio data.
+      
+    Example Response:
+      {
+        "symbol": "RELIANCE",
+        "date": "2025-07-31",
+        "pe_ratio": 27.5,
+        "price": null,
+        "eps": null,
+        "ttm": false,
+        "consolidated": true,
+        "unit": "ratio"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "ttm": ttm,
+      "consolidated": consolidated,
+      "standalone": standalone
+    }
+    
+    if date:
+      params["date"] = date
+    
+    logger.debug("Fetching P/E ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.valuation.pe_ratio"], params=params)
+  
+  def get_pb_ratio(
+    self, 
+    symbol: str, 
+    date: Optional[str] = None,
+    consolidated: bool = True,
+    standalone: bool = False
+  ) -> Dict[str, Any]:
+    """
+    Get Price to Book (P/B) ratio.
+    
+    Args:
+      symbol (str): Stock symbol.
+      date (str, optional): Date in "YYYY-MM-DD" format.
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      
+    Returns:
+      Dict[str, Any]: P/B ratio data.
+      
+    Example Response:
+      {
+        "symbol": "HDFC",
+        "date": "2025-07-31",
+        "pb_ratio": 3.2,
+        "price": null,
+        "book_value": null,
+        "consolidated": true,
+        "unit": "ratio"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "consolidated": consolidated,
+      "standalone": standalone
+    }
+    
+    if date:
+      params["date"] = date
+    
+    logger.debug("Fetching P/B ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.valuation.pb_ratio"], params=params)
+  
+  def get_ev_ebitda(
+    self, 
+    symbol: str, 
+    date: Optional[str] = None,
+    ttm: bool = False,
+    consolidated: bool = True,
+    standalone: bool = False
+  ) -> Dict[str, Any]:
+    """
+    Get Enterprise Value to EBITDA ratio.
+    
+    Args:
+      symbol (str): Stock symbol.
+      date (str, optional): Date in "YYYY-MM-DD" format.
+      ttm (bool, optional): Use trailing twelve months. Defaults to False.
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      
+    Returns:
+      Dict[str, Any]: EV/EBITDA ratio data.
+      
+    Example Response:
+      {
+        "symbol": "LTI",
+        "date": "2025-06-30",
+        "ev_ebitda": 22.8,
+        "enterprise_value": null,
+        "ebitda": null,
+        "ttm": false,
+        "unit": "ratio"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "ttm": ttm,
+      "consolidated": consolidated,
+      "standalone": standalone
+    }
+    
+    if date:
+      params["date"] = date
+    
+    logger.debug("Fetching EV/EBITDA for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.valuation.ev_ebitda"], params=params)
+  
+  def get_fcf_yield(
+    self, 
+    symbol: str, 
+    date: Optional[str] = None,
+    ttm: bool = False,
+    consolidated: bool = True,
+    standalone: bool = False
+  ) -> Dict[str, Any]:
+    """
+    Get Free Cash Flow yield.
+    
+    Args:
+      symbol (str): Stock symbol.
+      date (str, optional): Date in "YYYY-MM-DD" format.
+      ttm (bool, optional): Use trailing twelve months. Defaults to False.
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      standalone (bool, optional): Use standalone financials. Defaults to False.
+      
+    Returns:
+      Dict[str, Any]: FCF yield data.
+      
+    Example Response:
+      {
+        "symbol": "HDFCAMC",
+        "date": "2025-06-30",
+        "fcf_yield": 4.5,
+        "fcf": null,
+        "market_cap": null,
+        "ttm": false,
+        "unit": "%"
+      }
+    """
+    params = {
+      "symbol": symbol,
+      "ttm": ttm,
+      "consolidated": consolidated,
+      "standalone": standalone
+    }
+    
+    if date:
+      params["date"] = date
+    
+    logger.debug("Fetching FCF yield for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.valuation.fcf_yield"], params=params)
+  
+  # --- Returns Methods ---
+  
+  
+  def get_quarterly_returns(
+    self, 
+    symbol: str, 
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get quarterly returns for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      adjusted (bool, optional): Use adjusted prices. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: Quarterly returns data.
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted
+    })
+    
+    logger.debug("Fetching quarterly returns for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.returns.quarterly"], params=params)
+  
+  def get_monthly_returns(
+    self, 
+    symbol: str, 
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get monthly returns for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      adjusted (bool, optional): Use adjusted prices. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: Monthly returns data.
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted
+    })
+    
+    logger.debug("Fetching monthly returns for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.returns.monthly"], params=params)
+  
+  # --- Market Data Methods ---
+  
+  def get_analytics_ohlcv_daily(
+    self, 
+    symbol: str, 
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get daily OHLCV data from analytics API.
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      adjusted (bool, optional): Use adjusted prices. Defaults to True (ignored as adjusted data not available).
+      
+    Returns:
+      Dict[str, Any]: Daily OHLCV data.
+      
+    Example Response:
+      {
+        "data": [
+          {
+            "date": "2025-01-01",
+            "open": 2305.0,
+            "high": 2340.0,
+            "low": 2290.0,
+            "close": 2325.0,
+            "volume": 12500000,
+            "symbol": "RELIANCE"
+          }
+        ]
+      }
+      
+    Note: Maximum 365 days per request.
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted
+    })
+    
+    logger.debug("Fetching analytics OHLCV daily data for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.marketdata.ohlcv_daily"], params=params)
+  
+  def get_analytics_historical_prices(
+    self, 
+    symbol: str, 
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Get historical prices from analytics API (same as OHLCV daily).
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      adjusted (bool, optional): Use adjusted prices. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: Historical price data.
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted
+    })
+    
+    logger.debug("Fetching analytics historical prices for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.marketdata.historical_prices"], params=params)
+  
+  def get_free_float_market_cap(
+    self, 
+    symbol: str, 
+    date: Optional[str] = None
+  ) -> Dict[str, Any]:
+    """
+    Get free-float market capitalization.
+    
+    Args:
+      symbol (str): Stock symbol.
+      date (str, optional): Date in "YYYY-MM-DD" format. Defaults to most recent.
+      
+    Returns:
+      Dict[str, Any]: Free-float market cap data.
+      
+    Example Response:
+      {
+        "symbol": "RELIANCE",
+        "date": "2025-07-31",
+        "free_float_market_cap": 1054321.89,
+        "market_cap": 1234567.89,
+        "promoter_holding_percent": 14.6,
+        "unit": "₹ Crores"
+      }
+    """
+    params = {"symbol": symbol}
+    
+    if date:
+      params["date"] = date
+    
+    logger.debug("Fetching free-float market cap for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.marketdata.free_float_market_cap"], params=params)
+  
+  # --- Ownership Methods ---
+  
+  def get_fii_dii_holdings(
+    self, 
+    symbol: str, 
+    quarter: Optional[str] = None
+  ) -> Dict[str, Any]:
+    """
+    Get FII and DII holdings percentages.
+    
+    Args:
+      symbol (str): Stock symbol.
+      quarter (str, optional): Quarter in "Q1FY24" format. Defaults to latest.
+      
+    Returns:
+      Dict[str, Any]: FII and DII holdings data.
+      
+    Example Response:
+      {
+        "symbol": "RELIANCE",
+        "quarter": "Q4FY23",
+        "fii_percentage": 24.3,
+        "dii_percentage": 18.7,
+        "institutional_total": 43.0,
+        "unit": "%"
+      }
+    """
+    params = {"symbol": symbol}
+    
+    if quarter:
+      params["quarter"] = quarter
+    
+    logger.debug("Fetching FII/DII holdings for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.ownership.fii_dii"], params=params)
+  
+  def get_fii_change(self, symbol: str) -> Dict[str, Any]:
+    """
+    Get FII holding change from previous quarter.
+    
+    Args:
+      symbol (str): Stock symbol.
+      
+    Returns:
+      Dict[str, Any]: FII change data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "quarter": "2025-03-31",
+        "fii_change": 1.2,
+        "current_fii": 33.5,
+        "previous_fii": 32.3,
+        "unit": "%"
+      }
+    """
+    params = {"symbol": symbol}
+    
+    logger.debug("Fetching FII change for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.ownership.fii_change"], params=params)
+  
+  def get_dii_change(self, symbol: str) -> Dict[str, Any]:
+    """
+    Get DII holding change from previous quarter.
+    
+    Args:
+      symbol (str): Stock symbol.
+      
+    Returns:
+      Dict[str, Any]: DII change data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "quarter": "2025-03-31",
+        "dii_change": -0.5,
+        "current_dii": 15.2,
+        "previous_dii": 15.7,
+        "unit": "%"
+      }
+    """
+    params = {"symbol": symbol}
+    
+    logger.debug("Fetching DII change for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.ownership.dii_change"], params=params)
+  
+  # --- Index Data Methods ---
+  
+  def get_index_ohlc_daily(
+    self, 
+    symbol: str, 
+    start_date: str,
+    end_date: str
+  ) -> Dict[str, Any]:
+    """
+    Get daily OHLC data for an index.
+    
+    Args:
+      symbol (str): Index symbol (e.g., "NIFTY50").
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      
+    Returns:
+      Dict[str, Any]: Index OHLC data.
+      
+    Example Response:
+      {
+        "data": [
+          {
+            "date": "2025-01-01",
+            "open": 18250.0,
+            "high": 18350.0,
+            "low": 18200.0,
+            "close": 18325.0,
+            "symbol": "NIFTY50"
+          }
+        ]
+      }
+    """
+    params = self._normalize_params({
+      "index": symbol,
+      "startDate": start_date,
+      "endDate": end_date
+    })
+    
+    logger.debug("Fetching index OHLC daily data for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.marketdata.index_ohlc_daily"], params=params)
+  
+  # --- Metrics Methods ---
+  
+  def get_sortino_ratio(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    rf: float = 0.065,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get Sortino ratio for a stock/strategy/index.
+    
+    Args:
+      symbol (str): Stock/strategy/index symbol.
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      rf (float, optional): Annualized risk-free rate. Defaults to 0.065.
+      interval (str, optional): Return frequency: daily, weekly, monthly. Defaults to "daily".
+      
+    Returns:
+      Dict[str, Any]: Sortino ratio data.
+      
+    Example Response:
+      {
+        "symbol": "HDFCBANK",
+        "startDate": "2024-01-01",
+        "endDate": "2025-01-01",
+        "interval": "daily",
+        "rf": 0.065,
+        "sortinoRatio": 1.8542,
+        "annualizedReturn": 0.1234,
+        "downsideDeviation": 0.0321,
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "rf": rf,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching Sortino ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.metrics.sortino_ratio"], params=params)
+  
+  def get_upside_capture(
+    self,
+    symbol: str,
+    benchmark_symbol: str,
+    start_date: str,
+    end_date: str,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get upside capture ratio for a stock/portfolio.
+    
+    Args:
+      symbol (str): Stock/portfolio symbol.
+      benchmark_symbol (str): Benchmark symbol.
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      interval (str, optional): Comparison interval. Defaults to "daily".
+      
+    Returns:
+      Dict[str, Any]: Upside capture ratio data.
+      
+    Example Response:
+      {
+        "symbol": "ICICIBANK",
+        "benchmarkSymbol": "NIFTY50",
+        "startDate": "2024-01-01",
+        "endDate": "2025-01-01",
+        "interval": "daily",
+        "upsideCaptureRatio": 112.50,
+        "periodsAnalyzed": 250,
+        "positiveBenchmarkPeriods": 135,
+        "unit": "%"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "benchmarkSymbol": benchmark_symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching upside capture ratio for %s vs %s", symbol, benchmark_symbol)
+    return self._make_request("GET", self._routes["analytics.metrics.upside_capture"], params=params)
+  
+  # --- Macro Methods ---
+  
+  def get_risk_free_rate(
+    self,
+    start_date: str,
+    end_date: str,
+    tenor: str = "10Y",
+    country: str = "IN",
+    method: str = "average"
+  ) -> Dict[str, Any]:
+    """
+    Get risk-free rates for various tenors and countries.
+    
+    Args:
+      start_date (str): Start date in "YYYY-MM-DD" format.
+      end_date (str): End date in "YYYY-MM-DD" format.
+      tenor (str, optional): Maturity: 3M, 6M, 1Y, 5Y, 10Y. Defaults to "10Y".
+      country (str, optional): Country code. Defaults to "IN".
+      method (str, optional): Calculation: average, start, end, daily_series. Defaults to "average".
+      
+    Returns:
+      Dict[str, Any]: Risk-free rate data.
+      
+    Example Response:
+      {
+        "country": "IN",
+        "tenor": "10Y",
+        "startDate": "2024-01-01",
+        "endDate": "2024-12-31",
+        "method": "average",
+        "riskFreeRate": 0.0735,
+        "source": "RBI/FIMMDA (Default)",
+        "unit": "decimal"
+      }
+    """
+    params = self._normalize_params({
+      "startDate": start_date,
+      "endDate": end_date,
+      "tenor": tenor,
+      "country": country,
+      "method": method
+    })
+    
+    logger.debug("Fetching risk-free rate for %s %s", country, tenor)
+    return self._make_request("GET", self._routes["analytics.macro.risk_free_rate"], params=params)
+  
+  # --- Risk Analysis Methods ---
+  
+  def get_max_drawdown(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Calculate maximum drawdown for a stock over a specified period.
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Analysis start date (YYYY-MM-DD).
+      end_date (str): Analysis end date (YYYY-MM-DD).
+      adjusted (bool, optional): Use adjusted prices. Defaults to True.
+      interval (str, optional): Data frequency: daily, weekly, monthly. Defaults to "daily".
+      
+    Returns:
+      Dict[str, Any]: Maximum drawdown data.
+      
+    Example Response:
+      {
+        "symbol": "TCS",
+        "startDate": "2024-01-01",
+        "endDate": "2024-12-31",
+        "adjusted": true,
+        "interval": "daily",
+        "maxDrawdown": -0.1847,
+        "peakDate": "2024-03-15",
+        "troughDate": "2024-06-08",
+        "peakPrice": 4250.50,
+        "troughPrice": 3465.75,
+        "unit": "decimal"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching max drawdown for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.risk.max_drawdown"], params=params)
+  
+  def get_returns_volatility(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    frequency: str = "daily",
+    periods: Optional[int] = None
+  ) -> Dict[str, Any]:
+    """
+    Calculate returns volatility using standard deviation over a specified period.
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Analysis start date (YYYY-MM-DD).
+      end_date (str): Analysis end date (YYYY-MM-DD).
+      frequency (str, optional): Return frequency: daily, weekly, monthly. Defaults to "daily".
+      periods (int, optional): Rolling window size (5-250). Auto-calculated if not provided.
+      
+    Returns:
+      Dict[str, Any]: Volatility analysis data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "startDate": "2024-01-01",
+        "endDate": "2024-06-30",
+        "frequency": "daily",
+        "volatility": 0.0243,
+        "annualizedVolatility": 0.3856,
+        "periods": 125,
+        "unit": "decimal"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "frequency": frequency
+    })
+    
+    if periods is not None:
+      params["periods"] = str(periods)
+    
+    logger.debug("Fetching returns volatility for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.risk.returns_volatility"], params=params)
+  
+  # --- Metadata Methods ---
+  
+  def get_sector_classification(
+    self,
+    symbol: str
+  ) -> Dict[str, Any]:
+    """
+    Get comprehensive sector and industry classification for a stock.
+    
+    Args:
+      symbol (str): Stock symbol.
+      
+    Returns:
+      Dict[str, Any]: Sector classification data.
+      
+    Example Response:
+      {
+        "symbol": "TATASTEEL",
+        "sector": "Basic Materials",
+        "industry": "Steel",
+        "subIndustry": "Integrated Steel",
+        "classification": "Industrial Metals & Mining",
+        "lastUpdated": "2024-01-15"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol
+    })
+    
+    logger.debug("Fetching sector classification for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.metadata.sector"], params=params)
+  
+  # --- Leverage Analysis Methods ---
+  
+  def get_debt_equity_ratio(
+    self,
+    symbol: str,
+    date: Optional[str] = None,
+    consolidated: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Calculate debt-to-equity ratio using most recent financial data.
+    
+    Args:
+      symbol (str): Stock symbol.
+      date (str, optional): Specific quarter-end date (YYYY-MM-DD). Latest if not provided.
+      consolidated (bool, optional): Use consolidated financials. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: Debt-to-equity ratio data.
+      
+    Example Response:
+      {
+        "symbol": "RELIANCE",
+        "date": "2024-09-30",
+        "deRatio": 0.3247,
+        "totalDebt": 287450.25,
+        "shareholderEquity": 884972.10,
+        "source": "consolidated",
+        "quarter": "Q2FY25",
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "consolidated": consolidated
+    })
+    
+    if date:
+      params["date"] = date
+    
+    logger.debug("Fetching debt-to-equity ratio for %s", symbol)
+    return self._make_request("GET", self._routes["analytics.leverage.debt_equity_ratio"], params=params)
+  
+  def get_cagr(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True
+  ) -> Dict[str, Any]:
+    """
+    Calculate Compound Annual Growth Rate (CAGR) over a specified time period.
+    
+    Args:
+      symbol (str): Stock symbol.
+      start_date (str): Investment start date (YYYY-MM-DD).
+      end_date (str): Investment end date (YYYY-MM-DD).
+      adjusted (bool, optional): Use adjusted prices. Defaults to True.
+      
+    Returns:
+      Dict[str, Any]: CAGR calculation data.
+      
+    Example Response:
+      {
+        "symbol": "TCS",
+        "startDate": "2020-01-01",
+        "endDate": "2024-12-31",
+        "cagr": 12.45,
+        "startPrice": 2150.30,
+        "endPrice": 3847.60,
+        "years": 5.0,
+        "adjusted": true,
+        "unit": "%"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted
+    })
+    
+    logger.debug("Fetching CAGR for %s from %s to %s", symbol, start_date, end_date)
+    return self._make_request("GET", self._routes["analytics.returns.cagr"], params=params)
+
+  # --- New Analytics Methods ---
+  
+  def get_average_traded_volume(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get average traded volume for a stock over a specified period.
+    
+    Args:
+      symbol (str): Stock symbol (e.g., HDFCBANK, NSE:RELIANCE).
+      start_date (str): Period start date (YYYY-MM-DD).
+      end_date (str): Period end date (YYYY-MM-DD).
+      interval (str, optional): Time interval ('daily', 'weekly', 'monthly'). Defaults to 'daily'.
+      
+    Returns:
+      Dict[str, Any]: Average volume data.
+      
+    Example Response:
+      {
+        "symbol": "HDFCBANK",
+        "startDate": "2024-04-01",
+        "endDate": "2024-06-30",
+        "interval": "daily",
+        "averageVolume": 1234567,
+        "totalDays": 61,
+        "unit": "shares"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching average traded volume for %s from %s to %s", symbol, start_date, end_date)
+    return self._make_request("GET", self._routes["analytics.marketdata.average_volume"], params=params)
+  
+  def get_index_max_drawdown(
+    self,
+    index_symbol: str,
+    start_date: str,
+    end_date: str,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get maximum drawdown for an index over a specified period.
+    
+    Args:
+      index_symbol (str): Index symbol (e.g., NIFTY50, BANKNIFTY, SENSEX).
+      start_date (str): Period start date (YYYY-MM-DD).
+      end_date (str): Period end date (YYYY-MM-DD).
+      interval (str, optional): Time interval ('daily', 'weekly', 'monthly'). Defaults to 'daily'.
+      
+    Returns:
+      Dict[str, Any]: Maximum drawdown data.
+      
+    Example Response:
+      {
+        "indexSymbol": "NIFTY50",
+        "startDate": "2023-01-01",
+        "endDate": "2024-01-01",
+        "interval": "daily",
+        "maxDrawdown": -15.23,
+        "drawdownDate": "2023-10-26",
+        "peakDate": "2023-09-19",
+        "unit": "%"
+      }
+    """
+    params = self._normalize_params({
+      "indexSymbol": index_symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching index max drawdown for %s from %s to %s", index_symbol, start_date, end_date)
+    return self._make_request("GET", self._routes["analytics.index.max_drawdown"], params=params)
+  
+  def get_drawdown_duration(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get drawdown duration analysis for a stock or index.
+    
+    Args:
+      symbol (str): Stock or index symbol (e.g., INFY, NIFTY50).
+      start_date (str): Start of analysis period (YYYY-MM-DD).
+      end_date (str): End of analysis period (YYYY-MM-DD).
+      interval (str, optional): Time interval ('daily', 'weekly', 'monthly'). Defaults to 'daily'.
+      
+    Returns:
+      Dict[str, Any]: Drawdown duration data.
+      
+    Example Response:
+      {
+        "symbol": "INFY",
+        "startDate": "2022-01-01",
+        "endDate": "2024-01-01",
+        "interval": "daily",
+        "maxDrawdownDuration": 147,
+        "averageDrawdownDuration": 23.5,
+        "totalDrawdowns": 12,
+        "unit": "days"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching drawdown duration for %s from %s to %s", symbol, start_date, end_date)
+    return self._make_request("GET", self._routes["analytics.instrument.drawdown_duration"], params=params)
+  
+  def get_rolling_peak_price(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    window: int,
+    adjusted: bool = True,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get rolling peak price analysis for a stock.
+    
+    Args:
+      symbol (str): Stock symbol (e.g., RELIANCE, NSE:TCS).
+      start_date (str): Start of evaluation period (YYYY-MM-DD).
+      end_date (str): End of evaluation period (YYYY-MM-DD).
+      window (int): Rolling window size in days (1-252).
+      adjusted (bool, optional): Adjust for corporate actions. Defaults to True.
+      interval (str, optional): Time interval ('daily', 'weekly', 'monthly'). Defaults to 'daily'.
+      
+    Returns:
+      Dict[str, Any]: Rolling peak price data.
+      
+    Example Response:
+      {
+        "symbol": "NSE:TCS",
+        "startDate": "2024-01-01",
+        "endDate": "2024-06-30",
+        "window": 20,
+        "interval": "daily",
+        "adjusted": true,
+        "data": [
+          {"date": "2024-01-01", "price": 3500.0, "rollingPeak": 3500.0},
+          {"date": "2024-01-02", "price": 3520.0, "rollingPeak": 3520.0}
+        ]
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "window": window,
+      "adjusted": adjusted,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching rolling peak price for %s from %s to %s with window %d", symbol, start_date, end_date, window)
+    return self._make_request("GET", self._routes["analytics.price.rolling_peak"], params=params)
+  
+  def get_rolling_price_mean(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    window: int,
+    adjusted: bool = True,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get rolling mean price analysis for a stock.
+    
+    Args:
+      symbol (str): Stock symbol (e.g., HDFCBANK, NSE:WIPRO).
+      start_date (str): Start of evaluation period (YYYY-MM-DD).
+      end_date (str): End of evaluation period (YYYY-MM-DD).
+      window (int): Rolling window size in days (1-252).
+      adjusted (bool, optional): Adjust for corporate actions. Defaults to True.
+      interval (str, optional): Time interval ('daily', 'weekly', 'monthly'). Defaults to 'daily'.
+      
+    Returns:
+      Dict[str, Any]: Rolling mean price data.
+      
+    Example Response:
+      {
+        "symbol": "NSE:HDFCBANK",
+        "startDate": "2024-01-01",
+        "endDate": "2024-06-30",
+        "window": 20,
+        "interval": "daily",
+        "adjusted": true,
+        "data": [
+          {"date": "2024-01-01", "price": 1500.0, "rollingMean": 1500.0},
+          {"date": "2024-01-02", "price": 1510.0, "rollingMean": 1505.0}
+        ]
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "window": window,
+      "adjusted": adjusted,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching rolling mean price for %s from %s to %s with window %d", symbol, start_date, end_date, window)
+    return self._make_request("GET", self._routes["analytics.price.rolling_mean"], params=params)
+  
+  def get_realized_volatility(
+    self,
+    symbol: str,
+    start_date: str,
+    end_date: str,
+    adjusted: bool = True,
+    interval: str = "daily"
+  ) -> Dict[str, Any]:
+    """
+    Get realized price volatility for a stock.
+    
+    Args:
+      symbol (str): Stock symbol or instrument ID (e.g., NSE:ITC, BHARTIARTL).
+      start_date (str): Start of volatility calculation window (YYYY-MM-DD).
+      end_date (str): End of volatility calculation window (YYYY-MM-DD).
+      adjusted (bool, optional): Adjust prices for corporate actions. Defaults to True.
+      interval (str, optional): Time interval ('daily', 'weekly', 'monthly'). Defaults to 'daily'.
+      
+    Returns:
+      Dict[str, Any]: Realized volatility data.
+      
+    Example Response:
+      {
+        "symbol": "NSE:ITC",
+        "startDate": "2024-01-01",
+        "endDate": "2024-06-30",
+        "interval": "daily",
+        "adjusted": true,
+        "realizedVolatility": 22.45,
+        "annualizedVolatility": 35.67,
+        "unit": "%"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "startDate": start_date,
+      "endDate": end_date,
+      "adjusted": adjusted,
+      "interval": interval
+    })
+    
+    logger.debug("Fetching realized volatility for %s from %s to %s", symbol, start_date, end_date)
+    return self._make_request("GET", self._routes["analytics.volatility.realized"], params=params)
+  
+  def get_beta_90d(
+    self,
+    symbol: str,
+    benchmark: str = "NIFTY50"
+  ) -> Dict[str, Any]:
+    """
+    Get 90-day CAPM Beta for a stock relative to a benchmark.
+    
+    Args:
+      symbol (str): Stock symbol (e.g., RELIANCE, ITC).
+      benchmark (str, optional): Benchmark index. Defaults to 'NIFTY50'.
+      
+    Returns:
+      Dict[str, Any]: 90-day beta data.
+      
+    Example Response:
+      {
+        "symbol": "ITC",
+        "benchmark": "NIFTY50",
+        "period": "90d",
+        "beta": 0.85,
+        "correlation": 0.72,
+        "rSquared": 0.52,
+        "alpha": 0.03,
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "benchmark": benchmark
+    })
+    
+    logger.debug("Fetching 90d beta for %s vs %s", symbol, benchmark)
+    return self._make_request("GET", self._routes["analytics.risk.beta_90d"], params=params)
+  
+  def get_beta_custom_period(
+    self,
+    symbol: str,
+    benchmark: str,
+    start_date: str,
+    end_date: str
+  ) -> Dict[str, Any]:
+    """
+    Get CAPM Beta for a stock relative to a benchmark over a custom period.
+    
+    Args:
+      symbol (str): Stock symbol.
+      benchmark (str): Benchmark index symbol.
+      start_date (str): Start date (YYYY-MM-DD).
+      end_date (str): End date (YYYY-MM-DD).
+      
+    Returns:
+      Dict[str, Any]: Custom period beta data.
+      
+    Example Response:
+      {
+        "symbol": "ITC",
+        "benchmark": "NIFTY50",
+        "startDate": "2023-01-01",
+        "endDate": "2025-01-01",
+        "beta": 0.87,
+        "correlation": 0.74,
+        "rSquared": 0.55,
+        "alpha": 0.02,
+        "unit": "ratio"
+      }
+    """
+    params = self._normalize_params({
+      "symbol": symbol,
+      "benchmark": benchmark,
+      "startDate": start_date,
+      "endDate": end_date
+    })
+    
+    logger.debug("Fetching custom period beta for %s vs %s from %s to %s", symbol, benchmark, start_date, end_date)
+    return self._make_request("GET", self._routes["analytics.risk.beta_custom"], params=params)