lixinger-python 0.1.2__py3-none-any.whl

lixinger/api/cn/fund/asset_industry_combination.py

@@ -0,0 +1,93 @@
+"""Fund asset industry combination API."""
+
+from typing import Any
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.fund.asset_industry_combination import AssetIndustryCombination
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class FundAssetIndustryCombinationAPI(BaseAPI):
+    """Fund asset industry combination API."""
+
+    def get_asset_industry_combination(
+        self,
+        stock_code: str,
+        start_date: str,
+        end_date: str | None = None,
+        limit: int | None = None,
+    ) -> pd.DataFrame:
+        """获取按行业分类的股票投资组合数据.
+
+        API Endpoint: /cn/fund/asset-industry-combination
+        API Method: POST
+        Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund/asset-industry-combination
+
+        Args:
+            stock_code: 基金代码
+            start_date: 开始日期 (YYYY-MM-DD)
+            end_date: 结束日期 (YYYY-MM-DD), 可选
+            limit: 限制返回的报告期数量, 可选
+
+        Returns:
+            DataFrame containing fund asset industry combination data
+
+        """
+        payload: dict[str, Any] = {
+            "stockCode": stock_code,
+            "startDate": start_date,
+        }
+        if end_date is not None:
+            payload["endDate"] = end_date
+        if limit is not None:
+            payload["limit"] = limit
+
+        data = self._request("POST", "/cn/fund/asset-industry-combination", json=payload)
+
+        # Flatten nested industry combination data
+        flattened_data = []
+        for item in data:
+            date = item["date"]
+            for aic in item.get("aic_cn", []):
+                record = {
+                    "date": date,
+                    "stock_code": stock_code,
+                    **aic,
+                }
+                flattened_data.append(record)
+
+        return get_response_df(flattened_data, AssetIndustryCombination)
+
+
+# Functional API instance
+_api_instance = FundAssetIndustryCombinationAPI()
+
+
+@api
+def get_fund_asset_industry_combination(
+    stock_code: str,
+    start_date: str,
+    end_date: str | None = None,
+    limit: int | None = None,
+) -> pd.DataFrame:
+    """获取按行业分类的股票投资组合数据.
+
+    Args:
+        stock_code: 基金代码
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD), 可选
+        limit: 限制返回的报告期数量, 可选
+
+    Returns:
+        DataFrame containing fund asset industry combination data
+
+    """
+    return _api_instance.get_asset_industry_combination(
+        stock_code=stock_code,
+        start_date=start_date,
+        end_date=end_date,
+        limit=limit,
+    )

lixinger/api/cn/fund/candlestick.py

@@ -0,0 +1,84 @@
+"""Fund candlestick data APIs."""
+
+from typing import Any, Literal
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.fund.candlestick import FundCandlestick
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class FundCandlestickAPI(BaseAPI):
+    """Fund candlestick data APIs."""
+
+    def get_candlestick(
+        self,
+        type: Literal["normal", "total_return"],
+        stock_code: str,
+        start_date: str,
+        end_date: str,
+    ) -> pd.DataFrame:
+        """获取基金K线数据.
+
+        API Endpoint: /cn/fund/candlestick
+        API Method: POST
+        Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund/candlestick
+
+        Args:
+            type: K线类型 (normal, total_return)
+            stock_code: 基金代码
+            start_date: 开始日期 (YYYY-MM-DD)
+            end_date: 结束日期 (YYYY-MM-DD)
+
+        Returns:
+            DataFrame containing fund candlestick data
+
+        """
+        payload: dict[str, Any] = {
+            "type": type,
+            "stockCode": stock_code,
+            "startDate": start_date,
+            "endDate": end_date,
+        }
+
+        data = self._request("POST", "/cn/fund/candlestick", json=payload)
+        for item in data:
+            item["stockCode"] = stock_code
+        return get_response_df(data, FundCandlestick)
+
+
+# Functional API instance
+_api_instance = FundCandlestickAPI()
+
+
+@api
+def get_fund_candlestick(
+    type: Literal["normal", "total_return"],
+    stock_code: str,
+    start_date: str,
+    end_date: str,
+) -> pd.DataFrame:
+    """获取基金K线数据.
+
+    API Endpoint: /cn/fund/candlestick
+    API Method: POST
+    Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund/candlestick
+
+    Args:
+        type: K线类型 (normal, total_return)
+        stock_code: 基金代码
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD)
+
+    Returns:
+        DataFrame containing fund candlestick data
+
+    """
+    return _api_instance.get_candlestick(
+        type=type,
+        stock_code=stock_code,
+        start_date=start_date,
+        end_date=end_date,
+    )

lixinger/api/cn/fund/fund.py

@@ -0,0 +1,70 @@
+"""Fund-related APIs.
+
+This module provides APIs for querying fund information.
+"""
+
+from typing import Any
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.fund import Fund
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class FundAPI(BaseAPI):
+    """Fund related APIs."""
+
+    def get_fund(
+        self,
+        stock_codes: list[str] | None = None,
+        page_index: int | None = None,
+    ) -> pd.DataFrame:
+        """获取基金信息.
+
+        API Endpoint: /cn/fund
+        API Method: POST
+        Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund
+
+        Args:
+            stock_codes: 基金代码列表
+            page_index: 分页索引
+
+        Returns:
+            DataFrame containing fund information
+
+        """
+        payload: dict[str, Any] = {}
+        if stock_codes is not None:
+            payload["stockCodes"] = stock_codes
+        if page_index is not None:
+            payload["pageIndex"] = page_index
+
+        data = self._request("POST", "/cn/fund", json=payload)
+        return get_response_df(data, Fund)
+
+
+# Functional API instance
+_api_instance = FundAPI()
+
+
+@api
+def get_fund(
+    stock_codes: list[str] | None = None,
+    page_index: int | None = None,
+) -> pd.DataFrame:
+    """获取基金信息.
+
+    Args:
+        stock_codes: 基金代码列表
+        page_index: 分页索引
+
+    Returns:
+        DataFrame containing fund information
+
+    """
+    return _api_instance.get_fund(
+        stock_codes=stock_codes,
+        page_index=page_index,
+    )

lixinger/api/cn/fund/profile.py

@@ -0,0 +1,60 @@
+"""Fund profile APIs."""
+
+from typing import Any
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.fund.profile import FundProfile
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class FundProfileAPI(BaseAPI):
+    """Fund profile APIs."""
+
+    def get_profile(
+        self,
+        stock_codes: list[str],
+    ) -> pd.DataFrame:
+        """获取基金基本概况.
+
+        API Endpoint: /cn/fund/profile
+        API Method: POST
+        Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund/profile
+
+        Args:
+            stock_codes: 基金代码列表
+
+        Returns:
+            DataFrame containing fund profile information
+
+        """
+        payload: dict[str, Any] = {
+            "stockCodes": stock_codes,
+        }
+
+        data = self._request("POST", "/cn/fund/profile", json=payload)
+        return get_response_df(data, FundProfile)
+
+
+# Functional API instance
+_api_instance = FundProfileAPI()
+
+
+@api
+def get_fund_profile(
+    stock_codes: list[str],
+) -> pd.DataFrame:
+    """获取基金基本概况.
+
+    Args:
+        stock_codes: 基金代码列表
+
+    Returns:
+        DataFrame containing fund profile information
+
+    """
+    return _api_instance.get_profile(
+        stock_codes=stock_codes,
+    )

lixinger/api/cn/fund/shareholdings.py

@@ -0,0 +1,86 @@
+"""Fund shareholdings API."""
+
+from typing import Any
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.fund.shareholdings import Shareholding
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class FundShareholdingsAPI(BaseAPI):
+    """Fund shareholdings API."""
+
+    def get_shareholdings(
+        self,
+        stock_code: str,
+        start_date: str,
+        end_date: str | None = None,
+        limit: int | None = None,
+    ) -> pd.DataFrame:
+        """获取基金持仓数据.
+
+        API Endpoint: /cn/fund/shareholdings
+        API Method: POST
+        Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund/shareholdings
+
+        Args:
+            stock_code: 基金代码
+            start_date: 开始日期 (YYYY-MM-DD)
+            end_date: 结束日期 (YYYY-MM-DD), 可选
+            limit: 限制返回的报告期数量, 可选
+
+        Returns:
+            DataFrame containing fund shareholdings data
+
+        """
+        payload: dict[str, Any] = {
+            "stockCode": stock_code,
+            "startDate": start_date,
+        }
+        if end_date is not None:
+            payload["endDate"] = end_date
+        if limit is not None:
+            payload["limit"] = limit
+
+        data = self._request("POST", "/cn/fund/shareholdings", json=payload)
+        for item in data:
+            item["fund_stock_code"] = stock_code
+        return get_response_df(data, Shareholding)
+
+
+# Functional API instance
+_api_instance = FundShareholdingsAPI()
+
+
+@api
+def get_fund_shareholdings(
+    stock_code: str,
+    start_date: str,
+    end_date: str | None = None,
+    limit: int | None = None,
+) -> pd.DataFrame:
+    """获取基金持仓数据.
+
+    API Endpoint: /cn/fund/shareholdings
+    API Method: POST
+    Documentation: https://www.lixinger.com/open/api/doc?api-key=cn/fund/shareholdings
+
+    Args:
+        stock_code: 基金代码
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD), 可选
+        limit: 限制返回的报告期数量, 可选
+
+    Returns:
+        DataFrame containing fund shareholdings data
+
+    """
+    return _api_instance.get_shareholdings(
+        stock_code=stock_code,
+        start_date=start_date,
+        end_date=end_date,
+        limit=limit,
+    )

lixinger/api/cn/index/__init__.py

@@ -0,0 +1,32 @@
+"""Index-related APIs."""
+
+from lixinger.api.cn.index.candlestick import IndexCandlestickAPI, get_candlestick
+from lixinger.api.cn.index.constituent_weightings import (
+    ConstituentWeightingsAPI,
+    get_constituent_weightings,
+)
+from lixinger.api.cn.index.constituents import ConstituentsAPI, get_constituents
+from lixinger.api.cn.index.drawdown import DrawdownAPI, get_drawdown
+from lixinger.api.cn.index.fundamental import (
+    IndexFundamentalAPI,
+    get_index_fundamental,
+)
+from lixinger.api.cn.index.index import IndexAPI, get_index
+from lixinger.api.cn.index.tracking_fund import TrackingFundAPI, get_tracking_fund
+
+__all__ = [
+    "IndexAPI",
+    "get_index",
+    "ConstituentsAPI",
+    "get_constituents",
+    "ConstituentWeightingsAPI",
+    "get_constituent_weightings",
+    "IndexCandlestickAPI",
+    "get_candlestick",
+    "DrawdownAPI",
+    "get_drawdown",
+    "IndexFundamentalAPI",
+    "get_index_fundamental",
+    "TrackingFundAPI",
+    "get_tracking_fund",
+]

lixinger/api/cn/index/candlestick.py

@@ -0,0 +1,86 @@
+"""Index candlestick data APIs."""
+
+from typing import Any, Literal
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.index.candlestick import IndexCandlestick
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class IndexCandlestickAPI(BaseAPI):
+    """Index candlestick data APIs."""
+
+    def get_candlestick(
+        self,
+        type: Literal["normal", "total_return"],
+        stock_code: str,
+        start_date: str,
+        end_date: str,
+        adjust_type: Literal["none", "qxw", "hxw"] | None = None,
+    ) -> pd.DataFrame:
+        """获取指数K线数据.
+
+        API Endpoint: /cn/index/candlestick
+        API Method: POST
+
+        Args:
+            type: K线类型 (normal, total_return)
+            stock_code: 指数代码
+            start_date: 开始日期 (YYYY-MM-DD)
+            end_date: 结束日期 (YYYY-MM-DD)
+            adjust_type: 复权类型 (none, qxw, hxw)
+
+        Returns:
+            DataFrame containing index candlestick data
+
+        """
+        payload: dict[str, Any] = {
+            "type": type,
+            "stockCode": stock_code,
+            "startDate": start_date,
+            "endDate": end_date,
+        }
+        if adjust_type is not None:
+            payload["adjustType"] = adjust_type
+
+        data = self._request("POST", "/cn/index/candlestick", json=payload)
+        for item in data:
+            item["stockCode"] = stock_code
+        return get_response_df(data, IndexCandlestick)
+
+
+# Functional API instance
+_api_instance = IndexCandlestickAPI()
+
+
+@api
+def get_candlestick(
+    type: Literal["normal", "total_return"],
+    stock_code: str,
+    start_date: str,
+    end_date: str,
+    adjust_type: Literal["none", "qxw", "hxw"] | None = None,
+) -> pd.DataFrame:
+    """获取指数K线数据.
+
+    Args:
+        type: K线类型 (normal, total_return)
+        stock_code: 指数代码
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD)
+        adjust_type: 复权类型 (none, qxw, hxw)
+
+    Returns:
+        DataFrame containing index candlestick data
+
+    """
+    return _api_instance.get_candlestick(
+        type=type,
+        stock_code=stock_code,
+        start_date=start_date,
+        end_date=end_date,
+        adjust_type=adjust_type,
+    )

lixinger/api/cn/index/constituent_weightings.py

@@ -0,0 +1,71 @@
+"""Index constituent weightings APIs."""
+
+from typing import Any
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.index.constituent_weightings import ConstituentWeighting
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class ConstituentWeightingsAPI(BaseAPI):
+    """Index constituent weightings APIs."""
+
+    def get_constituent_weightings(
+        self,
+        stock_code: str,
+        start_date: str,
+        end_date: str,
+    ) -> pd.DataFrame:
+        """获取指数权重股及其权重.
+
+        API Endpoint: /cn/index/constituent-weightings
+        API Method: POST
+
+        Args:
+            stock_code: 指数代码
+            start_date: 开始日期 (YYYY-MM-DD)
+            end_date: 结束日期 (YYYY-MM-DD)
+
+        Returns:
+            DataFrame containing index constituent weightings information
+
+        """
+        payload: dict[str, Any] = {
+            "stockCode": stock_code,
+            "startDate": start_date,
+            "endDate": end_date,
+        }
+
+        data = self._request("POST", "/cn/index/constituent-weightings", json=payload)
+        return get_response_df(data, ConstituentWeighting)
+
+
+# Functional API instance
+_api_instance = ConstituentWeightingsAPI()
+
+
+@api
+def get_constituent_weightings(
+    stock_code: str,
+    start_date: str,
+    end_date: str,
+) -> pd.DataFrame:
+    """获取指数权重股及其权重.
+
+    Args:
+        stock_code: 指数代码
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD)
+
+    Returns:
+        DataFrame containing index constituent weightings information
+
+    """
+    return _api_instance.get_constituent_weightings(
+        stock_code=stock_code,
+        start_date=start_date,
+        end_date=end_date,
+    )

lixinger/api/cn/index/constituents.py

@@ -0,0 +1,71 @@
+"""Index constituents APIs."""
+
+from typing import Any
+
+import pandas as pd
+
+from lixinger.api.base import BaseAPI
+from lixinger.models.cn.index.constituents import Constituent
+from lixinger.utils.api import api
+from lixinger.utils.dataframe import get_response_df
+
+
+class ConstituentsAPI(BaseAPI):
+    """Index constituents APIs."""
+
+    def get_constituents(
+        self,
+        stock_codes: list[str],
+        date: str,
+    ) -> pd.DataFrame:
+        """获取指数权重股.
+
+        API Endpoint: /cn/index/constituents
+        API Method: POST
+
+        Args:
+            stock_codes: 指数代码列表
+            date: 日期 (YYYY-MM-DD)
+
+        Returns:
+            DataFrame containing index constituents information
+
+        """
+        payload: dict[str, Any] = {
+            "stockCodes": stock_codes,
+            "date": date,
+        }
+
+        data = self._request("POST", "/cn/index/constituents", json=payload)
+        flattened_data = []
+        for item in data:
+            index_stock_code = item["stockCode"]
+            for constituent in item["constituents"]:
+                constituent["index_stock_code"] = index_stock_code
+                flattened_data.append(constituent)
+        return get_response_df(flattened_data, Constituent)
+
+
+# Functional API instance
+_api_instance = ConstituentsAPI()
+
+
+@api
+def get_constituents(
+    stock_codes: list[str],
+    date: str,
+) -> pd.DataFrame:
+    """获取指数权重股.
+
+    Args:
+        stock_codes: 指数代码列表
+        date: 日期 (YYYY-MM-DD)
+
+    Returns:
+        DataFrame containing index constituents information
+
+    """
+    return _api_instance.get_constituents(
+        stock_codes=stock_codes,
+        date=date,
+    )