akshare-one 0.3.9__tar.gz → 0.3.11__tar.gz

{akshare_one-0.3.9 → akshare_one-0.3.11}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: akshare-one
-Version: 0.3.9
+Version: 0.3.11
 Summary: Standardized interface for Chinese financial market data, built on AKShare with unified data formats and simplified APIs
 Keywords: akshare,financial-data,stock-data,quant
 License-Expression: MIT
-Requires-Dist: akshare>=1.17.38
+Requires-Dist: akshare>=1.17.41
 Requires-Dist: cachetools>=5.5.2
 Requires-Dist: ta-lib>=0.6.4 ; extra == 'talib'
 Requires-Python: >=3.10

{akshare_one-0.3.9 → akshare_one-0.3.11}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "akshare-one"
-version = "0.3.9"
+version = "0.3.11"
 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.38",
+    "akshare>=1.17.41",
     "cachetools>=5.5.2",
 ]
 license = "MIT"
@@ -46,5 +46,21 @@ addopts = "-v --cov=akshare_one --cov-report=term-missing"
 [tool.ruff]
 line-length = 88
 
+[tool.ruff.lint]
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+]
+
 [tool.mypy]
 strict = true

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/__init__.py

@@ -14,14 +14,16 @@ Example:
     >>> df = get_realtime_data(symbol="600000")
 """
 
-from typing import Optional, Literal
+from typing import Literal
+
 import pandas as pd
+
 from .modules.financial.factory import FinancialDataFactory
 from .modules.historical.factory import HistoricalDataFactory
-from .modules.realtime.factory import RealtimeDataFactory
 from .modules.info.factory import InfoDataFactory
-from .modules.news.factory import NewsDataFactory
 from .modules.insider.factory import InsiderDataFactory
+from .modules.news.factory import NewsDataFactory
+from .modules.realtime.factory import RealtimeDataFactory
 
 
 def get_basic_info(
@@ -91,7 +93,7 @@ def get_hist_data(
 
 
 def get_realtime_data(
-    symbol: Optional[str] = None,
+    symbol: str | None = None,
     source: Literal["eastmoney", "eastmoney_direct", "xueqiu"] = "eastmoney_direct",
 ) -> pd.DataFrame:
     """Get real-time market quotes

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/eastmoney/client.py

@@ -1,5 +1,6 @@
+from typing import Any
+
 import requests
-from typing import Dict, Any
 
 
 class EastMoneyClient:
@@ -44,7 +45,7 @@ class EastMoneyClient:
 
     def fetch_historical_klines(
         self, symbol: str, klt: str, fqt: str, start_date: str, end_date: str
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         Fetches historical K-line (candlestick) data.
         """
@@ -63,7 +64,7 @@ class EastMoneyClient:
         response.raise_for_status()
         return response.json()  # type: ignore
 
-    def fetch_realtime_quote(self, symbol: str) -> Dict[str, Any]:
+    def fetch_realtime_quote(self, symbol: str) -> dict[str, Any]:
         """
         Fetches real-time quote data for a single stock.
         """
@@ -72,7 +73,9 @@ class EastMoneyClient:
         params = {
             "invt": "2",
             "fltt": "2",
-            "fields": "f43,f57,f58,f169,f170,f46,f60,f44,f51,f168,f47,f164,f163,f116,f60,f45,f52,f50,f48,f167,f117,f71,f161,f49,f530",
+            "fields": (
+                "f43,f57,f58,f169,f170,f46,f60,f44,f51,f168,f47,f164,f163,f116,f60,f45,f52,f50,f48,f167,f117,f71,f161,f49,f530"
+            ),
             "secid": secid,
         }
         response = self.session.get(url, params=params)

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/eastmoney/utils.py

@@ -1,8 +1,9 @@
+from typing import Any
+
 import pandas as pd
-from typing import Dict, Any
 
 
-def parse_kline_data(data: Dict[str, Any]) -> pd.DataFrame:
+def parse_kline_data(data: dict[str, Any]) -> pd.DataFrame:
     """
     Parses K-line data from the API response into a pandas DataFrame.
     """
@@ -35,7 +36,7 @@ def parse_kline_data(data: Dict[str, Any]) -> pd.DataFrame:
     return df
 
 
-def parse_realtime_data(data: Dict[str, Any]) -> pd.DataFrame:
+def parse_realtime_data(data: dict[str, Any]) -> pd.DataFrame:
     """
     Parses real-time quote data from the API response into a pandas DataFrame.
     """

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/indicators.py

@@ -38,6 +38,7 @@ Provides common technical analysis indicators like:
 """
 
 import pandas as pd
+
 from .modules.indicators.factory import IndicatorFactory
 
 

akshare_one-0.3.11/src/akshare_one/modules/cache.py

@@ -0,0 +1,45 @@
+import os
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from cachetools import TTLCache, cached
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+# 缓存配置
+CACHE_CONFIG: dict[str, TTLCache[Any, Any]] = {
+    "hist_data_cache": TTLCache(maxsize=1000, ttl=3600),  # 历史数据缓存1小时
+    "realtime_cache": TTLCache(maxsize=500, ttl=60),  # 实时数据缓存1分钟
+    "news_cache": TTLCache(maxsize=500, ttl=3600),  # 新闻数据缓存1小时
+    "financial_cache": TTLCache(maxsize=500, ttl=86400),  # 财务数据缓存24小时
+    "info_cache": TTLCache(maxsize=500, ttl=86400),  # 信息数据缓存24小时
+}
+
+
+def cache(cache_key: str, key: Callable[..., Any] | None = None) -> Callable[[F], F]:
+    def decorator(func: F) -> F:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            cache_enabled = os.getenv("AKSHARE_ONE_CACHE_ENABLED", "true").lower() in (
+                "1",
+                "true",
+                "yes",
+                "on",
+            )
+
+            if cache_enabled:
+                if cache_key not in CACHE_CONFIG:
+                    raise KeyError(
+                        f"Cache configuration '{cache_key}' not found. "
+                        f"Available keys: {list(CACHE_CONFIG.keys())}"
+                    )
+                if key is not None:
+                    return cached(CACHE_CONFIG[cache_key], key=key)(func)(
+                        *args, **kwargs
+                    )
+                else:
+                    return cached(CACHE_CONFIG[cache_key])(func)(*args, **kwargs)
+            return func(*args, **kwargs)
+
+        return wrapper  # type: ignore
+
+    return decorator

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/financial/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/financial/eastmoney_direct.py

@@ -2,6 +2,7 @@ import pandas as pd
 import requests
 
 from akshare_one.modules.cache import cache
+
 from .base import FinancialDataProvider
 
 
@@ -49,7 +50,7 @@ class EastMoneyDirectFinancialReport(FinancialDataProvider):
 
     @cache(
         "financial_cache",
-        key=lambda self, symbol=None: f"eastmoney_financial_metrics_{self.symbol}",
+        key=lambda self: f"eastmoney_financial_metrics_{self.symbol}",
     )
     def get_financial_metrics(self) -> pd.DataFrame:
         """获取三大财务报表关键指标"""

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/financial/sina.py

@@ -1,5 +1,5 @@
+import akshare as ak  # type: ignore
 import pandas as pd
-import akshare as ak # type: ignore
 
 from ..cache import cache
 from .base import FinancialDataProvider
@@ -18,9 +18,7 @@ class SinaFinancialReport(FinancialDataProvider):
             f"sh{symbol}" if not symbol.startswith(("sh", "sz", "bj")) else symbol
         )
 
-    @cache(
-        "financial_cache", key=lambda self, symbol=None: f"sina_balance_{self.symbol}"
-    )
+    @cache("financial_cache", key=lambda self: f"sina_balance_{self.symbol}")
     def get_balance_sheet(self) -> pd.DataFrame:
         """获取资产负债表数据
 
@@ -33,9 +31,7 @@ class SinaFinancialReport(FinancialDataProvider):
         raw_df = ak.stock_financial_report_sina(stock=self.stock, symbol="资产负债表")
         return self._clean_balance_data(raw_df)
 
-    @cache(
-        "financial_cache", key=lambda self, symbol=None: f"sina_income_{self.symbol}"
-    )
+    @cache("financial_cache", key=lambda self: f"sina_income_{self.symbol}")
     def get_income_statement(self) -> pd.DataFrame:
         """获取利润表数据
 
@@ -48,7 +44,7 @@ class SinaFinancialReport(FinancialDataProvider):
         raw_df = ak.stock_financial_report_sina(stock=self.stock, symbol="利润表")
         return self._clean_income_data(raw_df)
 
-    @cache("financial_cache", key=lambda self, symbol=None: f"sina_cash_{self.symbol}")
+    @cache("financial_cache", key=lambda self: f"sina_cash_{self.symbol}")
     def get_cash_flow(self) -> pd.DataFrame:
         """获取现金流量表数据
 
@@ -81,8 +77,10 @@ class SinaFinancialReport(FinancialDataProvider):
         column_mapping = {
             "币种": "currency",
             "经营活动产生的现金流量净额": "net_cash_flow_from_operations",
-            "购建固定资产、无形资产和其他长期资产支付的现金": "capital_expenditure",
-            "取得子公司及其他营业单位支付的现金净额": "business_acquisitions_and_disposals",
+            "购建固定资产、无形资产和其他长期资产支付的现金": ("capital_expenditure"),
+            "取得子公司及其他营业单位支付的现金净额": (
+                "business_acquisitions_and_disposals"
+            ),
             "投资活动产生的现金流量净额": "net_cash_flow_from_investing",
             "取得借款收到的现金": "issuance_or_repayment_of_debt_securities",
             "吸收投资收到的现金": "issuance_or_purchase_of_equity_shares",
@@ -101,7 +99,9 @@ class SinaFinancialReport(FinancialDataProvider):
             "处置固定资产、无形资产收回的现金": "cash_from_asset_sales",
             "投资活动现金流入小计": "total_cash_inflow_from_investing",
             "投资活动现金流出小计": "total_cash_outflow_from_investing",
-            "分配股利、利润或偿付利息所支付的现金": "cash_paid_for_dividends_and_interest",
+            "分配股利、利润或偿付利息所支付的现金": (
+                "cash_paid_for_dividends_and_interest"
+            ),
             "偿还债务支付的现金": "cash_paid_for_debt_repayment",
             "筹资活动现金流入小计": "total_cash_inflow_from_financing",
             "筹资活动现金流出小计": "total_cash_outflow_from_financing",

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/historical/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 
@@ -25,7 +26,7 @@ class HistoricalDataProvider(ABC):
             pd.to_datetime(self.start_date)
             pd.to_datetime(self.end_date)
         except ValueError:
-            raise ValueError("Invalid date format. Please use YYYY-MM-DD.")
+            raise ValueError("Invalid date format. Please use YYYY-MM-DD.") from None
 
     @classmethod
     def get_supported_intervals(cls) -> list[str]:

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/historical/eastmoney.py

@@ -1,7 +1,8 @@
-from .base import HistoricalDataProvider
-import akshare as ak # type: ignore
+import akshare as ak  # type: ignore
 import pandas as pd
+
 from ..cache import cache
+from .base import HistoricalDataProvider
 
 
 class EastMoneyHistorical(HistoricalDataProvider):
@@ -9,7 +10,9 @@ class EastMoneyHistorical(HistoricalDataProvider):
 
     @cache(
         "hist_data_cache",
-        key=lambda self: f"eastmoney_hist_{self.symbol}_{self.interval}_{self.interval_multiplier}_{self.adjust}",
+        key=lambda self: (
+            f"eastmoney_hist_{self.symbol}_{self.interval}_{self.interval_multiplier}_{self.adjust}"
+        ),
     )
     def get_hist_data(self) -> pd.DataFrame:
         """Fetches EastMoney historical market data
@@ -34,7 +37,7 @@ class EastMoneyHistorical(HistoricalDataProvider):
 
             return df
         except Exception as e:
-            raise ValueError(f"Failed to fetch historical data: {str(e)}")
+            raise ValueError(f"Failed to fetch historical data: {str(e)}") from e
 
     def _get_intraday_data(self) -> pd.DataFrame:
         """Fetches intraday data at minute or hour intervals"""

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/historical/eastmoney_direct.py

@@ -1,10 +1,13 @@
-import pandas as pd
 from typing import Any
-from .base import HistoricalDataProvider
-from ..cache import cache
+
+import pandas as pd
+
 from akshare_one.eastmoney.client import EastMoneyClient
 from akshare_one.eastmoney.utils import parse_kline_data, resample_historical_data
 
+from ..cache import cache
+from .base import HistoricalDataProvider
+
 
 class EastMoneyDirectHistorical(HistoricalDataProvider):
     """Direct implementation for EastMoney historical stock data API"""
@@ -15,7 +18,9 @@ class EastMoneyDirectHistorical(HistoricalDataProvider):
 
     @cache(
         "hist_data_cache",
-        key=lambda self: f"eastmoney_direct_hist_{self.symbol}_{self.interval}_{self.interval_multiplier}_{self.adjust}",
+        key=lambda self: (
+            f"eastmoney_direct_hist_{self.symbol}_{self.interval}_{self.interval_multiplier}_{self.adjust}"
+        ),
     )
     def get_hist_data(self) -> pd.DataFrame:
         """Fetches EastMoney historical market data directly from API"""
@@ -46,7 +51,9 @@ class EastMoneyDirectHistorical(HistoricalDataProvider):
             return df
 
         except Exception as e:
-            raise ValueError(f"Failed to fetch historical data for {self.symbol}: {e}")
+            raise ValueError(
+                f"Failed to fetch historical data for {self.symbol}: {e}"
+            ) from e
 
     def _get_kline_type(self) -> str:
         """Get K-line type based on interval."""

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/historical/sina.py

@@ -1,16 +1,18 @@
-from cachetools import cached
-from .base import HistoricalDataProvider
 import akshare as ak  # type: ignore
 import pandas as pd
-from ..cache import CACHE_CONFIG
+
+from ..cache import cache
+from .base import HistoricalDataProvider
 
 
 class SinaHistorical(HistoricalDataProvider):
     """Adapter for Sina historical stock data API"""
 
-    @cached(
-        cache=CACHE_CONFIG["hist_data_cache"],
-        key=lambda self: f"sina_hist_{self.symbol}_{self.interval}_{self.interval_multiplier}_{self.adjust}",
+    @cache(
+        "hist_data_cache",
+        key=lambda self: (
+            f"sina_hist_{self.symbol}_{self.interval}_{self.interval_multiplier}_{self.adjust}"
+        ),
     )
     def get_hist_data(self) -> pd.DataFrame:
         """Fetches Sina historical market data
@@ -43,7 +45,7 @@ class SinaHistorical(HistoricalDataProvider):
 
             return df
         except Exception as e:
-            raise ValueError(f"Failed to fetch historical data: {str(e)}")
+            raise ValueError(f"Failed to fetch historical data: {str(e)}") from e
 
     def _get_minute_data(self, stock: str) -> pd.DataFrame:
         """Fetches minute level data"""
@@ -114,8 +116,9 @@ class SinaHistorical(HistoricalDataProvider):
             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_data(raw_df, self.interval, self.interval_multiplier)
+                raw_df = self._resample_data(
+                    raw_df, self.interval, self.interval_multiplier
+                )
         else:
             raw_df = ak.stock_zh_b_daily(
                 symbol=stock,

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/indicators/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/indicators/simple.py

@@ -1,5 +1,6 @@
-import pandas as pd
 import numpy as np
+import pandas as pd
+
 from .base import BaseIndicatorCalculator
 
 
@@ -13,7 +14,8 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
             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."
+                f"Unsupported ma_type: {ma_type} in simple calculator. "
+                f"Only SMA (0) and EMA (1) are supported."
             )
 
     def _wilder_smooth(self, series: pd.Series, window: int) -> pd.Series:
@@ -358,8 +360,8 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
         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")
+        trix = 100 * ema3.diff(1) / ema3.shift(1)  # type: ignore
+        return pd.DataFrame({"trix": trix}, index=df.index)
 
     def calculate_ultosc(
         self, df: pd.DataFrame, window1: int, window2: int, window3: int
@@ -381,5 +383,5 @@ class SimpleIndicatorCalculator(BaseIndicatorCalculator):
         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")
+        ultosc = 100 * (4 * avg1 + 2 * avg2 + avg3) / (4 + 2 + 1)
+        return pd.DataFrame({"ultosc": ultosc}, index=df.index)

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/indicators/talib.py

@@ -1,30 +1,46 @@
-import talib # type: ignore
+import numpy as np
 import pandas as pd
+import talib
+from talib import MA_Type  # type: ignore
+
 from .base import BaseIndicatorCalculator
 
+# Create a mapping from integer values to MA_Type enum values
+MA_TYPE_MAPPING = {
+    0: MA_Type.SMA,
+    1: MA_Type.EMA,
+    2: MA_Type.WMA,
+    3: MA_Type.DEMA,
+    4: MA_Type.TEMA,
+    5: MA_Type.TRIMA,
+    6: MA_Type.KAMA,
+    7: MA_Type.MAMA,
+    8: MA_Type.T3,
+}
+
 
 class TalibIndicatorCalculator(BaseIndicatorCalculator):
     """TA-Lib based indicator implementations"""
 
     def calculate_sma(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
-        close = df["close"].values
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         macd, signal_line, histogram = talib.MACD(
             close, fastperiod=fast, slowperiod=slow, signalperiod=signal
         )
@@ -36,9 +52,9 @@ class TalibIndicatorCalculator(BaseIndicatorCalculator):
     def calculate_bollinger_bands(
         self, df: pd.DataFrame, window: int, std: int
     ) -> pd.DataFrame:
-        close = df["close"].values
+        close = df["close"].values.astype(np.float64)
         upper, middle, lower = talib.BBANDS(
-            close, timeperiod=window, nbdevup=std, nbdevdn=std, matype=talib.MA_Type.SMA
+            close, timeperiod=window, nbdevup=std, nbdevdn=std, matype=MA_Type.SMA
         )
         return pd.DataFrame(
             {"upper_band": upper, "middle_band": middle, "lower_band": lower},
@@ -48,210 +64,214 @@ class TalibIndicatorCalculator(BaseIndicatorCalculator):
     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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         slow_k, slow_d = talib.STOCH(
             high,
             low,
             close,
             fastk_period=window,
             slowk_period=smooth_k,
-            slowk_matype=talib.MA_Type.SMA,
+            slowk_matype=MA_Type.SMA,
             slowd_period=smooth_d,
-            slowd_matype=talib.MA_Type.SMA,
+            slowd_matype=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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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)
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
+        volume = df["volume"].values.astype(np.float64)
         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)
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
+        volume = df["volume"].values.astype(np.float64)
         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)
+        close = df["close"].values.astype(np.float64)
+        volume = df["volume"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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: int
     ) -> pd.DataFrame:
-        close = df["close"].values
+        close = df["close"].values.astype(np.float64)
+        # Convert integer to MA_Type enum value
+        ma_type_enum = MA_TYPE_MAPPING.get(ma_type, MA_Type.SMA)
         apo = talib.APO(
-            close, fastperiod=fast_period, slowperiod=slow_period, matype=ma_type
+            close, fastperiod=fast_period, slowperiod=slow_period, matype=ma_type_enum
         )
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
         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
+        open_ = df["open"].values.astype(np.float64)
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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)
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
+        volume = df["volume"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
         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: int
     ) -> pd.DataFrame:
-        close = df["close"].values
+        close = df["close"].values.astype(np.float64)
+        # Convert integer to MA_Type enum value
+        ma_type_enum = MA_TYPE_MAPPING.get(ma_type, MA_Type.SMA)
         ppo = talib.PPO(
-            close, fastperiod=fast_period, slowperiod=slow_period, matype=ma_type
+            close, fastperiod=fast_period, slowperiod=slow_period, matype=ma_type_enum
         )
         return pd.DataFrame({"ppo": ppo}, index=df.index)
 
     def calculate_roc(self, df: pd.DataFrame, window: int) -> pd.DataFrame:
-        close = df["close"].values
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        close = df["close"].values.astype(np.float64)
         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
+        high = df["high"].values.astype(np.float64)
+        low = df["low"].values.astype(np.float64)
+        close = df["close"].values.astype(np.float64)
         ultosc = talib.ULTOSC(
             high,
             low,

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/info/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/info/eastmoney.py

@@ -1,5 +1,5 @@
+import akshare as ak  # type: ignore
 import pandas as pd
-import akshare as ak # type: ignore
 
 from ..cache import cache
 from .base import InfoDataProvider
@@ -20,7 +20,7 @@ class EastmoneyInfo(InfoDataProvider):
 
     @cache(
         "info_cache",
-        key=lambda self, symbol=None: f"eastmoney_{symbol}",
+        key=lambda self: f"eastmoney_{self.symbol}",
     )
     def get_basic_info(self) -> pd.DataFrame:
         """获取东方财富个股信息"""

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/insider/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/insider/xueqiu.py

@@ -1,8 +1,9 @@
+import akshare as ak  # type: ignore
 import pandas as pd
-import akshare as ak # type: ignore
-from .base import InsiderDataProvider
-from ..utils import convert_xieqiu_symbol
+
 from ..cache import cache
+from ..utils import convert_xieqiu_symbol
+from .base import InsiderDataProvider
 
 
 class XueQiuInsider(InsiderDataProvider):
@@ -10,7 +11,7 @@ class XueQiuInsider(InsiderDataProvider):
 
     @cache(
         "financial_cache",
-        key=lambda self, symbol=None: f"xueqiu_insider_{symbol if symbol else 'all'}",
+        key=lambda self: f"xueqiu_insider_{self.symbol if self.symbol else 'all'}",
     )
     def get_inner_trade_data(self) -> pd.DataFrame:
         """获取雪球内部交易数据

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/news/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/realtime/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+
 import pandas as pd
 
 

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/realtime/eastmoney.py

@@ -1,5 +1,5 @@
-import pandas as pd
 import akshare as ak  # type: ignore
+import pandas as pd
 
 from ..cache import cache
 from .base import RealtimeDataProvider
@@ -8,7 +8,7 @@ from .base import RealtimeDataProvider
 class EastmoneyRealtime(RealtimeDataProvider):
     @cache(
         "realtime_cache",
-        key=lambda self, symbol=None: f"eastmoney_{symbol if symbol else 'all'}",
+        key=lambda self: f"eastmoney_{self.symbol if self.symbol else 'all'}",
     )
     def get_current_data(self) -> pd.DataFrame:
         """获取沪深京A股实时行情数据"""

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/realtime/eastmoney_direct.py

@@ -1,9 +1,11 @@
 import pandas as pd
-from .base import RealtimeDataProvider
-from ..cache import cache
+
 from akshare_one.eastmoney.client import EastMoneyClient
 from akshare_one.eastmoney.utils import parse_realtime_data
 
+from ..cache import cache
+from .base import RealtimeDataProvider
+
 
 class EastMoneyDirectRealtime(RealtimeDataProvider):
     """Direct implementation for EastMoney realtime stock data API"""
@@ -33,4 +35,6 @@ class EastMoneyDirectRealtime(RealtimeDataProvider):
             return df
 
         except Exception as e:
-            raise ValueError(f"Failed to get real-time data for {self.symbol}: {e}")
+            raise ValueError(
+                f"Failed to get real-time data for {self.symbol}: {e}"
+            ) from e

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/realtime/factory.py

@@ -1,7 +1,7 @@
-from .eastmoney import EastmoneyRealtime
-from .xueqiu import XueQiuRealtime
 from .base import RealtimeDataProvider
+from .eastmoney import EastmoneyRealtime
 from .eastmoney_direct import EastMoneyDirectRealtime
+from .xueqiu import XueQiuRealtime
 
 
 class RealtimeDataFactory:
@@ -16,7 +16,9 @@ class RealtimeDataFactory:
     }
 
     @classmethod
-    def get_provider(cls, provider_name: str, **kwargs: object) -> "RealtimeDataProvider":
+    def get_provider(
+        cls, provider_name: str, **kwargs: object
+    ) -> "RealtimeDataProvider":
         """
         Get a realtime data provider by name
 
@@ -38,26 +40,8 @@ class RealtimeDataFactory:
         symbol = kwargs.get("symbol", "")
         if not isinstance(symbol, str):
             raise ValueError("symbol must be a string")
-        
-        return provider_class(symbol=symbol)
-        """
-        Get a realtime data provider by name
-
-        Args:
-            provider_name: Name of the provider (e.g., 'eastmoney')
-            **kwargs: Additional arguments to pass to the provider's constructor
 
-        Returns:
-            RealtimeDataProvider: An instance of the requested provider
-
-        Raises:
-            ValueError: If the requested provider is not found
-        """
-        provider_class = cls._providers.get(provider_name.lower())
-        if not provider_class:
-            raise ValueError(f"Unknown realtime data provider: {provider_name}")
-
-        return provider_class(**kwargs)
+        return provider_class(symbol=symbol)
 
     @classmethod
     def register_provider(cls, name: str, provider_class: type) -> None:

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/realtime/xueqiu.py

@@ -1,14 +1,15 @@
-import pandas as pd
 import akshare as ak  # type: ignore
-from ..utils import convert_xieqiu_symbol
+import pandas as pd
+
 from ..cache import cache
+from ..utils import convert_xieqiu_symbol
 from .base import RealtimeDataProvider
 
 
 class XueQiuRealtime(RealtimeDataProvider):
     @cache(
         "realtime_cache",
-        key=lambda self, symbol=None: f"xueqiu_{symbol}",
+        key=lambda self: f"xueqiu_{self.symbol}",
     )
     def get_current_data(self) -> pd.DataFrame:
         """获取雪球实时行情数据

akshare_one-0.3.9/src/akshare_one/modules/cache.py

@@ -1,30 +0,0 @@
-from cachetools import TTLCache, cached
-import os
-from typing import Any, Callable, TypeVar, Optional
-
-F = TypeVar('F', bound=Callable[..., Any])
-
-# 缓存配置
-CACHE_CONFIG: dict[str, TTLCache[Any, Any]] = {
-    "hist_data_cache": TTLCache(maxsize=1000, ttl=3600),  # 历史数据缓存1小时
-    "realtime_cache": TTLCache(maxsize=500, ttl=60),  # 实时数据缓存1分钟
-    "news_cache": TTLCache(maxsize=500, ttl=3600),  # 新闻数据缓存1小时
-    "financial_cache": TTLCache(maxsize=500, ttl=86400),  # 财务数据缓存24小时
-    "info_cache": TTLCache(maxsize=500, ttl=86400),  # 信息数据缓存24小时
-}
-
-
-def cache(cache_key: str, key: Optional[Callable[..., Any]] = None) -> Callable[[F], F]:
-    cache_enabled = os.getenv("AKSHARE_ONE_CACHE_ENABLED", "true").lower() in (
-        "1",
-        "true",
-        "yes",
-        "on",
-    )
-
-    def decorator(func: F) -> F:
-        if cache_enabled:
-            return cached(CACHE_CONFIG[cache_key], key=key)(func)  # type: ignore
-        return func
-
-    return decorator

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/financial/factory.py

@@ -1,6 +1,6 @@
+from .base import FinancialDataProvider
 from .eastmoney_direct import EastMoneyDirectFinancialReport
 from .sina import SinaFinancialReport
-from .base import FinancialDataProvider
 
 
 class FinancialDataFactory:

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/info/factory.py

@@ -1,5 +1,5 @@
-from .eastmoney import EastmoneyInfo
 from .base import InfoDataProvider
+from .eastmoney import EastmoneyInfo
 
 
 class InfoDataFactory:

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/insider/factory.py

@@ -1,5 +1,5 @@
-from .xueqiu import XueQiuInsider
 from .base import InsiderDataProvider
+from .xueqiu import XueQiuInsider
 
 
 class InsiderDataFactory:

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/news/eastmoney.py

@@ -1,5 +1,5 @@
-import pandas as pd
 import akshare as ak  # type: ignore
+import pandas as pd
 
 from ..cache import cache
 from .base import NewsDataProvider

{akshare_one-0.3.9 → akshare_one-0.3.11}/src/akshare_one/modules/news/factory.py

@@ -1,5 +1,5 @@
-from .eastmoney import EastMoneyNews
 from .base import NewsDataProvider
+from .eastmoney import EastMoneyNews
 
 
 class NewsDataFactory: