如何实现类似Pydantic和Dataclass的动态类实例化类型提示？

问题背景 #

Pydantic和Dataclass都能基于属性类型为对象创建提供类型提示，同时自动文档化对象属性，示例代码如下：

from pydantic import BaseModel, PrivateAttr
from dataclasses import dataclass

# Pydantic方式
class Person(BaseModel):
    name : str
    address : str
    _valid : bool = PrivateAttr(default=False)

# dataclass方式
@dataclass
class PersonDataclass():
    name : str
    address : str
    _valid : bool = False

bob = Person(name="Bob", address="New York")
bobDataclass = PersonDataclass("Bob", "New York")

创建对象时，IDE会自动给出参数类型提示，对象属性也会被类型检查器识别。

我的尝试（无效实现） #

我尝试通过元类手动实现类似逻辑，代码能正常运行，但无法触发类型提示：

class MyBaseModelMeta(type):
    def __new__(cls, name, bases, dct):
        def new_init(self : cls, /, name : str, address : str):
            self.name = name
            self.address = address
            self._valid = False

        dct["__init__"] = new_init
        dct["__annotations__"] = {"__init__": {"name": str, "address": str, "_valid": bool}}
        return super().__new__(cls, name, bases, dct)

class MyBaseModel(metaclass=MyBaseModelMeta):
    def __repr__(self) -> str:
        return f"MyBaseModel: {self.__dict__}"

class MyPerson(MyBaseModel):
    pass

myBob = MyPerson("Bob", "New York")

错误原因分析 #

1. __annotations__设置错误：类的__annotations__应该存储类属性的类型注解，而非给__init__塞一个参数字典，你之前的写法完全不符合类型检查器的识别规范。
2. 静态分析限制：类型检查器（如Pyright、Mypy）是静态分析工具，不会执行元类的__new__代码，因此动态插入的__init__签名无法被识别。
3. 缺少显式属性声明：子类MyPerson没有显式声明属性，类型检查器无法静态推断出类的结构。

修正方案 #

方案1：元类读取子类注解并生成标准签名 #

让子类显式声明属性，元类读取这些注解生成符合规范的__init__，同时保留类注解供类型检查器识别：

import inspect
from typing import Any, Dict

class MyBaseModelMeta(type):
    def __new__(cls, name: str, bases: tuple[type, ...], dct: Dict[str, Any]) -> type:
        # 提取公共属性注解（排除私有属性）
        field_annotations = {k: v for k, v in dct.get('__annotations__', {}).items() if not k.startswith('_')}
        # 提取私有属性及默认值
        private_fields = {k: v for k, v in dct.items() if k.startswith('_')}

        def new_init(self, **kwargs: Any) -> None:
            # 初始化必填公共属性
            for field_name in field_annotations:
                if field_name not in kwargs:
                    raise ValueError(f"缺少必填字段: {field_name}")
                setattr(self, field_name, kwargs[field_name])
            # 初始化私有属性
            for field_name, default_val in private_fields.items():
                setattr(self, field_name, default_val)

        # 给__init__添加标准签名，让IDE识别参数提示
        sig_params = [
            inspect.Parameter('self', inspect.Parameter.POSITIONAL_OR_KEYWORD),
            *[
                inspect.Parameter(
                    name,
                    inspect.Parameter.KEYWORD_ONLY,
                    annotation=anno
                )
                for name, anno in field_annotations.items()
            ]
        ]
        new_init.__signature__ = inspect.Signature(sig_params)

        # 保留类的属性注解，让类型检查器识别对象属性
        dct['__init__'] = new_init
        dct.setdefault('__annotations__', {}).update({k: type(v) for k, v in private_fields.items()})
        return super().__new__(cls, name, bases, dct)

class MyBaseModel(metaclass=MyBaseModelMeta):
    def __repr__(self) -> str:
        return f"MyBaseModel: {self.__dict__}"

class MyPerson(MyBaseModel):
    name: str
    address: str
    _valid: bool = False

myBob = MyPerson(name="Bob", address="New York")

方案2：用协议类辅助类型提示 #

如果不想处理元类签名，可以定义Protocol协议类，让子类继承协议，告诉类型检查器类的结构：

from typing import Protocol

class PersonProtocol(Protocol):
    name: str
    address: str
    _valid: bool

class MyBaseModelMeta(type):
    def __new__(cls, name, bases, dct):
        def new_init(self, name: str, address: str):
            self.name = name
            self.address = address
            self._valid = False
        dct["__init__"] = new_init
        return super().__new__(cls, name, bases, dct)

class MyBaseModel(metaclass=MyBaseModelMeta):
    def __repr__(self) -> str:
        return f"MyBaseModel: {self.__dict__}"

class MyPerson(MyBaseModel, PersonProtocol):
    pass

myBob: PersonProtocol = MyPerson("Bob", "New York")

内容的提问来源于stack exchange，提问作者Murilo Rocha