akshare-one 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

akshare_one/indicators.py

@@ -0,0 +1,395 @@
+"""Technical indicators module
+
+Provides common technical analysis indicators like:
+- Simple Moving Average (SMA)
+- Exponential Moving Average (EMA)
+- Relative Strength Index (RSI)
+- Moving Average Convergence Divergence (MACD)
+- Bollinger Bands (BBANDS)
+- Stochastic Oscillator (STOCH)
+- Average True Range (ATR)
+- Commodity Channel Index (CCI)
+- Average Directional Index (ADX)
+- Williams' %R (WILLR)
+- Chaikin A/D Line (AD)
+- Chaikin A/D Oscillator (ADOSC)
+- On Balance Volume (OBV)
+- Momentum (MOM)
+- Parabolic SAR (SAR)
+- Time Series Forecast (TSF)
+- Absolute Price Oscillator (APO)
+- Aroon (AROON)
+- Aroon Oscillator (AROONOSC)
+- Balance of Power (BOP)
+- Chande Momentum Oscillator (CMO)
+- Directional Movement Index (DX)
+- Money Flow Index (MFI)
+- Minus Directional Indicator (MINUS_DI)
+- Minus Directional Movement (MINUS_DM)
+- Plus Directional Indicator (PLUS_DI)
+- Plus Directional Movement (PLUS_DM)
+- Percentage Price Oscillator (PPO)
+- Rate of change (ROC)
+- Rate of change Percentage (ROCP)
+- Rate of change ratio (ROCR)
+- Rate of change ratio 100 scale (ROCR100)
+- 1-day Rate of Change (ROC) of a Triple Smooth EMA (TRIX)
+- Ultimate Oscillator (ULTOSC)
+"""
+
+import pandas as pd
+from .modules.indicators.factory import IndicatorFactory
+
+
+def get_sma(
+    df: pd.DataFrame, window: int = 20, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Simple Moving Average
+
+    Args:
+        df: DataFrame with 'close' column
+        window: Lookback window size
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_sma(df, window)
+
+
+def get_ema(
+    df: pd.DataFrame, window: int = 20, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Exponential Moving Average
+
+    Args:
+        df: DataFrame with 'close' column
+        window: Lookback window size
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_ema(df, window)
+
+
+def get_rsi(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Relative Strength Index
+
+    Args:
+        df: DataFrame with 'close' column
+        window: Lookback window size
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_rsi(df, window)
+
+
+def get_macd(
+    df: pd.DataFrame,
+    fast: int = 12,
+    slow: int = 26,
+    signal: int = 9,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate MACD
+
+    Args:
+        df: DataFrame with 'close' column
+        fast: Fast period
+        slow: Slow period
+        signal: Signal period
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_macd(df, fast, slow, signal)
+
+
+def get_bollinger_bands(
+    df: pd.DataFrame,
+    window: int = 20,
+    std: int = 2,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Bollinger Bands
+
+    Args:
+        df: DataFrame with 'close' column
+        window: Lookback window size
+        std: Standard deviation
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_bollinger_bands(df, window, std)
+
+
+def get_stoch(
+    df: pd.DataFrame,
+    window: int = 14,
+    smooth_d: int = 3,
+    smooth_k: int = 3,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Stochastic Oscillator
+
+    Args:
+        df: DataFrame with 'high', 'low', 'close' columns
+        window: Lookback window size
+        smooth_d: Smoothing for D line
+        smooth_k: Smoothing for K line
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_stoch(df, window, smooth_d, smooth_k)
+
+
+def get_atr(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Average True Range
+
+    Args:
+        df: DataFrame with 'high', 'low', 'close' columns
+        window: Lookback window size
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_atr(df, window)
+
+
+def get_cci(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Commodity Channel Index
+
+    Args:
+        df: DataFrame with 'high', 'low', 'close' columns
+        window: Lookback window size
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_cci(df, window)
+
+
+def get_adx(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Average Directional Index
+
+    Args:
+        df: DataFrame with 'high', 'low', 'close' columns
+        window: Lookback window size
+        calculator_type: ('talib', 'simple')
+    """
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_adx(df, window)
+
+
+def get_willr(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Williams' %R"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_willr(df, window)
+
+
+def get_ad(df: pd.DataFrame, calculator_type: str = "talib") -> pd.DataFrame:
+    """Calculate Chaikin A/D Line"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_ad(df)
+
+
+def get_adosc(
+    df: pd.DataFrame,
+    fast_period: int = 3,
+    slow_period: int = 10,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Chaikin A/D Oscillator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_adosc(df, fast_period, slow_period)
+
+
+def get_obv(df: pd.DataFrame, calculator_type: str = "talib") -> pd.DataFrame:
+    """Calculate On Balance Volume"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_obv(df)
+
+
+def get_mom(
+    df: pd.DataFrame, window: int = 10, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Momentum"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_mom(df, window)
+
+
+def get_sar(
+    df: pd.DataFrame,
+    acceleration: float = 0.02,
+    maximum: float = 0.2,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Parabolic SAR"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_sar(df, acceleration, maximum)
+
+
+def get_tsf(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Time Series Forecast"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_tsf(df, window)
+
+
+def get_apo(
+    df: pd.DataFrame,
+    fast_period: int = 12,
+    slow_period: int = 26,
+    ma_type: int = 0,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Absolute Price Oscillator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_apo(df, fast_period, slow_period, ma_type)
+
+
+def get_aroon(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Aroon"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_aroon(df, window)
+
+
+def get_aroonosc(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Aroon Oscillator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_aroonosc(df, window)
+
+
+def get_bop(df: pd.DataFrame, calculator_type: str = "talib") -> pd.DataFrame:
+    """Calculate Balance of Power"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_bop(df)
+
+
+def get_cmo(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Chande Momentum Oscillator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_cmo(df, window)
+
+
+def get_dx(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Directional Movement Index"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_dx(df, window)
+
+
+def get_mfi(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Money Flow Index"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_mfi(df, window)
+
+
+def get_minus_di(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Minus Directional Indicator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_minus_di(df, window)
+
+
+def get_minus_dm(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Minus Directional Movement"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_minus_dm(df, window)
+
+
+def get_plus_di(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Plus Directional Indicator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_plus_di(df, window)
+
+
+def get_plus_dm(
+    df: pd.DataFrame, window: int = 14, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Plus Directional Movement"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_plus_dm(df, window)
+
+
+def get_ppo(
+    df: pd.DataFrame,
+    fast_period: int = 12,
+    slow_period: int = 26,
+    ma_type: int = 0,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Percentage Price Oscillator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_ppo(df, fast_period, slow_period, ma_type)
+
+
+def get_roc(
+    df: pd.DataFrame, window: int = 10, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Rate of change"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_roc(df, window)
+
+
+def get_rocp(
+    df: pd.DataFrame, window: int = 10, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Rate of change Percentage"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_rocp(df, window)
+
+
+def get_rocr(
+    df: pd.DataFrame, window: int = 10, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Rate of change ratio"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_rocr(df, window)
+
+
+def get_rocr100(
+    df: pd.DataFrame, window: int = 10, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate Rate of change ratio 100 scale"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_rocr100(df, window)
+
+
+def get_trix(
+    df: pd.DataFrame, window: int = 30, calculator_type: str = "talib"
+) -> pd.DataFrame:
+    """Calculate 1-day Rate of Change (ROC) of a Triple Smooth EMA"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_trix(df, window)
+
+
+def get_ultosc(
+    df: pd.DataFrame,
+    window1: int = 7,
+    window2: int = 14,
+    window3: int = 28,
+    calculator_type: str = "talib",
+) -> pd.DataFrame:
+    """Calculate Ultimate Oscillator"""
+    calculator = IndicatorFactory.get_calculator(calculator_type)
+    return calculator.calculate_ultosc(df, window1, window2, window3)

akshare_one/modules/eastmoney/client.py

@@ -35,9 +35,9 @@ class EastMoneyClient:
             market = "116"
             code = symbol[2:]
         elif len(symbol) == 6:
-            if symbol.startswith(("000", "001", "002", "003", "300")):
+            if symbol.startswith(("000", "001", "002", "003", "300", "200")):
                 market = "0"
-            elif symbol.startswith(("600", "601", "603", "605", "688")):
+            elif symbol.startswith(("600", "601", "603", "605", "688", "900")):
                 market = "1"
             else:
                 market = "0"  # Default to SZ for ambiguity

akshare_one/modules/historical/base.py

@@ -18,6 +18,14 @@ class HistoricalDataProvider(ABC):
         self.start_date = start_date
         self.end_date = end_date
         self.adjust = adjust
+        self._validate_dates()
+
+    def _validate_dates(self):
+        try:
+            pd.to_datetime(self.start_date)
+            pd.to_datetime(self.end_date)
+        except ValueError:
+            raise ValueError("Invalid date format. Please use YYYY-MM-DD.")
 
     @classmethod
     def get_supported_intervals(cls):

akshare_one/modules/historical/sina.py

@@ -98,8 +98,44 @@ class SinaHistorical(HistoricalDataProvider):
         )
         return self._clean_minute_data(raw_df)
 
+    def _get_b_share_data(self, stock: str) -> pd.DataFrame:
+        """Fetches B-share historical data"""
+        start_date = self._convert_date_format(self.start_date)
+        end_date = self._convert_date_format(self.end_date)
+
+        if self.interval in ["minute", "hour"]:
+            period = "1" if self.interval == "minute" else "60"
+            raw_df = ak.stock_zh_b_minute(
+                symbol=stock,
+                period=period,
+                adjust=self._map_adjust_param(self.adjust),
+            )
+            # Rename 'day' to 'date' for consistency
+            raw_df = raw_df.rename(columns={"day": "date"})
+
+            if self.interval_multiplier > 1:
+                freq = f"{self.interval_multiplier}{'min' if self.interval == 'minute' else 'h'}"
+                raw_df = self._resample_intraday_data(raw_df, freq)
+        else:
+            raw_df = ak.stock_zh_b_daily(
+                symbol=stock,
+                start_date=start_date,
+                end_date=end_date,
+                adjust=self._map_adjust_param(self.adjust),
+            )
+            if self.interval_multiplier > 1:
+                raw_df = self._resample_data(
+                    raw_df, self.interval, self.interval_multiplier
+                )
+
+        return self._clean_data(raw_df)
+
     def _get_daily_plus_data(self, stock: str) -> pd.DataFrame:
         """Fetches daily and higher-level data (day/week/month/year)"""
+        # Check if it's a B-share symbol
+        if stock.startswith(("sh9", "sz2")):
+            return self._get_b_share_data(stock)
+
         start_date = self._convert_date_format(self.start_date)
         end_date = self._convert_date_format(self.end_date)
 

akshare_one/modules/indicators/base.py

@@ -0,0 +1,158 @@
+from abc import ABC, abstractmethod
+import pandas as pd
+
+
+class BaseIndicatorCalculator(ABC):
+    """Base class for indicator calculators"""
+
+    @abstractmethod
+    def calculate_sma(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_ema(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_rsi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_macd(
+        self, df: pd.DataFrame, fast: int, slow: int, signal: int
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_bollinger_bands(
+        self, df: pd.DataFrame, window: int, std: int
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_stoch(
+        self, df: pd.DataFrame, window: int, smooth_d: int, smooth_k: int
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_atr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_cci(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_adx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_willr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_ad(self, df: pd.DataFrame) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_adosc(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_obv(self, df: pd.DataFrame) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_mom(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_sar(
+        self, df: pd.DataFrame, acceleration: float, maximum: float
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_tsf(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_apo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type: int
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_aroon(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_aroonosc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_bop(self, df: pd.DataFrame) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_cmo(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_dx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_mfi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_minus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_minus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_plus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_plus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_ppo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type: int
+    ) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_roc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_rocp(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_rocr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_rocr100(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_trix(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def calculate_ultosc(
+        self, df: pd.DataFrame, window1: int, window2: int, window3: int
+    ) -> pd.DataFrame:
+        pass

akshare_one/modules/indicators/factory.py

@@ -0,0 +1,33 @@
+from .base import BaseIndicatorCalculator
+from .simple import SimpleIndicatorCalculator
+
+_calculators = {
+    "simple": SimpleIndicatorCalculator,
+}
+TALIB_AVAILABLE = False
+try:
+    from .talib import TalibIndicatorCalculator
+
+    _calculators["talib"] = TalibIndicatorCalculator
+    TALIB_AVAILABLE = True
+except ImportError:
+    # talib is optional
+    pass
+
+
+class IndicatorFactory:
+    """Factory for indicator calculators"""
+
+    @classmethod
+    def get_calculator(cls, calculator_type: str = "talib") -> BaseIndicatorCalculator:
+        """Get indicator calculator instance
+
+        If talib is not installed, it will fall back to the simple implementation.
+        """
+        if calculator_type == "talib" and not TALIB_AVAILABLE:
+            calculator_type = "simple"
+
+        calculator_class = _calculators.get(calculator_type)
+        if not calculator_class:
+            raise ValueError(f"Unsupported calculator type: {calculator_type}")
+        return calculator_class()

akshare_one/modules/indicators/simple.py

@@ -0,0 +1,230 @@
+import pandas as pd
+from .base import BaseIndicatorCalculator
+
+
+class SimpleIndicatorCalculator(BaseIndicatorCalculator):
+    """Basic pandas-based indicator implementations"""
+
+    def calculate_sma(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        return (
+            df["close"]
+            .rolling(window=window, min_periods=window)
+            .mean()
+            .to_frame("sma")
+        )
+
+    def calculate_ema(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        return (
+            df["close"]
+            .ewm(span=window, adjust=False, min_periods=window)
+            .mean()
+            .to_frame("ema")
+        )
+
+    def calculate_rsi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        delta = df["close"].diff()
+        gain = delta.clip(lower=0)
+        loss = -delta.clip(upper=0)
+
+        avg_gain = gain.ewm(alpha=1 / window, min_periods=window, adjust=False).mean()
+        avg_loss = loss.ewm(alpha=1 / window, min_periods=window, adjust=False).mean()
+
+        rs = avg_gain / avg_loss
+        rsi = 100 - (100 / (1 + rs))
+
+        return rsi.clip(0, 100).to_frame("rsi")
+
+    def calculate_macd(
+        self, df: pd.DataFrame, fast: int, slow: int, signal: int
+    ) -> pd.DataFrame:
+        close = df["close"]
+        ema_fast = close.ewm(span=fast, adjust=False, min_periods=fast).mean()
+        ema_slow = close.ewm(span=slow, adjust=False, min_periods=slow).mean()
+
+        macd_line = ema_fast - ema_slow
+        signal_line = macd_line.ewm(
+            span=signal, adjust=False, min_periods=signal
+        ).mean()
+
+        return pd.DataFrame(
+            {
+                "macd": macd_line,
+                "signal": signal_line,
+                "histogram": macd_line - signal_line,
+            }
+        )
+
+    def calculate_bollinger_bands(
+        self, df: pd.DataFrame, window: int, std: int
+    ) -> pd.DataFrame:
+        close = df["close"]
+        sma = close.rolling(window=window, min_periods=window).mean()
+        rolling_std = close.rolling(window=window, min_periods=window).std()
+        upper_band = sma + (rolling_std * std)
+        lower_band = sma - (rolling_std * std)
+        return pd.DataFrame(
+            {"upper_band": upper_band, "middle_band": sma, "lower_band": lower_band}
+        )
+
+    def calculate_stoch(
+        self, df: pd.DataFrame, window: int, smooth_d: int, smooth_k: int
+    ) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        close = df["close"]
+
+        lowest_low = low.rolling(window=window).min()
+        highest_high = high.rolling(window=window).max()
+
+        k = 100 * (close - lowest_low) / (highest_high - lowest_low)
+        slow_k = k.rolling(window=smooth_k).mean()
+        slow_d = slow_k.rolling(window=smooth_d).mean()
+
+        return pd.DataFrame({"slow_k": slow_k, "slow_d": slow_d})
+
+    def calculate_atr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        close = df["close"]
+
+        tr1 = high - low
+        tr2 = abs(high - close.shift())
+        tr3 = abs(low - close.shift())
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+
+        atr = tr.ewm(alpha=1 / window, adjust=False, min_periods=window).mean()
+        return atr.to_frame("atr")
+
+    def calculate_cci(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        close = df["close"]
+
+        tp = (high + low + close) / 3
+        tp_sma = tp.rolling(window=window, min_periods=window).mean()
+        mean_dev = tp.rolling(window=window, min_periods=window).apply(
+            lambda x: (x - x.mean()).abs().mean()
+        )
+
+        cci = (tp - tp_sma) / (0.015 * mean_dev)
+        return cci.to_frame("cci")
+
+    def calculate_adx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        close = df["close"]
+
+        # Calculate +DM, -DM and TR
+        move_up = high.diff()
+        move_down = low.diff().apply(abs)
+
+        plus_dm = pd.Series((move_up > move_down) & (move_up > 0)).astype(int) * move_up
+        minus_dm = (
+            pd.Series((move_down > move_up) & (move_down > 0)).astype(int) * move_down
+        )
+
+        tr1 = high - low
+        tr2 = abs(high - close.shift())
+        tr3 = abs(low - close.shift())
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+
+        # Smooth +DM, -DM and TR
+        atr = tr.ewm(alpha=1 / window, adjust=False, min_periods=window).mean()
+        plus_di = 100 * (
+            plus_dm.ewm(alpha=1 / window, adjust=False, min_periods=window).mean() / atr
+        )
+        minus_di = 100 * (
+            minus_dm.ewm(alpha=1 / window, adjust=False, min_periods=window).mean()
+            / atr
+        )
+
+        # Calculate ADX
+        dx = 100 * (abs(plus_di - minus_di) / (plus_di + minus_di))
+        adx = dx.ewm(alpha=1 / window, adjust=False, min_periods=window).mean()
+
+        return adx.to_frame("adx")
+
+    def calculate_willr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("WILLR not implemented in simple calculator")
+
+    def calculate_ad(self, df: pd.DataFrame) -> pd.DataFrame:
+        raise NotImplementedError("AD not implemented in simple calculator")
+
+    def calculate_adosc(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int
+    ) -> pd.DataFrame:
+        raise NotImplementedError("ADOSC not implemented in simple calculator")
+
+    def calculate_obv(self, df: pd.DataFrame) -> pd.DataFrame:
+        raise NotImplementedError("OBV not implemented in simple calculator")
+
+    def calculate_mom(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("MOM not implemented in simple calculator")
+
+    def calculate_sar(
+        self, df: pd.DataFrame, acceleration: float, maximum: float
+    ) -> pd.DataFrame:
+        raise NotImplementedError("SAR not implemented in simple calculator")
+
+    def calculate_tsf(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("TSF not implemented in simple calculator")
+
+    def calculate_apo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type: int
+    ) -> pd.DataFrame:
+        raise NotImplementedError("APO not implemented in simple calculator")
+
+    def calculate_aroon(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("AROON not implemented in simple calculator")
+
+    def calculate_aroonosc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("AROONOSC not implemented in simple calculator")
+
+    def calculate_bop(self, df: pd.DataFrame) -> pd.DataFrame:
+        raise NotImplementedError("BOP not implemented in simple calculator")
+
+    def calculate_cmo(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("CMO not implemented in simple calculator")
+
+    def calculate_dx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("DX not implemented in simple calculator")
+
+    def calculate_mfi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("MFI not implemented in simple calculator")
+
+    def calculate_minus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("MINUS_DI not implemented in simple calculator")
+
+    def calculate_minus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("MINUS_DM not implemented in simple calculator")
+
+    def calculate_plus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("PLUS_DI not implemented in simple calculator")
+
+    def calculate_plus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("PLUS_DM not implemented in simple calculator")
+
+    def calculate_ppo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type: int
+    ) -> pd.DataFrame:
+        raise NotImplementedError("PPO not implemented in simple calculator")
+
+    def calculate_roc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("ROC not implemented in simple calculator")
+
+    def calculate_rocp(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("ROCP not implemented in simple calculator")
+
+    def calculate_rocr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("ROCR not implemented in simple calculator")
+
+    def calculate_rocr100(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("ROCR100 not implemented in simple calculator")
+
+    def calculate_trix(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        raise NotImplementedError("TRIX not implemented in simple calculator")
+
+    def calculate_ultosc(
+        self, df: pd.DataFrame, window1: int, window2: int, window3: int
+    ) -> pd.DataFrame:
+        raise NotImplementedError("ULTOSC not implemented in simple calculator")

akshare_one/modules/indicators/talib.py

@@ -0,0 +1,263 @@
+import talib
+import pandas as pd
+from .base import BaseIndicatorCalculator
+
+
+class TalibIndicatorCalculator(BaseIndicatorCalculator):
+    """TA-Lib based indicator implementations"""
+
+    def calculate_sma(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        sma = talib.SMA(close, timeperiod=window)
+        return pd.DataFrame({"sma": sma}, index=df.index)
+
+    def calculate_ema(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        ema = talib.EMA(close, timeperiod=window)
+        return pd.DataFrame({"ema": ema}, index=df.index)
+
+    def calculate_rsi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        rsi = talib.RSI(close, timeperiod=window)
+        return pd.DataFrame({"rsi": rsi}, index=df.index)
+
+    def calculate_macd(
+        self, df: pd.DataFrame, fast: int, slow: int, signal: int
+    ) -> pd.DataFrame:
+        close = df["close"].values
+        macd, signal_line, histogram = talib.MACD(
+            close, fastperiod=fast, slowperiod=slow, signalperiod=signal
+        )
+        return pd.DataFrame(
+            {"macd": macd, "signal": signal_line, "histogram": histogram},
+            index=df.index,
+        )
+
+    def calculate_bollinger_bands(
+        self, df: pd.DataFrame, window: int, std: int
+    ) -> pd.DataFrame:
+        close = df["close"].values
+        upper, middle, lower = talib.BBANDS(
+            close, timeperiod=window, nbdevup=std, nbdevdn=std, matype=talib.MA_Type.SMA
+        )
+        return pd.DataFrame(
+            {"upper_band": upper, "middle_band": middle, "lower_band": lower},
+            index=df.index,
+        )
+
+    def calculate_stoch(
+        self, df: pd.DataFrame, window: int, smooth_d: int, smooth_k: int
+    ) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        slow_k, slow_d = talib.STOCH(
+            high,
+            low,
+            close,
+            fastk_period=window,
+            slowk_period=smooth_k,
+            slowk_matype=talib.MA_Type.SMA,
+            slowd_period=smooth_d,
+            slowd_matype=talib.MA_Type.SMA,
+        )
+        return pd.DataFrame({"slow_k": slow_k, "slow_d": slow_d}, index=df.index)
+
+    def calculate_atr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        atr = talib.ATR(high, low, close, timeperiod=window)
+        return pd.DataFrame({"atr": atr}, index=df.index)
+
+    def calculate_cci(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        cci = talib.CCI(high, low, close, timeperiod=window)
+        return pd.DataFrame({"cci": cci}, index=df.index)
+
+    def calculate_adx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        adx = talib.ADX(high, low, close, timeperiod=window)
+        return pd.DataFrame({"adx": adx}, index=df.index)
+
+    def calculate_willr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        willr = talib.WILLR(high, low, close, timeperiod=window)
+        return pd.DataFrame({"willr": willr}, index=df.index)
+
+    def calculate_ad(self, df: pd.DataFrame) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        volume = df["volume"].values.astype(float)
+        ad = talib.AD(high, low, close, volume)
+        return pd.DataFrame({"ad": ad}, index=df.index)
+
+    def calculate_adosc(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int
+    ) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        volume = df["volume"].values.astype(float)
+        adosc = talib.ADOSC(
+            high, low, close, volume, fastperiod=fast_period, slowperiod=slow_period
+        )
+        return pd.DataFrame({"adosc": adosc}, index=df.index)
+
+    def calculate_obv(self, df: pd.DataFrame) -> pd.DataFrame:
+        close = df["close"].values
+        volume = df["volume"].values.astype(float)
+        obv = talib.OBV(close, volume)
+        return pd.DataFrame({"obv": obv}, index=df.index)
+
+    def calculate_mom(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        mom = talib.MOM(close, timeperiod=window)
+        return pd.DataFrame({"mom": mom}, index=df.index)
+
+    def calculate_sar(
+        self, df: pd.DataFrame, acceleration: float, maximum: float
+    ) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        sar = talib.SAR(high, low, acceleration=acceleration, maximum=maximum)
+        return pd.DataFrame({"sar": sar}, index=df.index)
+
+    def calculate_tsf(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        tsf = talib.TSF(close, timeperiod=window)
+        return pd.DataFrame({"tsf": tsf}, index=df.index)
+
+    def calculate_apo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type
+    ) -> pd.DataFrame:
+        close = df["close"].values
+        apo = talib.APO(
+            close, fastperiod=fast_period, slowperiod=slow_period, matype=ma_type
+        )
+        return pd.DataFrame({"apo": apo}, index=df.index)
+
+    def calculate_aroon(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        aroon_down, aroon_up = talib.AROON(high, low, timeperiod=window)
+        return pd.DataFrame(
+            {"aroon_down": aroon_down, "aroon_up": aroon_up}, index=df.index
+        )
+
+    def calculate_aroonosc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        aroonosc = talib.AROONOSC(high, low, timeperiod=window)
+        return pd.DataFrame({"aroonosc": aroonosc}, index=df.index)
+
+    def calculate_bop(self, df: pd.DataFrame) -> pd.DataFrame:
+        open_ = df["open"].values
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        bop = talib.BOP(open_, high, low, close)
+        return pd.DataFrame({"bop": bop}, index=df.index)
+
+    def calculate_cmo(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        cmo = talib.CMO(close, timeperiod=window)
+        return pd.DataFrame({"cmo": cmo}, index=df.index)
+
+    def calculate_dx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        dx = talib.DX(high, low, close, timeperiod=window)
+        return pd.DataFrame({"dx": dx}, index=df.index)
+
+    def calculate_mfi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        volume = df["volume"].values.astype(float)
+        mfi = talib.MFI(high, low, close, volume, timeperiod=window)
+        return pd.DataFrame({"mfi": mfi}, index=df.index)
+
+    def calculate_minus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        minus_di = talib.MINUS_DI(high, low, close, timeperiod=window)
+        return pd.DataFrame({"minus_di": minus_di}, index=df.index)
+
+    def calculate_minus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        minus_dm = talib.MINUS_DM(high, low, timeperiod=window)
+        return pd.DataFrame({"minus_dm": minus_dm}, index=df.index)
+
+    def calculate_plus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        plus_di = talib.PLUS_DI(high, low, close, timeperiod=window)
+        return pd.DataFrame({"plus_di": plus_di}, index=df.index)
+
+    def calculate_plus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        plus_dm = talib.PLUS_DM(high, low, timeperiod=window)
+        return pd.DataFrame({"plus_dm": plus_dm}, index=df.index)
+
+    def calculate_ppo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type
+    ) -> pd.DataFrame:
+        close = df["close"].values
+        ppo = talib.PPO(
+            close, fastperiod=fast_period, slowperiod=slow_period, matype=ma_type
+        )
+        return pd.DataFrame({"ppo": ppo}, index=df.index)
+
+    def calculate_roc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        roc = talib.ROC(close, timeperiod=window)
+        return pd.DataFrame({"roc": roc}, index=df.index)
+
+    def calculate_rocp(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        rocp = talib.ROCP(close, timeperiod=window)
+        return pd.DataFrame({"rocp": rocp}, index=df.index)
+
+    def calculate_rocr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        rocr = talib.ROCR(close, timeperiod=window)
+        return pd.DataFrame({"rocr": rocr}, index=df.index)
+
+    def calculate_rocr100(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        rocr100 = talib.ROCR100(close, timeperiod=window)
+        return pd.DataFrame({"rocr100": rocr100}, index=df.index)
+
+    def calculate_trix(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"].values
+        trix = talib.TRIX(close, timeperiod=window)
+        return pd.DataFrame({"trix": trix}, index=df.index)
+
+    def calculate_ultosc(
+        self, df: pd.DataFrame, window1: int, window2: int, window3: int
+    ) -> pd.DataFrame:
+        high = df["high"].values
+        low = df["low"].values
+        close = df["close"].values
+        ultosc = talib.ULTOSC(
+            high,
+            low,
+            close,
+            timeperiod1=window1,
+            timeperiod2=window2,
+            timeperiod3=window3,
+        )
+        return pd.DataFrame({"ultosc": ultosc}, index=df.index)

akshare_one/modules/insider/xueqiu.py

@@ -112,4 +112,4 @@ class XueQiuInsider(InsiderDataProvider):
             if col in df.columns:
                 df[col] = pd.to_numeric(df[col], errors="coerce")
 
-        return df
+        return df.reset_index(drop=True)

{akshare_one-0.2.3.dist-info → akshare_one-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akshare-one
-Version: 0.2.3
+Version: 0.3.1
 Summary: Standardized interface for Chinese financial market data, built on AKShare with unified data formats and simplified APIs
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/zwldarren/akshare-one
@@ -9,8 +9,10 @@ Keywords: akshare,financial-data,stock-data,quant
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: akshare>=1.17.5
+Requires-Dist: akshare>=1.17.15
 Requires-Dist: cachetools>=6.1.0
+Provides-Extra: talib
+Requires-Dist: ta-lib>=0.6.4; extra == "talib"
 Dynamic: license-file
 
 <div align="center">
@@ -38,6 +40,7 @@ Dynamic: license-file
 | Stock news | `get_news_data` |
 | Financial data | `get_balance_sheet`/`get_income_statement`/`get_cash_flow` |
 | Internal transactions | `get_inner_trade_data` |
+| Technical indicators | See [indicators.py](akshare_one/indicators.py) |
 
 ## 📦 Quick Installation
 
@@ -48,17 +51,18 @@ pip install akshare-one
 ## 💻 Usage Example
 
 ```python
-from akshare_one import get_hist_data, get_realtime_data
+from akshare_one import get_hist_data
+from akshare_one.indicators import get_sma
 
 # Get historical data
-df_hist = get_hist_data(
+df = get_hist_data(
     symbol="600000",
     interval="day",
     adjust="hfq"
 )
 
-# Get real-time data
-df_realtime = get_realtime_data(symbol="600000")
+# Calculate 20-day Simple Moving Average
+df_sma = get_sma(df, window=20)
 ```
 
 ## 📚 Documentation

{akshare_one-0.2.3.dist-info → akshare_one-0.3.1.dist-info}/RECORD

@@ -1,23 +1,29 @@
 akshare_one/__init__.py,sha256=M4eXCnBzGqa5FihT-q7DHaluTvidnqwVF7AgPgCikKU,878
 akshare_one/financial.py,sha256=XAsonRzGK8akKtW2Q7LUrew4OFRnRAfZm0nw0JY73Jc,1426
+akshare_one/indicators.py,sha256=CltxhMoy6qbiQKIq2veTQ6xsf4_q7Ir3Zw8IfHyr4FI,12138
 akshare_one/insider.py,sha256=fM6wvlLSGm7a2NkQFvxEK2PkhN5WudrO-V0BboVz2Bo,1092
 akshare_one/news.py,sha256=yrYeCaKTgCGP-TSyOfOou9gMw8185qiWrg380fD9-f8,669
 akshare_one/stock.py,sha256=kldPmfggrgUH8pEcU8HGR5ofsxzYXJiUqj8GXCM5pBk,2266
 akshare_one/modules/cache.py,sha256=47A80Xtfr4gkKvEfBQrT8Dz8hNFR769rBa2gU6ew25s,373
 akshare_one/modules/utils.py,sha256=H4nrGf8m4_ezTiW5-OcNPxpV-neTYfffEfaOLDFLY9Y,323
-akshare_one/modules/eastmoney/client.py,sha256=_fOXtvAbs65WHY3s2Ge1bsCTpVDbfkNj9yaVErF6GoU,3104
+akshare_one/modules/eastmoney/client.py,sha256=AprWA4SxX_B4RzvG6B0_ciOMYaoRFcmIwHGRkEtvfHQ,3118
 akshare_one/modules/eastmoney/utils.py,sha256=KzT0x6dF8y6wgc9Wzewr450NCee1i_dK2EhocBJQc5g,2896
 akshare_one/modules/financial/base.py,sha256=qj_XeujG7Tn2oO1niuIG4s7lMH3xg5zERDbcj75DUnU,536
 akshare_one/modules/financial/factory.py,sha256=GqzFp6LoHWj7t5VwtZJkLFxBuaAW_0b__bduBrmlcOg,1301
 akshare_one/modules/financial/sina.py,sha256=Hf6fVeN0gClS9GU2N9Hg6QJ1f8X4mecpEA6KWVgiwTc,10914
-akshare_one/modules/historical/base.py,sha256=UeKfMU_k8SgazXn27M1FVNaYJ5vBNgUB0jVBDpgXnz8,980
+akshare_one/modules/historical/base.py,sha256=EkSNFk9bV1zbbuuIvI5Yk3r6s0EsomZJ4VFROYe4prU,1245
 akshare_one/modules/historical/eastmoney.py,sha256=2bYXobIwlrd5vG8pHlUZVE6edjQqn8AEGCVFGcWCCKk,8248
 akshare_one/modules/historical/eastmoney_direct.py,sha256=QRgGrY6NhAB2NAWCh_H3G0q2wKnSEnYQBRjMq-GjXGM,2814
 akshare_one/modules/historical/factory.py,sha256=K1JwhScNPvuP-wR33C5VnosJYXJ3u1RykJuaMU6-3ls,1500
-akshare_one/modules/historical/sina.py,sha256=R-5hBOP5zslDuC0qfzw5zNhQyWmbmkmqB2sI2WhKVgI,7249
+akshare_one/modules/historical/sina.py,sha256=D6xYpwoV5aNDsTLqUphnXye_2k7TVZZTdfvoLFu70Ds,8685
+akshare_one/modules/indicators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+akshare_one/modules/indicators/base.py,sha256=oNfP2p1ZO-jdV9Ay7CECO7LrFCGs9y3Xxg7ewg9uAZ0,4218
+akshare_one/modules/indicators/factory.py,sha256=FDERSNI7r22qN06PYzyzkB5fyhXa2f_v1Yj-A_e6dFc,988
+akshare_one/modules/indicators/simple.py,sha256=8GdDteLchQv-ON6lEYlq57u3ryPaHAOo-RksmLcze3s,9112
+akshare_one/modules/indicators/talib.py,sha256=w7C-21TZfiLcVA_WgE7aQ1nYVzbyhb99r5rzKS7a6aU,10510
 akshare_one/modules/insider/base.py,sha256=xOhBDzMtZd1DutsHaJWe931P17fgW7dlivo1vz5ZflI,949
 akshare_one/modules/insider/factory.py,sha256=om51vX-GTXknpptZGvmDD9m10FfgEVmy402xZ3bBsNM,1280
-akshare_one/modules/insider/xueqiu.py,sha256=2gmSrcer8qw2Jb80kYT3tHNJ3U88hxd0dJSfoh846EY,3971
+akshare_one/modules/insider/xueqiu.py,sha256=UnvyLyfpz_OJCcPjGEaD_tm8YEpOag7H1cpel0rVhEU,3994
 akshare_one/modules/news/base.py,sha256=yrBZf1q1QwJkCXygNmeLIEjvcqm1iti63tjb3s40L_4,559
 akshare_one/modules/news/eastmoney.py,sha256=efVT4plk03s8TbSfhAhRLWgMLlR5G_2G0xGZTQgSxmY,1333
 akshare_one/modules/news/factory.py,sha256=Em6c7m46K760iwIX3GZ15HdFu7pXT2w-n4QsjwHezjY,1264
@@ -26,8 +32,8 @@ akshare_one/modules/realtime/eastmoney.py,sha256=7IR35dwPr5xj0ErdBajYwyBivEoi55w
 akshare_one/modules/realtime/eastmoney_direct.py,sha256=yFH1fNcZRieyxFN5YzX7Gcw5-CR-dUEgUHSeR0NPD0g,1238
 akshare_one/modules/realtime/factory.py,sha256=qHdCDY6dA7ck4JgK3yUDqcne9WrruAA6XzbRT69kT2w,1480
 akshare_one/modules/realtime/xueqiu.py,sha256=LKu0fW0EMt3c2m1w2kqBbEt9s2TcHUeBFpbFtueJgbU,2241
-akshare_one-0.2.3.dist-info/licenses/LICENSE,sha256=Gg6A1GNSJCZWQ73aHJ7TXOa0i8RQ3FejZCTZ6Db07cU,1066
-akshare_one-0.2.3.dist-info/METADATA,sha256=jDbWls7NZNuJd6jOpSl8oGguxl4NLBCLGo16aL89VKw,1896
-akshare_one-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-akshare_one-0.2.3.dist-info/top_level.txt,sha256=kNiucyLVAGa89wmUSpXbBLWD7pF_RuahuiaOfLHZSyw,12
-akshare_one-0.2.3.dist-info/RECORD,,
+akshare_one-0.3.1.dist-info/licenses/LICENSE,sha256=Gg6A1GNSJCZWQ73aHJ7TXOa0i8RQ3FejZCTZ6Db07cU,1066
+akshare_one-0.3.1.dist-info/METADATA,sha256=rJ0LO-mZZcvL78bqVVVhL7U8FAS7nSeNn-V60FuDYRg,2062
+akshare_one-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+akshare_one-0.3.1.dist-info/top_level.txt,sha256=kNiucyLVAGa89wmUSpXbBLWD7pF_RuahuiaOfLHZSyw,12
+akshare_one-0.3.1.dist-info/RECORD,,