Mercurial > hg

comparison mercurial/urllibcompat.py @ 48896:4286ec1d9842

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
urllibcompat: remove Python 2 support code We had to move the `import` statements to appease the import checker. This whole module could probably be deleted as its point in life is to pave over Python 2/3 differences. But that's for a different commit. Differential Revision: https://phab.mercurial-scm.org/D12299
author Gregory Szorc <gregory.szorc@gmail.com>
date Mon, 21 Feb 2022 10:35:20 -0700
parents 6000f5b25c9b
children 642e31cb55f0
comparison
equal deleted inserted replaced
48895:62baa61efe8f 48896:4286ec1d9842
2 # 2 #
3 # Copyright 2017 Google, Inc. 3 # Copyright 2017 Google, Inc.
4 # 4 #
5 # This software may be used and distributed according to the terms of the 5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version. 6 # GNU General Public License version 2 or any later version.
7
8 import http.server
9 import urllib.error
10 import urllib.parse
11 import urllib.request
12 import urllib.response
7 13
8 from .pycompat import getattr 14 from .pycompat import getattr
9 from . import pycompat 15 from . import pycompat
10 16
11 _sysstr = pycompat.sysstr 17 _sysstr = pycompat.sysstr
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