akshare-one 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

akshare_one/modules/indicators/base.py

@@ -1,158 +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
+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

@@ -1,33 +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()
+from .base import BaseIndicatorCalculator
+from .simple import SimpleIndicatorCalculator
+
+_calculators = {
+    "simple": SimpleIndicatorCalculator,
+}
+TALIB_AVAILABLE = False
+try:
+    from .talib import TalibIndicatorCalculator
+
+    _calculators["talib"] = TalibIndicatorCalculator  # type: ignore
+    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

@@ -220,13 +220,14 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
     def calculate_tsf(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
         close = df["close"]
 
-        def linear_reg_forecast(y):
+        def linear_reg_forecast(y: np.ndarray) -> float:
             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)
+            result = a + b * len(y)
+            return float(result)
 
         tsf = close.rolling(window=window, min_periods=window).apply(
             linear_reg_forecast, raw=True
@@ -267,8 +268,8 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
 
     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()
+        sum_up = close_diff.where(close_diff > 0, 0).rolling(window=window).sum()  # type: ignore
+        sum_down = -close_diff.where(close_diff < 0, 0).rolling(window=window).sum()  # type: ignore
         cmo = 100 * (sum_up - sum_down) / (sum_up + sum_down).replace(0, np.nan)
         cmo = cmo.fillna(0)
         return cmo.to_frame("cmo")
@@ -284,8 +285,8 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
         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 = money_flow.where(price_diff > 0, 0)  # type: ignore
+        negative_mf = money_flow.where(price_diff < 0, 0)  # type: ignore
         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)
@@ -304,7 +305,7 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
         low = df["low"]
         up_move = high.diff()
         down_move = -low.diff()
-        minus_dm = down_move.where((down_move > up_move) & (down_move > 0), 0)
+        minus_dm = down_move.where((down_move > up_move) & (down_move > 0), 0)  # type: ignore
         smoothed_minus_dm = self._wilder_smooth(minus_dm, window)
         return smoothed_minus_dm.to_frame("minus_dm")
 
@@ -319,7 +320,7 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
         low = df["low"]
         up_move = high.diff()
         down_move = -low.diff()
-        plus_dm = up_move.where((up_move > down_move) & (up_move > 0), 0)
+        plus_dm = up_move.where((up_move > down_move) & (up_move > 0), 0)  # type: ignore
         smoothed_plus_dm = self._wilder_smooth(plus_dm, window)
         return smoothed_plus_dm.to_frame("plus_dm")