Coverage for src/kwai/core/settings.py: 97%

1"""Module for the settings of this application.""" 

2 

3import os 

4import tomllib 

5 

6from functools import lru_cache 

7from typing import Annotated, Any, Literal, Optional, Union 

8 

9from anyio import Path 

10from pydantic import BaseModel, Field 

11 

12 

13ENV_SETTINGS_FILE = "KWAI_SETTINGS_FILE" 

14 

15 

16class SettingsException(Exception): 

17 """Raised when a problem occurred while loading the settings.""" 

18 

19 

20class ApplicationSettingsModel(BaseModel): 

21 """Settings that apply to all applications.""" 

22 

23 default: bool = False # Set to true for selecting the default application 

24 vite_server: str | None = None # Only required in development. 

25 variables: dict[str, Any] | None = None 

26 

27 

28class AdminApplicationSettings(ApplicationSettingsModel): 

29 """Settings for the admin application.""" 

30 

31 name: Literal["admin"] 

32 

33 

34class AuthenticationApplicationSettings(ApplicationSettingsModel): 

35 """Settings for the auth application.""" 

36 

37 name: Literal["auth"] 

38 

39 

40class AuthorApplicationSettings(ApplicationSettingsModel): 

41 """Settings for the author application.""" 

42 

43 name: Literal["author"] 

44 

45 

46class ClubApplicationSettings(ApplicationSettingsModel): 

47 """Settings for the club application.""" 

48 

49 name: Literal["club"] 

50 

51 

52class CoachApplicationSettings(ApplicationSettingsModel): 

53 """Settings for the portal application.""" 

54 

55 name: Literal["coach"] 

56 

57 

58class PortalApplicationSettings(ApplicationSettingsModel): 

59 """Settings for the portal application.""" 

60 

61 name: Literal["portal"] 

62 

63 

64Application = Annotated[ 

65 Union[ 

66 AdminApplicationSettings, 

67 AuthenticationApplicationSettings, 

68 AuthorApplicationSettings, 

69 ClubApplicationSettings, 

70 CoachApplicationSettings, 

71 PortalApplicationSettings, 

72 ], 

73 Field(discriminator="name"), 

74] 

75 

76 

77class FrontendSettings(BaseModel): 

78 """Settings for the frontend.""" 

79 

80 test: bool = False 

81 path: str 

82 apps: list[Application] 

83 

84 

85class FilesSettings(BaseModel): 

86 """Settings for files (upload).""" 

87 

88 path: str 

89 

90 

91class AdminSettings(BaseModel): 

92 """Settings for the administrator of the website.""" 

93 

94 name: str 

95 email: str 

96 

97 

98class ContactSettings(BaseModel): 

99 """Settings for the contact of the club.""" 

100 

101 street: str 

102 city: str 

103 email: str 

104 

105 

106class WebsiteSettings(BaseModel): 

107 """Settings about the website.""" 

108 

109 url: str 

110 email: str 

111 name: str 

112 copyright: Optional[str] = None 

113 admin: Optional[AdminSettings] = None 

114 contact: Optional[ContactSettings] = None 

115 

116 

117class DatabaseSettings(BaseModel): 

118 """Settings for the database connection.""" 

119 

120 host: str 

121 name: str 

122 user: str 

123 password: str 

124 

125 

126class CORSSettings(BaseModel): 

127 """Settings for configuring CORS.""" 

128 

129 origins: list[str] = Field(default_factory=list) 

130 methods: list[str] = Field(default_factory=lambda: ["*"]) 

131 headers: list[str] = Field(default_factory=lambda: ["*"]) 

132 

133 

134class LoggerSettings(BaseModel): 

135 """Settings for the logger.""" 

136 

137 file: os.PathLike[str] = Field(default=Path("kwai.log")) 

138 level: str = "DEBUG" 

139 retention: str = "7 days" 

140 rotation: str = "1 day" 

141 

142 

143class EmailSettings(BaseModel): 

144 """Settings for sending emails.""" 

145 

146 host: str 

147 port: int 

148 ssl: bool = True 

149 tls: bool = True 

150 user: str | None = None 

151 password: str | None = None 

152 address: str = Field(alias="from") 

153 

154 

155class RedisSettings(BaseModel): 

156 """Settings for Redis.""" 

157 

158 host: str = "127.0.0.1" 

159 port: int = 6379 

160 password: str | None = None 

161 logger: LoggerSettings | None = None 

162 

163 

164class GoogleSSOSettings(BaseModel): 

165 """Settings for Google SSO.""" 

166 

167 client_id: str 

168 client_secret: str 

169 

170 

171class SecuritySettings(BaseModel): 

172 """Setting or security.""" 

173 

174 access_token_expires_in: int = 60 # minutes 

175 refresh_token_expires_in: int = 43200 # 30 days 

176 jwt_algorithm: str = "HS256" 

177 jwt_secret: str 

178 jwt_refresh_secret: str 

179 

180 google: GoogleSSOSettings | None = None 

181 

182 

183class Settings(BaseModel): 

184 """Class with settings.""" 

185 

186 frontend: FrontendSettings 

187 

188 files: FilesSettings 

189 

190 security: SecuritySettings 

191 

192 logger: LoggerSettings | None = None 

193 

194 cors: CORSSettings | None = None 

195 

196 db: DatabaseSettings 

197 

198 website: WebsiteSettings 

199 

200 email: EmailSettings 

201 

202 redis: RedisSettings 

203 

204 

205@lru_cache 

206def get_settings() -> Settings: 

207 """Dependency function for creating the Settings instance. 

208 

209 The settings are cached with lru_cache, which means the file is only loaded ounce. 

210 

211 :raises: 

212 core.settings.SettingsException: Raised when the env variable is not set, or 

213 when the file 

214 can't be read. 

215 """ 

216 if ENV_SETTINGS_FILE in os.environ: 

217 settings_file = os.environ.get(ENV_SETTINGS_FILE, "") 

218 try: 

219 with open(settings_file, mode="rb") as file_handle: 

220 return Settings.model_validate(tomllib.load(file_handle)) 

221 except OSError as exc: 

222 raise SettingsException(f"Could not load {settings_file}") from exc 

223 raise SettingsException( 

224 f"{ENV_SETTINGS_FILE} should be set as environment variable" 

225 )