panda-data 0.1.0__py3-none-any.whl

panda_data/__init__.py

@@ -0,0 +1,68 @@
+"""panda_data SDK public interface."""
+
+from .client import get_client, get_factory
+from .readers import (
+    financial_and_factors_reader,
+    future_reader,
+    market_reader,
+    market_reference_reader,
+    trading_tools_reader,
+    init_token
+)
+
+init_token = init_token.init_token
+
+# market
+get_market_data = market_reader.get_market_data
+get_market_min_data = market_reader.get_market_min_data
+get_future_tick = market_reader.get_future_tick
+get_hk_daily = market_reader.get_hk_daily
+get_us_daily = market_reader.get_us_daily
+get_hk_transaction = market_reader.get_hk_transaction
+
+# market_reference
+get_stock_detail = market_reference_reader.get_stock_detail
+get_index_detail = market_reference_reader.get_index_detail
+get_concept_list = market_reference_reader.get_concept_list
+get_concept_constituents = market_reference_reader.get_concept_constituents
+get_industry_detail = market_reference_reader.get_industry_detail
+get_industry_constituents = market_reference_reader.get_industry_constituents
+get_stock_industry = market_reference_reader.get_stock_industry
+get_index_indicator = market_reference_reader.get_index_indicator
+get_index_weights = market_reference_reader.get_index_weights
+get_lhb_list = market_reference_reader.get_lhb_list
+get_lhb_detail = market_reference_reader.get_lhb_detail
+get_repurchase = market_reference_reader.get_repurchase
+get_margin = market_reference_reader.get_margin
+get_hsgt_hold = market_reference_reader.get_hsgt_hold
+get_investor_activity = market_reference_reader.get_investor_activity
+get_restricted_list = market_reference_reader.get_restricted_list
+get_holder_count = market_reference_reader.get_holder_count
+get_top_holders = market_reference_reader.get_top_holders
+get_block_trade = market_reference_reader.get_block_trade
+get_share_float = market_reference_reader.get_share_float
+
+# financial_and_factors
+get_fina_forecast = financial_and_factors_reader.get_fina_forecast
+get_fina_performance = financial_and_factors_reader.get_fina_performance
+get_fina_reports = financial_and_factors_reader.get_fina_reports
+get_financial_statement = financial_and_factors_reader.get_financial_statement
+get_financial_statement_daily = financial_and_factors_reader.get_financial_statement_daily
+get_audit_opinion = financial_and_factors_reader.get_audit_opinion
+get_factor = financial_and_factors_reader.get_factor
+get_adj_factor = financial_and_factors_reader.get_adj_factor
+
+# future
+get_future_detail = future_reader.get_future_detail
+get_future_market_post = future_reader.get_future_market_post
+get_future_dominant = future_reader.get_future_dominant
+
+# trading_tools
+get_trade_cal = trading_tools_reader.get_trade_cal
+get_prev_trade_date = trading_tools_reader.get_prev_trade_date
+get_last_trade_date = trading_tools_reader.get_last_trade_date
+get_stock_status_change = trading_tools_reader.get_stock_status_change
+get_trade_list = trading_tools_reader.get_trade_list
+
+
+__all__ = [name for name in globals().keys() if name.startswith('get_')] + ['init_token', 'get_client', 'get_factory']

panda_data/client.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from threading import Lock
+from typing import Any, Dict, Iterable, Optional, Type, TypeVar
+from urllib.parse import urlparse
+
+import pandas as pd
+
+
+# 模块级函数，用于多进程处理（必须定义在类外部）
+def _build_dataframe_chunk(chunk_data):
+    """在子进程中构建 DataFrame（模块级函数，可被多进程序列化）"""
+    return pd.DataFrame(chunk_data)
+
+
+from panda_data.config import get_config
+from panda_data.exceptions import ServiceError
+from panda_data.transport.http import (
+    HTTPClient,
+    HTTPClientConfig,
+)
+from panda_data.utils.common_utils import find_project_root
+
+
+@dataclass(frozen=True)
+class ClientConfig:
+    base_url: str  # HTTP base URL, 例如: "http://localhost:8080"
+    username: str = field(default="")
+    password: str = field(default="")
+    timeout: float = 30.0
+    retry: int = 3
+    verify_ssl: bool = True
+    proxy_type: Optional[str] = None
+    proxy_host: Optional[str] = None
+    proxy_port: Optional[int] = None
+    proxy_username: Optional[str] = None
+    proxy_password: Optional[str] = None
+    use_gzip: bool = False
+    data_field: Iterable[str] | None = field(default_factory=lambda: ("data",))
+    abnormal_endpoint: str = field(default="/abnormal")
+
+
+def _extract_nested(data: Any, path: Optional[Iterable[str]]) -> Any:
+    """Utility to extract a nested value from a dictionary-like payload."""
+    if data is None or path is None:
+        return data
+
+    # 如果 data 是列表，说明可能是流式响应直接返回的数据列表
+    # 这种情况下，直接返回列表，不进行嵌套提取
+    if isinstance(data, list):
+        return data
+
+    # 确保 current 是字典类型
+    if not isinstance(data, dict):
+        # 如果不是字典也不是列表，可能是其他类型，直接返回
+        return data
+
+    current = data
+    # 检查错误码（只有当 current 是字典时才检查）
+    if isinstance(current, dict):
+        code = current.get("code")
+        if code is not None and code != 200 and code != '200':
+            raise ServiceError(f"服务返回错误:[错误码 {code} ：{current.get('message', '未知错误')}]")
+
+    for key in path:
+        if not isinstance(current, dict):
+            return None
+        current = current.get(key)
+        if current is None:
+            return None
+    return current
+
+
+class PandaServiceClient:
+    """Client responsible for communicating with the Java service via HTTP."""
+
+    def __init__(self, config: ClientConfig) -> None:
+        self._config = config
+        http_config = HTTPClientConfig(
+            base_url=config.base_url,
+            username=config.username,
+            password=config.password,
+            timeout=config.timeout,
+            max_retries=config.retry,
+            verify_ssl=config.verify_ssl,
+            proxy_type=config.proxy_type,
+            proxy_host=config.proxy_host,
+            proxy_port=config.proxy_port,
+            proxy_username=config.proxy_username,
+            proxy_password=config.proxy_password,
+            use_gzip=config.use_gzip,
+        )
+        self._http_client = HTTPClient(http_config)
+
+    @property
+    def config(self) -> ClientConfig:
+        return self._config
+
+    def request(
+            self,
+            *,
+            endpoint: str,
+            payload: Optional[Dict[str, Any]] = None,
+            method: str = "POST",
+            params: Optional[Dict[str, Any]] = None,
+            headers: Optional[Dict[str, str]] = None,
+            data_path: Optional[Iterable[str]] = None,
+    ) -> Any:
+        result = self._http_client.request(
+            method=method,
+            endpoint=endpoint,
+            payload=payload,
+            params=params,
+            headers=headers,
+        )
+        data = _extract_nested(result, data_path or self._config.data_field)
+        return data
+
+    def fetch_dataframe(
+            self,
+            *,
+            endpoint: str,
+            payload: Optional[Dict[str, Any]] = None,
+            method: str = "POST",
+            params: Optional[Dict[str, Any]] = None,
+            headers: Optional[Dict[str, str]] = None,
+            data_path: Optional[Iterable[str]] = None,
+    ) -> pd.DataFrame:
+        data = self.request(
+            endpoint=endpoint,
+            payload=payload,
+            method=method,
+            params=params,
+            headers=headers,
+            data_path=data_path,
+        )
+
+        if data is None:
+            return pd.DataFrame()
+
+        # 检查是否直接是 DataFrame（Parquet 返回的情况，经过 _extract_nested 后）
+        if isinstance(data, pd.DataFrame):
+            return data
+
+        # 检查是否是 Parquet 格式返回的 DataFrame（特殊标记）
+        if isinstance(data, dict) and "__dataframe__" in data:
+            return data["__dataframe__"]
+
+        if isinstance(data, dict):
+            # 如果数据是字典，检查是否有 'data' 字段
+            if 'data' in data:
+                # 检查 data 字段是否是 DataFrame（Parquet 返回的情况）
+                if isinstance(data['data'], pd.DataFrame):
+                    return data['data']
+                elif isinstance(data['data'], list):
+                    # 如果 data 字段是列表，直接使用它
+                    data_list = data['data']
+                else:
+                    # 其他类型，转换为列表
+                    data_list = [data['data']]
+            else:
+                # 否则将整个字典作为一行
+                data_list = [data]
+        elif isinstance(data, (list, tuple)):
+            data_list = data
+        else:
+            raise ServiceError(
+                f"Unexpected payload format returned by the service. Type: {type(data)}, Value: {str(data)[:200]}")
+
+        # 对于大数据量，使用分块处理以避免内存峰值和提升性能
+        if len(data_list) > 100000:  # 超过 10 万条记录时使用分块处理
+            total_rows = len(data_list)
+            chunk_size = 100000  # 增大块大小到 10 万条，减少合并次数
+
+            # 对于超大数据量，使用优化的单进程分块处理
+            # 注意：多进程的数据序列化开销很大，对于 Python 对象列表，单进程可能更快
+            # 如果未来需要多进程，建议使用共享内存或 Arrow 格式
+            chunks = []
+            for i in range(0, total_rows, chunk_size):
+                chunk_end = min(i + chunk_size, total_rows)
+                chunk = data_list[i:chunk_end]
+                df_chunk = pd.DataFrame(chunk)
+                chunks.append(df_chunk)
+            if chunks:
+                df = pd.concat(chunks, ignore_index=True)
+                del chunks
+                import gc
+                gc.collect()
+            else:
+                df = pd.DataFrame()
+        else:
+            df = pd.DataFrame(data_list)
+        return df
+
+    def close(self) -> None:
+        self._http_client.close()
+
+
+ReaderT = TypeVar("ReaderT")
+
+
+class ClientFactory:
+    """Factory responsible for creating readers bound to a shared client instance."""
+
+    def __init__(self, client: PandaServiceClient) -> None:
+        self._client = client
+        self._instances: Dict[Type[Any], Any] = {}
+        self._lock = Lock()
+
+    @property
+    def client(self) -> PandaServiceClient:
+        return self._client
+
+    def get_reader(self, reader_cls: Type[ReaderT]) -> ReaderT:
+        with self._lock:
+            if reader_cls not in self._instances:
+                self._instances[reader_cls] = reader_cls(self._client)
+            return self._instances[reader_cls]
+
+
+_factory: Optional[ClientFactory] = None
+_factory_lock = Lock()
+
+
+def _parse_address(address: str) -> tuple:
+    """解析地址字符串为(host, port)"""
+    # 支持格式: "host:port", "tcp://host:port", "host"
+    if "://" in address:
+        parsed = urlparse(address)
+        host = parsed.hostname or parsed.path.split(":")[0]
+        port = parsed.port or (int(parsed.path.split(":")[-1]) if ":" in parsed.path else 8080)
+    elif ":" in address:
+        parts = address.rsplit(":", 1)
+        host = parts[0]
+        port = int(parts[1])
+    else:
+        host = address
+        port = 8080  # 默认端口
+
+    if not host:
+        raise ServiceError(f"Invalid address format: {address}")
+
+    return host, port
+
+
+def init(
+        *,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        base_url: Optional[str] = None,  # HTTP base URL, 例如: "http://localhost:8080"
+        address: Optional[str] = None,  # 兼容旧接口，格式: "host:port" 或 "http://host:port"
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+        verify_ssl: Optional[bool] = None,
+        proxy_type: Optional[str] = None,
+        proxy_host: Optional[str] = None,
+        proxy_port: Optional[int] = None,
+        proxy_username: Optional[str] = None,
+        proxy_password: Optional[str] = None,
+        use_gzip: Optional[bool] = None,
+        data_field: Optional[Iterable[str]] = None,
+        abnormal_endpoint: Optional[str] = None,
+) -> PandaServiceClient:
+    """
+    初始化客户端。需先调用 init_token() 登录后使用。
+    """
+    global _factory
+    service_config = get_config()
+
+    if not username:
+        username = service_config.get("DEFAULT_USERNAME", "")
+    if not password:
+        password = service_config.get("DEFAULT_PASSWORD", "")
+
+    # 解析 base_url
+    if base_url:
+        http_base_url = base_url
+    elif address:
+        # 兼容旧的 address 格式
+        if address.startswith("http://") or address.startswith("https://"):
+            http_base_url = address
+        else:
+            # 格式: "host:port" 或 "tcp://host:port"
+            parsed_host, parsed_port = _parse_address(address)
+            http_base_url = f"http://{parsed_host}:{parsed_port}"
+    else:
+        # 从配置中获取
+        http_base_url = (
+                service_config.get("HTTP_SERVICE_BASE_URL")
+                or service_config.get("JAVA_SERVICE_BASE_URL")
+        )
+        if http_base_url:
+            # 如果配置中没有协议，添加 http://
+            if not http_base_url.startswith(("http://", "https://")):
+                parsed_host, parsed_port = _parse_address(http_base_url)
+                http_base_url = f"http://{parsed_host}:{parsed_port}"
+        else:
+            http_base_url = "http://localhost:8080"
+
+    config_kwargs: Dict[str, Any] = {
+        "base_url": http_base_url + "/pandaData",
+        "username": username,
+        "password": password,
+        "timeout": timeout or float(
+            service_config.get("HTTP_TIMEOUT") or service_config.get("JAVA_SERVICE_TIMEOUT", 30.0)),
+        "retry": max_retries
+        if max_retries is not None
+        else int(service_config.get("HTTP_MAX_RETRIES") or service_config.get("JAVA_SERVICE_MAX_RETRIES", 3)),
+        "verify_ssl": (
+            verify_ssl
+            if verify_ssl is not None
+            else service_config.get("HTTP_VERIFY_SSL",
+                                    service_config.get("JAVA_SERVICE_VERIFY_SSL", "true")).lower() in {"true", "1",
+                                                                                                       "yes"}
+        ),
+        "proxy_type": proxy_type or service_config.get("HTTP_PROXY_TYPE"),
+        "proxy_host": proxy_host or service_config.get("HTTP_PROXY_HOST"),
+        "proxy_port": (
+            proxy_port
+            if proxy_port is not None
+            else (
+                int(service_config["HTTP_PROXY_PORT"])
+                if service_config.get("HTTP_PROXY_PORT")
+                else None
+            )
+        ),
+        "proxy_username": proxy_username or service_config.get("HTTP_PROXY_USERNAME"),
+        "proxy_password": proxy_password or service_config.get("HTTP_PROXY_PASSWORD"),
+        "use_gzip": (
+            use_gzip
+            if use_gzip is not None
+            else service_config.get("HTTP_USE_GZIP", "false").lower() in {"true", "1", "yes"}
+        ),
+        "data_field": data_field
+        if data_field is not None
+        else _parse_data_field(service_config.get("HTTP_DATA_FIELD") or service_config.get("JAVA_SERVICE_DATA_FIELD")),
+        "abnormal_endpoint": abnormal_endpoint
+                             or service_config.get("HTTP_ABNORMAL_ENDPOINT")
+                             or service_config.get("JAVA_SERVICE_ABNORMAL_ENDPOINT", "/abnormal"),
+    }
+
+    client_config = ClientConfig(**config_kwargs)
+    client = PandaServiceClient(client_config)
+
+    with _factory_lock:
+        _factory = ClientFactory(client)
+
+    return client
+
+
+def get_factory(base_url: Optional[str] = None) -> ClientFactory:
+    if _factory is None:
+        # 要求必须先调用 init() 或 init_token() 才能使用
+        # 不再自动从token文件读取配置，确保安全性
+        from panda_data.exceptions import ClientNotInitializedError
+        raise ClientNotInitializedError(
+            "客户端未初始化，请先调用 panda_data.init_token() 进行登录！"
+        )
+    return _factory
+
+
+def get_client(base_url: Optional[str] = None) -> PandaServiceClient:
+    return get_factory(base_url).client
+
+
+def _parse_data_field(raw: Optional[str]) -> Optional[Iterable[str]]:
+    if not raw:
+        return None
+    parts = [segment.strip() for segment in raw.split(".") if segment.strip()]
+    return tuple(parts) if parts else None

panda_data/config/__init__.py

@@ -0,0 +1,177 @@
+"""
+配置模块，用于加载和管理配置信息
+支持从配置文件和环境变量导入，环境变量优先级更高
+"""
+import os
+import logging
+
+
+# 获取logger
+try:
+    from panda_data.logger.config import logger
+except ImportError:
+    # 如果无法导入logger，创建一个基本的logger
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger("config")
+
+
+# 初始化配置变量config = None
+
+def load_config():
+    """加载配置文件，并从环境变量更新配置"""
+    global config
+
+    config = {}
+
+    # ========== 日志配置 ==========
+    config["LOG_LEVEL"] = os.getenv("LOG_LEVEL", "DEBUG")
+    config["log_file"] = os.getenv("LOG_FILE", "logs/panda_data.log")
+    config["log_rotation"] = os.getenv("LOG_ROTATION", "1 MB")
+    config["LOG_PATH"] = os.getenv("LOG_PATH", "~/log")
+
+    # ========== HTTP 通用配置（client / init_token 等使用） ==========
+    config["DEFAULT_USERNAME"] = os.getenv("DEFAULT_USERNAME", "")
+    config["DEFAULT_PASSWORD"] = os.getenv("DEFAULT_PASSWORD", "")
+
+    config["HTTP_SERVICE_BASE_URL"] = os.getenv("HTTP_SERVICE_BASE_URL")
+    config["HTTP_TIMEOUT"] = os.getenv("HTTP_TIMEOUT", "300")
+    config["HTTP_MAX_RETRIES"] = os.getenv("HTTP_MAX_RETRIES", "3")
+    config["HTTP_VERIFY_SSL"] = os.getenv("HTTP_VERIFY_SSL", "true")
+    config["HTTP_PROXY_TYPE"] = os.getenv("HTTP_PROXY_TYPE")  # "http" or "https"
+    config["HTTP_PROXY_HOST"] = os.getenv("HTTP_PROXY_HOST")
+    config["HTTP_PROXY_PORT"] = os.getenv("HTTP_PROXY_PORT")
+    config["HTTP_PROXY_USERNAME"] = os.getenv("HTTP_PROXY_USERNAME")
+    config["HTTP_PROXY_PASSWORD"] = os.getenv("HTTP_PROXY_PASSWORD")
+    config["HTTP_USE_GZIP"] = os.getenv("HTTP_USE_GZIP", "false")
+    config["HTTP_DATA_FIELD"] = os.getenv("HTTP_DATA_FIELD", "data")
+    config["HTTP_ABNORMAL_ENDPOINT"] = os.getenv("HTTP_ABNORMAL_ENDPOINT", "/abnormal")
+
+    # Legacy HTTP service config (for backward compatibility)
+    config["JAVA_SERVICE_BASE_URL"] = os.getenv("JAVA_SERVICE_BASE_URL", "http://pandadata.pandaai.online")
+    config["JAVA_SERVICE_TIMEOUT"] = os.getenv("JAVA_SERVICE_TIMEOUT", "15")
+    config["JAVA_SERVICE_MAX_POOL_SIZE"] = os.getenv("JAVA_SERVICE_MAX_POOL_SIZE", "10")
+    config["JAVA_SERVICE_MAX_RETRIES"] = os.getenv("JAVA_SERVICE_MAX_RETRIES", "3")
+    config["JAVA_SERVICE_BACKOFF_FACTOR"] = os.getenv("JAVA_SERVICE_BACKOFF_FACTOR", "0.3")
+    config["JAVA_SERVICE_VERIFY_SSL"] = os.getenv("JAVA_SERVICE_VERIFY_SSL", "true")
+    config["JAVA_SERVICE_DATA_FIELD"] = os.getenv("JAVA_SERVICE_DATA_FIELD", "data")
+    config["JAVA_SERVICE_ABNORMAL_ENDPOINT"] = os.getenv("JAVA_SERVICE_ABNORMAL_ENDPOINT", "/abnormal")
+
+    # ========== init_token（登录） ==========
+    config["JAVA_SERVICE_USER_ENDPOINT"] = os.getenv("JAVA_SERVICE_USER_ENDPOINT", "/dataUser")
+    config["JAVA_SERVICE_USER_PATH_LOGIN"] = os.getenv("JAVA_SERVICE_USER_PATH_LOGIN", "/login")
+
+    # ========== market_reader（行情数据） ==========
+    config["JAVA_SERVICE_KLINE_ENDPOINT"] = os.getenv("JAVA_SERVICE_KLINE_ENDPOINT", "/multi")
+    config["JAVA_SERVICE_KLINE_PATH_GET_MARKET_DATA"] = os.getenv("JAVA_SERVICE_KLINE_PATH_GET_MARKET_DATA", "/getMultiMarketData")
+    config["JAVA_SERVICE_KLINE_PATH_GET_MARKET_MIN_DATA"] = os.getenv("JAVA_SERVICE_KLINE_PATH_GET_MARKET_MIN_DATA", "/getMultiMarketMinData")
+    config["JAVA_SERVICE_TICK_PATH_FUTURE_TICK"] = os.getenv("JAVA_SERVICE_TICK_PATH_FUTURE_TICK", "/getFutureTickData")
+
+    # ========== market_reference_reader（市场参考） ==========
+    # KLINE - 股票详情
+    config["JAVA_SERVICE_KLINE_PATH_GET_STOCK_DETAIL"] = os.getenv("JAVA_SERVICE_KLINE_PATH_GET_STOCK_DETAIL", "/getStockDetail")
+
+    # INDEX - 指数
+    config["JAVA_SERVICE_INDEX_ENDPOINT"] = os.getenv("JAVA_SERVICE_INDEX_ENDPOINT", "/index")
+    config["JAVA_SERVICE_INDEX_PATH_GET_SYMBOL"] = os.getenv("JAVA_SERVICE_INDEX_PATH_GET_SYMBOL", "/getIndexSymbolData")
+    config["JAVA_SERVICE_INDEX_PATH_GET_INDICATOR"] = os.getenv("JAVA_SERVICE_INDEX_PATH_GET_INDICATOR", "/getIndexIndicatorData")
+    config["JAVA_SERVICE_INDEX_PATH_GET_WEIGHTS"] = os.getenv("JAVA_SERVICE_INDEX_PATH_GET_WEIGHTS", "/getIndexWeightsData")
+
+    # CONCEPT - 概念
+    config["JAVA_SERVICE_CONCEPT_ENDPOINT"] = os.getenv("JAVA_SERVICE_CONCEPT_ENDPOINT", "/concept")
+    config["JAVA_SERVICE_CONCEPT_PATH_GET_CONCEPT_LIST"] = os.getenv("JAVA_SERVICE_CONCEPT_PATH_GET_CONCEPT_LIST", "/getConceptData")
+    config["JAVA_SERVICE_CONCEPT_PATH_GET_CONCEPT_STOCK"] = os.getenv("JAVA_SERVICE_CONCEPT_PATH_GET_CONCEPT_STOCK", "/getConceptStockData")
+
+    # INDUSTRY - 行业
+    config["JAVA_SERVICE_INDUSTRY_ENDPOINT"] = os.getenv("JAVA_SERVICE_INDUSTRY_ENDPOINT", "/industry")
+    config["JAVA_SERVICE_INDUSTRY_PATH_GET_STOCK"] = os.getenv("JAVA_SERVICE_INDUSTRY_PATH_GET_STOCK", "/getIndustryStockData")
+    config["JAVA_SERVICE_INDUSTRY_PATH_GET_LIST"] = os.getenv("JAVA_SERVICE_INDUSTRY_PATH_GET_LIST", "/getIndustryList")
+    config["JAVA_SERVICE_INDUSTRY_PATH_GET_STOCK_INDUSTRY"] = os.getenv("JAVA_SERVICE_INDUSTRY_PATH_GET_STOCK_INDUSTRY", "/getStockIndustry")
+
+    # ABNORMAL - 龙虎榜
+    config["JAVA_SERVICE_ABNORMAL_PATH_GET_ABNORMAL_DATA"] = os.getenv("JAVA_SERVICE_ABNORMAL_PATH_GET_ABNORMAL_DATA", "/getAbnormalData")
+    config["JAVA_SERVICE_ABNORMAL_PATH_GET_ABNORMAL_DETAIL"] = os.getenv(
+        "JAVA_SERVICE_ABNORMAL_PATH_GET_ABNORMAL_DETAIL", "/getAbnormalDetailData")
+
+    # BUYBACK - 回购
+    config["JAVA_SERVICE_BUY_BACK_ENDPOINT"] = os.getenv("JAVA_SERVICE_BUY_BACK_ENDPOINT", "/buyback")
+    config["JAVA_SERVICE_BUY_BACK_PATH_GET_BUY_BACK_DATA"] = os.getenv(
+        "JAVA_SERVICE_BUY_BACK_PATH_GET_BUY_BACK_DATA", "/getBuyBackData")
+
+    # SECURITIES_MARGIN / STOCK_CONNECT / STOCK - 两融、北向、资金等
+    config["JAVA_SERVICE_SECURITIES_MARGIN_ENDPOINT"] = os.getenv("JAVA_SERVICE_SECURITIES_MARGIN_ENDPOINT", "/stock")
+    config["JAVA_SERVICE_SECURITIES_MARGIN_PATH_GET_MARGIN"] = os.getenv("JAVA_SERVICE_SECURITIES_MARGIN_PATH_GET_MARGIN", "/getSecuritiesMarginData")
+
+    config["JAVA_SERVICE_STOCK_CONNECT_ENDPOINT"] = os.getenv("JAVA_SERVICE_STOCK_CONNECT_ENDPOINT", "/stock")
+    config["JAVA_SERVICE_STOCK_CONNECT_PATH_GET_STOCK_CONNECT_DATA"] = os.getenv("JAVA_SERVICE_STOCK_CONNECT_PATH_GET_STOCK_CONNECT_DATA", "/getStockConnectData")
+
+    config["JAVA_SERVICE_STOCK_ENDPOINT"] = os.getenv("JAVA_SERVICE_STOCK_ENDPOINT", "/stock")
+    config["JAVA_SERVICE_STOCK_PATH_GET_FLOW"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_FLOW", "/getStockFlowData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_INVESTOR_ACTIVITIES"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_INVESTOR_ACTIVITIES", "/getStockInvestorData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_RESTRICTED_DETAILS"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_RESTRICTED_DETAILS", "/getStockRestrictedData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_HOLDER_NUMBER"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_HOLDER_NUMBER", "/getStockHolderNumberData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_MAIN_SHAREHOLDER"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_MAIN_SHAREHOLDER", "/getStockMainHolderData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_BLOCK_TRADE"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_BLOCK_TRADE", "/getStockBlockTradeData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_SHARES"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_SHARES", "/getStockShareData")
+
+    # ========== financial_and_factors_reader（财务与因子） ==========
+    # FINANCIAL - 财务
+    config["JAVA_SERVICE_FINANCIAL_ENDPOINT"] = os.getenv("JAVA_SERVICE_FINANCIAL_ENDPOINT", "/financial")
+    config["JAVA_SERVICE_FINANCIAL_PATH_GET_FORECAST"] = os.getenv("JAVA_SERVICE_FINANCIAL_PATH_GET_FORECAST", "/getFinancialForecastData")
+    config["JAVA_SERVICE_FINANCIAL_PATH_GET_PERFORMANCE"] = os.getenv("JAVA_SERVICE_FINANCIAL_PATH_GET_PERFORMANCE", "/getFinancialPerformanceData")
+    config["JAVA_SERVICE_FINANCIAL_PATH_GET_EX"] = os.getenv("JAVA_SERVICE_FINANCIAL_PATH_GET_EX", "/getFinancialExData")
+    config["JAVA_SERVICE_FINANCIAL_PATH_GET_STATEMENT"] = os.getenv("JAVA_SERVICE_FINANCIAL_PATH_GET_STATEMENT", "/getFinancialStatementData")
+    config["JAVA_SERVICE_FINANCIAL_PATH_GET_STATEMENT_DAILY"] = os.getenv("JAVA_SERVICE_FINANCIAL_PATH_GET_STATEMENT_DAILY", "/getFinancialStatementDailyData")
+
+    # STOCK - 审计、复权因子
+    config["JAVA_SERVICE_STOCK_PATH_GET_AUDIT_OPINION"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_AUDIT_OPINION", "/getStockAuditData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_FACTOR_RESTORED"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_FACTOR_RESTORED", "/getFactorRestoredData")
+
+    # KLINE - 因子
+    config["JAVA_SERVICE_KLINE_PATH_GET_FACTOR"] = os.getenv("JAVA_SERVICE_KLINE_PATH_GET_FACTOR", "/getFactor")
+
+    # ========== future_reader（期货） ==========
+    config["JAVA_SERVICE_FUTURE_ENDPOINT"] = os.getenv("JAVA_SERVICE_FUTURE_ENDPOINT", "/future")
+    config["JAVA_SERVICE_FUTURE_PATH_GET_FUTURE_LIST"] = os.getenv("JAVA_SERVICE_FUTURE_PATH_GET_FUTURE_LIST", "/getFutureList")
+    config["JAVA_SERVICE_FUTURE_PATH_GET_FACTOR_POST"] = os.getenv("JAVA_SERVICE_FUTURE_PATH_GET_FACTOR_POST", "/getFutureMarketPostData")
+    config["JAVA_SERVICE_FUTURE_PATH_FUTURE_DOMINANT"] = os.getenv("JAVA_SERVICE_FUTURE_PATH_FUTURE_DOMINANT", "/getFutureDominantData")
+
+    # ========== trading_tools_reader（交易工具） ==========
+    config["JAVA_SERVICE_CALENDAR_ENDPOINT"] = os.getenv("JAVA_SERVICE_CALENDAR_ENDPOINT", "/tradeCalendar")
+    config["JAVA_SERVICE_CALENDAR_PATH_GET_TRADE_CALENDAR_DATA"] = os.getenv("JAVA_SERVICE_CALENDAR_PATH_GET_TRADE_CALENDAR_DATA", "/getTradeCalendarData")
+    config["JAVA_SERVICE_CALENDAR_PATH_GET_PREVIOUS_NTH_TRADING_DAY"] = os.getenv("JAVA_SERVICE_CALENDAR_PATH_GET_PREVIOUS_NTH_TRADING_DAY", "/getPreviousNthTradingDay")
+    config["JAVA_SERVICE_CALENDAR_PATH_GET_LATEST_TRADING_DAY"] = os.getenv("JAVA_SERVICE_CALENDAR_PATH_GET_LATEST_TRADING_DAY", "/getLatestTradingDay")
+
+    config["JAVA_SERVICE_STOCK_PATH_GET_SPECIAL_TREATMENT"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_SPECIAL_TREATMENT", "/getStockSpecialTreatmentData")
+    config["JAVA_SERVICE_STOCK_PATH_GET_TRADING_STOCK_LIST"] = os.getenv("JAVA_SERVICE_STOCK_PATH_GET_TRADING_STOCK_LIST", "/getTradingStockList")
+
+    # 打包前可加入 panda_data_local_config 模块覆盖配置
+    try:
+        import panda_data_local_config as _local
+        if getattr(_local, "JAVA_SERVICE_BASE_URL", None):
+            config["JAVA_SERVICE_BASE_URL"] = _local.JAVA_SERVICE_BASE_URL
+    except ImportError:
+        pass
+
+    return config
+
+
+def get_config():
+    """
+    获取配置对象，如果配置未加载则先加载配置
+
+    Returns:
+        dict: 配置信息字典
+    """
+    global config
+    if config is None:
+        config = load_config()
+    return config
+
+
+# 初始加载配置
+try:
+    config = load_config()
+    # logger.info(f"初始化配置成功: {config}")  # 已禁用初始化配置日志
+except Exception as e:
+    logger.error(f"初始化配置失败: {str(e)}")
+    # 不在初始化时抛出异常，留到实际使用时再处理

panda_data/core/__init__.py

@@ -0,0 +1,2 @@
+from .service import fetch_dataframe, request_service
+__all__ = ["fetch_dataframe", "request_service"]

panda_data/core/service.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, Optional
+
+import pandas as pd
+
+from panda_data.client import get_client
+
+
+def request_service(
+    endpoint: str,
+    base_url: Optional[str] = None,
+    *,
+    payload: Optional[Dict[str, Any]] = None,
+    method: str = "POST",
+    params: Optional[Dict[str, Any]] = None,
+    headers: Optional[Dict[str, str]] = None,
+    data_path: Optional[Iterable[str]] = None,
+) -> Any:
+    client = get_client(base_url)
+    return client.request(
+        endpoint=endpoint,
+        payload=payload,
+        method=method,
+        params=params,
+        headers=headers,
+        data_path=data_path,
+    )
+
+
+def fetch_dataframe(
+    endpoint: str,
+    *,
+    payload: Optional[Dict[str, Any]] = None,
+    method: str = "POST",
+    params: Optional[Dict[str, Any]] = None,
+    headers: Optional[Dict[str, str]] = None,
+    data_path: Optional[Iterable[str]] = None,
+) -> pd.DataFrame:
+    client = get_client()
+    return client.fetch_dataframe(
+        endpoint=endpoint,
+        payload=payload,
+        method=method,
+        params=params,
+        headers=headers,
+        data_path=data_path,
+    )
+