lib-x17-fintech 2.1.3__py3-none-any.whl

xfintech/data/source/tushare/stock/__init__.py

@@ -0,0 +1,55 @@
+from .adjfactor.adjfactor import AdjFactor
+from .capflow.capflow import Capflow
+from .capflowdc.capflowdc import CapflowDC
+from .capflowths.capflowths import CapflowTHS
+from .company.company import Company
+from .companycashflow.companycashflow import CompanyCashflow
+from .companydebt.companydebt import CompanyDebt
+from .companyoverview.companyoverview import CompanyOverview
+from .companyprofit.companyprofit import CompanyProfit
+from .conceptcapflowdc.conceptcapflowdc import ConceptCapflowDC
+from .conceptcapflowths.conceptcapflowths import ConceptCapflowTHS
+from .dayline.dayline import Dayline
+from .industrycapflowths.industrycapflowths import IndustryCapflowTHS
+from .marketindexcapflowdc.marketindexcapflowdc import MarketIndexCapflowDC
+from .monthline.monthline import Monthline
+from .stock.stock import Stock
+from .stockdividend.stockdividend import StockDividend
+from .stockinfo.stockinfo import StockInfo
+from .stockipo.stockipo import StockIpo
+from .stockpledge.stockpledge import StockPledge
+from .stockpledgedetail.stockpledgedetail import StockPledgeDetail
+from .stockst.stockst import StockSt
+from .stocksuspend.stocksuspend import StockSuspend
+from .techindex.techindex import TechIndex
+from .tradedate.tradedate import TradeDate
+from .weekline.weekline import Weekline
+
+__all__ = [
+    "AdjFactor",
+    "Capflow",
+    "CapflowDC",
+    "CapflowTHS",
+    "Company",
+    "CompanyCashflow",
+    "CompanyDebt",
+    "CompanyOverview",
+    "CompanyProfit",
+    "ConceptCapflowDC",
+    "ConceptCapflowTHS",
+    "Dayline",
+    "IndustryCapflowTHS",
+    "MarketIndexCapflowDC",
+    "Monthline",
+    "Stock",
+    "StockDividend",
+    "StockInfo",
+    "StockIpo",
+    "StockPledge",
+    "StockPledgeDetail",
+    "StockSt",
+    "StockSuspend",
+    "TechIndex",
+    "TradeDate",
+    "Weekline",
+]

xfintech/data/source/tushare/stock/adjfactor/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from xfintech.data.source.tushare.stock.adjfactor.adjfactor import AdjFactor
+from xfintech.data.source.tushare.stock.adjfactor.constant import (
+    KEY,
+    NAME,
+    PAGINATE,
+    SOURCE,
+    TARGET,
+)
+
+__all__ = [
+    "AdjFactor",
+    "KEY",
+    "NAME",
+    "PAGINATE",
+    "SOURCE",
+    "TARGET",
+]

xfintech/data/source/tushare/stock/adjfactor/adjfactor.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import pandas as pd
+
+from xfintech.data.common.cache import Cache
+from xfintech.data.common.coolant import Coolant
+from xfintech.data.common.params import Params
+from xfintech.data.common.retry import Retry
+from xfintech.data.job import JobHouse
+from xfintech.data.source.tushare.job import TushareJob
+from xfintech.data.source.tushare.session.session import Session
+from xfintech.data.source.tushare.stock.adjfactor.constant import (
+    KEY,
+    NAME,
+    PAGINATE,
+    SOURCE,
+    TARGET,
+)
+
+
+@JobHouse.register(KEY, alias=KEY)
+class AdjFactor(TushareJob):
+    """
+    描述:
+    - 获取A股复权因子数据
+    - 盘前9点15~20分完成当日复权因子入库
+    - 2000积分起，5000以上可高频调取
+    - API文档: https://tushare.pro/document/2?doc_id=28
+    - SCALE: CrossSection & Individual
+    - TYPE: Partitioned
+    - PAGINATE: 2000 rows / 1000 pages
+
+    属性:
+    - name: str, 作业名称 'adjfactor'。
+    - key: str, 作业键 '/tushare/adjfactor'。
+    - session: Session, Tushare会话对象。
+    - source: TableInfo, 源表信息（Tushare原始格式）。
+    - target: TableInfo, 目标表信息（转换后格式）。
+    - params: Params, 查询参数。
+        - ts_code: str, 可选, 股票代码
+        - trade_date: str, 可选, 特定交易日期（YYYYMMDD）
+        - start_date: str, 可选, 开始日期（YYYYMMDD）
+        - end_date: str, 可选, 结束日期（YYYYMMDD）
+    - coolant: Coolant, 请求冷却控制。
+    - paginate: Paginate, 分页控制（pagesize=2000, pagelimit=10）。
+    - retry: Retry, 重试策略。
+    - cache: Cache, 缓存管理。
+
+    方法:
+    - run(): 执行作业，返回复权因子DataFrame。
+    - _run(): 内部执行逻辑，处理日期参数。
+    - transform(data): 转换数据格式，将源格式转为目标格式。
+
+    例子:
+    ```python
+        from xfintech.data.source.tushare.session import Session
+        from xfintech.data.source.tushare.stock.adjfactor import AdjFactor
+
+        session = Session(credential="your_token")
+        job = AdjFactor(
+            session=session,
+            params={
+                "start_date": "20241101",
+                "end_date": "20241231",
+            },
+        )
+        df = job.run()
+        print(df)
+    ```
+    """
+
+    def __init__(
+        self,
+        session: Session,
+        params: Optional[Params | Dict[str, Any]] = None,
+        coolant: Optional[Coolant | Dict[str, Any]] = None,
+        retry: Optional[Retry | Dict[str, Any]] = None,
+        cache: Optional[Cache | Dict[str, str] | bool] = None,
+    ) -> None:
+        super().__init__(
+            name=NAME,
+            key=KEY,
+            session=session,
+            source=SOURCE,
+            target=TARGET,
+            params=params,
+            coolant=coolant,
+            paginate=PAGINATE,
+            retry=retry,
+            cache=cache,
+        )
+
+    def _run(self) -> pd.DataFrame:
+        cached = self._load_cache()
+        if cached is not None:
+            return cached
+
+        # Prepare payload dict
+        payload = self.params.to_dict()
+        payload = self._parse_date_params(
+            payload,
+            keys=["trade_date", "start_date", "end_date"],
+        )
+        payload = self._parse_string_params(
+            payload,
+            keys=["ts_code"],
+        )
+
+        # Fetch data from API
+        data = self._fetchall(
+            api=self.connection.adj_factor,
+            **payload,
+        )
+        result = self.transform(data)
+        self._save_cache(result)
+        return result
+
+    def transform(
+        self,
+        data: pd.DataFrame,
+    ) -> pd.DataFrame:
+        cols = self.target.list_column_names()
+        if data is None or data.empty:
+            return pd.DataFrame(columns=cols)
+
+        # Transform logic
+        out = data.copy()
+        out["code"] = out["ts_code"].astype(str)
+        out["date"] = pd.to_datetime(
+            out["trade_date"],
+            format="%Y%m%d",
+            errors="coerce",
+        ).dt.strftime("%Y-%m-%d")
+        out["datecode"] = out["trade_date"].astype(str)
+
+        # Convert numeric fields
+        for field in ["adj_factor"]:
+            out[field] = pd.to_numeric(
+                out[field],
+                errors="coerce",
+            )
+
+        # Finalize output
+        out = out[cols].drop_duplicates()
+        out = out.sort_values(by=["code", "date"])
+        out = out.reset_index(drop=True)
+        self.markpoint("transform[OK]")
+        return out

xfintech/data/source/tushare/stock/adjfactor/constant.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from xfintech.data.common.paginate import Paginate
+from xfintech.fabric.column.info import ColumnInfo
+from xfintech.fabric.column.kind import ColumnKind
+from xfintech.fabric.table.info import TableInfo
+
+PROVIDER = "tushare"
+SOURCE_NAME = "adj_factor"
+URL = "https://tushare.pro/document/2?doc_id=28"
+ARGS = {
+    "ts_code": {
+        "type": ColumnKind.STRING,
+        "required": "N",
+        "desc": "股票代码",
+    },
+    "trade_date": {
+        "type": ColumnKind.STRING,
+        "required": "N",
+        "desc": "特定交易日期(YYYYMMDD)",
+    },
+    "start_date": {
+        "type": ColumnKind.STRING,
+        "required": "N",
+        "desc": "开始日期(YYYYMMDD)",
+    },
+    "end_date": {
+        "type": ColumnKind.STRING,
+        "required": "N",
+        "desc": "结束日期(YYYYMMDD)",
+    },
+}
+
+# Exported constants
+NAME = "adjfactor"
+KEY = "/tushare/adjfactor"
+PAGINATE = Paginate(
+    pagesize=2000,
+    pagelimit=1000,
+)
+SOURCE = TableInfo(
+    desc="A股复权因子数据（Tushare格式）",
+    meta={
+        "provider": PROVIDER,
+        "source": SOURCE_NAME,
+        "url": URL,
+        "args": ARGS,
+        "type": "partitioned",
+        "scale": "crosssection",
+    },
+    columns=[
+        ColumnInfo(name="ts_code", kind=ColumnKind.STRING, desc="股票代码"),
+        ColumnInfo(name="trade_date", kind=ColumnKind.STRING, desc="交易日期"),
+        ColumnInfo(name="adj_factor", kind=ColumnKind.FLOAT, desc="复权因子"),
+    ],
+)
+TARGET = TableInfo(
+    desc="A股复权因子数据（xfintech格式）",
+    meta={
+        "key": KEY,
+        "name": NAME,
+        "type": "partitioned",
+        "scale": "crosssection",
+    },
+    columns=[
+        ColumnInfo(name="code", kind=ColumnKind.STRING, desc="股票代码"),
+        ColumnInfo(name="date", kind=ColumnKind.STRING, desc="交易日期"),
+        ColumnInfo(name="datecode", kind=ColumnKind.STRING, desc="交易日期代码(YYYYMMDD)"),
+        ColumnInfo(name="adj_factor", kind=ColumnKind.FLOAT, desc="复权因子"),
+    ],
+)

xfintech/data/source/tushare/stock/adjfactor/tests/test_class_adjfactor_all.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+import pytest
+
+from xfintech.data.source.tushare.stock.adjfactor import (
+    KEY,
+    NAME,
+    PAGINATE,
+    SOURCE,
+    TARGET,
+    AdjFactor,
+)
+
+
+@pytest.fixture
+def mock_session():
+    session = MagicMock()
+    mock_connection = MagicMock()
+    mock_connection.adj_factor = MagicMock()
+    session.connection = mock_connection
+    return session
+
+
+@pytest.fixture
+def sample_source_data():
+    """创建样本源数据"""
+    return pd.DataFrame(
+        {
+            "ts_code": ["000001.SZ", "000002.SZ", "600000.SH"],
+            "trade_date": ["20241201", "20241201", "20241201"],
+            "adj_factor": [1.234567, 2.345678, 3.456789],
+        }
+    )
+
+
+# Initialization Tests
+
+
+class TestAdjFactorInitialization:
+    def test_init_basic(self, mock_session):
+        """测试基础初始化"""
+        job = AdjFactor(session=mock_session)
+        assert job.name == NAME
+        assert job.key == KEY
+        assert job.source == SOURCE
+        assert job.target == TARGET
+
+    def test_init_with_params(self, mock_session):
+        """测试带参数的初始化"""
+        params = {"ts_code": "000001.SZ"}
+        job = AdjFactor(session=mock_session, params=params)
+        assert job.params.get("ts_code") == "000001.SZ"
+
+    def test_init_with_all_components(self, mock_session):
+        """测试带所有组件的初始化"""
+        params = {"ts_code": "000001.SZ"}
+        coolant = {"interval": 0.1}
+        retry = {"max_retries": 3}
+
+        job = AdjFactor(
+            session=mock_session,
+            params=params,
+            coolant=coolant,
+            retry=retry,
+            cache=False,
+        )
+
+        assert job.name == NAME
+        assert job.key == KEY
+        assert job.params.get("ts_code") == "000001.SZ"
+
+    def test_name_constant(self):
+        """测试NAME常量"""
+        assert NAME == "adjfactor"
+
+    def test_key_constant(self):
+        """测试KEY常量"""
+        assert KEY == "/tushare/adjfactor"
+
+    def test_paginate_constant(self):
+        """测试PAGINATE常量"""
+        assert PAGINATE.pagesize
+        assert PAGINATE.pagelimit
+
+    def test_source_schema(self):
+        """测试SOURCE表结构"""
+        columns_list = SOURCE.list_columns()
+        assert columns_list is not None
+        assert len(columns_list) == 3
+        column_names = [col.name for col in columns_list]
+        assert "ts_code" in column_names
+        assert "trade_date" in column_names
+        assert "adj_factor" in column_names
+
+    def test_target_schema(self):
+        """测试TARGET表结构"""
+        columns_list = TARGET.list_columns()
+        assert columns_list is not None
+        assert len(columns_list) == 4
+        column_names = [col.name for col in columns_list]
+        assert "code" in column_names
+        assert "date" in column_names
+        assert "datecode" in column_names
+        assert "adj_factor" in column_names
+
+
+# Transform Tests
+
+
+class TestAdjFactorTransform:
+    def test_transform_basic(self, mock_session, sample_source_data):
+        """测试基本转换"""
+        job = AdjFactor(session=mock_session)
+        result = job.transform(sample_source_data)
+
+        assert "code" in result.columns
+        assert "date" in result.columns
+        assert "datecode" in result.columns
+        assert "adj_factor" in result.columns
+        assert len(result) == 3
+
+    def test_transform_date_conversion(self, mock_session, sample_source_data):
+        """测试日期转换"""
+        job = AdjFactor(session=mock_session)
+        result = job.transform(sample_source_data)
+
+        # Check date format YYYY-MM-DD
+        assert result["date"].iloc[0] == "2024-12-01"
+        # Check datecode format YYYYMMDD
+        assert result["datecode"].iloc[0] == "20241201"
+
+    def test_transform_adj_factor_values(self, mock_session, sample_source_data):
+        """测试复权因子值保持不变"""
+        job = AdjFactor(session=mock_session)
+        result = job.transform(sample_source_data)
+
+        assert result["adj_factor"].iloc[0] == 1.234567
+        assert result["adj_factor"].iloc[1] == 2.345678
+        assert result["adj_factor"].iloc[2] == 3.456789
+
+    def test_transform_empty_data(self, mock_session):
+        """测试空数据转换"""
+        job = AdjFactor(session=mock_session)
+        empty_df = pd.DataFrame()
+        result = job.transform(empty_df)
+
+        assert result.empty
+        assert "code" in result.columns
+
+    def test_transform_none_data(self, mock_session):
+        """测试None数据转换"""
+        job = AdjFactor(session=mock_session)
+        result = job.transform(None)
+
+        assert result.empty
+        assert "code" in result.columns
+
+    def test_transform_invalid_dates(self, mock_session):
+        """测试无效日期处理"""
+        job = AdjFactor(session=mock_session)
+        data = pd.DataFrame(
+            {
+                "ts_code": ["000001.SZ"],
+                "trade_date": ["invalid"],
+                "adj_factor": [1.0],
+            }
+        )
+        result = job.transform(data)
+
+        # Should handle invalid dates gracefully
+        assert len(result) == 1
+        assert pd.isna(result["date"].iloc[0]) or result["date"].iloc[0] == "NaT"
+
+    def test_transform_duplicates_removed(self, mock_session):
+        """测试重复数据删除"""
+        job = AdjFactor(session=mock_session)
+        data = pd.DataFrame(
+            {
+                "ts_code": ["000001.SZ", "000001.SZ", "000002.SZ"],
+                "trade_date": ["20241201", "20241201", "20241201"],
+                "adj_factor": [1.0, 1.0, 2.0],
+            }
+        )
+        result = job.transform(data)
+
+        # Duplicates should be removed
+        assert len(result) == 2
+
+    def test_transform_sorting(self, mock_session):
+        """测试数据排序"""
+        job = AdjFactor(session=mock_session)
+        data = pd.DataFrame(
+            {
+                "ts_code": ["600000.SH", "000001.SZ", "000002.SZ"],
+                "trade_date": ["20241203", "20241201", "20241202"],
+                "adj_factor": [3.0, 1.0, 2.0],
+            }
+        )
+        result = job.transform(data)
+
+        # Should be sorted by code and date
+        assert result["code"].iloc[0] == "000001.SZ"
+        assert result["code"].iloc[1] == "000002.SZ"
+        assert result["code"].iloc[2] == "600000.SH"
+
+
+# Run Tests
+
+
+class TestAdjFactorRun:
+    def test_run_basic(self, mock_session, sample_source_data):
+        """测试基本运行"""
+        job = AdjFactor(session=mock_session, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) == 3
+            assert "code" in result.columns
+
+    def test_run_with_ts_code(self, mock_session, sample_source_data):
+        """测试指定股票代码运行"""
+        params = {"ts_code": "000001.SZ"}
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_with_trade_date_string(self, mock_session, sample_source_data):
+        """测试交易日期（字符串）运行"""
+        params = {"trade_date": "20241201"}
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_with_trade_date_datetime(self, mock_session, sample_source_data):
+        """测试交易日期（datetime）运行"""
+        params = {"trade_date": datetime(2024, 12, 1)}
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_with_trade_date_date(self, mock_session, sample_source_data):
+        """测试交易日期（date）运行"""
+        params = {"trade_date": date(2024, 12, 1)}
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_with_date_range_string(self, mock_session, sample_source_data):
+        """测试日期区间（字符串）运行"""
+        params = {"start_date": "20241101", "end_date": "20241231"}
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_with_date_range_datetime(self, mock_session, sample_source_data):
+        """测试日期区间（datetime）运行"""
+        params = {
+            "start_date": datetime(2024, 11, 1),
+            "end_date": datetime(2024, 12, 31),
+        }
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_with_date_range_date(self, mock_session, sample_source_data):
+        """测试日期区间（date）运行"""
+        params = {"start_date": date(2024, 11, 1), "end_date": date(2024, 12, 31)}
+        job = AdjFactor(session=mock_session, params=params, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) > 0
+
+    def test_run_calls_transform(self, mock_session, sample_source_data):
+        """测试运行时调用transform"""
+        job = AdjFactor(session=mock_session, cache=False)
+
+        with (
+            patch.object(job, "_fetchall", return_value=sample_source_data),
+            patch.object(job, "transform", wraps=job.transform) as mock_transform,
+        ):
+            job.run()
+            mock_transform.assert_called_once()
+
+
+# Cache Tests
+
+
+class TestAdjFactorCache:
+    def test_cache_persistence(self, mock_session, sample_source_data):
+        """测试缓存持久性"""
+        job = AdjFactor(session=mock_session, cache=True)
+
+        with (
+            patch.object(job, "_fetchall", return_value=sample_source_data),
+            patch.object(job, "_load_cache", return_value=None),
+            patch.object(job, "_save_cache") as mock_save,
+        ):
+            job.run()
+            mock_save.assert_called_once()
+
+    def test_run_without_cache(self, mock_session, sample_source_data):
+        """测试不使用缓存运行"""
+        job = AdjFactor(session=mock_session, cache=False)
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            result = job.run()
+            assert len(result) == 3
+
+
+# Integration Tests
+
+
+class TestAdjFactorIntegration:
+    def test_full_workflow(self, mock_session, sample_source_data):
+        """测试完整工作流程"""
+        job = AdjFactor(
+            session=mock_session,
+            params={"ts_code": "000001.SZ"},
+            cache=False,
+        )
+
+        with patch.object(job, "_fetchall", return_value=sample_source_data):
+            # Run job
+            result = job.run()
+            assert not result.empty
+
+    def test_large_dataset_handling(self, mock_session):
+        """测试大数据集处理"""
+        # Create large dataset
+        large_data = pd.DataFrame(
+            {
+                "ts_code": [f"{i:06d}.SZ" for i in range(1000)],
+                "trade_date": ["20241201"] * 1000,
+                "adj_factor": [1.0 + i * 0.001 for i in range(1000)],
+            }
+        )
+        job = AdjFactor(session=mock_session, cache=False)
+        with patch.object(job, "_fetchall", return_value=large_data):
+            result = job.run()
+            assert len(result) == 1000
+
+    def test_missing_fields_handling(self, mock_session):
+        """测试缺失字段处理"""
+        data = pd.DataFrame(
+            {
+                "ts_code": ["000001.SZ", "000002.SZ"],
+                "trade_date": ["20241201", "20241201"],
+                "adj_factor": [1.0, None],
+            }
+        )
+        job = AdjFactor(session=mock_session, cache=False)
+        with patch.object(job, "_fetchall", return_value=data):
+            result = job.run()
+            # Should handle None/NaN gracefully
+            assert len(result) == 2

xfintech/data/source/tushare/stock/capflow/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from xfintech.data.source.tushare.stock.capflow.capflow import Capflow
+from xfintech.data.source.tushare.stock.capflow.constant import (
+    KEY,
+    NAME,
+    PAGINATE,
+    SOURCE,
+    TARGET,
+)
+
+__all__ = [
+    "Capflow",
+    "KEY",
+    "NAME",
+    "PAGINATE",
+    "SOURCE",
+    "TARGET",
+]