akshare-one 0.3.6__tar.gz → 0.3.7__tar.gz

{akshare_one-0.3.6 → akshare_one-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akshare-one
-Version: 0.3.6
+Version: 0.3.7
 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,7 +9,7 @@ Keywords: akshare,financial-data,stock-data,quant
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: akshare>=1.17.21
+Requires-Dist: akshare>=1.17.26
 Requires-Dist: cachetools>=5.5.2
 Provides-Extra: talib
 Requires-Dist: ta-lib>=0.6.4; extra == "talib"

akshare_one-0.3.7/akshare_one/modules/indicators/simple.py

@@ -0,0 +1,384 @@
+import pandas as pd
+import numpy as np
+from .base import BaseIndicatorCalculator
+
+
+class SimpleIndicatorCalculator(BaseIndicatorCalculator):
+    """Basic pandas-based indicator implementations"""
+
+    def _get_ma(self, series: pd.Series, window: int, ma_type: int) -> pd.Series:
+        if ma_type == 0:
+            return series.rolling(window=window, min_periods=window).mean()
+        elif ma_type == 1:
+            return series.ewm(span=window, adjust=False, min_periods=window).mean()
+        else:
+            raise ValueError(
+                f"Unsupported ma_type: {ma_type} in simple calculator. Only SMA (0) and EMA (1) are supported."
+            )
+
+    def _wilder_smooth(self, series: pd.Series, window: int) -> pd.Series:
+        return series.ewm(alpha=1 / window, adjust=False, min_periods=window).mean()
+
+    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).replace(0, np.nan)
+        slow_k = k.rolling(window=smooth_k, min_periods=smooth_k).mean()
+        slow_d = slow_k.rolling(window=smooth_d, min_periods=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 = self._wilder_smooth(tr, window)
+        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:
+        dx = self.calculate_dx(df, window)["dx"]
+        adx = self._wilder_smooth(dx, window)
+        return adx.to_frame("adx")
+
+    def calculate_willr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        close = df["close"]
+        highest_high = high.rolling(window=window, min_periods=window).max()
+        lowest_low = low.rolling(window=window, min_periods=window).min()
+        willr = -100 * (highest_high - close) / (highest_high - lowest_low)
+        return willr.to_frame("willr")
+
+    def calculate_ad(self, df: pd.DataFrame) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        close = df["close"]
+        volume = df["volume"]
+        mfm = ((close - low) - (high - close)) / (high - low).replace(0, np.nan)
+        mfm = mfm.fillna(0)
+        mfv = mfm * volume
+        ad = mfv.cumsum()
+        return ad.to_frame("ad")
+
+    def calculate_adosc(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int
+    ) -> pd.DataFrame:
+        ad = self.calculate_ad(df)["ad"]
+        ema_fast = ad.ewm(span=fast_period, adjust=False).mean()
+        ema_slow = ad.ewm(span=slow_period, adjust=False).mean()
+        adosc = ema_fast - ema_slow
+        return adosc.to_frame("adosc")
+
+    def calculate_obv(self, df: pd.DataFrame) -> pd.DataFrame:
+        close = df["close"]
+        volume = df["volume"]
+        sign = (close > close.shift(1)).astype(int) - (close < close.shift(1)).astype(
+            int
+        )
+        obv = (volume * sign).cumsum()
+        return obv.to_frame("obv")
+
+    def calculate_mom(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+        mom = close.diff(periods=window)
+        return mom.to_frame("mom")
+
+    def calculate_sar(
+        self, df: pd.DataFrame, acceleration: float, maximum: float
+    ) -> pd.DataFrame:
+        high, low = df["high"], df["low"]
+        sar = pd.Series(index=df.index, dtype=float)
+        uptrend = True
+        accel_factor = acceleration
+        extreme_point = high[0]
+        sar.iloc[0] = low[0]
+
+        for i in range(1, len(df)):
+            prev_sar = sar.iloc[i - 1]
+
+            if uptrend:
+                sar.iloc[i] = prev_sar + accel_factor * (extreme_point - prev_sar)
+                sar.iloc[i] = min(sar.iloc[i], low.iloc[i - 1])
+                if i > 1:
+                    sar.iloc[i] = min(sar.iloc[i], low.iloc[i - 2])
+
+                if low[i] < sar.iloc[i]:
+                    uptrend = False
+                    sar.iloc[i] = extreme_point
+                    extreme_point = low[i]
+                    accel_factor = acceleration
+                else:
+                    if high[i] > extreme_point:
+                        extreme_point = high[i]
+                        accel_factor = min(maximum, accel_factor + acceleration)
+            else:
+                sar.iloc[i] = prev_sar - accel_factor * (prev_sar - extreme_point)
+                sar.iloc[i] = max(sar.iloc[i], high.iloc[i - 1])
+                if i > 1:
+                    sar.iloc[i] = max(sar.iloc[i], high.iloc[i - 2])
+
+                if high[i] > sar.iloc[i]:
+                    uptrend = True
+                    sar.iloc[i] = extreme_point
+                    extreme_point = high[i]
+                    accel_factor = acceleration
+                else:
+                    if low[i] < extreme_point:
+                        extreme_point = low[i]
+                        accel_factor = min(maximum, accel_factor + acceleration)
+
+        return sar.to_frame("sar")
+
+    def calculate_tsf(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+
+        def linear_reg_forecast(y):
+            x = np.arange(1, len(y) + 1)
+            b_num = len(x) * np.sum(x * y) - np.sum(x) * np.sum(y)
+            b_den = len(x) * np.sum(x * x) - np.sum(x) ** 2
+            b = b_num / b_den if b_den != 0 else 0
+            a = np.mean(y) - b * np.mean(x)
+            return a + b * len(y)
+
+        tsf = close.rolling(window=window, min_periods=window).apply(
+            linear_reg_forecast, raw=True
+        )
+        return tsf.to_frame("tsf")
+
+    def calculate_apo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type: int
+    ) -> pd.DataFrame:
+        close = df["close"]
+        fast_ma = self._get_ma(close, fast_period, ma_type)
+        slow_ma = self._get_ma(close, slow_period, ma_type)
+        apo = fast_ma - slow_ma
+        return apo.to_frame("apo")
+
+    def calculate_aroon(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        periods_since_high = high.rolling(window=window, min_periods=window).apply(
+            lambda x: len(x) - 1 - np.argmax(x), raw=True
+        )
+        periods_since_low = low.rolling(window=window, min_periods=window).apply(
+            lambda x: len(x) - 1 - np.argmin(x), raw=True
+        )
+        aroon_up = ((window - periods_since_high) / window) * 100
+        aroon_down = ((window - periods_since_low) / window) * 100
+        return pd.DataFrame({"aroon_up": aroon_up, "aroon_down": aroon_down})
+
+    def calculate_aroonosc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        aroon_df = self.calculate_aroon(df, window)
+        aroonosc = aroon_df["aroon_up"] - aroon_df["aroon_down"]
+        return aroonosc.to_frame("aroonosc")
+
+    def calculate_bop(self, df: pd.DataFrame) -> pd.DataFrame:
+        bop = (df["close"] - df["open"]) / (df["high"] - df["low"]).replace(0, np.nan)
+        bop = bop.fillna(0)
+        return bop.to_frame("bop")
+
+    def calculate_cmo(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close_diff = df["close"].diff(1)
+        sum_up = close_diff.where(close_diff > 0, 0).rolling(window=window).sum()
+        sum_down = -close_diff.where(close_diff < 0, 0).rolling(window=window).sum()
+        cmo = 100 * (sum_up - sum_down) / (sum_up + sum_down).replace(0, np.nan)
+        cmo = cmo.fillna(0)
+        return cmo.to_frame("cmo")
+
+    def calculate_dx(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        plus_di = self.calculate_plus_di(df, window)["plus_di"]
+        minus_di = self.calculate_minus_di(df, window)["minus_di"]
+        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di).replace(0, np.nan)
+        dx = dx.fillna(0)
+        return dx.to_frame("dx")
+
+    def calculate_mfi(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        typical_price = (df["high"] + df["low"] + df["close"]) / 3
+        money_flow = typical_price * df["volume"]
+        price_diff = typical_price.diff()
+        positive_mf = money_flow.where(price_diff > 0, 0)
+        negative_mf = money_flow.where(price_diff < 0, 0)
+        positive_mf_sum = positive_mf.rolling(window=window).sum()
+        negative_mf_sum = negative_mf.rolling(window=window).sum()
+        money_ratio = positive_mf_sum / negative_mf_sum.replace(0, np.nan)
+        money_ratio = money_ratio.fillna(0)
+        mfi = 100 - (100 / (1 + money_ratio))
+        return mfi.to_frame("mfi")
+
+    def calculate_minus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        atr = self.calculate_atr(df, window)["atr"]
+        minus_dm = self.calculate_minus_dm(df, window)["minus_dm"]
+        minus_di = 100 * (minus_dm / atr)
+        return minus_di.to_frame("minus_di")
+
+    def calculate_minus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        up_move = high.diff()
+        down_move = -low.diff()
+        minus_dm = down_move.where((down_move > up_move) & (down_move > 0), 0)
+        smoothed_minus_dm = self._wilder_smooth(minus_dm, window)
+        return smoothed_minus_dm.to_frame("minus_dm")
+
+    def calculate_plus_di(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        atr = self.calculate_atr(df, window)["atr"]
+        plus_dm = self.calculate_plus_dm(df, window)["plus_dm"]
+        plus_di = 100 * (plus_dm / atr)
+        return plus_di.to_frame("plus_di")
+
+    def calculate_plus_dm(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        high = df["high"]
+        low = df["low"]
+        up_move = high.diff()
+        down_move = -low.diff()
+        plus_dm = up_move.where((up_move > down_move) & (up_move > 0), 0)
+        smoothed_plus_dm = self._wilder_smooth(plus_dm, window)
+        return smoothed_plus_dm.to_frame("plus_dm")
+
+    def calculate_ppo(
+        self, df: pd.DataFrame, fast_period: int, slow_period: int, ma_type: int
+    ) -> pd.DataFrame:
+        close = df["close"]
+        fast_ma = self._get_ma(close, fast_period, ma_type)
+        slow_ma = self._get_ma(close, slow_period, ma_type)
+        ppo = ((fast_ma - slow_ma) / slow_ma) * 100
+        return ppo.to_frame("ppo")
+
+    def calculate_roc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+        roc = (close.diff(window) / close.shift(window)) * 100
+        return roc.to_frame("roc")
+
+    def calculate_rocp(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+        rocp = close.diff(window) / close.shift(window)
+        return rocp.to_frame("rocp")
+
+    def calculate_rocr(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+        rocr = close / close.shift(window)
+        return rocr.to_frame("rocr")
+
+    def calculate_rocr100(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+        rocr100 = (close / close.shift(window)) * 100
+        return rocr100.to_frame("rocr100")
+
+    def calculate_trix(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
+        close = df["close"]
+        ema1 = close.ewm(span=window, adjust=False).mean()
+        ema2 = ema1.ewm(span=window, adjust=False).mean()
+        ema3 = ema2.ewm(span=window, adjust=False).mean()
+        trix = 100 * ema3.diff(1) / ema3.shift(1)
+        return trix.to_frame("trix")
+
+    def calculate_ultosc(
+        self, df: pd.DataFrame, window1: int, window2: int, window3: int
+    ) -> pd.DataFrame:
+        low = df["low"]
+        high = df["high"]
+        close = df["close"]
+        close_prev = close.shift(1)
+        true_low = pd.concat([low, close_prev], axis=1).min(axis=1)
+        true_high = pd.concat([high, close_prev], axis=1).max(axis=1)
+        bp = close - true_low
+        tr = true_high - true_low
+        tr_sum1 = tr.rolling(window=window1).sum()
+        tr_sum2 = tr.rolling(window=window2).sum()
+        tr_sum3 = tr.rolling(window=window3).sum()
+        avg1 = bp.rolling(window=window1).sum() / tr_sum1.replace(0, np.nan)
+        avg2 = bp.rolling(window=window2).sum() / tr_sum2.replace(0, np.nan)
+        avg3 = bp.rolling(window=window3).sum() / tr_sum3.replace(0, np.nan)
+        avg1 = avg1.fillna(0)
+        avg2 = avg2.fillna(0)
+        avg3 = avg3.fillna(0)
+        ultosc = 100 * (4 * avg1 + 2 * avg2 + 1 * avg3) / (4 + 2 + 1)
+        return ultosc.to_frame("ultosc")

{akshare_one-0.3.6 → akshare_one-0.3.7}/akshare_one.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akshare-one
-Version: 0.3.6
+Version: 0.3.7
 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,7 +9,7 @@ Keywords: akshare,financial-data,stock-data,quant
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: akshare>=1.17.21
+Requires-Dist: akshare>=1.17.26
 Requires-Dist: cachetools>=5.5.2
 Provides-Extra: talib
 Requires-Dist: ta-lib>=0.6.4; extra == "talib"

{akshare_one-0.3.6 → akshare_one-0.3.7}/akshare_one.egg-info/requires.txt

@@ -1,4 +1,4 @@
-akshare>=1.17.21
+akshare>=1.17.26
 cachetools>=5.5.2
 
 [talib]

{akshare_one-0.3.6 → akshare_one-0.3.7}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "akshare-one"
-version = "0.3.6"
+version = "0.3.7"
 description = "Standardized interface for Chinese financial market data, built on AKShare with unified data formats and simplified APIs"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "akshare>=1.17.21",
+    "akshare>=1.17.26",
     "cachetools>=5.5.2",
 ]
 license = "MIT"

{akshare_one-0.3.6 → akshare_one-0.3.7}/tests/test_indicators.py

@@ -94,12 +94,30 @@ class TestIndicators(unittest.TestCase):
         result = get_stoch(self.df, 14, 3, 3, calculator_type="simple")
         self.assertEqual(len(result), len(self.df))
         self.assertEqual(set(result.columns), {"slow_k", "slow_d"})
+        # Test handling of zero range (high == low)
+        df_zero_range = self.df.copy()
+        df_zero_range["high"] = df_zero_range["low"]
+        result_zero = get_stoch(df_zero_range, 14, 3, 3, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_zero_range))
+        self.assertTrue(
+            not result_zero["slow_k"].isna().all()
+        )  # Should handle zero range
 
     def test_simple_atr(self):
         result = get_atr(self.df, 14, calculator_type="simple")
         self.assertEqual(len(result), len(self.df))
         self.assertTrue("atr" in result.columns)
 
+    def test_simple_willr(self):
+        result = get_willr(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("willr" in result.columns)
+        # Test handling of zero range (high == low)
+        df_zero_range = self.df.copy()
+        df_zero_range["high"] = df_zero_range["low"]
+        result_zero = get_willr(df_zero_range, 14, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_zero_range))
+
     def test_simple_cci(self):
         result = get_cci(self.df, 14, calculator_type="simple")
         self.assertEqual(len(result), len(self.df))
@@ -110,6 +128,17 @@ class TestIndicators(unittest.TestCase):
         self.assertEqual(len(result), len(self.df))
         self.assertTrue("adx" in result.columns)
 
+    def test_simple_ad(self):
+        result = get_ad(self.df, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("ad" in result.columns)
+        # Test handling of zero range (high == low)
+        df_zero_range = self.df.copy()
+        df_zero_range["high"] = df_zero_range["low"]
+        result_zero = get_ad(df_zero_range, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_zero_range))
+        self.assertTrue(not result_zero["ad"].isna().all())  # Should handle zero range
+
     # Explicitly test talib implementation
     @unittest.skipUnless(TALIB_AVAILABLE, "talib not installed")
     def test_talib_sma(self):
@@ -329,3 +358,163 @@ class TestIndicators(unittest.TestCase):
         result = get_ultosc(self.df, 7, 14, 28)
         self.assertEqual(len(result), len(self.df))
         self.assertTrue("ultosc" in result.columns)
+
+    # Additional tests for edge cases in simple implementation
+    def test_simple_bop_edge_case(self):
+        result = get_bop(self.df, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("bop" in result.columns)
+        # Test handling of zero range (high == low)
+        df_zero_range = self.df.copy()
+        df_zero_range["high"] = df_zero_range["low"]
+        result_zero = get_bop(df_zero_range, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_zero_range))
+        self.assertTrue(not result_zero["bop"].isna().all())  # Should handle zero range
+
+    def test_simple_mfi_edge_case(self):
+        result = get_mfi(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("mfi" in result.columns)
+        # Test handling of zero negative money flow
+        df_constant_price = self.df.copy()
+        df_constant_price["close"] = 100  # All prices are the same
+        result_zero = get_mfi(df_constant_price, 14, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_constant_price))
+        self.assertTrue(
+            not result_zero["mfi"].isna().all()
+        )  # Should handle zero negative flow
+
+    def test_simple_dx_edge_case(self):
+        result = get_dx(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("dx" in result.columns)
+        # Test handling of zero DI sum
+        df_flat = self.df.copy()
+        df_flat["high"] = df_flat["low"]  # No directional movement
+        result_zero = get_dx(df_flat, 14, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_flat))
+        self.assertTrue(not result_zero["dx"].isna().all())  # Should handle zero DI sum
+
+    def test_simple_cmo_edge_case(self):
+        result = get_cmo(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("cmo" in result.columns)
+        # Test handling of zero price movement
+        df_flat = self.df.copy()
+        df_flat["close"] = 100  # No price movement
+        result_zero = get_cmo(df_flat, 14, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_flat))
+        self.assertTrue(
+            not result_zero["cmo"].isna().all()
+        )  # Should handle zero movement
+
+    def test_simple_ultosc_edge_case(self):
+        result = get_ultosc(self.df, 7, 14, 28, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("ultosc" in result.columns)
+        # Test handling of zero true range
+        df_flat = self.df.copy()
+        df_flat["high"] = df_flat["low"]  # Zero true range
+        result_zero = get_ultosc(df_flat, 7, 14, 28, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_flat))
+        self.assertTrue(not result_zero["ultosc"].isna().all())  # Should handle zero TR
+
+    def test_simple_sar_edge_case(self):
+        result = get_sar(self.df, 0.02, 0.2, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("sar" in result.columns)
+        # Test handling of flat market
+        df_flat = self.df.copy()
+        df_flat["high"] = df_flat["low"] = df_flat["close"]  # Flat market
+        result_zero = get_sar(df_flat, 0.02, 0.2, calculator_type="simple")
+        self.assertEqual(len(result_zero), len(df_flat))
+        self.assertTrue(
+            not result_zero["sar"].isna().all()
+        )  # Should handle flat market
+
+    # Tests for other simple implementation functions not covered above
+    def test_simple_adosc(self):
+        result = get_adosc(self.df, 3, 10, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("adosc" in result.columns)
+
+    def test_simple_obv(self):
+        result = get_obv(self.df, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("obv" in result.columns)
+
+    def test_simple_mom(self):
+        result = get_mom(self.df, 10, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("mom" in result.columns)
+
+    def test_simple_tsf(self):
+        result = get_tsf(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("tsf" in result.columns)
+
+    def test_simple_apo(self):
+        result = get_apo(self.df, 12, 26, 0, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("apo" in result.columns)
+
+    def test_simple_aroon(self):
+        result = get_aroon(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("aroon_up" in result.columns)
+        self.assertTrue("aroon_down" in result.columns)
+
+    def test_simple_aroonosc(self):
+        result = get_aroonosc(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("aroonosc" in result.columns)
+
+    def test_simple_ppo(self):
+        result = get_ppo(self.df, 12, 26, 0, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("ppo" in result.columns)
+
+    def test_simple_roc(self):
+        result = get_roc(self.df, 10, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("roc" in result.columns)
+
+    def test_simple_rocp(self):
+        result = get_rocp(self.df, 10, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("rocp" in result.columns)
+
+    def test_simple_rocr(self):
+        result = get_rocr(self.df, 10, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("rocr" in result.columns)
+
+    def test_simple_rocr100(self):
+        result = get_rocr100(self.df, 10, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("rocr100" in result.columns)
+
+    def test_simple_trix(self):
+        result = get_trix(self.df, 30, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("trix" in result.columns)
+
+    def test_simple_minus_di(self):
+        result = get_minus_di(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("minus_di" in result.columns)
+
+    def test_simple_minus_dm(self):
+        result = get_minus_dm(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("minus_dm" in result.columns)
+
+    def test_simple_plus_di(self):
+        result = get_plus_di(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("plus_di" in result.columns)
+
+    def test_simple_plus_dm(self):
+        result = get_plus_dm(self.df, 14, calculator_type="simple")
+        self.assertEqual(len(result), len(self.df))
+        self.assertTrue("plus_dm" in result.columns)

akshare_one-0.3.6/akshare_one/modules/indicators/simple.py

@@ -1,230 +0,0 @@
-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")