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

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)