tea-bond 0.2.8__cp310-abi3-macosx_11_0_arm64.whl

pybond/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from .bond import Bond
+
+# from .pnl import calc_bond_trade_pnl
+from .pybond import Future, Ib, Sse
+from .pybond import TfEvaluator as _TfEvaluatorRS
+
+
+class TfEvaluator(_TfEvaluatorRS):
+    def __new__(cls, future, bond, *args, **kwargs):
+        if not isinstance(bond, Bond):
+            bond = Bond(bond)
+        return super().__new__(cls, future, bond, *args, **kwargs)
+
+
+__all__ = ["Bond", "Future", "Ib", "Sse", "TfEvaluator"]

pybond/bond.py

@@ -0,0 +1,185 @@
+import os
+from datetime import date
+from importlib.util import find_spec
+from pathlib import Path
+
+from .pybond import Bond as _BondRS
+from .pybond import Future, download_bond
+
+WIND_AVAILABLE = find_spec("WindPy") is not None
+
+if os.environ.get("BONDS_INFO_PATH") is not None:
+    bonds_info_environ_flag = True
+    bonds_info_path = Path(os.environ.get("BONDS_INFO_PATH"))
+else:
+    bonds_info_environ_flag = False
+    bonds_info_path = Path(__file__).parent / "data" / "bonds_info"
+
+if not bonds_info_path.exists():
+    bonds_info_path.mkdir(parents=True)
+
+
+class Bond(_BondRS):
+    def __new__(cls, code: str | int = "", path: str | Path | None = None):
+        """
+        Create a new Bond instance.
+
+        Args:
+            code (str | int): The bond code. If no extension is provided, '.IB' will be appended.
+            path (str | Path | None): Path to the bond info file. If None, uses default bonds_info_path.
+
+        Returns:
+            Bond: A new Bond instance, either loaded from existing JSON file or downloaded.
+
+        Note:
+            If a JSON file for the bond code doesn't exist at the specified path,
+            the bond info will be downloaded automatically.
+        """
+        code = str(code)
+        if code == "":
+            return super().__new__(cls, "", path)
+        if "." not in code:
+            code = code + ".IB"
+        path = bonds_info_path if path is None else Path(path)
+        if (path / (code + ".json")).exists():
+            return super().__new__(cls, code, path)
+        else:
+            cls.download(code, path)
+            return super().__new__(cls, code, path)
+
+    @classmethod
+    def from_json(cls, data: str | dict) -> "Bond":
+        if isinstance(data, str):
+            import json
+
+            data = json.loads(data)
+        bond = Bond()
+        for k, v in data.items():
+            setattr(bond, k, v)
+        return bond
+
+    @staticmethod
+    def download(
+        code: str, path: str | None = None, source: str | None = None, save=True
+    ):
+        """
+        Download bond information from a specified source.
+
+        This method downloads bond information for a given bond code from either Wind or Rust.
+        If no source is specified, it defaults to Wind if the WindPy module is available; otherwise,
+        it falls back to Rust.
+
+        If the source is 'rust', the method will download IB bond information from China Money and
+        SH bond information from SSE (Shanghai Stock Exchange).
+
+        Args:
+            code (str): The bond code in the format 'XXXXXX.YY'. The code must include a dot.
+            path (str | None): The directory path where the downloaded bond information should be saved.
+                              If None, the default path is used.
+            source (str | None): The source from which to download the bond information. Valid options are
+                                'wind' or 'rust'. If None, the source is automatically determined.
+            save (bool): Whether to save the downloaded bond information to the specified path.
+                        Defaults to True.
+
+        Returns:
+            Bond: The downloaded bond object if the source is 'rust' and save is False.
+                  Otherwise, returns None.
+
+        Raises:
+            AssertionError: If the code is not in the correct format or if the source is invalid.
+        """
+        if source is None:
+            # 优先从wind下载
+            source = "wind" if WIND_AVAILABLE else "rust"
+        assert "." in code, "code should be in the format of XXXXXX.YY"
+        assert source in ("wind", "rust")
+        if source == "wind":
+            from .download import fetch_symbols, login
+
+            print(f"Start downloading bond info for {code} from Wind")
+            login()
+            fetch_symbols([code], save=save, save_folder=path)
+        else:
+            # let rust side handle the download
+            print(f"download {code}")
+            bond = download_bond(code)
+            if save:
+                bond.save(path)
+            return bond
+
+    def accrued_interest(
+        self, date: date, cp_dates: tuple[date, date] | None = None
+    ) -> float:
+        """
+        计算应计利息
+
+        银行间和交易所的计算规则不同,银行间是算头不算尾,而交易所是算头又算尾
+        """
+        return self.calc_accrued_interest(date, cp_dates=cp_dates)
+
+    def dirty_price(
+        self,
+        ytm: float,
+        date: date,
+        cp_dates: tuple[date, date] | None = None,
+        remain_cp_num: int | None = None,
+    ) -> float:
+        """通过ytm计算债券全价"""
+        return self.calc_dirty_price_with_ytm(
+            ytm, date, cp_dates=cp_dates, remain_cp_num=remain_cp_num
+        )
+
+    def clean_price(
+        self,
+        ytm: float,
+        date: date,
+        cp_dates: tuple[date, date] | None = None,
+        remain_cp_num: int | None = None,
+    ) -> float:
+        """通过ytm计算债券净价"""
+        return self.calc_clean_price_with_ytm(
+            ytm, date, cp_dates=cp_dates, remain_cp_num=remain_cp_num
+        )
+
+    def macaulay_duration(
+        self,
+        ytm: float,
+        date: date,
+        cp_dates: tuple[date, date] | None = None,
+        remain_cp_num: int | None = None,
+    ) -> float:
+        """计算麦考利久期"""
+        return self.calc_macaulay_duration(
+            ytm, date, cp_dates=cp_dates, remain_cp_num=remain_cp_num
+        )
+
+    def duration(
+        self,
+        ytm: float,
+        date: date,
+        cp_dates: tuple[date, date] | None = None,
+        remain_cp_num: int | None = None,
+    ) -> float:
+        """计算修正久期"""
+        return self.calc_duration(
+            ytm, date, cp_dates=cp_dates, remain_cp_num=remain_cp_num
+        )
+
+    def cf(self, future: str | Future) -> float:
+        """计算转换因子"""
+        from .pybond import TfEvaluator
+
+        return TfEvaluator(future, self).cf
+
+    def calc_ytm_with_clean_price(
+        self,
+        clean_price: float,
+        date: date,
+        cp_dates: tuple[date, date] | None = None,
+        remain_cp_num: int | None = None,
+    ) -> float:
+        """通过净价计算债券ytm"""
+        dirty_price = clean_price + self.accrued_interest(date, cp_dates=cp_dates)
+        return self.calc_ytm_with_price(
+            dirty_price, date, cp_dates=cp_dates, remain_cp_num=remain_cp_num
+        )

pybond/download.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import json
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+
+from WindPy import w
+
+default_save_folder = Path("bonds_info")
+# if not default_save_folder.exists():
+#     default_save_folder.mkdir()
+
+
+def save_json(path: Path | str, data: dict) -> None:
+    """
+    Save data into json file in temp path.
+    """
+    path = Path(path)
+    with path.open(mode="w+", encoding="UTF-8") as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)
+
+
+def get_interest_type(typ: str):
+    if typ == "固定利率":
+        return "Fixed"
+    elif typ == "浮动利率":
+        return "Floating"
+    elif typ == "累进利率":
+        return "Progressive"
+    elif typ == "零息":
+        return "Zero"
+    else:
+        msg = f"Unknown interest type: {typ}"
+        raise ValueError(msg)
+
+
+def get_payment_type(typ: str):
+    if typ == "附息":
+        return "Coupon_Bear"
+    elif typ == "到期一次还本付息":
+        return "One_Time"
+    elif typ == "贴现":
+        return "Zero_Coupon"
+    else:
+        msg = f"Unknown payment type: {typ}"
+        raise ValueError(msg)
+
+
+def fetch_symbols(
+    symbols: list[str],
+    *,
+    save: bool = True,
+    skip: bool = True,
+    save_folder: Path | str | None = None,
+):
+    if save_folder is None:
+        save_folder = default_save_folder
+    if isinstance(save_folder, str):
+        save_folder = Path(save_folder)
+    if skip:
+        symbols = [s for s in symbols if not (save_folder / f"{s}.json").exists()]
+    data = w.wss(
+        symbols,
+        "sec_name,carrydate,maturitydate,interesttype,couponrate,paymenttype,actualbenchmark,coupon,interestfrequency,latestpar",
+        f"tradeDate={date.today()}",
+    ).Data
+    returns = []
+    for i, symbol in enumerate(symbols):
+        m = {"bond_code": symbol}
+        m["mkt"] = symbol.split(".")[1].upper()
+        m["abbr"] = data[0][i]  # 债券简称
+        m["par_value"] = float(data[9][i])  # 面值
+        m["cp_type"] = get_payment_type(data[7][i])  # 付息频率
+        m["interest_type"] = get_interest_type(data[3][i])  # 付息方式
+        m["cp_rate_1st"] = float(Decimal(str(data[4][i])) / 100)  # 票面利率
+        m["base_rate"] = None
+        m["rate_spread"] = None
+        if m["cp_type"] == "Coupon_Bear":
+            m["inst_freq"] = int(data[8][i])  # 年付息次数
+        elif m["cp_type"] == "One_Time":
+            m["inst_freq"] = 1
+        elif m["cp_type"] == "Zero_Coupon":
+            m["inst_freq"] = 0
+        m["carry_date"] = data[1][i].strftime("%Y-%m-%d")  # 起息日
+        m["maturity_date"] = data[2][i].strftime("%Y-%m-%d")  # 到期日
+        m["day_count"] = data[6][i]  # 实际基准
+        returns.append(m)
+        print(m)
+        if save:
+            if not save_folder.exists():
+                save_folder.mkdir(parents=True)
+            path = save_folder / f"{symbol}.json"
+            save_json(path, m)
+        return returns
+
+
+WAIT_LOGIN = False
+
+
+def login():
+    global WAIT_LOGIN
+    if w.isconnected():
+        return
+    if WAIT_LOGIN:
+        import time
+
+        time.sleep(0.2)
+        login()
+    WAIT_LOGIN = True
+    login_res = w.start(waitTime=8)
+    WAIT_LOGIN = False
+    if login_res.ErrorCode != 0:
+        msg = f"Failed to login to Wind: {login_res.ErrorCode}"
+        raise RuntimeError(msg)
+
+
+def get_all_symbols():
+    sector_ids = (
+        # "a101010101000000",  # 国债银行间
+        # "a101010104000000",  # 政策性银行债
+        "a101010201000000",  # 上交所国债
+    )
+    res = []
+    names = []
+    for sector_id in sector_ids:
+        all_symbols = w.wset(
+            "sectorconstituent", f"sectorid={sector_id};field=wind_code,sec_name"
+        ).Data
+        res.extend(all_symbols[0])
+        names.extend(all_symbols[1])
+    print("共有", len(res), "只债券")
+    return res
+
+
+if __name__ == "__main__":
+    login()
+    # symbols = ["220003.IB", "220021.IB", "220006.IB", "220010.IB"]
+    # symbols = ["240006.IB"]
+
+    # symbols = ["019733.SH"]
+    # symbols = ["020647.SH"]
+    # symbols = ["019727.SH"]
+    symbols = ["2400006.IB"]
+    # symbols = get_all_symbols()
+
+    fetch_symbols(symbols, save=0, skip=True)

pybond/ffi/__init__.py

@@ -0,0 +1,3 @@
+from .bond import *
+from .datetime import *
+from .duration import *

pybond/ffi/bond.py

@@ -0,0 +1,68 @@
+import ctypes
+
+from .lib import lib
+
+create_bond = lib.create_bond
+create_bond.argstypes = (ctypes.c_void_p, ctypes.c_size_t)
+create_bond.restype = ctypes.c_void_p
+
+free_bond = lib.free_bond
+free_bond.argtypes = [ctypes.c_void_p]
+free_bond.restype = None
+
+bond_coupon_rate = lib.bond_coupon_rate
+bond_coupon_rate.argtypes = [ctypes.c_void_p]
+bond_coupon_rate.restype = ctypes.c_double
+
+bond_full_code = lib.bond_full_code
+bond_full_code.argtypes = [ctypes.c_void_p]
+bond_full_code.restype = ctypes.c_char_p
+
+bond_calc_ytm = lib.bond_calc_ytm
+bond_calc_ytm.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_double,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+]
+bond_calc_ytm.restype = ctypes.c_double
+
+bond_duration = lib.bond_duration
+bond_duration.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_double,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+]
+bond_duration.restype = ctypes.c_double
+
+bond_accrued_interest = lib.bond_accrued_interest
+bond_accrued_interest.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+]
+bond_accrued_interest.restype = ctypes.c_double
+
+bond_dirty_price = lib.bond_dirty_price
+bond_dirty_price.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_double,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+]
+bond_dirty_price.restype = ctypes.c_double
+
+bond_clean_price = lib.bond_clean_price
+bond_clean_price.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_double,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+]
+bond_clean_price.restype = ctypes.c_double

pybond/ffi/datetime.py

@@ -0,0 +1,58 @@
+import ctypes
+
+from .lib import lib
+
+build_datetime_ns = lib.build_datetime_ns
+build_datetime_ns.argtypes = (ctypes.c_int64,)
+build_datetime_ns.restype = ctypes.c_void_p
+
+build_datetime_from_utc_ns = lib.build_datetime_from_utc_ns
+build_datetime_from_utc_ns.argtypes = (ctypes.c_int64,)
+build_datetime_from_utc_ns.restype = ctypes.c_void_p
+
+local_timestamp_nanos = lib.local_timestamp_nanos
+local_timestamp_nanos.argtypes = (ctypes.c_void_p,)
+local_timestamp_nanos.restype = ctypes.c_int64
+
+timestamp_nanos = lib.timestamp_nanos
+timestamp_nanos.argtypes = (ctypes.c_void_p,)
+timestamp_nanos.restype = ctypes.c_int64
+
+utc_timestamp_to_local = lib.utc_timestamp_to_local
+utc_timestamp_to_local.argtypes = (ctypes.c_int64,)
+utc_timestamp_to_local.restype = ctypes.c_int64
+
+_free_datetime = lib.free_datetime
+_free_datetime.argtypes = (ctypes.c_void_p,)
+
+get_datetime_year = lib.get_datetime_year
+get_datetime_year.argtypes = (ctypes.c_void_p,)
+get_datetime_year.restype = ctypes.c_int32
+
+get_datetime_month = lib.get_datetime_month
+get_datetime_month.argtypes = (ctypes.c_void_p,)
+get_datetime_month.restype = ctypes.c_int32
+
+get_datetime_day = lib.get_datetime_day
+get_datetime_day.argtypes = (ctypes.c_void_p,)
+get_datetime_day.restype = ctypes.c_int32
+
+get_datetime_hour = lib.get_datetime_hour
+get_datetime_hour.argtypes = (ctypes.c_void_p,)
+get_datetime_hour.restype = ctypes.c_int32
+
+get_datetime_minute = lib.get_datetime_minute
+get_datetime_minute.argtypes = (ctypes.c_void_p,)
+get_datetime_minute.restype = ctypes.c_int32
+
+get_datetime_second = lib.get_datetime_second
+get_datetime_second.argtypes = (ctypes.c_void_p,)
+get_datetime_second.restype = ctypes.c_int32
+
+get_datetime_nanosecond = lib.get_datetime_nanosecond
+get_datetime_nanosecond.argtypes = (ctypes.c_void_p,)
+get_datetime_nanosecond.restype = ctypes.c_int32
+
+datetime_with_time = lib.datetime_with_time
+datetime_with_time.argtypes = (ctypes.c_void_p, (ctypes.c_uint32 * 6))
+datetime_with_time.restype = ctypes.c_void_p

pybond/ffi/duration.py

@@ -0,0 +1,19 @@
+import ctypes
+
+from .lib import lib
+
+parse_duration = lib.parse_duration
+parse_duration.argtypes = [ctypes.c_void_p, ctypes.c_size_t]
+parse_duration.restype = ctypes.c_void_p
+
+datetime_sub_datetime = lib.datetime_sub_datetime
+datetime_sub_datetime.argtypes = [ctypes.c_int64, ctypes.c_int64]
+datetime_sub_datetime.restype = ctypes.c_void_p
+
+datetime_add_duration = lib.datetime_add_duration
+datetime_add_duration.argtypes = [ctypes.c_int64, ctypes.c_void_p]
+datetime_add_duration.restype = ctypes.c_int64
+
+datetime_sub_duration = lib.datetime_sub_duration
+datetime_sub_duration.argtypes = [ctypes.c_int64, ctypes.c_void_p]
+datetime_sub_duration.restype = ctypes.c_int64

pybond/ffi/lib.py

@@ -0,0 +1,8 @@
+import ctypes
+
+import llvmlite.binding
+
+from pybond import pybond
+
+lib = ctypes.cdll.LoadLibrary(pybond.__file__)
+llvmlite.binding.load_library_permanently(pybond.__file__)

pybond/nb/__init__.py

@@ -0,0 +1,27 @@
+# from datetime import date, datetime, time
+
+from .nb_bond import Bond, BondType, bond_type
+from .nb_date import DateType, date_type
+from .nb_datetime import DateTime, DateTimeType, datetime_type
+from .nb_duration import Duration, DurationType, duration_type
+from .nb_time import Time, TimeType, time_type
+
+__all__ = [
+    "Bond",
+    "BondType",
+    "bond_type",
+    "DateTime",
+    "DateTimeType",
+    "DateType",
+    "Duration",
+    "DurationType",
+    "duration_type",
+    "Time",
+    "TimeType",
+    # "date",
+    "date_type",
+    # "datetime",
+    "datetime_type",
+    # "time",
+    "time_type",
+]

pybond/nb/ir_utils.py

@@ -0,0 +1,47 @@
+from llvmlite import ir
+from numba.core import cgutils
+
+
+def ir_isinstance(pyapi, obj, typ):
+    fnty = ir.FunctionType(ir.IntType(1), [pyapi.pyobj, pyapi.pyobj])
+    fn = cgutils.get_or_insert_function(
+        pyapi.builder.module, fnty, name="PyObject_IsInstance"
+    )
+    return pyapi.builder.call(fn, (obj, typ))
+
+
+def ir_build_datetime(val, builder, *, from_utc: bool = False):
+    mod = builder.module
+    fnty = ir.FunctionType(ir.PointerType(ir.IntType(8)), [ir.IntType(64)])
+    if not from_utc:
+        build_datetime_ns_fn = cgutils.get_or_insert_function(
+            mod, fnty, "build_datetime_ns"
+        )
+    else:
+        build_datetime_ns_fn = cgutils.get_or_insert_function(
+            mod, fnty, "build_datetime_from_utc_ns"
+        )
+    ptr = builder.call(build_datetime_ns_fn, [val])
+    return ptr
+
+
+def ir_timestamp_nanos(ptr, builder):
+    mod = builder.module
+    fnty = ir.FunctionType(ir.IntType(64), [ir.PointerType(ir.IntType(8))])
+    fn = cgutils.get_or_insert_function(mod, fnty, "timestamp_nanos")
+    ptr = builder.call(fn, [ptr])
+    return ptr
+
+
+def ir_local_timestamp_nanos(ptr, builder):
+    mod = builder.module
+    fnty = ir.FunctionType(ir.IntType(64), [ir.PointerType(ir.IntType(8))])
+    fn = cgutils.get_or_insert_function(mod, fnty, "local_timestamp_nanos")
+    ptr = builder.call(fn, [ptr])
+    return ptr
+
+
+def long_as_ulong(pyapi, numobj):
+    fnty = ir.FunctionType(pyapi.ulong, [pyapi.pyobj])
+    fn = pyapi._get_function(fnty, name="PyLong_AsUnsignedLong")
+    return pyapi.builder.call(fn, [numobj])