如何为从配置文件动态加载属性的Python类实现类型提示？

在Python或PyCharm中，是否存在可为从文件动态加载属性的类生成属性类型提示的方法？现有如下Settings类：

import re


class Settings:
    """
    This class loads a settings file and creates properties for each name in the file.
    The values are either strings or numbers.
    If the name starts with a star, the value is saved to self.cfg_dict to be used for wandb config.
    """

    def __init__(self, path):
        self.path = path
        self.cfg_dict = {}
        self.load_settings()

    def load_settings(self):
        with open(self.path, 'r') as file:
            for line in file:
                # if line is empty or starts with a comment, skip it
                if not line.strip() or line.strip().startswith('#'):
                    continue

                if '=' in line:
                    name, value = line.split('=')
                    name = name.strip()
                    value = value.strip()

                    # check if name has a star on the beginning and if so, save it to self.cfg_dict
                    if name.startswith('*'):
                        name = name[1:]
                        self.cfg_dict[name] = value.strip('"')
                    else:
                        # check if value is a number, either int or float
                        if re.match(r'^-?\d+$', value):
                            value = int(value)
                        elif re.match(r'^-?\d+\.\d+$', value):
                            value = float(value)
                        else:
                            value = value.strip('"')

                        setattr(self, name, value)

示例配置文件：

var_a=5
var_b="Hello World"

当通过a = Settings('myconfig.cfg')初始化该类后，能否为动态生成的a.var_a、a.var_b等属性添加类型提示？该需求是否可行，还是直接使用dataclass并动态修改参数更合适？

一、为动态属性添加类型提示的可行方法 #

动态生成的属性无法在类定义时静态声明，但可以通过以下方式让PyCharm等IDE识别类型提示：

• 重写__getattr__添加类型注解
  给__getattr__方法添加返回类型的Union注解，配合文档字符串说明可能的属性范围，能让IDE提示属性的大致类型：

  from typing import Union, Any
  
  class Settings:
      # ... 原有代码 ...
  
      def __getattr__(self, name: str) -> Union[int, float, str, Any]:
          """
          动态加载的配置属性，类型为int/float/str
          具体属性取决于配置文件，例如var_a、var_b等
          """
          raise AttributeError(f"'Settings' object has no attribute '{name}'")
  

  缺点是无法精准对应每个属性的具体类型。

• 自动生成类型存根文件（.pyi）
  编写辅助脚本读取配置文件，自动生成Settings类的存根文件，IDE会读取存根提供精准提示：

  # generate_stub.py
  def generate_stub(config_path: str, stub_path: str = "settings.pyi"):
      with open(config_path, 'r') as f:
          lines = f.readlines()
      
      attributes = []
      for line in lines:
          line = line.strip()
          if not line or line.startswith('#') or '*' in line:
              continue
          name, val = line.split('=')
          name = name.strip()
          val = val.strip()
          # 判断属性类型
          if val.isdigit() or (val.startswith('-') and val[1:].isdigit()):
              attr_type = "int"
          elif '.' in val and (val.replace('.', '', 1).isdigit() or (val.startswith('-') and val[1:].replace('.', '', 1).isdigit())):
              attr_type = "float"
          else:
              attr_type = "str"
          attributes.append(f"    {name}: {attr_type}")
      
      stub_content = f"""
  

class Settings:
path: str
cfg_dict: dict[str, str]
{chr(10).join(attributes)}
def init(self, path: str) -> None: ...
def load_settings(self) -> None: ...
"""
with open(stub_path, 'w') as f:
f.write(stub_content.strip())

运行脚本生成`settings.pyi`后，IDE就能识别每个动态属性的具体类型。

- **结合`TypedDict`与类型断言**
先定义对应配置的`TypedDict`，再将实例的属性字典转为该类型，实现精准提示：
```python
from typing import TypedDict

class Config(TypedDict):
    var_a: int
    var_b: str

a = Settings('myconfig.cfg')
cfg: Config = a.__dict__

缺点是需要手动维护TypedDict与配置文件的一致性。

二、对比使用dataclass的方案 #

如果配置结构相对稳定，用dataclass会更简洁，且原生支持类型提示：

• 动态修改dataclass参数的实现

  from dataclasses import dataclass, fields
  import re
  
  @dataclass
  class Settings:
      path: str
      cfg_dict: dict[str, str] = None
      # 预先声明已知配置字段
      var_a: int = None
      var_b: str = None
  
      def __post_init__(self):
          if self.cfg_dict is None:
              self.cfg_dict = {}
          self.load_settings()
  
      def load_settings(self):
          with open(self.path, 'r') as file:
              for line in file:
                  if not line.strip() or line.strip().startswith('#'):
                      continue
                  if '=' in line:
                      name, value = line.split('=')
                      name = name.strip()
                      value = value.strip()
                      if name.startswith('*'):
                          name = name[1:]
                          self.cfg_dict[name] = value.strip('"')
                      else:
                          # 类型转换逻辑
                          if re.match(r'^-?\d+$', value):
                              value = int(value)
                          elif re.match(r'^-?\d+\.\d+$', value):
                              value = float(value)
                          else:
                              value = value.strip('"')
                          # 给已声明的字段赋值，动态字段仍需用setattr
                          field_names = [f.name for f in fields(self)]
                          if name in field_names:
                              setattr(self, name, value)
                          else:
                              setattr(self, name, value)
  

  预先声明的字段能获得完美的类型提示，但动态新增的属性仍无法被IDE识别。

• 场景选择建议

  • 若配置字段固定，直接在dataclass中声明所有字段是最优方案，原生支持类型检查和IDE提示。
  • 若配置字段完全动态，自动生成存根文件的方式更合适，能兼顾动态加载和类型提示需求。

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