1
model_name = config["model"]["name"]
2
pool_size = config["database"]["pool_size"]

1
from pathlib import Path
2
import tomllib
3

4

5
def load_config() -> dict:
6
    with Path("config.toml").open("rb") as file:
7
        return tomllib.load(file)

01
from pathlib import Path
02
import tomllib
03

04
PROJECT_ROOT = Path(__file__).resolve().parents[2]
05
DEFAULT_CONFIG_PATH = PROJECT_ROOT / "config.toml"
06

07

08
def load_toml(path: Path = DEFAULT_CONFIG_PATH) -> dict:
09
    with path.open("rb") as file:
10
        return tomllib.load(file)

1
from pathlib import Path
2

3
from app.core.config_loader import load_toml
4

5
TESTS_DIR = Path(__file__).resolve().parent
6
test_config = load_toml(TESTS_DIR / "fixtures/config.toml")

01
from typing import Literal
02

03
from pydantic import BaseModel, ConfigDict, Field, HttpUrl
04

05

06
class StrictConfigModel(BaseModel):
07
    model_config = ConfigDict(extra="forbid")
08

09

10
class ApplicationConfig(StrictConfigModel):
11
    name: str = Field(min_length=1)
12
    environment: Literal["development", "test", "staging", "production"]
13
    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
14

15

16
class CorsConfig(StrictConfigModel):
17
    allow_origins: list[str]
18
    allow_methods: list[str]
19

20

21
class ServerConfig(StrictConfigModel):
22
    host: str = Field(min_length=1)
23
    port: int = Field(ge=1, le=65535)
24
    cors: CorsConfig
25

26

27
class ModelConfig(StrictConfigModel):
28
    provider: str = Field(min_length=1)
29
    name: str = Field(min_length=1)
30
    base_url: HttpUrl
31
    temperature: float = Field(ge=0, le=2)
32
    timeout_seconds: float = Field(gt=0)
33
    max_retries: int = Field(ge=0, le=10)
34

35

36
class LangGraphConfig(StrictConfigModel):
37
    recursion_limit: int = Field(gt=0)
38
    checkpoint_backend: Literal["memory", "postgres"]
39

40

41
class DatabaseConfig(StrictConfigModel):
42
    pool_size: int = Field(gt=0)
43
    pool_timeout_seconds: float = Field(gt=0)
44

45

46
class AppConfig(StrictConfigModel):
47
    app: ApplicationConfig
48
    server: ServerConfig
49
    model: ModelConfig
50
    langgraph: LangGraphConfig
51
    database: DatabaseConfig

01
from pathlib import Path
02
import tomllib
03

04
from app.core.config_schema import AppConfig
05

06

07
def load_config(path: Path) -> AppConfig:
08
    with path.open("rb") as file:
09
        raw_config = tomllib.load(file)
10

11
    return AppConfig.model_validate(raw_config)

1
config = load_config(DEFAULT_CONFIG_PATH)
2

3
print(config.model.name)
4
print(config.database.pool_size)

1
class ModelConfig(BaseModel):
2
    temperature: float = 0.7

1
class ModelConfig(BaseModel):
2
    name: str
3
    base_url: HttpUrl

01
from pathlib import Path
02
import tomllib
03

04
from pydantic import ValidationError
05

06
from app.core.config_schema import AppConfig
07

08

09
class ConfigError(RuntimeError):
10
    pass
11

12

13
def load_config(path: Path) -> AppConfig:
14
    try:
15
        with path.open("rb") as file:
16
            raw_config = tomllib.load(file)
17
    except FileNotFoundError as error:
18
        raise ConfigError(f"配置文件不存在：{path}") from error
19
    except tomllib.TOMLDecodeError as error:
20
        raise ConfigError(f"TOML 语法错误：{error}") from error
21

22
    try:
23
        return AppConfig.model_validate(raw_config)
24
    except ValidationError as error:
25
        details = "; ".join(
26
            f"{'.'.join(str(part) for part in item['loc'])}: {item['msg']}"
27
            for item in error.errors(include_input=False)
28
        )
29
        raise ConfigError(f"配置字段校验失败：{details}") from error