0
# HTTP Handling
1

2
Django's HTTP handling system provides comprehensive support for processing HTTP requests and generating responses, including request objects, response classes, middleware, and cookie management.
3

4
## Core Imports
5

6
```python
7
# HTTP request and response classes
8
from django.http import (
9
    HttpRequest, HttpResponse, HttpResponseRedirect,
10
    HttpResponsePermanentRedirect, HttpResponseNotModified,
11
    HttpResponseBadRequest, HttpResponseNotFound,
12
    HttpResponseForbidden, HttpResponseNotAllowed,
13
    HttpResponseGone, HttpResponseServerError,
14
    JsonResponse, StreamHttpResponse, FileResponse
15
)
16

17
# Query handling
18
from django.http import QueryDict
19

20
# File uploads
21
from django.core.files.uploadedfile import UploadedFile, TemporaryUploadedFile, InMemoryUploadedFile
22

23
# HTTP exceptions
24
from django.http import Http404, HttpResponseBadRequest
25

26
# Cookie handling  
27
from django.http.cookie import SimpleCookie
28

29
# Utilities
30
from django.utils.datastructures import MultiValueDict
31
```
32

33
## Capabilities
34

35
### HTTP Request
36

37
Request object containing all information about the HTTP request from the client.
38

39
```python { .api }
40
class HttpRequest:
41
    """
42
    HTTP request object containing client request data.
43
    
44
    Attributes:
45
        method (str): HTTP method (GET, POST, etc.)
46
        path (str): Request path
47
        path_info (str): Path info portion of URL
48
        GET (QueryDict): GET parameters
49
        POST (QueryDict): POST data
50
        COOKIES (dict): Request cookies
51
        FILES (MultiValueDict): Uploaded files
52
        META (dict): Request metadata and headers
53
        user: Authenticated user object
54
        session: Session data
55
    """
56
    method: str
57
    path: str
58
    path_info: str
59
    GET: QueryDict
60
    POST: QueryDict
61
    COOKIES: dict
62
    FILES: MultiValueDict
63
    META: dict
64
    user: Any
65
    session: Any
66
    
67
    def build_absolute_uri(self, location: str = None) -> str: ...
68
    def get_full_path(self, force_append_slash: bool = False) -> str: ...
69
    def get_full_path_info(self, force_append_slash: bool = False) -> str: ...
70
    def get_host(self) -> str: ...
71
    def get_port(self) -> str: ...
72
    def get_raw_uri(self) -> str: ...
73
    def get_signed_cookie(self, key: str, default=None, salt: str = '', max_age: int = None) -> str: ...
74
    def is_secure(self) -> bool: ...
75
    def is_ajax(self) -> bool: ...
76
    def read(self, size: int = None) -> bytes: ...
77
    def readline(self, size: int = None) -> bytes: ...
78
    def readlines(self) -> list: ...
79
    def xreadlines(self): ...
80
    def __iter__(self): ...
81
```
82

83
### HTTP Response Classes
84

85
Response objects for returning data to the client with various content types and status codes.
86

87
```python { .api }
88
class HttpResponseBase:
89
    """Base HTTP response class."""
90
    def __init__(self, content_type: str = None, status: int = None, reason: str = None, charset: str = None): ...
91
    
92
    def __setitem__(self, header: str, value: str) -> None: ...
93
    def __delitem__(self, header: str) -> None: ...
94
    def __getitem__(self, header: str) -> str: ...
95
    def has_header(self, header: str) -> bool: ...
96
    def setdefault(self, header: str, value: str) -> str: ...
97
    def set_cookie(self, key: str, value: str = '', max_age: int = None, expires=None, 
98
                   path: str = '/', domain: str = None, secure: bool = False, 
99
                   httponly: bool = False, samesite: str = None) -> None: ...
100
    def set_signed_cookie(self, key: str, value: str, salt: str = '', **kwargs) -> None: ...
101
    def delete_cookie(self, key: str, path: str = '/', domain: str = None, samesite: str = None) -> None: ...
102
    def write(self, content) -> None: ...
103
    def flush(self) -> None: ...
104
    def tell(self) -> int: ...
105
    def readable(self) -> bool: ...
106
    def seekable(self) -> bool: ...
107
    def writable(self) -> bool: ...
108
    def writelines(self, lines) -> None: ...
109
    
110
    status_code: int
111
    reason_phrase: str
112
    charset: str
113
    streaming: bool
114
    closed: bool
115

116
class HttpResponse(HttpResponseBase):
117
    """Standard HTTP response."""
118
    def __init__(self, content=b'', content_type: str = None, status: int = 200, reason: str = None, charset: str = None): ...
119
    
120
    content: bytes
121

122
class HttpResponseRedirect(HttpResponse):
123
    """HTTP redirect response (302)."""
124
    status_code: int = 302
125
    def __init__(self, redirect_to: str, *args, **kwargs): ...
126
    url: str
127

128
class HttpResponsePermanentRedirect(HttpResponse):
129
    """HTTP permanent redirect response (301)."""
130
    status_code: int = 301
131
    def __init__(self, redirect_to: str, *args, **kwargs): ...
132
    url: str
133

134
class HttpResponseNotModified(HttpResponse):
135
    """HTTP not modified response (304)."""
136
    status_code: int = 304
137
    def __init__(self, *args, **kwargs): ...
138

139
class HttpResponseBadRequest(HttpResponse):
140
    """HTTP bad request response (400)."""
141
    status_code: int = 400
142

143
class HttpResponseNotFound(HttpResponse):
144
    """HTTP not found response (404)."""
145
    status_code: int = 404
146

147
class HttpResponseForbidden(HttpResponse):
148
    """HTTP forbidden response (403)."""
149
    status_code: int = 403
150

151
class HttpResponseNotAllowed(HttpResponse):
152
    """HTTP method not allowed response (405)."""
153
    status_code: int = 405
154
    def __init__(self, permitted_methods: list, *args, **kwargs): ...
155

156
class HttpResponseGone(HttpResponse):
157
    """HTTP gone response (410)."""
158
    status_code: int = 410
159

160
class HttpResponseServerError(HttpResponse):
161
    """HTTP server error response (500)."""
162
    status_code: int = 500
163
```
164

165
### Specialized Response Classes
166

167
Response classes for specific content types and use cases.
168

169
```python { .api }
170
class StreamingHttpResponse(HttpResponseBase):
171
    """HTTP response for streaming content."""
172
    def __init__(self, streaming_content=(), content_type: str = 'text/html; charset=utf-8', 
173
                 status: int = 200, reason: str = None, charset: str = None): ...
174
    
175
    streaming_content: Any
176
    streaming: bool = True
177

178
class FileResponse(StreamingHttpResponse):
179
    """HTTP response for serving files."""
180
    def __init__(self, open_file, as_attachment: bool = False, filename: str = '', 
181
                 content_type: str = None, **kwargs): ...
182
    
183
    def set_headers(self, open_file) -> None: ...
184

185
class JsonResponse(HttpResponse):
186
    """HTTP response for JSON content."""
187
    def __init__(self, data, encoder=None, safe: bool = True, json_dumps_params: dict = None, **kwargs): ...
188
```
189

190
### Query Parameters and Data
191

192
Classes for handling query parameters and form data.
193

194
```python { .api }
195
class QueryDict(MultiValueDict):
196
    """
197
    Dictionary for handling query parameters and form data.
198
    
199
    Supports multiple values per key and URL encoding/decoding.
200
    """
201
    def __init__(self, query_string: str = None, mutable: bool = False, encoding: str = None): ...
202
    
203
    def urlencode(self, safe: str = None) -> str: ...
204
    def copy(self) -> QueryDict: ...
205
    def __deepcopy__(self, memo: dict): ...
206
    def __copy__(self): ...
207
    def pop(self, key: str, default=None): ...
208
    def popitem(self): ...
209
    def clear(self) -> None: ...
210
    def setdefault(self, key: str, default=None): ...
211
    def update(self, other_dict) -> None: ...
212
```
213

214
### File Uploads
215

216
Classes for handling uploaded files and multipart form data.
217

218
```python { .api }
219
class MultiValueDict(dict):
220
    """Dictionary that can store multiple values for each key."""
221
    def __init__(self, key_to_list_mapping=()): ...
222
    
223
    def __getitem__(self, key: str): ...
224
    def __setitem__(self, key: str, value) -> None: ...
225
    def __copy__(self): ...
226
    def __deepcopy__(self, memo: dict): ...
227
    def get(self, key: str, default=None): ...
228
    def getlist(self, key: str, default: list = None) -> list: ...
229
    def setlist(self, key: str, list_: list) -> None: ...
230
    def setlistdefault(self, key: str, default_list: list = None) -> list: ...
231
    def appendlist(self, key: str, value) -> None: ...
232
    def update(self, *args, **kwargs) -> None: ...
233
    def pop(self, key: str, default=None): ...
234
    def popitem(self): ...
235
    def dict(self) -> dict: ...
236
    def lists(self): ...
237
    def values(self): ...
238
    def items(self): ...
239

240
class UploadedFile:
241
    """Uploaded file wrapper."""
242
    def __init__(self, file=None, name: str = None, content_type: str = None, size: int = None, charset: str = None, content_type_extra: dict = None): ...
243
    
244
    def read(self, num_bytes: int = None) -> bytes: ...
245
    def readline(self, length: int = None) -> bytes: ...
246
    def readlines(self) -> list: ...
247
    def chunks(self, chunk_size: int = None): ...
248
    def multiple_chunks(self, chunk_size: int = None) -> bool: ...
249
    def __iter__(self): ...
250
    def open(self, mode: str = 'rb'): ...
251
    def close(self) -> None: ...
252
    
253
    name: str
254
    size: int
255
    content_type: str
256
    content_type_extra: dict
257
    charset: str
258

259
class InMemoryUploadedFile(UploadedFile):
260
    """Uploaded file stored in memory."""
261
    def __init__(self, file, field_name: str, name: str, content_type: str, size: int, charset: str, content_type_extra: dict = None): ...
262

263
class TemporaryUploadedFile(UploadedFile):
264
    """Uploaded file stored in temporary file."""
265
    def __init__(self, name: str, content_type: str, size: int, charset: str, content_type_extra: dict = None): ...
266
    def temporary_file_path(self) -> str: ...
267
```
268

269
### HTTP Exceptions
270

271
Exception classes for HTTP error conditions.
272

273
```python { .api }
274
class Http404(Exception):
275
    """HTTP 404 Not Found exception."""
276
    pass
277

278
class BadHeaderError(ValueError):
279
    """Invalid HTTP header error."""
280
    pass
281

282
class RawPostDataException(Exception):
283
    """Exception for accessing raw POST data incorrectly."""
284
    pass
285

286
class UnreadablePostError(OSError):
287
    """Exception for unreadable POST data."""
288
    pass
289
```
290

291
### Cookie Handling
292

293
Utilities for HTTP cookie management and parsing.
294

295
```python { .api }
296
class SimpleCookie(dict):
297
    """Simple cookie implementation."""
298
    def __init__(self, input: str = None): ...
299
    def load(self, rawdata: str) -> None: ...
300
    def output(self, attrs: list = None, header: str = "Set-Cookie:", sep: str = "\\r\\n") -> str: ...
301
    def js_output(self, attrs: list = None) -> str: ...
302
    def value_decode(self, val: str) -> tuple: ...
303
    def value_encode(self, val) -> tuple: ...
304

305
def parse_cookie(cookie: str) -> dict:
306
    """Parse cookie string into dictionary."""
307
```
308

309
### HTTP Headers and Metadata
310

311
Utilities for handling HTTP headers and request metadata.
312

313
```python { .api }
314
class HttpHeaders(dict):
315
    """Case-insensitive HTTP headers dictionary."""
316
    def __getitem__(self, key: str) -> str: ...
317
    def __setitem__(self, key: str, value: str) -> None: ...
318
    def __delitem__(self, key: str) -> None: ...
319
    def __contains__(self, key: str) -> bool: ...
320
    def get(self, key: str, default: str = None) -> str: ...
321
    def keys(self): ...
322
    def values(self): ...
323
    def items(self): ...
324

325
def parse_header_parameters(header: str) -> tuple:
326
    """Parse header parameters into main value and parameters dict."""
327

328
def quote_etag(etag: str, weak: bool = False) -> str:
329
    """Quote ETag for HTTP headers."""
330

331
def unquote_etag(etag: str) -> tuple:
332
    """Unquote ETag from HTTP headers."""
333

334
def parse_etags(etag_str: str) -> list:
335
    """Parse multiple ETags from header."""
336

337
def quote(s: str, safe: str = '/') -> str:
338
    """URL quote string."""
339

340
def unquote(s: str) -> str:
341
    """URL unquote string."""
342

343
def unquote_plus(s: str) -> str:
344
    """URL unquote string with plus signs."""
345
```
346

347
### Content Types and Encoding
348

349
Utilities for handling content types and character encoding.
350

351
```python { .api }
352
def parse_accept_lang_header(lang_string: str) -> list:
353
    """Parse Accept-Language header."""
354

355
def get_content_charset_from_headers(headers: dict) -> str:
356
    """Extract charset from Content-Type header."""
357

358
def is_same_domain(host: str, pattern: str) -> bool:
359
    """Check if host matches domain pattern."""
360

361
def escape_uri_path(path: str) -> str:
362
    """Escape URI path for safe HTTP transmission."""
363

364
def http_date(epoch_seconds: float = None) -> str:
365
    """Format timestamp as HTTP date string."""
366

367
def parse_http_date(date: str) -> float:
368
    """Parse HTTP date string to timestamp."""
369

370
def conditional_content_removal(request: HttpRequest, response: HttpResponse) -> HttpResponse:
371
    """Remove content for conditional requests."""
372
```
373

374
### Request Processing
375

376
Utilities for processing and validating HTTP requests.
377

378
```python { .api }
379
def get_token(request: HttpRequest) -> str:
380
    """Get CSRF token from request."""
381

382
def same_origin(url1: str, url2: str) -> bool:
383
    """Check if two URLs have the same origin."""
384

385
def is_safe_url(url: str, allowed_hosts: set = None, require_https: bool = False) -> bool:
386
    """Check if URL is safe for redirects."""
387

388
def urlencode(query: dict, doseq: bool = False, safe: str = '', encoding: str = None, errors: str = None, quote_via=None) -> str:
389
    """Encode dictionary as URL query string."""
390

391
def urlencode_bytes(query: dict, doseq: bool = False) -> bytes:
392
    """Encode dictionary as URL query bytes."""
393
```
394

395
### Middleware Support
396

397
Base classes and utilities for HTTP middleware.
398

399
```python { .api }
400
class MiddlewareMixin:
401
    """Base mixin for middleware classes."""
402
    def __init__(self, get_response=None): ...
403
    def __call__(self, request: HttpRequest) -> HttpResponse: ...
404
    
405
    def process_request(self, request: HttpRequest): ...
406
    def process_view(self, request: HttpRequest, view_func, view_args: tuple, view_kwargs: dict): ...
407
    def process_template_response(self, request: HttpRequest, response): ...
408
    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...
409
    def process_exception(self, request: HttpRequest, exception: Exception): ...
410
```