Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/httpx/_api.py: 61%

1from __future__ import annotations 

2 

3import typing 

4from contextlib import contextmanager 

5 

6from ._client import Client 

7from ._config import DEFAULT_TIMEOUT_CONFIG 

8from ._models import Response 

9from ._types import ( 

10 AuthTypes, 

11 CertTypes, 

12 CookieTypes, 

13 HeaderTypes, 

14 ProxiesTypes, 

15 ProxyTypes, 

16 QueryParamTypes, 

17 RequestContent, 

18 RequestData, 

19 RequestFiles, 

20 TimeoutTypes, 

21 VerifyTypes, 

22) 

23from ._urls import URL 

24 

25__all__ = [ 

26 "delete", 

27 "get", 

28 "head", 

29 "options", 

30 "patch", 

31 "post", 

32 "put", 

33 "request", 

34 "stream", 

35] 

36 

37 

38def request( 

39 method: str, 

40 url: URL | str, 

41 *, 

42 params: QueryParamTypes | None = None, 

43 content: RequestContent | None = None, 

44 data: RequestData | None = None, 

45 files: RequestFiles | None = None, 

46 json: typing.Any | None = None, 

47 headers: HeaderTypes | None = None, 

48 cookies: CookieTypes | None = None, 

49 auth: AuthTypes | None = None, 

50 proxy: ProxyTypes | None = None, 

51 proxies: ProxiesTypes | None = None, 

52 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

53 follow_redirects: bool = False, 

54 verify: VerifyTypes = True, 

55 cert: CertTypes | None = None, 

56 trust_env: bool = True, 

57) -> Response: 

58 """ 

59 Sends an HTTP request. 

60 

61 **Parameters:** 

62 

63 * **method** - HTTP method for the new `Request` object: `GET`, `OPTIONS`, 

64 `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE`. 

65 * **url** - URL for the new `Request` object. 

66 * **params** - *(optional)* Query parameters to include in the URL, as a 

67 string, dictionary, or sequence of two-tuples. 

68 * **content** - *(optional)* Binary content to include in the body of the 

69 request, as bytes or a byte iterator. 

70 * **data** - *(optional)* Form data to include in the body of the request, 

71 as a dictionary. 

72 * **files** - *(optional)* A dictionary of upload files to include in the 

73 body of the request. 

74 * **json** - *(optional)* A JSON serializable object to include in the body 

75 of the request. 

76 * **headers** - *(optional)* Dictionary of HTTP headers to include in the 

77 request. 

78 * **cookies** - *(optional)* Dictionary of Cookie items to include in the 

79 request. 

80 * **auth** - *(optional)* An authentication class to use when sending the 

81 request. 

82 * **proxy** - *(optional)* A proxy URL where all the traffic should be routed. 

83 * **proxies** - *(optional)* A dictionary mapping proxy keys to proxy URLs. 

84 * **timeout** - *(optional)* The timeout configuration to use when sending 

85 the request. 

86 * **follow_redirects** - *(optional)* Enables or disables HTTP redirects. 

87 * **verify** - *(optional)* SSL certificates (a.k.a CA bundle) used to 

88 verify the identity of requested hosts. Either `True` (default CA bundle), 

89 a path to an SSL certificate file, an `ssl.SSLContext`, or `False` 

90 (which will disable verification). 

91 * **cert** - *(optional)* An SSL certificate used by the requested host 

92 to authenticate the client. Either a path to an SSL certificate file, or 

93 two-tuple of (certificate file, key file), or a three-tuple of (certificate 

94 file, key file, password). 

95 * **trust_env** - *(optional)* Enables or disables usage of environment 

96 variables for configuration. 

97 

98 **Returns:** `Response` 

99 

100 Usage: 

101 

102 ``` 

103 >>> import httpx 

104 >>> response = httpx.request('GET', 'https://httpbin.org/get') 

105 >>> response 

106 <Response [200 OK]> 

107 ``` 

108 """ 

109 with Client( 

110 cookies=cookies, 

111 proxy=proxy, 

112 proxies=proxies, 

113 cert=cert, 

114 verify=verify, 

115 timeout=timeout, 

116 trust_env=trust_env, 

117 ) as client: 

118 return client.request( 

119 method=method, 

120 url=url, 

121 content=content, 

122 data=data, 

123 files=files, 

124 json=json, 

125 params=params, 

126 headers=headers, 

127 auth=auth, 

128 follow_redirects=follow_redirects, 

129 ) 

130 

131 

132@contextmanager 

133def stream( 

134 method: str, 

135 url: URL | str, 

136 *, 

137 params: QueryParamTypes | None = None, 

138 content: RequestContent | None = None, 

139 data: RequestData | None = None, 

140 files: RequestFiles | None = None, 

141 json: typing.Any | None = None, 

142 headers: HeaderTypes | None = None, 

143 cookies: CookieTypes | None = None, 

144 auth: AuthTypes | None = None, 

145 proxy: ProxyTypes | None = None, 

146 proxies: ProxiesTypes | None = None, 

147 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

148 follow_redirects: bool = False, 

149 verify: VerifyTypes = True, 

150 cert: CertTypes | None = None, 

151 trust_env: bool = True, 

152) -> typing.Iterator[Response]: 

153 """ 

154 Alternative to `httpx.request()` that streams the response body 

155 instead of loading it into memory at once. 

156 

157 **Parameters**: See `httpx.request`. 

158 

159 See also: [Streaming Responses][0] 

160 

161 [0]: /quickstart#streaming-responses 

162 """ 

163 with Client( 

164 cookies=cookies, 

165 proxy=proxy, 

166 proxies=proxies, 

167 cert=cert, 

168 verify=verify, 

169 timeout=timeout, 

170 trust_env=trust_env, 

171 ) as client: 

172 with client.stream( 

173 method=method, 

174 url=url, 

175 content=content, 

176 data=data, 

177 files=files, 

178 json=json, 

179 params=params, 

180 headers=headers, 

181 auth=auth, 

182 follow_redirects=follow_redirects, 

183 ) as response: 

184 yield response 

185 

186 

187def get( 

188 url: URL | str, 

189 *, 

190 params: QueryParamTypes | None = None, 

191 headers: HeaderTypes | None = None, 

192 cookies: CookieTypes | None = None, 

193 auth: AuthTypes | None = None, 

194 proxy: ProxyTypes | None = None, 

195 proxies: ProxiesTypes | None = None, 

196 follow_redirects: bool = False, 

197 cert: CertTypes | None = None, 

198 verify: VerifyTypes = True, 

199 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

200 trust_env: bool = True, 

201) -> Response: 

202 """ 

203 Sends a `GET` request. 

204 

205 **Parameters**: See `httpx.request`. 

206 

207 Note that the `data`, `files`, `json` and `content` parameters are not available 

208 on this function, as `GET` requests should not include a request body. 

209 """ 

210 return request( 

211 "GET", 

212 url, 

213 params=params, 

214 headers=headers, 

215 cookies=cookies, 

216 auth=auth, 

217 proxy=proxy, 

218 proxies=proxies, 

219 follow_redirects=follow_redirects, 

220 cert=cert, 

221 verify=verify, 

222 timeout=timeout, 

223 trust_env=trust_env, 

224 ) 

225 

226 

227def options( 

228 url: URL | str, 

229 *, 

230 params: QueryParamTypes | None = None, 

231 headers: HeaderTypes | None = None, 

232 cookies: CookieTypes | None = None, 

233 auth: AuthTypes | None = None, 

234 proxy: ProxyTypes | None = None, 

235 proxies: ProxiesTypes | None = None, 

236 follow_redirects: bool = False, 

237 cert: CertTypes | None = None, 

238 verify: VerifyTypes = True, 

239 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

240 trust_env: bool = True, 

241) -> Response: 

242 """ 

243 Sends an `OPTIONS` request. 

244 

245 **Parameters**: See `httpx.request`. 

246 

247 Note that the `data`, `files`, `json` and `content` parameters are not available 

248 on this function, as `OPTIONS` requests should not include a request body. 

249 """ 

250 return request( 

251 "OPTIONS", 

252 url, 

253 params=params, 

254 headers=headers, 

255 cookies=cookies, 

256 auth=auth, 

257 proxy=proxy, 

258 proxies=proxies, 

259 follow_redirects=follow_redirects, 

260 cert=cert, 

261 verify=verify, 

262 timeout=timeout, 

263 trust_env=trust_env, 

264 ) 

265 

266 

267def head( 

268 url: URL | str, 

269 *, 

270 params: QueryParamTypes | None = None, 

271 headers: HeaderTypes | None = None, 

272 cookies: CookieTypes | None = None, 

273 auth: AuthTypes | None = None, 

274 proxy: ProxyTypes | None = None, 

275 proxies: ProxiesTypes | None = None, 

276 follow_redirects: bool = False, 

277 cert: CertTypes | None = None, 

278 verify: VerifyTypes = True, 

279 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

280 trust_env: bool = True, 

281) -> Response: 

282 """ 

283 Sends a `HEAD` request. 

284 

285 **Parameters**: See `httpx.request`. 

286 

287 Note that the `data`, `files`, `json` and `content` parameters are not available 

288 on this function, as `HEAD` requests should not include a request body. 

289 """ 

290 return request( 

291 "HEAD", 

292 url, 

293 params=params, 

294 headers=headers, 

295 cookies=cookies, 

296 auth=auth, 

297 proxy=proxy, 

298 proxies=proxies, 

299 follow_redirects=follow_redirects, 

300 cert=cert, 

301 verify=verify, 

302 timeout=timeout, 

303 trust_env=trust_env, 

304 ) 

305 

306 

307def post( 

308 url: URL | str, 

309 *, 

310 content: RequestContent | None = None, 

311 data: RequestData | None = None, 

312 files: RequestFiles | None = None, 

313 json: typing.Any | None = None, 

314 params: QueryParamTypes | None = None, 

315 headers: HeaderTypes | None = None, 

316 cookies: CookieTypes | None = None, 

317 auth: AuthTypes | None = None, 

318 proxy: ProxyTypes | None = None, 

319 proxies: ProxiesTypes | None = None, 

320 follow_redirects: bool = False, 

321 cert: CertTypes | None = None, 

322 verify: VerifyTypes = True, 

323 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

324 trust_env: bool = True, 

325) -> Response: 

326 """ 

327 Sends a `POST` request. 

328 

329 **Parameters**: See `httpx.request`. 

330 """ 

331 return request( 

332 "POST", 

333 url, 

334 content=content, 

335 data=data, 

336 files=files, 

337 json=json, 

338 params=params, 

339 headers=headers, 

340 cookies=cookies, 

341 auth=auth, 

342 proxy=proxy, 

343 proxies=proxies, 

344 follow_redirects=follow_redirects, 

345 cert=cert, 

346 verify=verify, 

347 timeout=timeout, 

348 trust_env=trust_env, 

349 ) 

350 

351 

352def put( 

353 url: URL | str, 

354 *, 

355 content: RequestContent | None = None, 

356 data: RequestData | None = None, 

357 files: RequestFiles | None = None, 

358 json: typing.Any | None = None, 

359 params: QueryParamTypes | None = None, 

360 headers: HeaderTypes | None = None, 

361 cookies: CookieTypes | None = None, 

362 auth: AuthTypes | None = None, 

363 proxy: ProxyTypes | None = None, 

364 proxies: ProxiesTypes | None = None, 

365 follow_redirects: bool = False, 

366 cert: CertTypes | None = None, 

367 verify: VerifyTypes = True, 

368 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

369 trust_env: bool = True, 

370) -> Response: 

371 """ 

372 Sends a `PUT` request. 

373 

374 **Parameters**: See `httpx.request`. 

375 """ 

376 return request( 

377 "PUT", 

378 url, 

379 content=content, 

380 data=data, 

381 files=files, 

382 json=json, 

383 params=params, 

384 headers=headers, 

385 cookies=cookies, 

386 auth=auth, 

387 proxy=proxy, 

388 proxies=proxies, 

389 follow_redirects=follow_redirects, 

390 cert=cert, 

391 verify=verify, 

392 timeout=timeout, 

393 trust_env=trust_env, 

394 ) 

395 

396 

397def patch( 

398 url: URL | str, 

399 *, 

400 content: RequestContent | None = None, 

401 data: RequestData | None = None, 

402 files: RequestFiles | None = None, 

403 json: typing.Any | None = None, 

404 params: QueryParamTypes | None = None, 

405 headers: HeaderTypes | None = None, 

406 cookies: CookieTypes | None = None, 

407 auth: AuthTypes | None = None, 

408 proxy: ProxyTypes | None = None, 

409 proxies: ProxiesTypes | None = None, 

410 follow_redirects: bool = False, 

411 cert: CertTypes | None = None, 

412 verify: VerifyTypes = True, 

413 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

414 trust_env: bool = True, 

415) -> Response: 

416 """ 

417 Sends a `PATCH` request. 

418 

419 **Parameters**: See `httpx.request`. 

420 """ 

421 return request( 

422 "PATCH", 

423 url, 

424 content=content, 

425 data=data, 

426 files=files, 

427 json=json, 

428 params=params, 

429 headers=headers, 

430 cookies=cookies, 

431 auth=auth, 

432 proxy=proxy, 

433 proxies=proxies, 

434 follow_redirects=follow_redirects, 

435 cert=cert, 

436 verify=verify, 

437 timeout=timeout, 

438 trust_env=trust_env, 

439 ) 

440 

441 

442def delete( 

443 url: URL | str, 

444 *, 

445 params: QueryParamTypes | None = None, 

446 headers: HeaderTypes | None = None, 

447 cookies: CookieTypes | None = None, 

448 auth: AuthTypes | None = None, 

449 proxy: ProxyTypes | None = None, 

450 proxies: ProxiesTypes | None = None, 

451 follow_redirects: bool = False, 

452 cert: CertTypes | None = None, 

453 verify: VerifyTypes = True, 

454 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

455 trust_env: bool = True, 

456) -> Response: 

457 """ 

458 Sends a `DELETE` request. 

459 

460 **Parameters**: See `httpx.request`. 

461 

462 Note that the `data`, `files`, `json` and `content` parameters are not available 

463 on this function, as `DELETE` requests should not include a request body. 

464 """ 

465 return request( 

466 "DELETE", 

467 url, 

468 params=params, 

469 headers=headers, 

470 cookies=cookies, 

471 auth=auth, 

472 proxy=proxy, 

473 proxies=proxies, 

474 follow_redirects=follow_redirects, 

475 cert=cert, 

476 verify=verify, 

477 timeout=timeout, 

478 trust_env=trust_env, 

479 )