Pydantic配置继承抽象基类模式

from pydantic import BaseModel


class StrictModel(BaseModel):
    class Config:
        extra = "forbid"  # 禁止额外字段
        anystr_strip_whitespace = True  # 自动去除空格
        validate_all = True  # 强制全字段校验
        json_encoders = {  # 自定义JSON编码
            datetime: lambda v: v.timestamp()
        }

class BaseConfigModel(BaseModel):
    class Config:
        allow_mutation = False
        use_enum_values = True


class UserModel(BaseConfigModel):
    class Config(BaseConfigModel.Config):
        anystr_lower = True  # 新增配置


# 验证配置继承
print(UserModel.Config.allow_mutation)  # 输出: False

class Tier1Config(BaseModel):
    class Config:
        allow_population_by_field_name = True


class Tier2Config(Tier1Config):
    class Config(Tier1Config.Config):
        json_loads = orjson.loads


class ProductionModel(Tier2Config):
    class Config(Tier2Config.Config):
        max_anystr_length = 1000

from types import SimpleNamespace


def create_configurable_model(config: SimpleNamespace):
    class DynamicModel(BaseModel):
        class Config:
            allow_mutation = config.allow_edit
            extra = config.extra_fields

    return DynamicModel


# 动态创建模型
prod_config = SimpleNamespace(
    allow_edit=False,
    extra_fields="ignore"
)
ProdModel = create_configurable_model(prod_config)

from pydantic import BaseModel, ConfigDict


class ReloadableModel(BaseModel):
    model_config = ConfigDict(
        validate_default=True,
        revalidate_instances="always"
    )

    @classmethod
    def reload_config(cls, new_config: dict):
        cls.model_config.update(new_config)

class MicroserviceBase(BaseModel):
    class Config:
        extra = "forbid"
        json_encoders = {
            SecretStr: lambda v: v.get_secret_value()
        }


class UserServiceModel(MicroserviceBase):
    class Config(MicroserviceBase.Config):
        anystr_strip_whitespace = True


class PaymentServiceModel(MicroserviceBase):
    class Config(MicroserviceBase.Config):
        arbitrary_types_allowed = True

class EnvironmentConfig:
    base = {"extra": "forbid"}
    dev = {**base, "strict": False}
    prod = {**base, "strict": True}


def create_env_model(model: Type[BaseModel], env: str):
    return type(
        f"{env}Model",
        (model,),
        {"Config": type("Config", (model.Config,), EnvironmentConfig.__dict__[env])}
    )


DevUserModel = create_env_model(UserModel, "dev")

try:
    class ConflictModel(BaseModel):
        class Config:
            extra = "allow"


    class SubModel(ConflictModel):
        class Config(ConflictModel.Config):
            extra = "forbid"  # 合法覆盖
            validate_all = "invalid_value"  # 非法配置类型
except TypeError as e:
    print(f"配置错误: {str(e)}")

def validate_config_inheritance(model: Type[BaseModel]):
    current_config = model.__config__
    parent_configs = [
        base.__config__
        for base in model.__bases__
        if hasattr(base, '__config__')
    ]

    for config in parent_configs:
        if not issubclass(current_config, config):
            raise TypeError("配置继承链断裂")