reportify-sdk 0.2.0__tar.gz → 0.2.1__tar.gz

{reportify_sdk-0.2.0/reportify_sdk.egg-info → reportify_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reportify-sdk
-Version: 0.2.0
+Version: 0.2.1
 Summary: Python SDK for Reportify API - Financial data and document search
 Author-email: Reportify <support@reportify.cn>
 License-Expression: MIT

{reportify_sdk-0.2.0 → reportify_sdk-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reportify-sdk"
-version = "0.2.0"
+version = "0.2.1"
 description = "Python SDK for Reportify API - Financial data and document search"
 readme = "README.md"
 license = "MIT"

reportify_sdk-0.2.1/reportify_sdk/quant.py

@@ -0,0 +1,404 @@
+"""
+Quant Module
+
+Provides quantitative analysis tools including indicators, factors, quotes, and backtesting.
+Based on Mai-language syntax compatible with TongDaXin/TongHuaShun.
+"""
+
+from typing import Any, Literal
+
+import pandas as pd
+
+
+StockMarket = Literal["cn", "hk", "us"]
+
+
+class QuantModule:
+    """
+    Quantitative analysis module
+
+    Access technical indicators, factors, OHLCV quotes, and backtesting functionality.
+    Uses Mai-language syntax for formulas.
+
+    Example:
+        >>> quant = client.quant
+        >>> # Compute RSI indicator
+        >>> df = quant.compute_indicators(["000001"], "RSI(14)")
+        >>> # Screen stocks by formula
+        >>> stocks = quant.screen(formula="RSI(14) < 30")
+    """
+
+    def __init__(self, client):
+        self._client = client
+
+    # -------------------------------------------------------------------------
+    # Indicators
+    # -------------------------------------------------------------------------
+
+    def list_indicators(self) -> list[dict[str, Any]]:
+        """
+        Get list of available technical indicators
+
+        Returns:
+            List of indicator definitions with name, description, and fields
+
+        Example:
+            >>> indicators = client.quant.list_indicators()
+            >>> for ind in indicators:
+            ...     print(f"{ind['name']}: {ind['description']}")
+            ...     print(f"  Fields: {ind['fields']}")
+        """
+        return self._client._get("/v1/quant/indicators")
+
+    def compute_indicators(
+        self,
+        symbols: list[str],
+        formula: str,
+        *,
+        market: StockMarket = "cn",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> pd.DataFrame:
+        """
+        Compute indicator values for given symbols
+
+        Args:
+            symbols: List of stock codes (e.g., ["000001", "600519"])
+            formula: Indicator formula (e.g., "RSI(14)", "MACD()", "MACD(12,26,9)")
+            market: Stock market ("cn", "hk", "us"), default "cn"
+            start_date: Start date (YYYY-MM-DD), default 3 months ago
+            end_date: End date (YYYY-MM-DD), default today
+
+        Returns:
+            DataFrame with indicator values
+
+        Example:
+            >>> # RSI indicator
+            >>> df = client.quant.compute_indicators(["000001"], "RSI(14)")
+            >>> print(df[["symbol", "date", "rsi"]])
+            
+            >>> # MACD indicator
+            >>> df = client.quant.compute_indicators(["000001"], "MACD()")
+            >>> print(df[["symbol", "date", "dif", "dea", "macd"]])
+            
+            >>> # KDJ indicator
+            >>> df = client.quant.compute_indicators(["000001"], "KDJ(9,3,3)")
+            >>> print(df[["symbol", "date", "k", "d", "j"]])
+        """
+        data: dict[str, Any] = {
+            "symbols": symbols,
+            "formula": formula,
+            "market": market,
+        }
+        if start_date:
+            data["start_date"] = start_date
+        if end_date:
+            data["end_date"] = end_date
+
+        response = self._client._post("/v1/quant/indicators/compute", json=data)
+        return self._to_dataframe(response.get("datas", []))
+
+    # -------------------------------------------------------------------------
+    # Factors
+    # -------------------------------------------------------------------------
+
+    def list_factors(self) -> list[dict[str, Any]]:
+        """
+        Get list of available factors (variables and functions)
+
+        Returns factors organized by level:
+        - Level 0 Variables: CLOSE, OPEN, HIGH, LOW, VOLUME
+        - Level 0 Functions: MA, EMA, REF, HHV, LLV, STD, etc.
+        - Level 1 Functions: CROSS, COUNT, EVERY, etc.
+        - Level 2 Functions: MACD, KDJ, RSI, BOLL, etc.
+
+        Returns:
+            List of factor definitions
+
+        Example:
+            >>> factors = client.quant.list_factors()
+            >>> for f in factors:
+            ...     print(f"{f['name']} ({f['type']}, level {f['level']})")
+        """
+        return self._client._get("/v1/quant/factors")
+
+    def compute_factors(
+        self,
+        symbols: list[str],
+        formula: str,
+        *,
+        market: StockMarket = "cn",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> pd.DataFrame:
+        """
+        Compute factor values for given symbols
+
+        Uses Mai-language syntax compatible with TongDaXin/TongHuaShun.
+
+        Args:
+            symbols: List of stock codes
+            formula: Factor formula using Mai-language syntax
+            market: Stock market ("cn", "hk", "us"), default "cn"
+            start_date: Start date (YYYY-MM-DD), default 3 months ago
+            end_date: End date (YYYY-MM-DD), default today
+
+        Returns:
+            DataFrame with factor values
+
+        Example:
+            >>> # Simple indicator
+            >>> df = client.quant.compute_factors(["000001"], "RSI(14)")
+            
+            >>> # MACD DIF line
+            >>> df = client.quant.compute_factors(["000001"], "MACD().dif")
+            
+            >>> # Close above 20-day MA (boolean)
+            >>> df = client.quant.compute_factors(["000001"], "CLOSE > MA(20)")
+            
+            >>> # Deviation from MA20 in percent
+            >>> df = client.quant.compute_factors(["000001"], "(CLOSE - MA(20)) / MA(20) * 100")
+
+        Supported Operators:
+            - Comparison: >, <, >=, <=, ==, !=
+            - Logical AND: & (NOT "AND")
+            - Logical OR: | (NOT "OR")
+            - Arithmetic: +, -, *, /
+
+        Supported Variables:
+            - CLOSE, C: Close price
+            - OPEN, O: Open price
+            - HIGH, H: High price
+            - LOW, L: Low price
+            - VOLUME, V, VOL: Volume
+        """
+        data: dict[str, Any] = {
+            "symbols": symbols,
+            "formula": formula,
+            "market": market,
+        }
+        if start_date:
+            data["start_date"] = start_date
+        if end_date:
+            data["end_date"] = end_date
+
+        response = self._client._post("/v1/quant/factors/compute", json=data)
+        return self._to_dataframe(response.get("datas", []))
+
+    def screen(
+        self,
+        formula: str,
+        *,
+        market: StockMarket = "cn",
+        check_date: str | None = None,
+        symbols: list[str] | None = None,
+    ) -> pd.DataFrame:
+        """
+        Screen stocks based on factor formula
+
+        Returns stocks where the formula evaluates to True (for boolean formulas)
+        or non-null (for numeric formulas).
+
+        Args:
+            formula: Screening formula using Mai-language syntax
+            market: Stock market ("cn", "hk", "us"), default "cn"
+            check_date: Check date (YYYY-MM-DD), default latest trading day
+            symbols: Stock codes to screen (None = full market)
+
+        Returns:
+            DataFrame with stocks that passed the filter
+
+        Example:
+            >>> # RSI oversold
+            >>> stocks = client.quant.screen(formula="RSI(14) < 30")
+            
+            >>> # Golden cross
+            >>> stocks = client.quant.screen(formula="CROSS(MA(5), MA(10))")
+            
+            >>> # Uptrend
+            >>> stocks = client.quant.screen(formula="(CLOSE > MA(20)) & (MA(20) > MA(60))")
+            
+            >>> # Above upper Bollinger Band
+            >>> stocks = client.quant.screen(formula="CLOSE > BOLL(20, 2).upper")
+            
+            >>> # Screen specific stocks
+            >>> stocks = client.quant.screen(
+            ...     formula="RSI(14) < 30",
+            ...     symbols=["000001", "600519", "000002"]
+            ... )
+        """
+        data: dict[str, Any] = {
+            "formula": formula,
+            "market": market,
+        }
+        if check_date:
+            data["check_date"] = check_date
+        if symbols:
+            data["symbols"] = symbols
+
+        response = self._client._post("/v1/quant/factors/screen", json=data)
+        return self._to_dataframe(response.get("datas", []))
+
+    # -------------------------------------------------------------------------
+    # Quotes
+    # -------------------------------------------------------------------------
+
+    def ohlcv(
+        self,
+        symbol: str,
+        *,
+        market: StockMarket = "cn",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> pd.DataFrame:
+        """
+        Get OHLCV (Open, High, Low, Close, Volume) daily data for a single symbol
+
+        Args:
+            symbol: Stock code
+            market: Stock market ("cn", "hk", "us"), default "cn"
+            start_date: Start date (YYYY-MM-DD), default 1 month ago
+            end_date: End date (YYYY-MM-DD), default today
+
+        Returns:
+            DataFrame with OHLCV data
+
+        Example:
+            >>> df = client.quant.ohlcv("000001")
+            >>> print(df[["open", "high", "low", "close", "volume"]])
+        """
+        params: dict[str, Any] = {
+            "symbol": symbol,
+            "market": market,
+        }
+        if start_date:
+            params["start_date"] = start_date
+        if end_date:
+            params["end_date"] = end_date
+
+        response = self._client._get("/v1/quant/quotes/ohlcv", params=params)
+        return self._to_dataframe(response.get("datas", []))
+
+    def ohlcv_batch(
+        self,
+        symbols: list[str],
+        *,
+        market: StockMarket = "cn",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> pd.DataFrame:
+        """
+        Get OHLCV data for multiple symbols
+
+        Args:
+            symbols: List of stock codes
+            market: Stock market ("cn", "hk", "us"), default "cn"
+            start_date: Start date (YYYY-MM-DD), default 1 month ago
+            end_date: End date (YYYY-MM-DD), default today
+
+        Returns:
+            DataFrame with OHLCV data sorted by date (descending), then by symbol
+
+        Example:
+            >>> df = client.quant.ohlcv_batch(["000001", "600519"])
+            >>> print(df[["symbol", "date", "close", "volume"]])
+        """
+        data: dict[str, Any] = {
+            "symbols": symbols,
+            "market": market,
+        }
+        if start_date:
+            data["start_date"] = start_date
+        if end_date:
+            data["end_date"] = end_date
+
+        response = self._client._post("/v1/quant/quotes/ohlcv/batch", json=data)
+        return self._to_dataframe(response.get("datas", []))
+
+    # -------------------------------------------------------------------------
+    # Backtest
+    # -------------------------------------------------------------------------
+
+    def backtest(
+        self,
+        symbol: str,
+        formula: str,
+        start_date: str,
+        end_date: str,
+        *,
+        market: StockMarket = "cn",
+        initial_cash: float = 100000.0,
+        commission: float = 0.0,
+        stop_loss: float = 0.0,
+        sizer_percent: int = 99,
+        auto_close: bool = True,
+    ) -> dict[str, Any]:
+        """
+        Execute strategy backtest
+
+        Args:
+            symbol: Stock code
+            formula: Trading strategy formula using Mai-language syntax
+            start_date: Backtest start date (YYYY-MM-DD)
+            end_date: Backtest end date (YYYY-MM-DD)
+            market: Stock market ("cn", "hk", "us"), default "cn"
+            initial_cash: Initial capital (default: 100000.0)
+            commission: Commission rate (default: 0.0)
+            stop_loss: Stop loss setting (default: 0.0, no stop loss)
+            sizer_percent: Position percentage (default: 99%)
+            auto_close: Auto close positions (default: True)
+
+        Returns:
+            Backtest results including:
+            - success: Whether backtest succeeded
+            - initial_cash: Initial capital
+            - final_cash: Final capital
+            - total_return: Total return
+            - total_return_pct: Total return percentage
+            - max_drawdown: Maximum drawdown
+            - profit_factor: Profit factor
+            - win_rate: Win rate
+            - total_trades: Total number of trades
+            - trades: List of trade details
+
+        Example:
+            >>> result = client.quant.backtest(
+            ...     symbol="000001",
+            ...     formula="CROSS(MA(5), MA(20))",  # Golden cross buy signal
+            ...     start_date="2023-01-01",
+            ...     end_date="2024-01-01",
+            ...     initial_cash=100000
+            ... )
+            >>> print(f"Total Return: {result['total_return_pct']:.2%}")
+            >>> print(f"Max Drawdown: {result['max_drawdown']:.2%}")
+            >>> print(f"Win Rate: {result['win_rate']:.2%}")
+        """
+        data = {
+            "symbol": symbol,
+            "formula": formula,
+            "start_date": start_date,
+            "end_date": end_date,
+            "market": market,
+            "initial_cash": initial_cash,
+            "commission": commission,
+            "stop_loss": stop_loss,
+            "sizer_percent": sizer_percent,
+            "auto_close": auto_close,
+        }
+
+        return self._client._post("/v1/quant/backtest", json=data)
+
+    # -------------------------------------------------------------------------
+    # Helper Methods
+    # -------------------------------------------------------------------------
+
+    def _to_dataframe(self, data: list[dict[str, Any]]) -> pd.DataFrame:
+        """Convert API response to DataFrame"""
+        if not data:
+            return pd.DataFrame()
+        df = pd.DataFrame(data)
+        # Convert date columns if present
+        for col in ["date", "check_date", "trade_date"]:
+            if col in df.columns:
+                df[col] = pd.to_datetime(df[col])
+        return df

{reportify_sdk-0.2.0 → reportify_sdk-0.2.1/reportify_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reportify-sdk
-Version: 0.2.0
+Version: 0.2.1
 Summary: Python SDK for Reportify API - Financial data and document search
 Author-email: Reportify <support@reportify.cn>
 License-Expression: MIT

reportify_sdk-0.2.0/reportify_sdk/quant.py

@@ -1,371 +0,0 @@
-"""
-Quant Module
-
-Provides quantitative analysis tools including indicators, factors, quotes, and backtesting.
-"""
-
-from typing import Any
-
-import pandas as pd
-
-
-class QuantModule:
-    """
-    Quantitative analysis module
-
-    Access technical indicators, factors, quotes, and backtesting functionality.
-
-    Example:
-        >>> quant = client.quant
-        >>> indicators = quant.indicators(symbols=["US:AAPL"], indicators=["ma", "rsi"])
-    """
-
-    def __init__(self, client):
-        self._client = client
-
-    # -------------------------------------------------------------------------
-    # Indicators
-    # -------------------------------------------------------------------------
-
-    def indicators(
-        self,
-        symbols: list[str],
-        indicators: list[str],
-        *,
-        start_date: str | None = None,
-        end_date: str | None = None,
-        interval: str = "1d",
-        params: dict[str, Any] | None = None,
-    ) -> pd.DataFrame:
-        """
-        Get technical indicators for given symbols
-
-        Args:
-            symbols: List of stock symbols (e.g., ["US:AAPL", "US:MSFT"])
-            indicators: List of indicator names (e.g., ["ma", "rsi", "macd", "bollinger"])
-            start_date: Start date (YYYY-MM-DD)
-            end_date: End date (YYYY-MM-DD)
-            interval: Data interval ("1d", "1w", "1m")
-            params: Additional indicator parameters (e.g., {"ma_period": 20})
-
-        Returns:
-            DataFrame with indicator values
-
-        Example:
-            >>> df = client.quant.indicators(
-            ...     symbols=["US:AAPL"],
-            ...     indicators=["ma", "rsi"],
-            ...     params={"ma_period": 20, "rsi_period": 14}
-            ... )
-            >>> print(df[["close", "ma_20", "rsi_14"]])
-        """
-        data: dict[str, Any] = {
-            "symbols": symbols,
-            "indicators": indicators,
-            "interval": interval,
-        }
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
-        if params:
-            data["params"] = params
-
-        response = self._client._post("/v2/quant/indicators", json=data)
-        return self._to_dataframe(response.get("data", []))
-
-    def indicator_list(self) -> list[dict[str, Any]]:
-        """
-        Get list of available technical indicators
-
-        Returns:
-            List of indicator definitions with name, description, and parameters
-
-        Example:
-            >>> indicators = client.quant.indicator_list()
-            >>> for ind in indicators:
-            ...     print(f"{ind['name']}: {ind['description']}")
-        """
-        response = self._client._get("/v2/quant/indicators")
-        return response.get("indicators", [])
-
-    # -------------------------------------------------------------------------
-    # Factors
-    # -------------------------------------------------------------------------
-
-    def factors(
-        self,
-        symbols: list[str],
-        factors: list[str],
-        *,
-        start_date: str | None = None,
-        end_date: str | None = None,
-        frequency: str = "daily",
-    ) -> pd.DataFrame:
-        """
-        Get factor data for given symbols
-
-        Args:
-            symbols: List of stock symbols
-            factors: List of factor names (e.g., ["momentum", "value", "quality", "size"])
-            start_date: Start date (YYYY-MM-DD)
-            end_date: End date (YYYY-MM-DD)
-            frequency: Data frequency ("daily", "weekly", "monthly")
-
-        Returns:
-            DataFrame with factor values
-
-        Example:
-            >>> df = client.quant.factors(
-            ...     symbols=["US:AAPL", "US:MSFT"],
-            ...     factors=["momentum", "value"],
-            ...     frequency="monthly"
-            ... )
-        """
-        data: dict[str, Any] = {
-            "symbols": symbols,
-            "factors": factors,
-            "frequency": frequency,
-        }
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
-
-        response = self._client._post("/v2/quant/factors", json=data)
-        return self._to_dataframe(response.get("data", []))
-
-    def factor_list(self) -> list[dict[str, Any]]:
-        """
-        Get list of available factors
-
-        Returns:
-            List of factor definitions
-
-        Example:
-            >>> factors = client.quant.factor_list()
-            >>> for f in factors:
-            ...     print(f"{f['name']}: {f['category']}")
-        """
-        response = self._client._get("/v2/quant/factors")
-        return response.get("factors", [])
-
-    def factor_exposure(
-        self,
-        symbols: list[str],
-        *,
-        date: str | None = None,
-    ) -> pd.DataFrame:
-        """
-        Get factor exposure for given symbols
-
-        Args:
-            symbols: List of stock symbols
-            date: Specific date (YYYY-MM-DD), defaults to latest
-
-        Returns:
-            DataFrame with factor exposures for each symbol
-
-        Example:
-            >>> exposure = client.quant.factor_exposure(["US:AAPL", "US:GOOGL"])
-            >>> print(exposure[["symbol", "momentum", "value", "quality"]])
-        """
-        data: dict[str, Any] = {"symbols": symbols}
-        if date:
-            data["date"] = date
-
-        response = self._client._post("/v2/quant/factors/exposure", json=data)
-        return self._to_dataframe(response.get("data", []))
-
-    # -------------------------------------------------------------------------
-    # Quotes
-    # -------------------------------------------------------------------------
-
-    def quotes(
-        self,
-        symbols: list[str],
-        *,
-        fields: list[str] | None = None,
-    ) -> pd.DataFrame:
-        """
-        Get real-time quotes for given symbols
-
-        Args:
-            symbols: List of stock symbols
-            fields: Specific fields to return (default: all)
-
-        Returns:
-            DataFrame with quote data
-
-        Example:
-            >>> quotes = client.quant.quotes(["US:AAPL", "US:MSFT"])
-            >>> print(quotes[["symbol", "price", "change", "volume"]])
-        """
-        data: dict[str, Any] = {"symbols": symbols}
-        if fields:
-            data["fields"] = fields
-
-        response = self._client._post("/v2/quant/quotes", json=data)
-        return self._to_dataframe(response.get("data", []))
-
-    def quotes_history(
-        self,
-        symbols: list[str],
-        *,
-        start_date: str | None = None,
-        end_date: str | None = None,
-        interval: str = "1d",
-        adjust: str = "forward",
-        limit: int = 100,
-    ) -> pd.DataFrame:
-        """
-        Get historical quotes data
-
-        Args:
-            symbols: List of stock symbols
-            start_date: Start date (YYYY-MM-DD)
-            end_date: End date (YYYY-MM-DD)
-            interval: Data interval ("1d", "1w", "1m")
-            adjust: Adjustment type ("forward", "backward", "none")
-            limit: Maximum records per symbol
-
-        Returns:
-            DataFrame with historical OHLCV data
-
-        Example:
-            >>> history = client.quant.quotes_history(
-            ...     ["US:AAPL"],
-            ...     start_date="2024-01-01",
-            ...     interval="1d"
-            ... )
-        """
-        data: dict[str, Any] = {
-            "symbols": symbols,
-            "interval": interval,
-            "adjust": adjust,
-            "limit": limit,
-        }
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
-
-        response = self._client._post("/v2/quant/quotes/history", json=data)
-        return self._to_dataframe(response.get("data", []))
-
-    # -------------------------------------------------------------------------
-    # Backtest
-    # -------------------------------------------------------------------------
-
-    def backtest(
-        self,
-        strategy: dict[str, Any],
-        *,
-        start_date: str,
-        end_date: str,
-        initial_capital: float = 1000000.0,
-        benchmark: str | None = None,
-    ) -> dict[str, Any]:
-        """
-        Run a backtest for a given strategy
-
-        Args:
-            strategy: Strategy definition dict
-            start_date: Backtest start date (YYYY-MM-DD)
-            end_date: Backtest end date (YYYY-MM-DD)
-            initial_capital: Starting capital (default: 1,000,000)
-            benchmark: Benchmark symbol for comparison (e.g., "US:SPY")
-
-        Returns:
-            Backtest results including returns, metrics, and trades
-
-        Example:
-            >>> result = client.quant.backtest(
-            ...     strategy={
-            ...         "type": "momentum",
-            ...         "universe": ["US:AAPL", "US:MSFT", "US:GOOGL"],
-            ...         "rebalance": "monthly",
-            ...         "top_n": 2
-            ...     },
-            ...     start_date="2020-01-01",
-            ...     end_date="2024-01-01",
-            ...     benchmark="US:SPY"
-            ... )
-            >>> print(f"Total Return: {result['metrics']['total_return']:.2%}")
-        """
-        data = {
-            "strategy": strategy,
-            "start_date": start_date,
-            "end_date": end_date,
-            "initial_capital": initial_capital,
-        }
-        if benchmark:
-            data["benchmark"] = benchmark
-
-        return self._client._post("/v2/quant/backtest", json=data)
-
-    def backtest_result(self, backtest_id: str) -> dict[str, Any]:
-        """
-        Get backtest result by ID
-
-        Args:
-            backtest_id: Backtest job ID
-
-        Returns:
-            Backtest results
-
-        Example:
-            >>> result = client.quant.backtest_result("bt_abc123")
-        """
-        return self._client._get(f"/v2/quant/backtest/{backtest_id}")
-
-    def backtest_returns(self, backtest_id: str) -> pd.DataFrame:
-        """
-        Get backtest return series
-
-        Args:
-            backtest_id: Backtest job ID
-
-        Returns:
-            DataFrame with daily returns
-
-        Example:
-            >>> returns = client.quant.backtest_returns("bt_abc123")
-            >>> print(returns[["date", "portfolio_value", "daily_return"]])
-        """
-        response = self._client._get(f"/v2/quant/backtest/{backtest_id}/returns")
-        return self._to_dataframe(response.get("data", []))
-
-    def backtest_trades(self, backtest_id: str) -> pd.DataFrame:
-        """
-        Get backtest trade history
-
-        Args:
-            backtest_id: Backtest job ID
-
-        Returns:
-            DataFrame with all trades
-
-        Example:
-            >>> trades = client.quant.backtest_trades("bt_abc123")
-            >>> print(trades[["date", "symbol", "action", "quantity", "price"]])
-        """
-        response = self._client._get(f"/v2/quant/backtest/{backtest_id}/trades")
-        return self._to_dataframe(response.get("data", []))
-
-    # -------------------------------------------------------------------------
-    # Helper Methods
-    # -------------------------------------------------------------------------
-
-    def _to_dataframe(self, data: list[dict[str, Any]]) -> pd.DataFrame:
-        """Convert API response to DataFrame"""
-        if not data:
-            return pd.DataFrame()
-        df = pd.DataFrame(data)
-        # Convert date columns if present
-        for col in ["date", "timestamp", "trade_date"]:
-            if col in df.columns:
-                df[col] = pd.to_datetime(df[col])
-                df = df.set_index(col)
-                break
-        return df