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

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 URLTypes, 

22 VerifyTypes, 

23) 

24 

25 

26def request( 

27 method: str, 

28 url: URLTypes, 

29 *, 

30 params: QueryParamTypes | None = None, 

31 content: RequestContent | None = None, 

32 data: RequestData | None = None, 

33 files: RequestFiles | None = None, 

34 json: typing.Any | None = None, 

35 headers: HeaderTypes | None = None, 

36 cookies: CookieTypes | None = None, 

37 auth: AuthTypes | None = None, 

38 proxy: ProxyTypes | None = None, 

39 proxies: ProxiesTypes | None = None, 

40 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

41 follow_redirects: bool = False, 

42 verify: VerifyTypes = True, 

43 cert: CertTypes | None = None, 

44 trust_env: bool = True, 

45) -> Response: 

46 """ 

47 Sends an HTTP request. 

48 

49 **Parameters:** 

50 

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

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

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

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

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

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

57 request, as bytes or a byte iterator. 

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

59 as a dictionary. 

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

61 body of the request. 

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

63 of the request. 

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

65 request. 

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

67 request. 

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

69 request. 

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

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

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

73 the request. 

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

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

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

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

78 (which will disable verification). 

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

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

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

82 file, key file, password). 

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

84 variables for configuration. 

85 

86 **Returns:** `Response` 

87 

88 Usage: 

89 

90 ``` 

91 >>> import httpx 

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

93 >>> response 

94 <Response [200 OK]> 

95 ``` 

96 """ 

97 with Client( 

98 cookies=cookies, 

99 proxy=proxy, 

100 proxies=proxies, 

101 cert=cert, 

102 verify=verify, 

103 timeout=timeout, 

104 trust_env=trust_env, 

105 ) as client: 

106 return client.request( 

107 method=method, 

108 url=url, 

109 content=content, 

110 data=data, 

111 files=files, 

112 json=json, 

113 params=params, 

114 headers=headers, 

115 auth=auth, 

116 follow_redirects=follow_redirects, 

117 ) 

118 

119 

120@contextmanager 

121def stream( 

122 method: str, 

123 url: URLTypes, 

124 *, 

125 params: QueryParamTypes | None = None, 

126 content: RequestContent | None = None, 

127 data: RequestData | None = None, 

128 files: RequestFiles | None = None, 

129 json: typing.Any | None = None, 

130 headers: HeaderTypes | None = None, 

131 cookies: CookieTypes | None = None, 

132 auth: AuthTypes | None = None, 

133 proxy: ProxyTypes | None = None, 

134 proxies: ProxiesTypes | None = None, 

135 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

136 follow_redirects: bool = False, 

137 verify: VerifyTypes = True, 

138 cert: CertTypes | None = None, 

139 trust_env: bool = True, 

140) -> typing.Iterator[Response]: 

141 """ 

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

143 instead of loading it into memory at once. 

144 

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

146 

147 See also: [Streaming Responses][0] 

148 

149 [0]: /quickstart#streaming-responses 

150 """ 

151 with Client( 

152 cookies=cookies, 

153 proxy=proxy, 

154 proxies=proxies, 

155 cert=cert, 

156 verify=verify, 

157 timeout=timeout, 

158 trust_env=trust_env, 

159 ) as client: 

160 with client.stream( 

161 method=method, 

162 url=url, 

163 content=content, 

164 data=data, 

165 files=files, 

166 json=json, 

167 params=params, 

168 headers=headers, 

169 auth=auth, 

170 follow_redirects=follow_redirects, 

171 ) as response: 

172 yield response 

173 

174 

175def get( 

176 url: URLTypes, 

177 *, 

178 params: QueryParamTypes | None = None, 

179 headers: HeaderTypes | None = None, 

180 cookies: CookieTypes | None = None, 

181 auth: AuthTypes | None = None, 

182 proxy: ProxyTypes | None = None, 

183 proxies: ProxiesTypes | None = None, 

184 follow_redirects: bool = False, 

185 cert: CertTypes | None = None, 

186 verify: VerifyTypes = True, 

187 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

188 trust_env: bool = True, 

189) -> Response: 

190 """ 

191 Sends a `GET` request. 

192 

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

194 

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

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

197 """ 

198 return request( 

199 "GET", 

200 url, 

201 params=params, 

202 headers=headers, 

203 cookies=cookies, 

204 auth=auth, 

205 proxy=proxy, 

206 proxies=proxies, 

207 follow_redirects=follow_redirects, 

208 cert=cert, 

209 verify=verify, 

210 timeout=timeout, 

211 trust_env=trust_env, 

212 ) 

213 

214 

215def options( 

216 url: URLTypes, 

217 *, 

218 params: QueryParamTypes | None = None, 

219 headers: HeaderTypes | None = None, 

220 cookies: CookieTypes | None = None, 

221 auth: AuthTypes | None = None, 

222 proxy: ProxyTypes | None = None, 

223 proxies: ProxiesTypes | None = None, 

224 follow_redirects: bool = False, 

225 cert: CertTypes | None = None, 

226 verify: VerifyTypes = True, 

227 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

228 trust_env: bool = True, 

229) -> Response: 

230 """ 

231 Sends an `OPTIONS` request. 

232 

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

234 

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

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

237 """ 

238 return request( 

239 "OPTIONS", 

240 url, 

241 params=params, 

242 headers=headers, 

243 cookies=cookies, 

244 auth=auth, 

245 proxy=proxy, 

246 proxies=proxies, 

247 follow_redirects=follow_redirects, 

248 cert=cert, 

249 verify=verify, 

250 timeout=timeout, 

251 trust_env=trust_env, 

252 ) 

253 

254 

255def head( 

256 url: URLTypes, 

257 *, 

258 params: QueryParamTypes | None = None, 

259 headers: HeaderTypes | None = None, 

260 cookies: CookieTypes | None = None, 

261 auth: AuthTypes | None = None, 

262 proxy: ProxyTypes | None = None, 

263 proxies: ProxiesTypes | None = None, 

264 follow_redirects: bool = False, 

265 cert: CertTypes | None = None, 

266 verify: VerifyTypes = True, 

267 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

268 trust_env: bool = True, 

269) -> Response: 

270 """ 

271 Sends a `HEAD` request. 

272 

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

274 

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

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

277 """ 

278 return request( 

279 "HEAD", 

280 url, 

281 params=params, 

282 headers=headers, 

283 cookies=cookies, 

284 auth=auth, 

285 proxy=proxy, 

286 proxies=proxies, 

287 follow_redirects=follow_redirects, 

288 cert=cert, 

289 verify=verify, 

290 timeout=timeout, 

291 trust_env=trust_env, 

292 ) 

293 

294 

295def post( 

296 url: URLTypes, 

297 *, 

298 content: RequestContent | None = None, 

299 data: RequestData | None = None, 

300 files: RequestFiles | None = None, 

301 json: typing.Any | None = None, 

302 params: QueryParamTypes | None = None, 

303 headers: HeaderTypes | None = None, 

304 cookies: CookieTypes | None = None, 

305 auth: AuthTypes | None = None, 

306 proxy: ProxyTypes | None = None, 

307 proxies: ProxiesTypes | None = None, 

308 follow_redirects: bool = False, 

309 cert: CertTypes | None = None, 

310 verify: VerifyTypes = True, 

311 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

312 trust_env: bool = True, 

313) -> Response: 

314 """ 

315 Sends a `POST` request. 

316 

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

318 """ 

319 return request( 

320 "POST", 

321 url, 

322 content=content, 

323 data=data, 

324 files=files, 

325 json=json, 

326 params=params, 

327 headers=headers, 

328 cookies=cookies, 

329 auth=auth, 

330 proxy=proxy, 

331 proxies=proxies, 

332 follow_redirects=follow_redirects, 

333 cert=cert, 

334 verify=verify, 

335 timeout=timeout, 

336 trust_env=trust_env, 

337 ) 

338 

339 

340def put( 

341 url: URLTypes, 

342 *, 

343 content: RequestContent | None = None, 

344 data: RequestData | None = None, 

345 files: RequestFiles | None = None, 

346 json: typing.Any | None = None, 

347 params: QueryParamTypes | None = None, 

348 headers: HeaderTypes | None = None, 

349 cookies: CookieTypes | None = None, 

350 auth: AuthTypes | None = None, 

351 proxy: ProxyTypes | None = None, 

352 proxies: ProxiesTypes | None = None, 

353 follow_redirects: bool = False, 

354 cert: CertTypes | None = None, 

355 verify: VerifyTypes = True, 

356 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

357 trust_env: bool = True, 

358) -> Response: 

359 """ 

360 Sends a `PUT` request. 

361 

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

363 """ 

364 return request( 

365 "PUT", 

366 url, 

367 content=content, 

368 data=data, 

369 files=files, 

370 json=json, 

371 params=params, 

372 headers=headers, 

373 cookies=cookies, 

374 auth=auth, 

375 proxy=proxy, 

376 proxies=proxies, 

377 follow_redirects=follow_redirects, 

378 cert=cert, 

379 verify=verify, 

380 timeout=timeout, 

381 trust_env=trust_env, 

382 ) 

383 

384 

385def patch( 

386 url: URLTypes, 

387 *, 

388 content: RequestContent | None = None, 

389 data: RequestData | None = None, 

390 files: RequestFiles | None = None, 

391 json: typing.Any | None = None, 

392 params: QueryParamTypes | None = None, 

393 headers: HeaderTypes | None = None, 

394 cookies: CookieTypes | None = None, 

395 auth: AuthTypes | None = None, 

396 proxy: ProxyTypes | None = None, 

397 proxies: ProxiesTypes | None = None, 

398 follow_redirects: bool = False, 

399 cert: CertTypes | None = None, 

400 verify: VerifyTypes = True, 

401 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

402 trust_env: bool = True, 

403) -> Response: 

404 """ 

405 Sends a `PATCH` request. 

406 

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

408 """ 

409 return request( 

410 "PATCH", 

411 url, 

412 content=content, 

413 data=data, 

414 files=files, 

415 json=json, 

416 params=params, 

417 headers=headers, 

418 cookies=cookies, 

419 auth=auth, 

420 proxy=proxy, 

421 proxies=proxies, 

422 follow_redirects=follow_redirects, 

423 cert=cert, 

424 verify=verify, 

425 timeout=timeout, 

426 trust_env=trust_env, 

427 ) 

428 

429 

430def delete( 

431 url: URLTypes, 

432 *, 

433 params: QueryParamTypes | None = None, 

434 headers: HeaderTypes | None = None, 

435 cookies: CookieTypes | None = None, 

436 auth: AuthTypes | None = None, 

437 proxy: ProxyTypes | None = None, 

438 proxies: ProxiesTypes | None = None, 

439 follow_redirects: bool = False, 

440 cert: CertTypes | None = None, 

441 verify: VerifyTypes = True, 

442 timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG, 

443 trust_env: bool = True, 

444) -> Response: 

445 """ 

446 Sends a `DELETE` request. 

447 

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

449 

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

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

452 """ 

453 return request( 

454 "DELETE", 

455 url, 

456 params=params, 

457 headers=headers, 

458 cookies=cookies, 

459 auth=auth, 

460 proxy=proxy, 

461 proxies=proxies, 

462 follow_redirects=follow_redirects, 

463 cert=cert, 

464 verify=verify, 

465 timeout=timeout, 

466 trust_env=trust_env, 

467 )