如何通过元类或装饰器处理父类（数据类）的必填属性

问题背景 #

原生Python Dataclasses或高版本Pydantic中，子类继承带有必填属性的父类时，必须初始化所有父类的必填属性，否则会触发TypeError。比如父类A包含a、b两个必填属性，实例化子类B(a=1)时会提示缺少b参数，但我们希望仅初始化指定的部分属性，其余属性不触发错误，后续可按需赋值。

解决方案：自定义元类实现属性过滤 #

原生Dataclasses实现 #

通过自定义元类重写实例化逻辑，筛选出需要传递给父类的参数，跳过未指定的必填属性，后续可手动赋值：

from dataclasses import dataclass, is_dataclass
import inspect

class PartialInitMeta(type):
    def __new__(cls, name, bases, namespace, *, include_attrs=None):
        # 兼容Dataclass元类逻辑
        if is_dataclass(bases[0]):
            original_cls = super().__new__(cls, name, bases, namespace)
            dataclass_cls = dataclass(original_cls)
            dataclass_cls.__include_attrs__ = include_attrs or []
            return dataclass_cls
        return super().__new__(cls, name, bases, namespace)
    
    def __call__(cls, *args, **kwargs):
        # 提取父类的必填参数列表
        parent_init_sig = inspect.signature(super(cls, cls).__init__)
        parent_required = {
            param.name for param in parent_init_sig.parameters.values()
            if param.default is inspect.Parameter.empty and param.name != 'self'
        }
        
        # 筛选需要传递给父类的参数：指定属性或非必填父类属性
        filtered_kwargs = {
            k: v for k, v in kwargs.items()
            if k in cls.__include_attrs__ or k not in parent_required
        }
        
        # 创建实例并传递筛选后的参数
        instance = super().__call__(*args, **filtered_kwargs)
        
        # 给未传递的属性手动赋值
        for k, v in kwargs.items():
            if k not in filtered_kwargs:
                setattr(instance, k, v)
        return instance

# 定义父类A
@dataclass
class A:
    a: int
    b: int

# 定义子类B，指定仅初始化a属性
class B(A, metaclass=PartialInitMeta, include_attrs=['a']):
    pass

# 测试实例化
b_instance = B(a=1)
print(b_instance.a)  # 输出: 1
# 后续手动赋值b
b_instance.b = 2
print(b_instance.b)  # 输出: 2

高版本Pydantic（v2+）实现 #

通过自定义元类调整Pydantic模型的实例化逻辑，跳过未指定的必填字段校验：

from pydantic import BaseModel
from pydantic._internal._model_construction import ModelMetaclass

class PartialPydanticMeta(ModelMetaclass):
    def __new__(cls, name, bases, namespace, *, include_attrs=None):
        new_cls = super().__new__(cls, name, bases, namespace)
        new_cls.__include_attrs__ = include_attrs or []
        return new_cls
    
    def __call__(cls, *args, **kwargs):
        # 提取父类的必填字段
        parent_required_fields = set()
        for base in cls.__bases__:
            if issubclass(base, BaseModel):
                parent_required_fields.update(
                    k for k, v in base.model_fields.items() if v.is_required()
                )
        
        # 筛选需要传递的参数
        filtered_kwargs = {
            k: v for k, v in kwargs.items()
            if k in cls.__include_attrs__ or k not in parent_required_fields
        }
        
        # 创建实例
        instance = super().__call__(*args, **filtered_kwargs)
        
        # 给剩余字段手动赋值
        for k, v in kwargs.items():
            if k not in filtered_kwargs:
                setattr(instance, k, v)
        return instance

# 定义父类A
class A(BaseModel):
    a: int
    b: int

# 定义子类B，指定仅初始化a属性
class B(A, metaclass=PartialPydanticMeta, include_attrs=['a']):
    pass

# 测试实例化
b_instance = B(a=1)
print(b_instance.a)  # 输出: 1
# 后续手动赋值b
b_instance.b = 2
print(b_instance.b)  # 输出: 2

注意事项 #

• 该方案会绕过原生Dataclass或Pydantic的必填校验，仅适合业务逻辑允许属性延迟赋值的场景。
• 若需要后续校验未初始化的属性，可在业务代码中手动添加校验逻辑，或在调用核心方法前触发校验。

内容的提问来源于stack exchange，提问作者Nasir Shah