1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

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

# -*- coding: utf-8 -*- 

 

""" 

requests.api 

~~~~~~~~~~~~ 

 

This module implements the Requests API. 

 

:copyright: (c) 2012 by Kenneth Reitz. 

:license: Apache2, see LICENSE for more details. 

""" 

 

from . import sessions 

 

 

def request(method, url, **kwargs): 

"""Constructs and sends a :class:`Request <Request>`. 

 

:param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``. 

:param url: URL for the new :class:`Request` object. 

:param params: (optional) Dictionary, list of tuples or bytes to send 

in the query string for the :class:`Request`. 

:param data: (optional) Dictionary, list of tuples, bytes, or file-like 

object to send in the body of the :class:`Request`. 

:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. 

:param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`. 

:param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`. 

:param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload. 

``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')`` 

or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string 

defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers 

to add for the file. 

:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth. 

:param timeout: (optional) How many seconds to wait for the server to send data 

before giving up, as a float, or a :ref:`(connect timeout, read 

timeout) <timeouts>` tuple. 

:type timeout: float or tuple 

:param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``. 

:type allow_redirects: bool 

:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy. 

:param verify: (optional) Either a boolean, in which case it controls whether we verify 

the server's TLS certificate, or a string, in which case it must be a path 

to a CA bundle to use. Defaults to ``True``. 

:param stream: (optional) if ``False``, the response content will be immediately downloaded. 

:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

 

Usage:: 

 

>>> import requests 

>>> req = requests.request('GET', 'https://httpbin.org/get') 

>>> req 

<Response [200]> 

""" 

 

# By using the 'with' statement we are sure the session is closed, thus we 

# avoid leaving sockets open which can trigger a ResourceWarning in some 

# cases, and look like a memory leak in others. 

with sessions.Session() as session: 

return session.request(method=method, url=url, **kwargs) 

 

 

def get(url, params=None, **kwargs): 

r"""Sends a GET request. 

 

:param url: URL for the new :class:`Request` object. 

:param params: (optional) Dictionary, list of tuples or bytes to send 

in the query string for the :class:`Request`. 

:param \*\*kwargs: Optional arguments that ``request`` takes. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

kwargs.setdefault('allow_redirects', True) 

return request('get', url, params=params, **kwargs) 

 

 

def options(url, **kwargs): 

r"""Sends an OPTIONS request. 

 

:param url: URL for the new :class:`Request` object. 

:param \*\*kwargs: Optional arguments that ``request`` takes. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

kwargs.setdefault('allow_redirects', True) 

return request('options', url, **kwargs) 

 

 

def head(url, **kwargs): 

r"""Sends a HEAD request. 

 

:param url: URL for the new :class:`Request` object. 

:param \*\*kwargs: Optional arguments that ``request`` takes. If 

`allow_redirects` is not provided, it will be set to `False` (as 

opposed to the default :meth:`request` behavior). 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

kwargs.setdefault('allow_redirects', False) 

return request('head', url, **kwargs) 

 

 

def post(url, data=None, json=None, **kwargs): 

r"""Sends a POST request. 

 

:param url: URL for the new :class:`Request` object. 

:param data: (optional) Dictionary, list of tuples, bytes, or file-like 

object to send in the body of the :class:`Request`. 

:param json: (optional) json data to send in the body of the :class:`Request`. 

:param \*\*kwargs: Optional arguments that ``request`` takes. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

return request('post', url, data=data, json=json, **kwargs) 

 

 

def put(url, data=None, **kwargs): 

r"""Sends a PUT request. 

 

:param url: URL for the new :class:`Request` object. 

:param data: (optional) Dictionary, list of tuples, bytes, or file-like 

object to send in the body of the :class:`Request`. 

:param json: (optional) json data to send in the body of the :class:`Request`. 

:param \*\*kwargs: Optional arguments that ``request`` takes. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

return request('put', url, data=data, **kwargs) 

 

 

def patch(url, data=None, **kwargs): 

r"""Sends a PATCH request. 

 

:param url: URL for the new :class:`Request` object. 

:param data: (optional) Dictionary, list of tuples, bytes, or file-like 

object to send in the body of the :class:`Request`. 

:param json: (optional) json data to send in the body of the :class:`Request`. 

:param \*\*kwargs: Optional arguments that ``request`` takes. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

return request('patch', url, data=data, **kwargs) 

 

 

def delete(url, **kwargs): 

r"""Sends a DELETE request. 

 

:param url: URL for the new :class:`Request` object. 

:param \*\*kwargs: Optional arguments that ``request`` takes. 

:return: :class:`Response <Response>` object 

:rtype: requests.Response 

""" 

 

return request('delete', url, **kwargs)