tea-bond 0.2.8__cp310-abi3-macosx_11_0_arm64.whl → 0.3.0__cp310-abi3-macosx_11_0_arm64.whl

pybond/__init__.py

@@ -2,7 +2,6 @@ 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
 
@@ -13,5 +12,4 @@ class TfEvaluator(_TfEvaluatorRS):
             bond = Bond(bond)
         return super().__new__(cls, future, bond, *args, **kwargs)
 
-
 __all__ = ["Bond", "Future", "Ib", "Sse", "TfEvaluator"]

pybond/bond.py

@@ -5,6 +5,7 @@ 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
 
@@ -14,6 +15,7 @@ if os.environ.get("BONDS_INFO_PATH") is not None:
 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)

pybond/ffi/__init__.py

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

pybond/ffi/bond.py

@@ -3,7 +3,7 @@ import ctypes
 from .lib import lib
 
 create_bond = lib.create_bond
-create_bond.argstypes = (ctypes.c_void_p, ctypes.c_size_t)
+create_bond.argtypes = (ctypes.c_void_p, ctypes.c_size_t)
 create_bond.restype = ctypes.c_void_p
 
 free_bond = lib.free_bond

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/nb/__init__.py

@@ -4,6 +4,7 @@ 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_evaluators import TfEvaluator, TfEvaluatorType, tf_evaluator_type
 from .nb_time import Time, TimeType, time_type
 
 __all__ = [
@@ -16,6 +17,9 @@ __all__ = [
     "Duration",
     "DurationType",
     "duration_type",
+    "TfEvaluator",
+    "TfEvaluatorType",
+    "tf_evaluator_type",
     "Time",
     "TimeType",
     # "date",

pybond/nb/nb_bond.py

@@ -1,25 +1,19 @@
-import numba as nb
 from llvmlite import ir
 from numba import types
 from numba.core import cgutils, utils
 from numba.cpython.hashing import _Py_hash_t
-from numba.experimental import jitclass
 from numba.extending import (
-    NativeValue,
     as_numba_type,
     box,
     intrinsic,
     lower_builtin,
-    lower_getattr,
     make_attribute_wrapper,
     models,
-    overload,
     overload_attribute,
     overload_method,
     register_model,
     type_callable,
     typeof_impl,
-    unbox,
 )
 
 from pybond import Bond
@@ -46,12 +40,12 @@ as_numba_type.register(Bond, bond_type)
 
 
 @typeof_impl.register(Bond)
-def typeof_index(val, c):
+def typeof_bond(val, c):
     return bond_type
 
 
 @type_callable(Bond)
-def type_datetime(context):
+def type_bond(context):
     def typer(val):
         return bond_type
 

pybond/nb/nb_date.py

@@ -93,9 +93,9 @@ def unbox_date(typ, obj, c):
     c.pyapi.decref(day_obj)
 
     date = cgutils.create_struct_proxy(typ)(c.context, c.builder)
-    date.year = year
-    date.month = month
-    date.day = second
+    date.year = c.builder.trunc(year, ir.IntType(32))
+    date.month = c.builder.trunc(month, ir.IntType(32))
+    date.day = c.builder.trunc(second, ir.IntType(32))
     # Check for errors
     is_error = cgutils.is_not_null(c.builder, c.pyapi.err_occurred())
     return NativeValue(date._getvalue(), is_error=is_error)

pybond/nb/nb_datetime.py

@@ -20,12 +20,9 @@ from numba.extending import (
     unbox,
 )
 
-# from pybond import ffi
 from pybond.ffi import (
     datetime_add_duration,
     datetime_sub_duration,
-    # build_datetime_from_utc_ns,
-    # build_datetime_ns,
     get_datetime_day,
     get_datetime_hour,
     get_datetime_minute,
@@ -33,9 +30,7 @@ from pybond.ffi import (
     get_datetime_nanosecond,
     get_datetime_second,
     get_datetime_year,
-    # local_timestamp_nanos,
     timestamp_nanos,
-    # utc_timestamp_to_local,
 )
 
 from .ir_utils import (

pybond/nb/nb_duration.py

@@ -1,27 +1,16 @@
-import datetime
-import operator
-
 from llvmlite import ir
 from numba import types
 from numba.core import cgutils, utils
 from numba.extending import (
-    NativeValue,
     as_numba_type,
-    box,
     lower_builtin,
     make_attribute_wrapper,
     models,
-    overload,
-    overload_attribute,
-    overload_method,
     register_model,
     type_callable,
     typeof_impl,
-    unbox,
 )
 
-# from .nb_time import Time
-
 
 class Duration:
     def __init__(self, fmt: str):

pybond/nb/nb_evaluators.py

@@ -0,0 +1,557 @@
+from llvmlite import ir
+from numba import types
+from numba.core import cgutils, utils
+from numba.extending import (
+    as_numba_type,
+    box,
+    intrinsic,
+    lower_builtin,
+    make_attribute_wrapper,
+    models,
+    overload_attribute,
+    overload_method,
+    register_model,
+    type_callable,
+    typeof_impl,
+)
+
+from pybond import TfEvaluator
+from pybond.ffi import (
+    tf_evaluator_accrued_interest,
+    tf_evaluator_basis_spread,
+    tf_evaluator_bond_ytm,
+    tf_evaluator_calc_all,
+    tf_evaluator_capital_rate,
+    tf_evaluator_carry,
+    tf_evaluator_cf,
+    tf_evaluator_clean_price,
+    tf_evaluator_deliver_accrued_interest,
+    tf_evaluator_deliver_cost,
+    tf_evaluator_dirty_price,
+    tf_evaluator_duration,
+    tf_evaluator_f_b_spread,
+    tf_evaluator_future_dirty_price,
+    tf_evaluator_future_price,
+    tf_evaluator_future_ytm,
+    tf_evaluator_irr,
+    tf_evaluator_is_deliverable,
+    tf_evaluator_net_basis_spread,
+    tf_evaluator_reinvest_rate,
+    tf_evaluator_remain_cp_num,
+    tf_evaluator_remain_cp_to_deliver,
+    tf_evaluator_remain_cp_to_deliver_wm,
+    tf_evaluator_remain_days_to_deliver,
+)
+
+from .nb_date import date_type
+
+
+class TfEvaluatorType(types.Type):
+    def __init__(self):
+        super().__init__(name="TfEvaluator")
+
+
+tf_evaluator_type = TfEvaluatorType()
+as_numba_type.register(TfEvaluator, tf_evaluator_type)
+
+
+@typeof_impl.register(TfEvaluator)
+def typeof_tf_evaluator(val, c):
+    return tf_evaluator_type
+
+
+@type_callable(TfEvaluator)
+def type_tf_evaluator(context):
+    def typer(
+        future,
+        bond,
+        date=None,
+        future_price=float("nan"),
+        bond_ytm=float("nan"),
+        capital_rate=float("nan"),
+        reinvest_rate=None,
+    ):
+        return tf_evaluator_type
+
+    return typer
+
+
+@register_model(TfEvaluatorType)
+class TfEvaluatorModel(models.StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ("ptr", types.voidptr),
+        ]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+
+make_attribute_wrapper(TfEvaluatorType, "ptr", "ptr")
+
+
+@lower_builtin(
+    TfEvaluator,
+    types.string,
+    types.string,
+    date_type,
+    types.float64,
+    types.float64,
+    types.float64,
+)
+def impl_tf_evaluator_builder(context, builder, sig, args):
+    typ = sig.return_type
+    (
+        future,
+        bond,
+        date_val,
+        future_price,
+        bond_ytm,
+        capital_rate,
+    ) = args
+
+    # Get string data from Numba strings
+    future_code = context.make_helper(builder, types.string, future)
+    bond_code = context.make_helper(builder, types.string, bond)
+    date = context.make_helper(builder, date_type, date_val)
+
+    # Call create_tf_evaluator
+    fn = cgutils.get_or_insert_function(
+        builder.module,
+        ir.FunctionType(
+            ir.PointerType(ir.IntType(8)),
+            [
+                ir.PointerType(ir.IntType(8)),  # future_code_ptr
+                ir.IntType(utils.MACHINE_BITS),  # future_code_len
+                ir.DoubleType(),  # future_price
+                ir.PointerType(ir.IntType(8)),  # bond_code_ptr
+                ir.IntType(utils.MACHINE_BITS),  # bond_code_len
+                ir.DoubleType(),  # bond_ytm
+                ir.DoubleType(),  # capital_rate
+                ir.IntType(32),  # year
+                ir.IntType(32),  # month
+                ir.IntType(32),  # day
+            ],
+        ),
+        name="create_tf_evaluator",
+    )
+
+    ptr = builder.call(
+        fn,
+        [
+            future_code.data,
+            future_code.length,
+            future_price,
+            bond_code.data,
+            bond_code.length,
+            bond_ytm,
+            capital_rate,
+            date.year,
+            date.month,
+            date.day,
+        ],
+    )
+
+    # Create TfEvaluator object
+    evaluator = cgutils.create_struct_proxy(typ)(context, builder)
+    evaluator.ptr = ptr
+    return evaluator._getvalue()
+
+
+@lower_builtin(
+    TfEvaluator,
+    types.string,
+    types.string,
+    date_type,
+    types.float64,
+    types.float64,
+    types.float64,
+    types.float64,
+)
+def impl_tf_evaluator_builder_with_reinvest(context, builder, sig, args):
+    typ = sig.return_type
+    (
+        future_code_val,
+        bond_code_val,
+        date_val,
+        future_price_val,
+        bond_ytm_val,
+        capital_rate_val,
+        reinvest_rate_val,
+    ) = args
+
+    # Get string data from Numba strings
+    future_code = context.make_helper(builder, types.string, future_code_val)
+    bond_code = context.make_helper(builder, types.string, bond_code_val)
+
+    # Get date components
+    date = context.make_helper(builder, date_type, date_val)
+
+    # Call create_tf_evaluator_with_reinvest
+    fn = cgutils.get_or_insert_function(
+        builder.module,
+        ir.FunctionType(
+            ir.PointerType(ir.IntType(8)),
+            [
+                ir.PointerType(ir.IntType(8)),  # future_code_ptr
+                ir.IntType(utils.MACHINE_BITS),  # future_code_len
+                ir.DoubleType(),  # future_price
+                ir.PointerType(ir.IntType(8)),  # bond_code_ptr
+                ir.IntType(utils.MACHINE_BITS),  # bond_code_len
+                ir.DoubleType(),  # bond_ytm
+                ir.DoubleType(),  # capital_rate
+                ir.DoubleType(),  # reinvest_rate
+                ir.IntType(32),  # year
+                ir.IntType(32),  # month
+                ir.IntType(32),  # day
+            ],
+        ),
+        name="create_tf_evaluator_with_reinvest",
+    )
+
+    ptr = builder.call(
+        fn,
+        [
+            future_code.data,
+            future_code.length,
+            future_price_val,
+            bond_code.data,
+            bond_code.length,
+            bond_ytm_val,
+            capital_rate_val,
+            reinvest_rate_val,
+            date.year,
+            date.month,
+            date.day,
+        ],
+    )
+
+    # Create TfEvaluator object
+    evaluator = cgutils.create_struct_proxy(typ)(context, builder)
+    evaluator.ptr = ptr
+    return evaluator._getvalue()
+
+
+# Property getters
+@overload_attribute(TfEvaluatorType, "is_deliverable")
+def tf_evaluator_attr_is_deliverable(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_is_deliverable(evaluator.ptr) == 1
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "bond_ytm")
+def tf_evaluator_attr_bond_ytm(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_bond_ytm(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "future_price")
+def tf_evaluator_attr_future_price(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_future_price(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "capital_rate")
+def tf_evaluator_attr_capital_rate(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_capital_rate(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "reinvest_rate")
+def tf_evaluator_attr_reinvest_rate(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_reinvest_rate(evaluator.ptr)
+
+    return impl
+
+
+# Calculation methods
+@overload_attribute(TfEvaluatorType, "accrued_interest")
+def tf_evaluator_method_accrued_interest(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_accrued_interest(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "deliver_accrued_interest")
+def tf_evaluator_method_deliver_accrued_interest(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_deliver_accrued_interest(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "cf")
+def tf_evaluator_method_cf(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_cf(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "dirty_price")
+def tf_evaluator_method_dirty_price(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_dirty_price(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "clean_price")
+def tf_evaluator_method_clean_price(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_clean_price(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "future_dirty_price")
+def tf_evaluator_method_future_dirty_price(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_future_dirty_price(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "deliver_cost")
+def tf_evaluator_method_deliver_cost(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_deliver_cost(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "basis_spread")
+def tf_evaluator_method_basis_spread(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_basis_spread(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "f_b_spread")
+def tf_evaluator_method_f_b_spread(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_f_b_spread(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "carry")
+def tf_evaluator_method_carry(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_carry(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "net_basis_spread")
+def tf_evaluator_method_net_basis_spread(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_net_basis_spread(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "duration")
+def tf_evaluator_method_duration(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_duration(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "irr")
+def tf_evaluator_method_irr(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_irr(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "future_ytm")
+def tf_evaluator_method_future_ytm(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_future_ytm(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "remain_days_to_deliver")
+def tf_evaluator_method_remain_days_to_deliver(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_remain_days_to_deliver(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "remain_cp_num")
+def tf_evaluator_method_remain_cp_num(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_remain_cp_num(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "remain_cp_to_deliver")
+def tf_evaluator_method_remain_cp_to_deliver(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_remain_cp_to_deliver(evaluator.ptr)
+
+    return impl
+
+
+@overload_attribute(TfEvaluatorType, "remain_cp_to_deliver_wm")
+def tf_evaluator_method_remain_cp_to_deliver_wm(evaluator):
+    def impl(evaluator):
+        return tf_evaluator_remain_cp_to_deliver_wm(evaluator.ptr)
+
+    return impl
+
+
+@overload_method(TfEvaluatorType, "calc_all")
+def tf_evaluator_method_calc_all(evaluator):
+    def impl(evaluator):
+        _ = tf_evaluator_calc_all(evaluator.ptr)
+        return evaluator
+
+    return impl
+
+
+@box(TfEvaluatorType)
+def box_tf_evaluator(typ, val, c):
+    """
+    Convert a native TfEvaluator structure to python TfEvaluator.
+    """
+    evaluator = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val)
+
+    # Convert the pointer to usize for from_ptr method
+    ptr_as_usize = c.builder.ptrtoint(evaluator.ptr, ir.IntType(64))
+    ptr_obj = c.pyapi.from_native_value(types.uint64, ptr_as_usize)
+
+    # Get TfEvaluator class and call from_ptr
+    class_obj = c.pyapi.unserialize(c.pyapi.serialize_object(TfEvaluator))
+    from_ptr_method = c.pyapi.object_getattr_string(class_obj, "from_ptr")
+
+    # Call TfEvaluator.from_ptr(ptr)
+    res = c.pyapi.call_function_objargs(from_ptr_method, (ptr_obj,))
+
+    # Clean up Python objects
+    c.pyapi.decref(ptr_obj)
+    c.pyapi.decref(class_obj)
+    c.pyapi.decref(from_ptr_method)
+
+    return res
+
+
+@intrinsic
+def _tf_evaluator_update_call(
+    typingctx,
+    evaluator_t,
+    future_price_t,
+    bond_ytm_t,
+    date_t,
+    future_code_t,
+    bond_code_t,
+    capital_rate_t,
+):
+    """Intrinsic for calling tf_evaluator_update_info FFI function."""
+
+    def codegen(context, builder, sig, args):
+        (
+            evaluator_val,
+            future_price_val,
+            bond_ytm_val,
+            date_val,
+            future_code_val,
+            bond_code_val,
+            capital_rate_val,
+        ) = args
+
+        # Get existing evaluator
+        evaluator = cgutils.create_struct_proxy(tf_evaluator_type)(
+            context, builder, value=evaluator_val
+        )
+
+        # Get string data from Numba strings
+        future_code = context.make_helper(builder, types.string, future_code_val)
+        bond_code = context.make_helper(builder, types.string, bond_code_val)
+
+        # Get date components
+        date = context.make_helper(builder, date_type, date_val)
+
+        # Call tf_evaluator_update_info
+        fn = cgutils.get_or_insert_function(
+            builder.module,
+            ir.FunctionType(
+                ir.IntType(32),  # return type: i32
+                [
+                    ir.PointerType(ir.IntType(8)),  # evaluator ptr
+                    ir.PointerType(ir.IntType(8)),  # future_code_ptr
+                    ir.IntType(utils.MACHINE_BITS),  # future_code_len
+                    ir.DoubleType(),  # future_price
+                    ir.PointerType(ir.IntType(8)),  # bond_code_ptr
+                    ir.IntType(utils.MACHINE_BITS),  # bond_code_len
+                    ir.DoubleType(),  # bond_ytm
+                    ir.DoubleType(),  # capital_rate
+                    ir.IntType(32),  # year
+                    ir.IntType(32),  # month
+                    ir.IntType(32),  # day
+                ],
+            ),
+            name="tf_evaluator_update_info",
+        )
+
+        result = builder.call(
+            fn,
+            [
+                evaluator.ptr,
+                future_code.data,
+                future_code.length,
+                future_price_val,
+                bond_code.data,
+                bond_code.length,
+                bond_ytm_val,
+                capital_rate_val,
+                date.year,
+                date.month,
+                date.day,
+            ],
+        )
+
+        return result
+
+    sig = types.int32(
+        evaluator_t,
+        future_price_t,
+        bond_ytm_t,
+        date_t,
+        future_code_t,
+        bond_code_t,
+        capital_rate_t,
+    )
+    return sig, codegen
+
+
+@overload_method(TfEvaluatorType, "update")
+# 采用和update pyi同样的参数顺序
+def tf_evaluator_method_update(
+    evaluator, future_price, bond_ytm, date, future, bond, capital_rate
+):
+    def update_impl(
+        evaluator, future_price, bond_ytm, date, future, bond, capital_rate
+    ):
+        _result = _tf_evaluator_update_call(
+            evaluator, future_price, bond_ytm, date, future, bond, capital_rate
+        )
+        # Return the evaluator itself (it's been updated in-place)
+        return evaluator
+
+    return update_impl

pybond/pl.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from polars.type_aliases import IntoExpr
+import polars as pl
+
+from .polars_utils import parse_into_expr, register_plugin
+
+
+class TfEvaluators:
+    """A class for treasury futures evaluation using Polars expressions."""
+
+    def __init__(
+        self,
+        future: IntoExpr = "future",
+        bond: IntoExpr = "bond",
+        date: IntoExpr = "date",
+        future_price: IntoExpr = "future_price",
+        bond_ytm: IntoExpr = "bond_ytm",
+        capital_rate: IntoExpr = "capital_rate",
+        reinvest_rate=None,
+    ):
+        """
+        Initialize TfEvaluators with default column expressions.
+
+        Args:
+            future: Future contract code column expression
+            bond: Bond code column expression
+            date: Evaluation date column expression
+            future_price: Future price column expression
+            bond_ytm: Bond yield to maturity column expression
+            capital_rate: Capital cost rate column expression
+            reinvest_rate: Reinvestment rate (optional)
+        """
+        if future is None:
+            future = pl.lit(None).cast(str)
+        self.future = parse_into_expr(future)
+        self.bond = parse_into_expr(bond)
+        self.date = parse_into_expr(date)
+        self.future_price = parse_into_expr(future_price)
+        self.bond_ytm = parse_into_expr(bond_ytm)
+        self.capital_rate = parse_into_expr(capital_rate)
+        self.reinvest_rate = reinvest_rate
+
+    def _call_plugin(self, symbol: str):
+        """Helper method to call plugin with consistent arguments."""
+        return register_plugin(
+            args=[
+                self.future,
+                self.bond,
+                self.date,
+                self.future_price,
+                self.bond_ytm,
+                self.capital_rate,
+            ],
+            kwargs={"reinvest_rate": self.reinvest_rate},
+            symbol=symbol,
+            is_elementwise=False,
+        )
+
+    @property
+    def net_basis_spread(self):
+        """
+        Calculate net basis spread (净基差).
+
+        Net basis spread = basis spread - carry return
+
+        Returns:
+            Polars expression for net basis spread
+        """
+        return self._call_plugin("evaluators_net_basis_spread")
+
+    @property
+    def accrued_interest(self):
+        """
+        Calculate accrued interest (应计利息).
+
+        Returns:
+            Polars expression for accrued interest
+        """
+        return self._call_plugin("evaluators_accrued_interest")
+
+    @property
+    def deliver_accrued_interest(self):
+        """
+        Calculate delivery accrued interest (国债期货交割应计利息).
+
+        Returns:
+            Polars expression for delivery accrued interest
+        """
+        return self._call_plugin("evaluators_deliver_accrued_interest")
+
+    @property
+    def cf(self):
+        """
+        Calculate conversion factor (转换因子).
+
+        Returns:
+            Polars expression for conversion factor
+        """
+        return self._call_plugin("evaluators_cf")
+
+    @property
+    def dirty_price(self):
+        """
+        Calculate bond dirty price (债券全价).
+
+        Returns:
+            Polars expression for bond dirty price
+        """
+        return self._call_plugin("evaluators_dirty_price")
+
+    @property
+    def clean_price(self):
+        """
+        Calculate bond clean price (债券净价).
+
+        Returns:
+            Polars expression for bond clean price
+        """
+        return self._call_plugin("evaluators_clean_price")
+
+    @property
+    def future_dirty_price(self):
+        """
+        Calculate future dirty price (期货全价/发票价格).
+
+        Returns:
+            Polars expression for future dirty price
+        """
+        return self._call_plugin("evaluators_future_dirty_price")
+
+    @property
+    def deliver_cost(self):
+        """
+        Calculate delivery cost (交割成本).
+
+        Delivery cost = bond dirty price - interim coupon payments
+
+        Returns:
+            Polars expression for delivery cost
+        """
+        return self._call_plugin("evaluators_deliver_cost")
+
+    @property
+    def basis_spread(self):
+        """
+        Calculate basis spread (基差).
+
+        Returns:
+            Polars expression for basis spread
+        """
+        return self._call_plugin("evaluators_basis_spread")
+
+    @property
+    def f_b_spread(self):
+        """
+        Calculate futures-bond spread (期现价差).
+
+        Returns:
+            Polars expression for futures-bond spread
+        """
+        return self._call_plugin("evaluators_f_b_spread")
+
+    @property
+    def carry(self):
+        """
+        Calculate carry return (持有收益).
+
+        Carry return = (delivery accrued - trading accrued + interim coupons) +
+                      capital cost rate * (weighted average interim coupons - bond dirty price * remaining days / 365)
+
+        Returns:
+            Polars expression for carry return
+        """
+        return self._call_plugin("evaluators_carry")
+
+    @property
+    def duration(self):
+        """
+        Calculate modified duration (修正久期).
+
+        Returns:
+            Polars expression for modified duration
+        """
+        return self._call_plugin("evaluators_duration")
+
+    @property
+    def irr(self):
+        """
+        Calculate internal rate of return (内部收益率).
+
+        Returns:
+            Polars expression for internal rate of return
+        """
+        return self._call_plugin("evaluators_irr")
+
+    @property
+    def future_ytm(self):
+        """
+        Calculate futures implied yield to maturity (期货隐含收益率).
+
+        Returns:
+            Polars expression for futures implied yield to maturity
+        """
+        return self._call_plugin("evaluators_future_ytm")
+
+    @property
+    def remain_cp_to_deliver(self):
+        """
+        Calculate remaining coupon payments to delivery (到交割的期间付息).
+
+        Returns:
+            Polars expression for remaining coupon payments to delivery
+        """
+        return self._call_plugin("evaluators_remain_cp_to_deliver")
+
+    @property
+    def remain_cp_to_deliver_wm(self):
+        """
+        Calculate weighted average remaining coupon payments to delivery (加权平均到交割的期间付息).
+
+        Returns:
+            Polars expression for weighted average remaining coupon payments to delivery
+        """
+        return self._call_plugin("evaluators_remain_cp_to_deliver_wm")
+
+    @property
+    def remain_cp_num(self):
+        """
+        Calculate remaining number of coupon payments (债券剩余付息次数).
+
+        Returns:
+            Polars expression for remaining number of coupon payments
+        """
+        return self._call_plugin("evaluators_remain_cp_num")
+
+
+class Bonds:
+    def __init__(self, bond: IntoExpr = "symbol"):
+        self.bond = bond
+
+    def _evaluator(self, date=None, ytm=None) -> TfEvaluators:
+        return TfEvaluators(
+            future=None,
+            bond=self.bond,
+            date=date,
+            bond_ytm=ytm,
+            future_price=None,
+            capital_rate=None,
+            reinvest_rate=None,
+        )
+
+    def accrued_interest(self, date="date"):
+        return self._evaluator(date=date).accrued_interest
+
+    def clean_price(self, ytm="ytm", date="date"):
+        return self._evaluator(date=date, ytm=ytm).clean_price
+
+    def dirty_price(self, ytm="ytm", date="date"):
+        return self._evaluator(date=date, ytm=ytm).dirty_price
+
+    def duration(self, ytm="ytm", date="date"):
+        return self._evaluator(date=date, ytm=ytm).duration
+
+    def remain_cp_num(self, date="date"):
+        return self._evaluator(date=date).remain_cp_num
+
+    # TODO(Teamon): 实现向量化根据净价反推ytm的函数

pybond/pybond.pyi

@@ -187,6 +187,26 @@ class TfEvaluator:
         reinvest_rate: float | None = None,
     ) -> None: ...
     def copy(self) -> TfEvaluator: ...
+
+    def date(self) -> date:
+        """获取计算日期"""
+
+    @property
+    def bond_code(self) -> str:
+        """获取债券代码"""
+
+    @property
+    def bond_ytm(self) -> float:
+        """获取债券收益率"""
+
+    @property
+    def future(self) -> str:
+        """获取期货代码"""
+
+    @property
+    def future_price(self) -> float:
+        """获取期货价格"""
+
     @property
     def deliverable(self) -> bool:
         """判断债券是否是期货的可交割券"""
@@ -277,8 +297,8 @@ class TfEvaluator:
         future_price: float | None = None,
         bond_ytm: float | None = None,
         date: date | None = None,
-        future: Future | None = None,
-        bond: Bond | None = None,
+        future: Future | str | None = None,
+        bond: Bond | str | int | None = None,
         capital_rate: float | None = None,
         reinvest_rate: float | None = None,
     ) -> TfEvaluator:

{tea_bond-0.2.8.dist-info → tea_bond-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tea-bond
-Version: 0.2.8
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

tea_bond-0.3.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+pybond/__init__.py,sha256=7x1hBQtlQRhvgxfe6Z0wtQ5tWpTfUPMnaKyjddRyk9Y,430
+pybond/bond.py,sha256=8Tgy5rnDVk8OM6a1pXQlvfiv358BK_qS410XhgfC7mU,6533
+pybond/download.py,sha256=ehl_LfcfjCB5dtVvqD0P9PJzK1UYlqhzpDcBq5BycDI,4222
+pybond/ffi/__init__.py,sha256=x4FSqdM-SZPir9DL_XSMjoO9c4CWsyE5XfQr4GraGsg,94
+pybond/ffi/bond.py,sha256=8SFjwBtf-t0uEEgdgdP2TCHkTr-pJCvVsJ7qIKsdh6c,1586
+pybond/ffi/datetime.py,sha256=84vkmBhIf0HH4NEFeMLFbf83D_VewB5-PKeaDUobNmE,1989
+pybond/ffi/duration.py,sha256=ryVI3MmkLFaCKUlQa6L6MWFm5rFXmkhq1XlolyZsZGE,670
+pybond/ffi/evaluators.py,sha256=wz-52tVrK-0uUmCwIMl0yuTA13wTIVoYAHbEHdosBEI,6875
+pybond/ffi/lib.py,sha256=PtAjBwzpNG8CYKJ-NbLAXJCcezMmFR4VZ3vpvmuhsUI,173
+pybond/nb/__init__.py,sha256=-JvP7GpzQTKz-1Hcow_46EnakBWzJsr-3OoZjW8RQLY,746
+pybond/nb/ir_utils.py,sha256=a4CoNvRdXR5ENUOmBn-h4ZEWRc3BnSZ1LlY2wX_RDbU,1557
+pybond/nb/nb_bond.py,sha256=dLKVCgUgAwQu4MZm-zhRbzKPgM2wiWW_RIlA0VUvY7Y,5863
+pybond/nb/nb_date.py,sha256=f4-3C8j4tz_j8cG4iuDBRsWiNnPalg9epJt-fd6VPQs,5621
+pybond/nb/nb_datetime.py,sha256=9fLD9rnfpHQ-cvX4H6PoFh_O3jgk475ZKrG8q_UxT34,10264
+pybond/nb/nb_duration.py,sha256=FSX1y2JbHB_SJn-hcVe-7Zf2v0xpQKKZ1MfWBY7d7IQ,1639
+pybond/nb/nb_evaluators.py,sha256=fCYxcvW717_1E4qY9AV8R5Pv8eTvWqKk3Zj-zMU1kiw,14987
+pybond/nb/nb_time.py,sha256=LaqXfcNvmYD_lZ2u108MwrxCXoVCBX3cr3oOnPp3c1g,8649
+pybond/pl.py,sha256=CakQvQPjvWu8XykDfkBznFmFkIB8m-lVllF-8_BrUsw,7860
+pybond/pnl.py,sha256=P3KXc-gz6_TA2QxDQR9NHJIJPCvLOGT_v4qN4gzdcRY,1568
+pybond/polars_utils.py,sha256=A8D5T0x08oMCndWiQ5DPhLsuWp8s4OPgqvAnK36d8yY,2567
+pybond/pybond.abi3.so,sha256=mjMUO5EJvRSLTrMqRUIyvPQYLuE9YVT3KOjO5QpaeDs,23194624
+pybond/pybond.pyi,sha256=xME119HJzVNqNCJ9FapVaQg1amxbNHlbd-qfFyiuhL4,11230
+tea_bond-0.3.0.dist-info/METADATA,sha256=c2dzL9VFNbo_TPTU0qanImpw1gZ1oMgQ0xdChChprD0,258
+tea_bond-0.3.0.dist-info/WHEEL,sha256=6SJFcjb7LrrHSS0REgEixoO-eTgWD5-kklKS9aVl8Lw,103
+tea_bond-0.3.0.dist-info/RECORD,,

{tea_bond-0.2.8.dist-info → tea_bond-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.0)
+Generator: maturin (1.9.1)
 Root-Is-Purelib: false
 Tag: cp310-abi3-macosx_11_0_arm64

tea_bond-0.2.8.dist-info/RECORD

@@ -1,22 +0,0 @@
-pybond/__init__.py,sha256=3jDh14aBcaYtIqcCdHgEmO3Um3_4iJu8oOmQ-TrP3no,470
-pybond/bond.py,sha256=vqp404MB6wtkCs7MVwXLLkqE9M3fF81XNXpgKdSp5T4,6432
-pybond/download.py,sha256=ehl_LfcfjCB5dtVvqD0P9PJzK1UYlqhzpDcBq5BycDI,4222
-pybond/ffi/__init__.py,sha256=AfoWeiKIR8kRNOtHRiVKSkKYdh76usXG9ca5CmTQig0,68
-pybond/ffi/bond.py,sha256=zxmDRaMX51rdDW5DLjqKbVGWFmalbw_oGuiXA_9vNp4,1587
-pybond/ffi/datetime.py,sha256=84vkmBhIf0HH4NEFeMLFbf83D_VewB5-PKeaDUobNmE,1989
-pybond/ffi/duration.py,sha256=ryVI3MmkLFaCKUlQa6L6MWFm5rFXmkhq1XlolyZsZGE,670
-pybond/ffi/lib.py,sha256=PtAjBwzpNG8CYKJ-NbLAXJCcezMmFR4VZ3vpvmuhsUI,173
-pybond/nb/__init__.py,sha256=cqo0ohfxkVwDY-TQr8A68X_DCBG04FuP12RnO4FF5b0,604
-pybond/nb/ir_utils.py,sha256=a4CoNvRdXR5ENUOmBn-h4ZEWRc3BnSZ1LlY2wX_RDbU,1557
-pybond/nb/nb_bond.py,sha256=lFLrM7pKHcSLc1OfhUzUHz9e8bRxcav0jkwUMaOk5Ag,5988
-pybond/nb/nb_date.py,sha256=YUOxn3ZMrPEh6r6WVSug8N6cXLq4qlKKXxObXg2WW_A,5522
-pybond/nb/nb_datetime.py,sha256=-pXT5t0f7JL9TFcoq9UplFJ_Dafk0aCd-FMXJcuI8PY,10407
-pybond/nb/nb_duration.py,sha256=2e-KpUW74-g4cfaHH3HG-TPFeFBgwjp0gmV2bw-jGb0,1797
-pybond/nb/nb_time.py,sha256=LaqXfcNvmYD_lZ2u108MwrxCXoVCBX3cr3oOnPp3c1g,8649
-pybond/pnl.py,sha256=P3KXc-gz6_TA2QxDQR9NHJIJPCvLOGT_v4qN4gzdcRY,1568
-pybond/polars_utils.py,sha256=A8D5T0x08oMCndWiQ5DPhLsuWp8s4OPgqvAnK36d8yY,2567
-pybond/pybond.abi3.so,sha256=fGWCyYB-B4OzRNIH6Xqh5xxB9ajPRrcynPGxoN4I_DY,22859280
-pybond/pybond.pyi,sha256=tfBUxdT-oArCqgBvkxBq0OBbuaIG9M0K24t4vYZQ9zg,10823
-tea_bond-0.2.8.dist-info/METADATA,sha256=XiFpennfidloYPdBFu_KydrPbyFzb2ZWjARwZiTdxyk,258
-tea_bond-0.2.8.dist-info/WHEEL,sha256=wD2Ctt3-v4IFHfNiZHWpu5VDIR34tiGUub2S7_0Exgc,103
-tea_bond-0.2.8.dist-info/RECORD,,