Python dataclass中自定义__eq__方法继承策略

import datetime
from dataclasses import dataclass, astuple
from typing import Iterator, Optional

class ComparisonMixin:
    """
    一个包含自定义__eq__方法的混入类
    """
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, type(self)):
            return NotImplemented

        # 假设可以通过astuple获取所有字段进行比较
        # 注意：这里需要确保子类可以被astuple处理
        # 实际应用中，可能需要更健壮的字段访问方式
        for s_val, o_val in zip(astuple(self), astuple(other)):
            if isinstance(s_val, datetime.datetime) and isinstance(o_val, datetime.datetime):
                margin = datetime.timedelta(days=3)
                if not (s_val - margin <= o_val <= s_val + margin):
                    return False
            elif s_val != o_val: # 对于其他类型，进行严格相等比较
                # 原始问题中有一个o_val的布尔判断，这里简化为直接比较
                return False
        return True

    def __iter__(self) -> Iterator:
        # 辅助方法，用于迭代dataclass的字段
        return iter(astuple(self))

@dataclass
class Bloodsample(ComparisonMixin):
    datetime: datetime.datetime
    substance: str
    value: float
    category: Optional[str] = None

# 预期行为：允许category字段为None或不同，但其他字段相同则相等
sample = Bloodsample(datetime.datetime(2024, 1, 9), "hemoglobin", 9.5, "hematology")
sample_with_none_category = Bloodsample(datetime.datetime(2024, 1, 9), "hemoglobin", 9.5, None)

# 此时，`sample == sample_with_none_category` 会返回 False
# 因为@dataclass默认生成的__eq__方法会比较所有字段，包括category
# 这与ComparisonMixin中期望的自定义逻辑相悖

import dataclasses
import datetime
from typing import Iterator, Optional

# 沿用之前的ComparisonMixin
class ComparisonMixin:
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, type(self)):
            return NotImplemented

        # 简化版，假设我们知道要比较的字段顺序和类型
        # 实际应用中，更稳健的方式是迭代self.__dict__或使用dataclasses.fields
        self_tuple = dataclasses.astuple(self)
        other_tuple = dataclasses.astuple(other)

        for s_val, o_val in zip(self_tuple, other_tuple):
            if isinstance(s_val, datetime.datetime) and isinstance(o_val, datetime.datetime):
                margin = datetime.timedelta(days=3)
                if not (s_val - margin <= o_val <= s_val + margin):
                    return False
            elif s_val != o_val:
                return False
        return True

    # 注意：__iter__在这里不直接影响__eq__的继承问题，但如果需要，可以保留
    # def __iter__(self) -> Iterator:
    #     return iter(dataclasses.astuple(self))

@dataclasses.dataclass(eq=False) # 关键：禁用dataclass自动生成__eq__
class Bloodsample(ComparisonMixin):
    datetime: datetime.datetime
    substance: str
    value: float
    category: Optional[str] = None

# 验证解决方案
sample = Bloodsample(datetime.datetime(2024, 1, 9), "hemoglobin", 9.5, "hematology")
sample_with_none_category = Bloodsample(datetime.datetime(2024, 1, 9), "hemoglobin", 9.5, None)

# 现在，由于eq=False，Bloodsample会使用ComparisonMixin中的__eq__方法
# 假设ComparisonMixin的__eq__逻辑允许category不同时仍视为相等
# （为了简化，这里我们假设自定义逻辑会忽略category字段的差异，
#  或根据其特定规则处理None值，以使这个assert通过。
#  原始问题中的__eq__逻辑是：如果o_val存在，则s_val == o_val，否则继续。
#  如果s_val是"hematology"而o_val是None，则s_val != o_val，会返回False。
#  为了让assert通过，ComparisonMixin的__eq__需要调整，例如显式忽略某些字段或处理None。）

# 为了演示eq=False的效果，我们使用一个更通用的例子来验证继承的__eq__是否被调用。
# 假设我们修改ComparisonMixin的__eq__来打印一条消息：
class DebugComparisonMixin:
    def __eq__(self, other):
        print("--- 调用了自定义的__eq__方法 ---")
        # 简单示例，实际逻辑应更复杂
        if not isinstance(other, type(self)):
            return NotImplemented
        return True # 总是返回True，仅为演示调用

@dataclasses.dataclass
class Bar(DebugComparisonMixin):
    x: int
    y: int

@dataclasses.dataclass(eq=False)
class Baz(DebugComparisonMixin):
    x: int
    y: int

print("\n--- 验证Bar类 (默认eq=True) ---")
# Bar会使用dataclass生成的__eq__，不会调用DebugComparisonMixin的__eq__
print(Bar(1, 2) == Bar(1, 3)) # 预期输出 False

print("\n--- 验证Baz类 (eq=False) ---")
# Baz会使用DebugComparisonMixin的__eq__
print(Baz(1, 2) == Baz(1, 3)) # 预期输出 "--- 调用了自定义的__eq__方法 ---" 和 True

--- 验证Bar类 (默认eq=True) ---
False

--- 验证Baz类 (eq=False) ---
--- 调用了自定义的__eq__方法 ---
True