37 |
43 |
38 httpserver = _pycompatstub() |
44 httpserver = _pycompatstub() |
39 urlreq = _pycompatstub() |
45 urlreq = _pycompatstub() |
40 urlerr = _pycompatstub() |
46 urlerr = _pycompatstub() |
41 |
47 |
42 if pycompat.ispy3: |
48 urlreq._registeraliases( |
43 import urllib.parse |
49 urllib.parse, |
|
50 ( |
|
51 b"splitattr", |
|
52 b"splitpasswd", |
|
53 b"splitport", |
|
54 b"splituser", |
|
55 b"urlparse", |
|
56 b"urlunparse", |
|
57 ), |
|
58 ) |
|
59 urlreq._registeralias(urllib.parse, b"parse_qs", b"parseqs") |
|
60 urlreq._registeralias(urllib.parse, b"parse_qsl", b"parseqsl") |
|
61 urlreq._registeralias(urllib.parse, b"unquote_to_bytes", b"unquote") |
44 |
62 |
45 urlreq._registeraliases( |
63 urlreq._registeraliases( |
46 urllib.parse, |
64 urllib.request, |
47 ( |
65 ( |
48 b"splitattr", |
66 b"AbstractHTTPHandler", |
49 b"splitpasswd", |
67 b"BaseHandler", |
50 b"splitport", |
68 b"build_opener", |
51 b"splituser", |
69 b"FileHandler", |
52 b"urlparse", |
70 b"FTPHandler", |
53 b"urlunparse", |
71 b"ftpwrapper", |
54 ), |
72 b"HTTPHandler", |
55 ) |
73 b"HTTPSHandler", |
56 urlreq._registeralias(urllib.parse, b"parse_qs", b"parseqs") |
74 b"install_opener", |
57 urlreq._registeralias(urllib.parse, b"parse_qsl", b"parseqsl") |
75 b"pathname2url", |
58 urlreq._registeralias(urllib.parse, b"unquote_to_bytes", b"unquote") |
76 b"HTTPBasicAuthHandler", |
59 import urllib.request |
77 b"HTTPDigestAuthHandler", |
60 |
78 b"HTTPPasswordMgrWithDefaultRealm", |
61 urlreq._registeraliases( |
79 b"ProxyHandler", |
62 urllib.request, |
80 b"Request", |
63 ( |
81 b"url2pathname", |
64 b"AbstractHTTPHandler", |
82 b"urlopen", |
65 b"BaseHandler", |
83 ), |
66 b"build_opener", |
84 ) |
67 b"FileHandler", |
|
68 b"FTPHandler", |
|
69 b"ftpwrapper", |
|
70 b"HTTPHandler", |
|
71 b"HTTPSHandler", |
|
72 b"install_opener", |
|
73 b"pathname2url", |
|
74 b"HTTPBasicAuthHandler", |
|
75 b"HTTPDigestAuthHandler", |
|
76 b"HTTPPasswordMgrWithDefaultRealm", |
|
77 b"ProxyHandler", |
|
78 b"Request", |
|
79 b"url2pathname", |
|
80 b"urlopen", |
|
81 ), |
|
82 ) |
|
83 import urllib.response |
|
84 |
|
85 urlreq._registeraliases( |
|
86 urllib.response, |
|
87 ( |
|
88 b"addclosehook", |
|
89 b"addinfourl", |
|
90 ), |
|
91 ) |
|
92 import urllib.error |
|
93 |
|
94 urlerr._registeraliases( |
|
95 urllib.error, |
|
96 ( |
|
97 b"HTTPError", |
|
98 b"URLError", |
|
99 ), |
|
100 ) |
|
101 import http.server |
|
102 |
|
103 httpserver._registeraliases( |
|
104 http.server, |
|
105 ( |
|
106 b"HTTPServer", |
|
107 b"BaseHTTPRequestHandler", |
|
108 b"SimpleHTTPRequestHandler", |
|
109 b"CGIHTTPRequestHandler", |
|
110 ), |
|
111 ) |
|
112 |
|
113 # urllib.parse.quote() accepts both str and bytes, decodes bytes |
|
114 # (if necessary), and returns str. This is wonky. We provide a custom |
|
115 # implementation that only accepts bytes and emits bytes. |
|
116 def quote(s, safe='/'): |
|
117 # bytestr has an __iter__ that emits characters. quote_from_bytes() |
|
118 # does an iteration and expects ints. We coerce to bytes to appease it. |
|
119 if isinstance(s, pycompat.bytestr): |
|
120 s = bytes(s) |
|
121 s = urllib.parse.quote_from_bytes(s, safe=safe) |
|
122 return s.encode('ascii', 'strict') |
|
123 |
|
124 # urllib.parse.urlencode() returns str. We use this function to make |
|
125 # sure we return bytes. |
|
126 def urlencode(query, doseq=False): |
|
127 s = urllib.parse.urlencode(query, doseq=doseq) |
|
128 return s.encode('ascii') |
|
129 |
|
130 urlreq.quote = quote |
|
131 urlreq.urlencode = urlencode |
|
132 |
|
133 def getfullurl(req): |
|
134 return req.full_url |
|
135 |
|
136 def gethost(req): |
|
137 return req.host |
|
138 |
|
139 def getselector(req): |
|
140 return req.selector |
|
141 |
|
142 def getdata(req): |
|
143 return req.data |
|
144 |
|
145 def hasdata(req): |
|
146 return req.data is not None |
|
147 |
85 |
148 |
86 |
149 else: |
87 urlreq._registeraliases( |
150 # pytype: disable=import-error |
88 urllib.response, |
151 import BaseHTTPServer |
89 ( |
152 import CGIHTTPServer |
90 b"addclosehook", |
153 import SimpleHTTPServer |
91 b"addinfourl", |
154 import urllib2 |
92 ), |
155 import urllib |
93 ) |
156 import urlparse |
|
157 |
94 |
158 # pytype: enable=import-error |
95 urlerr._registeraliases( |
|
96 urllib.error, |
|
97 ( |
|
98 b"HTTPError", |
|
99 b"URLError", |
|
100 ), |
|
101 ) |
159 |
102 |
160 urlreq._registeraliases( |
103 httpserver._registeraliases( |
161 urllib, |
104 http.server, |
162 ( |
105 ( |
163 b"addclosehook", |
106 b"HTTPServer", |
164 b"addinfourl", |
107 b"BaseHTTPRequestHandler", |
165 b"ftpwrapper", |
108 b"SimpleHTTPRequestHandler", |
166 b"pathname2url", |
109 b"CGIHTTPRequestHandler", |
167 b"quote", |
110 ), |
168 b"splitattr", |
111 ) |
169 b"splitpasswd", |
|
170 b"splitport", |
|
171 b"splituser", |
|
172 b"unquote", |
|
173 b"url2pathname", |
|
174 b"urlencode", |
|
175 ), |
|
176 ) |
|
177 urlreq._registeraliases( |
|
178 urllib2, |
|
179 ( |
|
180 b"AbstractHTTPHandler", |
|
181 b"BaseHandler", |
|
182 b"build_opener", |
|
183 b"FileHandler", |
|
184 b"FTPHandler", |
|
185 b"HTTPBasicAuthHandler", |
|
186 b"HTTPDigestAuthHandler", |
|
187 b"HTTPHandler", |
|
188 b"HTTPPasswordMgrWithDefaultRealm", |
|
189 b"HTTPSHandler", |
|
190 b"install_opener", |
|
191 b"ProxyHandler", |
|
192 b"Request", |
|
193 b"urlopen", |
|
194 ), |
|
195 ) |
|
196 urlreq._registeraliases( |
|
197 urlparse, |
|
198 ( |
|
199 b"urlparse", |
|
200 b"urlunparse", |
|
201 ), |
|
202 ) |
|
203 urlreq._registeralias(urlparse, b"parse_qs", b"parseqs") |
|
204 urlreq._registeralias(urlparse, b"parse_qsl", b"parseqsl") |
|
205 urlerr._registeraliases( |
|
206 urllib2, |
|
207 ( |
|
208 b"HTTPError", |
|
209 b"URLError", |
|
210 ), |
|
211 ) |
|
212 httpserver._registeraliases( |
|
213 BaseHTTPServer, |
|
214 ( |
|
215 b"HTTPServer", |
|
216 b"BaseHTTPRequestHandler", |
|
217 ), |
|
218 ) |
|
219 httpserver._registeraliases( |
|
220 SimpleHTTPServer, (b"SimpleHTTPRequestHandler",) |
|
221 ) |
|
222 httpserver._registeraliases(CGIHTTPServer, (b"CGIHTTPRequestHandler",)) |
|
223 |
112 |
224 def gethost(req): |
113 # urllib.parse.quote() accepts both str and bytes, decodes bytes |
225 return req.get_host() |
114 # (if necessary), and returns str. This is wonky. We provide a custom |
|
115 # implementation that only accepts bytes and emits bytes. |
|
116 def quote(s, safe='/'): |
|
117 # bytestr has an __iter__ that emits characters. quote_from_bytes() |
|
118 # does an iteration and expects ints. We coerce to bytes to appease it. |
|
119 if isinstance(s, pycompat.bytestr): |
|
120 s = bytes(s) |
|
121 s = urllib.parse.quote_from_bytes(s, safe=safe) |
|
122 return s.encode('ascii', 'strict') |
226 |
123 |
227 def getselector(req): |
|
228 return req.get_selector() |
|
229 |
124 |
230 def getfullurl(req): |
125 # urllib.parse.urlencode() returns str. We use this function to make |
231 return req.get_full_url() |
126 # sure we return bytes. |
|
127 def urlencode(query, doseq=False): |
|
128 s = urllib.parse.urlencode(query, doseq=doseq) |
|
129 return s.encode('ascii') |
232 |
130 |
233 def getdata(req): |
|
234 return req.get_data() |
|
235 |
131 |
236 def hasdata(req): |
132 urlreq.quote = quote |
237 return req.has_data() |
133 urlreq.urlencode = urlencode |
|
134 |
|
135 |
|
136 def getfullurl(req): |
|
137 return req.full_url |
|
138 |
|
139 |
|
140 def gethost(req): |
|
141 return req.host |
|
142 |
|
143 |
|
144 def getselector(req): |
|
145 return req.selector |
|
146 |
|
147 |
|
148 def getdata(req): |
|
149 return req.data |
|
150 |
|
151 |
|
152 def hasdata(req): |
|
153 return req.data is not None |