tea-bond 0.4.3__cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

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

pybond/nb/__init__.py

@@ -0,0 +1,31 @@
+# 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_evaluators import TfEvaluator, TfEvaluatorType, tf_evaluator_type
+from .nb_time import Time, TimeType, time_type
+
+__all__ = [
+    "Bond",
+    "BondType",
+    "DateTime",
+    "DateTimeType",
+    "DateType",
+    "Duration",
+    "DurationType",
+    "TfEvaluator",
+    "TfEvaluatorType",
+    "Time",
+    "TimeType",
+    "bond_type",
+    # "date",
+    "date_type",
+    # "datetime",
+    "datetime_type",
+    "duration_type",
+    "tf_evaluator_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])

pybond/nb/nb_bond.py

@@ -0,0 +1,213 @@
+from llvmlite import ir
+from numba import types
+from numba.core import cgutils, utils
+from numba.cpython.hashing import _Py_hash_t
+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 Bond
+from pybond.ffi import (
+    bond_accrued_interest,
+    bond_calc_ytm,
+    bond_clean_price,
+    bond_coupon_rate,
+    bond_dirty_price,
+    bond_duration,
+)
+from pybond.nb.nb_datetime import DateTimeType  # , create_bond
+
+from .nb_date import DateType
+
+
+class BondType(types.Type):
+    def __init__(self):
+        super().__init__(name="Bond")
+
+
+bond_type = BondType()
+as_numba_type.register(Bond, bond_type)
+
+
+@typeof_impl.register(Bond)
+def typeof_bond(val, c):
+    return bond_type
+
+
+@type_callable(Bond)
+def type_bond(context):
+    def typer(val):
+        return bond_type
+
+    return typer
+
+
+@register_model(BondType)
+class BondModel(models.StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ("ptr", types.voidptr),
+        ]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+
+make_attribute_wrapper(BondType, "ptr", "ptr")
+
+
+@lower_builtin(Bond, types.string)
+def impl_bond_builder(context, builder, sig, args):
+    typ = sig.return_type
+    (val,) = args
+    # Get string data from Numba string
+    code = context.make_helper(builder, types.string, val)
+    fn = cgutils.get_or_insert_function(
+        builder.module,
+        ir.FunctionType(
+            ir.PointerType(ir.IntType(8)),
+            [ir.PointerType(ir.IntType(8)), ir.IntType(utils.MACHINE_BITS)],
+        ),
+        name="create_bond",
+    )
+    ptr = builder.call(fn, [code.data, code.length])
+    # Create Bond object
+    bond = cgutils.create_struct_proxy(typ)(context, builder)
+    bond.ptr = ptr
+    return bond._getvalue()
+
+
+@overload_attribute(BondType, "coupon_rate")
+def bond_attr_coupon_rate(bond):
+    def impl(bond):
+        return bond_coupon_rate(bond.ptr)
+
+    return impl
+
+
+def ir_get_bond_full_code(ptr, context, builder):
+    """根据Bond的指针获取bond的代码(包括交易所信息)"""
+    fn = cgutils.get_or_insert_function(
+        builder.module,
+        ir.FunctionType(ir.PointerType(ir.IntType(8)), [ir.PointerType(ir.IntType(8))]),
+        name="bond_full_code",
+    )
+    cstr = builder.call(fn, [ptr])
+    # 使用 LLVM strlen
+    strlen_fn = cgutils.get_or_insert_function(
+        builder.module,
+        ir.FunctionType(ir.IntType(64), [ir.PointerType(ir.IntType(8))]),
+        name="strlen",
+    )
+    length = builder.call(strlen_fn, [cstr])
+    uni_str = cgutils.create_struct_proxy(types.unicode_type)(context, builder)
+    uni_str.data = cstr
+    uni_str.length = length
+    uni_str.kind = ir.Constant(ir.IntType(32), 1)  # kind=1 is PY_UNICODE_1BYTE_KIND
+    uni_str.is_ascii = ir.Constant(ir.IntType(32), 1)
+    uni_str.meminfo = context.get_constant_null(types.voidptr)
+    # Set hash to -1 to indicate that it should be computed.
+    # We cannot bake in the hash value because of hashseed randomization.
+    uni_str.hash = context.get_constant(_Py_hash_t, -1)
+    uni_str.parent = cgutils.get_null_value(uni_str.parent.type)
+    return uni_str._getvalue()
+
+
+@intrinsic
+def get_bond_full_code(typingctx, bond_ptr):
+    """根据Bond的指针获取bond的代码(包括交易所信息)"""
+
+    def codegen(context, builder, sig, args):
+        return ir_get_bond_full_code(args[0], context, builder)
+
+    sig = types.unicode_type(bond_ptr)
+    return sig, codegen
+
+
+@overload_attribute(BondType, "full_code")
+def get_full_code_attr(bond):
+    if isinstance(bond, BondType):
+
+        def impl(bond):
+            return get_bond_full_code(bond.ptr)
+
+        return impl
+
+
+@overload_method(BondType, "duration")
+def bond_calc_duration(bond, ytm, date):
+    if not isinstance(date, (DateType, DateTimeType)):
+        return
+
+    def impl(bond, ytm, date):
+        return bond_duration(bond.ptr, ytm, date.year, date.month, date.day)
+
+    return impl
+
+
+@overload_method(BondType, "accrued_interest")
+def bond_calc_accrued_interest(bond, date):
+    if not isinstance(date, (DateType, DateTimeType)):
+        return
+
+    def impl(bond, date):
+        return bond_accrued_interest(bond.ptr, date.year, date.month, date.day)
+
+    return impl
+
+
+@overload_method(BondType, "dirty_price")
+def bond_calc_dirty_price(bond, ytm, date):
+    if not isinstance(date, (DateType, DateTimeType)):
+        return
+
+    def impl(bond, ytm, date):
+        return bond_dirty_price(bond.ptr, ytm, date.year, date.month, date.day)
+
+    return impl
+
+
+@overload_method(BondType, "clean_price")
+def bond_calc_clean_price(bond, ytm, date):
+    if not isinstance(date, (DateType, DateTimeType)):
+        return
+
+    def impl(bond, ytm, date):
+        return bond_clean_price(bond.ptr, ytm, date.year, date.month, date.day)
+
+    return impl
+
+
+@overload_method(BondType, "calc_ytm_with_price")
+def bond_ytm_with_price(bond, dirty_price, date):
+    if not isinstance(date, (DateType, DateTimeType)):
+        return
+
+    def impl(bond, dirty_price, date):
+        return bond_calc_ytm(bond.ptr, dirty_price, date.year, date.month, date.day)
+
+    return impl
+
+
+@box(BondType)
+def box_bond(typ, val, c):
+    """
+    Convert a native Bond structure to python Bond.
+    """
+    bond = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val)
+    bond_code = ir_get_bond_full_code(bond.ptr, c.context, c.builder)
+    # Call Bond new to create a new Bond object
+    val_obj = c.pyapi.from_native_value(types.unicode_type, bond_code)
+    class_obj = c.pyapi.unserialize(c.pyapi.serialize_object(Bond))
+    res = c.pyapi.call_function_objargs(class_obj, (val_obj,))
+    c.pyapi.decref(val_obj)
+    c.pyapi.decref(class_obj)
+    return res

pybond/nb/nb_date.py

@@ -0,0 +1,209 @@
+import datetime
+import operator
+
+from llvmlite import ir
+from numba import types
+from numba.core import cgutils
+from numba.extending import (
+    NativeValue,
+    as_numba_type,
+    box,
+    lower_builtin,
+    make_attribute_wrapper,
+    models,
+    overload,
+    register_model,
+    type_callable,
+    typeof_impl,
+    unbox,
+)
+
+from .ir_utils import long_as_ulong
+
+
+class DateType(types.Type):
+    def __init__(self):
+        super().__init__(name="Date")
+
+
+date_type = DateType()
+as_numba_type.register(datetime.date, date_type)
+
+
+@typeof_impl.register(datetime.date)
+def typeof_datetime_date(val, c):
+    return date_type
+
+
+@type_callable(datetime.date)
+def type_date(context):
+    def typer(year, month, day):
+        return date_type
+
+    return typer
+
+
+@register_model(DateType)
+class DateModel(models.StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ("year", types.uint32),
+            ("month", types.uint32),
+            ("day", types.uint32),
+        ]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+
+make_attribute_wrapper(DateType, "year", "year")
+make_attribute_wrapper(DateType, "month", "month")
+make_attribute_wrapper(DateType, "day", "day")
+
+
+@lower_builtin(datetime.date, types.uint32, types.uint32, types.uint32)
+@lower_builtin(datetime.date, types.int32, types.int32, types.int32)
+def datetime_date_constructor_u32(context, builder, sig, args):
+    date_type = sig.return_type
+    date = cgutils.create_struct_proxy(date_type)(context, builder)
+    date.year = args[0]
+    date.month = args[1]
+    date.day = args[2]
+    return date._getvalue()
+
+
+@lower_builtin(datetime.date, types.int64, types.int64, types.int64)
+def datetime_date_constructor_i64(context, builder, sig, args):
+    date_type = sig.return_type
+    date = cgutils.create_struct_proxy(date_type)(context, builder)
+    date.year = builder.trunc(args[0], ir.IntType(32))
+    date.month = builder.trunc(args[1], ir.IntType(32))
+    date.day = builder.trunc(args[2], ir.IntType(32))
+    return date._getvalue()
+
+
+@unbox(DateType)
+def unbox_date(typ, obj, c):
+    year_obj = c.pyapi.object_getattr_string(obj, "year")
+    year = long_as_ulong(c.pyapi, year_obj)
+    month_obj = c.pyapi.object_getattr_string(obj, "month")
+    month = long_as_ulong(c.pyapi, month_obj)
+    day_obj = c.pyapi.object_getattr_string(obj, "day")
+    second = long_as_ulong(c.pyapi, day_obj)
+    c.pyapi.decref(year_obj)
+    c.pyapi.decref(month_obj)
+    c.pyapi.decref(day_obj)
+
+    date = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+    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)
+
+
+@box(DateType)
+def box_date(typ, val, c):
+    """
+    Box a native date object into a Python datetime.date object.
+    """
+    date = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val)
+    year_obj = c.pyapi.long_from_unsigned_int(date.year)
+    month_obj = c.pyapi.long_from_unsigned_int(date.month)
+    day_obj = c.pyapi.long_from_unsigned_int(date.day)
+
+    class_obj = c.pyapi.unserialize(c.pyapi.serialize_object(datetime.date))
+    date_obj = c.pyapi.call_function_objargs(class_obj, (year_obj, month_obj, day_obj))
+    c.pyapi.decref(year_obj)
+    c.pyapi.decref(month_obj)
+    c.pyapi.decref(day_obj)
+    return date_obj
+
+
+@overload(operator.ge)
+def impl_ge(dt, dt2):
+    if not isinstance(dt, DateType) or not isinstance(dt, DateType):
+        return
+
+    def impl(dt, dt2):
+        if dt.year == dt2.year:
+            if dt.month == dt2.month:
+                return dt.day >= dt2.day
+            else:
+                return dt.month >= dt2.month
+        else:
+            return dt.year >= dt2.year
+
+    return impl
+
+
+@overload(operator.gt)
+def impl_gt(dt, dt2):
+    if not isinstance(dt, DateType) or not isinstance(dt, DateType):
+        return
+
+    def impl(dt, dt2):
+        if dt.year == dt2.year:
+            if dt.month == dt2.month:
+                return dt.day > dt2.day
+            else:
+                return dt.month > dt2.month
+        else:
+            return dt.year > dt2.year
+
+    return impl
+
+
+@overload(operator.le)
+def impl_le(dt, dt2):
+    if not isinstance(dt, DateType) or not isinstance(dt, DateType):
+        return
+
+    def impl(dt, dt2):
+        if dt.year == dt2.year:
+            if dt.month == dt2.month:
+                return dt.day <= dt2.day
+            else:
+                return dt.month <= dt2.month
+        else:
+            return dt.year <= dt2.year
+
+    return impl
+
+
+@overload(operator.lt)
+def impl_lt(dt, dt2):
+    if not isinstance(dt, DateType) or not isinstance(dt, DateType):
+        return
+
+    def impl(dt, dt2):
+        if dt.year == dt2.year:
+            if dt.month == dt2.month:
+                return dt.day < dt2.day
+            else:
+                return dt.month < dt2.month
+        else:
+            return dt.year < dt2.year
+
+    return impl
+
+
+@overload(operator.eq)
+def impl_eq(dt, dt2):
+    if not isinstance(dt, DateType) or not isinstance(dt, DateType):
+        return
+
+    def impl(dt, dt2):
+        return dt.year == dt2.year and dt.month == dt2.month and dt.day == dt2.day
+
+    return impl
+
+
+@overload(operator.ne)
+def impl_ne(dt, dt2):
+    if not isinstance(dt, DateType) or not isinstance(dt, DateType):
+        return
+
+    def impl(dt, dt2):
+        return dt.year != dt2.year or dt.month != dt2.month or dt.day != dt2.day
+
+    return impl