如何基于字符串常量类生成Literal类型注解？求更优实现方案

问题场景 #

我用普通类存储字符串常量（比如部署环境ID、API主机名），不想用Enum或StrEnum（不需要它们的全部功能），但希望能用这些类的变量值标注Literal类型，避免硬编码常量带来的维护麻烦（比如常量变更时要全量修改）。

我自己实现了一个基于基类的方案，能通过静态类型检查，但觉得逻辑不够直观，想找更优的解决方法：

from typing import LiteralString

class StringConstantContainer:
    @classmethod
    def as_literal(cls) -> LiteralString:
        return Literal[
            tuple(
                v
                for k, v in vars(cls).items()
                if not k.startswith("_") and not callable(getattr(cls, k))
            )
        ]

# 使用示例
class MusicGenre(StringConstantContainer):
    ROCK = "rock'n'roll"
    POP = "pop music"
    ELECTRONIC = "techno"

def get_random_song(genre: MusicGenre.as_literal()) -> str:
    if genre == MusicGenre.ROCK:
        return "Smells Like Teen Spirit"
    else:
        return "That's not music, my friend"

补充：我大量使用Pydantic，如果用Enum或StrEnum，模型序列化会输出Enum实例而非字符串，必须写自定义序列化器才行，示例如下：

from enum import Enum
from pydantic import BaseModel

class MusicGenreEnum(str, Enum):
    ROCK = "rock'n'roll"
    POP = "pop music"
    ELECTRONIC = "techno"
    
class Music(BaseModel):
    genre: MusicGenre.as_literal()
    enum_genre: MusicGenreEnum
    
print(Music(genre="techno", enum_genre="pop music").model_dump())
# {'genre': 'techno', 'enum_genre': <MusicGenreEnum.POP: 'pop music'>}

优化方案 #

方案1：简化基类逻辑，明确处理字符串常量 #

把原基类的逻辑简化，只保留字符串类型的类变量，避免不必要的判断，代码更直观：

from typing import Literal, TypeVar

T = TypeVar("T", bound="StringConstantContainer")

class StringConstantContainer:
    @classmethod
    def as_literal(cls: type[T]) -> Literal[tuple[str, ...]]:
        # 只提取非私有、非方法的字符串常量
        constants = tuple(v for k, v in vars(cls).items() if not k.startswith("_") and isinstance(v, str))
        return Literal[constants]

# 使用示例不变，类型检查正常通过
class MusicGenre(StringConstantContainer):
    ROCK = "rock'n'roll"
    POP = "pop music"
    ELECTRONIC = "techno"

def get_random_song(genre: MusicGenre.as_literal()) -> str:
    if genre == MusicGenre.ROCK:
        return "Smells Like Teen Spirit"
    else:
        return "That's not music, my friend"

方案2：适配Pydantic的轻量化写法 #

针对Pydantic场景，直接在常量类里定义Literal类型别名，完全避免Enum的序列化问题，代码更简洁：

from typing import Literal
from pydantic import BaseModel

class MusicGenre:
    ROCK = "rock'n'roll"
    POP = "pop music"
    ELECTRONIC = "techno"
    # 直接定义Literal类型别名，使用时直接引用
    GenreLiteral = Literal[ROCK, POP, ELECTRONIC]

class Music(BaseModel):
    genre: MusicGenre.GenreLiteral

# 序列化输出天然是字符串，无需额外配置
print(Music(genre="techno").model_dump())  # {'genre': 'techno'}

方案3：动态生成Literal类型别名（适合常量较多的场景） #

如果常量类里的变量很多，不想手动枚举Literal成员，可以动态提取类变量生成类型，无需基类：

from typing import Literal

class MusicGenre:
    ROCK = "rock'n'roll"
    POP = "pop music"
    ELECTRONIC = "techno"

# 动态提取非私有类变量生成Literal类型
MusicGenreLiteral = Literal[tuple(v for k, v in vars(MusicGenre).items() if not k.startswith("_"))]

def get_random_song(genre: MusicGenreLiteral) -> str:
    if genre == MusicGenre.ROCK:
        return "Smells Like Teen Spirit"
    else:
        return "That's not music, my friend"

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