tea-bond 0.3.10__cp38-abi3-manylinux_2_34_x86_64.whl

pybond/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .bond import Bond
+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):
+            # 便于直接从Wind下载债券基础数据
+            bond = Bond(bond)
+        return super().__new__(cls, future, bond, *args, **kwargs)
+
+
+__all__ = ["Bond", "Future", "Ib", "Sse", "TfEvaluator"]

pybond/bond.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+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
+
+# from .ffi.utils import set_bond_data_path
+
+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"
+    os.environ["BONDS_INFO_PATH"] = str(bonds_info_path)
+
+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,4 @@
+from .bond import *
+from .datetime import *
+from .duration import *
+from .evaluators import *

pybond/ffi/bond.py

@@ -0,0 +1,68 @@
+import ctypes
+
+from .lib import lib
+
+create_bond = lib.create_bond
+create_bond.argtypes = (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/evaluators.py

@@ -0,0 +1,186 @@
+import ctypes
+
+from .lib import lib
+
+# TfEvaluator creation and destruction
+create_tf_evaluator = lib.create_tf_evaluator
+create_tf_evaluator.argtypes = [
+    ctypes.c_void_p,  # future_code_ptr
+    ctypes.c_size_t,  # future_code_len
+    ctypes.c_double,  # future_price
+    ctypes.c_void_p,  # bond_code_ptr
+    ctypes.c_size_t,  # bond_code_len
+    ctypes.c_double,  # bond_ytm
+    ctypes.c_double,  # capital_rate
+    ctypes.c_uint32,  # year
+    ctypes.c_uint32,  # month
+    ctypes.c_uint32,  # day
+]
+create_tf_evaluator.restype = ctypes.c_void_p
+
+create_tf_evaluator_with_reinvest = lib.create_tf_evaluator_with_reinvest
+create_tf_evaluator_with_reinvest.argtypes = [
+    ctypes.c_void_p,  # future_code_ptr
+    ctypes.c_size_t,  # future_code_len
+    ctypes.c_double,  # future_price
+    ctypes.c_void_p,  # bond_code_ptr
+    ctypes.c_size_t,  # bond_code_len
+    ctypes.c_double,  # bond_ytm
+    ctypes.c_double,  # capital_rate
+    ctypes.c_double,  # reinvest_rate
+    ctypes.c_uint32,  # year
+    ctypes.c_uint32,  # month
+    ctypes.c_uint32,  # day
+]
+create_tf_evaluator_with_reinvest.restype = ctypes.c_void_p
+
+free_tf_evaluator = lib.free_tf_evaluator
+free_tf_evaluator.argtypes = [ctypes.c_void_p]
+free_tf_evaluator.restype = None
+
+# Basic properties
+tf_evaluator_is_deliverable = lib.tf_evaluator_is_deliverable
+tf_evaluator_is_deliverable.argtypes = [ctypes.c_void_p]
+tf_evaluator_is_deliverable.restype = ctypes.c_int
+
+tf_evaluator_bond_code = lib.tf_evaluator_bond_code
+tf_evaluator_bond_code.argtypes = [ctypes.c_void_p]
+tf_evaluator_bond_code.restype = ctypes.c_char_p
+
+tf_evaluator_future_code = lib.tf_evaluator_future_code
+tf_evaluator_future_code.argtypes = [ctypes.c_void_p]
+tf_evaluator_future_code.restype = ctypes.c_char_p
+
+tf_evaluator_bond_ytm = lib.tf_evaluator_bond_ytm
+tf_evaluator_bond_ytm.argtypes = [ctypes.c_void_p]
+tf_evaluator_bond_ytm.restype = ctypes.c_double
+
+tf_evaluator_future_price = lib.tf_evaluator_future_price
+tf_evaluator_future_price.argtypes = [ctypes.c_void_p]
+tf_evaluator_future_price.restype = ctypes.c_double
+
+tf_evaluator_capital_rate = lib.tf_evaluator_capital_rate
+tf_evaluator_capital_rate.argtypes = [ctypes.c_void_p]
+tf_evaluator_capital_rate.restype = ctypes.c_double
+
+tf_evaluator_reinvest_rate = lib.tf_evaluator_reinvest_rate
+tf_evaluator_reinvest_rate.argtypes = [ctypes.c_void_p]
+tf_evaluator_reinvest_rate.restype = ctypes.c_double
+
+# Date functions
+tf_evaluator_get_date = lib.tf_evaluator_get_date
+tf_evaluator_get_date.argtypes = [
+    ctypes.c_void_p,
+    ctypes.POINTER(ctypes.c_uint32),
+    ctypes.POINTER(ctypes.c_uint32),
+    ctypes.POINTER(ctypes.c_uint32),
+]
+tf_evaluator_get_date.restype = None
+
+tf_evaluator_get_deliver_date = lib.tf_evaluator_get_deliver_date
+tf_evaluator_get_deliver_date.argtypes = [
+    ctypes.c_void_p,
+    ctypes.POINTER(ctypes.c_uint32),
+    ctypes.POINTER(ctypes.c_uint32),
+    ctypes.POINTER(ctypes.c_uint32),
+]
+tf_evaluator_get_deliver_date.restype = ctypes.c_int
+
+# Calculation functions
+tf_evaluator_accrued_interest = lib.tf_evaluator_accrued_interest
+tf_evaluator_accrued_interest.argtypes = [ctypes.c_void_p]
+tf_evaluator_accrued_interest.restype = ctypes.c_double
+
+tf_evaluator_deliver_accrued_interest = lib.tf_evaluator_deliver_accrued_interest
+tf_evaluator_deliver_accrued_interest.argtypes = [ctypes.c_void_p]
+tf_evaluator_deliver_accrued_interest.restype = ctypes.c_double
+
+tf_evaluator_cf = lib.tf_evaluator_cf
+tf_evaluator_cf.argtypes = [ctypes.c_void_p]
+tf_evaluator_cf.restype = ctypes.c_double
+
+tf_evaluator_dirty_price = lib.tf_evaluator_dirty_price
+tf_evaluator_dirty_price.argtypes = [ctypes.c_void_p]
+tf_evaluator_dirty_price.restype = ctypes.c_double
+
+tf_evaluator_clean_price = lib.tf_evaluator_clean_price
+tf_evaluator_clean_price.argtypes = [ctypes.c_void_p]
+tf_evaluator_clean_price.restype = ctypes.c_double
+
+tf_evaluator_future_dirty_price = lib.tf_evaluator_future_dirty_price
+tf_evaluator_future_dirty_price.argtypes = [ctypes.c_void_p]
+tf_evaluator_future_dirty_price.restype = ctypes.c_double
+
+tf_evaluator_deliver_cost = lib.tf_evaluator_deliver_cost
+tf_evaluator_deliver_cost.argtypes = [ctypes.c_void_p]
+tf_evaluator_deliver_cost.restype = ctypes.c_double
+
+tf_evaluator_basis_spread = lib.tf_evaluator_basis_spread
+tf_evaluator_basis_spread.argtypes = [ctypes.c_void_p]
+tf_evaluator_basis_spread.restype = ctypes.c_double
+
+tf_evaluator_f_b_spread = lib.tf_evaluator_f_b_spread
+tf_evaluator_f_b_spread.argtypes = [ctypes.c_void_p]
+tf_evaluator_f_b_spread.restype = ctypes.c_double
+
+tf_evaluator_carry = lib.tf_evaluator_carry
+tf_evaluator_carry.argtypes = [ctypes.c_void_p]
+tf_evaluator_carry.restype = ctypes.c_double
+
+tf_evaluator_net_basis_spread = lib.tf_evaluator_net_basis_spread
+tf_evaluator_net_basis_spread.argtypes = [ctypes.c_void_p]
+tf_evaluator_net_basis_spread.restype = ctypes.c_double
+
+tf_evaluator_duration = lib.tf_evaluator_duration
+tf_evaluator_duration.argtypes = [ctypes.c_void_p]
+tf_evaluator_duration.restype = ctypes.c_double
+
+tf_evaluator_irr = lib.tf_evaluator_irr
+tf_evaluator_irr.argtypes = [ctypes.c_void_p]
+tf_evaluator_irr.restype = ctypes.c_double
+
+tf_evaluator_future_ytm = lib.tf_evaluator_future_ytm
+tf_evaluator_future_ytm.argtypes = [ctypes.c_void_p]
+tf_evaluator_future_ytm.restype = ctypes.c_double
+
+tf_evaluator_remain_days_to_deliver = lib.tf_evaluator_remain_days_to_deliver
+tf_evaluator_remain_days_to_deliver.argtypes = [ctypes.c_void_p]
+tf_evaluator_remain_days_to_deliver.restype = ctypes.c_int
+
+tf_evaluator_remain_cp_num = lib.tf_evaluator_remain_cp_num
+tf_evaluator_remain_cp_num.argtypes = [ctypes.c_void_p]
+tf_evaluator_remain_cp_num.restype = ctypes.c_int
+
+tf_evaluator_remain_cp_to_deliver = lib.tf_evaluator_remain_cp_to_deliver
+tf_evaluator_remain_cp_to_deliver.argtypes = [ctypes.c_void_p]
+tf_evaluator_remain_cp_to_deliver.restype = ctypes.c_double
+
+tf_evaluator_remain_cp_to_deliver_wm = lib.tf_evaluator_remain_cp_to_deliver_wm
+tf_evaluator_remain_cp_to_deliver_wm.argtypes = [ctypes.c_void_p]
+tf_evaluator_remain_cp_to_deliver_wm.restype = ctypes.c_double
+
+tf_evaluator_calc_all = lib.tf_evaluator_calc_all
+tf_evaluator_calc_all.argtypes = [ctypes.c_void_p]
+tf_evaluator_calc_all.restype = ctypes.c_int
+
+# Update function
+tf_evaluator_update_info = lib.tf_evaluator_update_info
+tf_evaluator_update_info.argtypes = [
+    ctypes.c_void_p,  # evaluator
+    ctypes.c_void_p,  # future_code_ptr
+    ctypes.c_size_t,  # future_code_len
+    ctypes.c_double,  # future_price
+    ctypes.c_void_p,  # bond_code_ptr
+    ctypes.c_size_t,  # bond_code_len
+    ctypes.c_double,  # bond_ytm
+    ctypes.c_double,  # capital_rate
+    ctypes.c_uint32,  # year
+    ctypes.c_uint32,  # month
+    ctypes.c_uint32,  # day
+]
+tf_evaluator_update_info.restype = ctypes.c_int
+
+# Utility function
+free_string = lib.free_string
+free_string.argtypes = [ctypes.c_char_p]
+free_string.restype = None

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__)