티스토리 수익 글 보기

django/django/core/exceptions.py at main · django/django · GitHub

History

265 lines (175 loc) · 6.61 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

"""

Global Django exception classes.

"""

import operator

from django.utils.hashable import make_hashable

class FieldDoesNotExist(Exception):

"""The requested model field does not exist"""

pass

class AppRegistryNotReady(Exception):

"""The django.apps registry is not populated yet"""

pass

class ObjectDoesNotExist(Exception):

"""The requested object does not exist"""

silent_variable_failure = True

class ObjectNotUpdated(Exception):

"""The updated object no longer exists."""

class MultipleObjectsReturned(Exception):

"""The query returned multiple objects when only one was expected."""

pass

class SuspiciousOperation(Exception):

"""The user did something suspicious"""

class SuspiciousMultipartForm(SuspiciousOperation):

"""Suspect MIME request in multipart form data"""

pass

class SuspiciousFileOperation(SuspiciousOperation):

"""A Suspicious filesystem operation was attempted"""

pass

class DisallowedHost(SuspiciousOperation):

"""HTTP_HOST header contains invalid value"""

pass

class DisallowedRedirect(SuspiciousOperation):

"""Redirect was too long or scheme was not in allowed list."""

pass

class TooManyFieldsSent(SuspiciousOperation):

"""

The number of fields in a GET or POST request exceeded

settings.DATA_UPLOAD_MAX_NUMBER_FIELDS.

"""

pass

class TooManyFilesSent(SuspiciousOperation):

"""

The number of fields in a GET or POST request exceeded

settings.DATA_UPLOAD_MAX_NUMBER_FILES.

"""

pass

class RequestDataTooBig(SuspiciousOperation):

"""

The size of the request (excluding any file uploads) exceeded

settings.DATA_UPLOAD_MAX_MEMORY_SIZE.

"""

pass

class RequestAborted(Exception):

"""The request was closed before it was completed, or timed out."""

pass

class BadRequest(Exception):

"""The request is malformed and cannot be processed."""

pass

class PermissionDenied(Exception):

"""The user did not have permission to do that"""

pass

class ViewDoesNotExist(Exception):

"""The requested view does not exist"""

pass

class MiddlewareNotUsed(Exception):

"""This middleware is not used in this server configuration"""

pass

class ImproperlyConfigured(Exception):

"""Django is somehow improperly configured"""

pass

class FieldError(Exception):

"""Some kind of problem with a model field."""

pass

class FieldFetchBlocked(FieldError):

"""On-demand fetching of a model field blocked."""

pass

NON_FIELD_ERRORS = "__all__"

class ValidationError(Exception):

"""An error while validating data."""

def __init__(self, message, code=None, params=None):

"""

The `message` argument can be a single error, a list of errors, or a

dictionary that maps field names to lists of errors. What we define as

an "error" can be either a simple string or an instance of

ValidationError with its message attribute set, and what we define as

list or dictionary can be an actual `list` or `dict` or an instance

of ValidationError with its `error_list` or `error_dict` attribute set.

"""

super().__init__(message, code, params)

if isinstance(message, ValidationError):

if hasattr(message, "error_dict"):

message = message.error_dict

elif not hasattr(message, "message"):

message = message.error_list

else:

message, code, params = message.message, message.code, message.params

if isinstance(message, dict):

self.error_dict = {}

for field, messages in message.items():

if not isinstance(messages, ValidationError):

messages = ValidationError(messages)

self.error_dict[field] = messages.error_list

elif isinstance(message, list):

self.error_list = []

for message in message:

# Normalize plain strings to instances of ValidationError.

if not isinstance(message, ValidationError):

message = ValidationError(message)

if hasattr(message, "error_dict"):

self.error_list.extend(sum(message.error_dict.values(), []))

else:

self.error_list.extend(message.error_list)

else:

self.message = message

self.code = code

self.params = params

self.error_list = [self]

@property

def message_dict(self):

# Trigger an AttributeError if this ValidationError

# doesn't have an error_dict.

getattr(self, "error_dict")

return dict(self)

@property

def messages(self):

if hasattr(self, "error_dict"):

return sum(dict(self).values(), [])

return list(self)

def update_error_dict(self, error_dict):

if hasattr(self, "error_dict"):

for field, error_list in self.error_dict.items():

error_dict.setdefault(field, []).extend(error_list)

else:

error_dict.setdefault(NON_FIELD_ERRORS, []).extend(self.error_list)

return error_dict

def __iter__(self):

if hasattr(self, "error_dict"):

for field, errors in self.error_dict.items():

yield field, list(ValidationError(errors))

else:

for error in self.error_list:

message = error.message

if error.params:

message %= error.params

yield str(message)

def __str__(self):

if hasattr(self, "error_dict"):

return repr(dict(self))

return repr(list(self))

def __repr__(self):

return "ValidationError(%s)" % self

def __eq__(self, other):

if not isinstance(other, ValidationError):

return NotImplemented

return hash(self) == hash(other)

def __hash__(self):

if hasattr(self, "message"):

return hash(

(

self.message,

self.code,

make_hashable(self.params),

)

if hasattr(self, "error_dict"):

return hash(make_hashable(self.error_dict))

return hash(tuple(sorted(self.error_list, key=operator.attrgetter("message"))))

class EmptyResultSet(Exception):

"""A database query predicate is impossible."""

pass

class FullResultSet(Exception):

"""A database query predicate is matches everything."""

pass

class SynchronousOnlyOperation(Exception):

"""The user tried to call a sync-only function from an async context."""

pass

티스토리 수익 글 보기