This is an archive of the discontinued Mercurial Phabricator instance.

Differential D935

urllibcompat: move some adapters from pycompat to urllibcompat
ClosedPublic

Authored by durin42 on Oct 4 2017, 12:26 PM.

Details

Reviewers
pulkit
krbullock
Group Reviewers
hg-reviewers
Commits
rHG192f7b126ed2: urllibcompat: move some adapters from pycompat to urllibcompat
Summary

These are all the httpserver and urllib.* aliases. They seem to make
more sense in the slightly-more-specific urllibcompat package than the
general-purpose pycompat.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Oct 4 2017, 12:26 PM
pulkit accepted this revision.Oct 4 2017, 2:14 PM
krbullock accepted this revision.Oct 4 2017, 3:48 PM
This revision is now accepted and ready to land.Oct 4 2017, 3:48 PM
Closed by commit rHG192f7b126ed2: urllibcompat: move some adapters from pycompat to urllibcompat (authored by durin42). · Explain WhyOct 4 2017, 3:49 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/pycompat.py (147 lines)
Mmercurial/urllibcompat.py (146 lines)
Mmercurial/util.py (8 lines)

Diff 2431

mercurial/pycompat.py

sysargv = sys.argv sysargv = sys.argv
sysplatform = sys.platform sysplatform = sys.platform
getcwd = os.getcwd getcwd = os.getcwd
sysexecutable = sys.executable sysexecutable = sys.executable
shlexsplit = shlex.split shlexsplit = shlex.split
stringio = cStringIO.StringIO stringio = cStringIO.StringIO
maplist = map maplist = map
rawinput = raw_input rawinput = raw_input
class _pycompatstub(object):
def __init__(self):
self._aliases = {}
def _registeraliases(self, origin, items):
"""Add items that will be populated at the first access"""
items = map(sysstr, items)
self._aliases.update(
(item.replace(sysstr('_'), sysstr('')).lower(), (origin, item))
for item in items)
def _registeralias(self, origin, attr, name):
"""Alias ``origin``.``attr`` as ``name``"""
self._aliases[sysstr(name)] = (origin, sysstr(attr))
def __getattr__(self, name):
try:
origin, item = self._aliases[name]
except KeyError:
raise AttributeError(name)
self.__dict__[name] = obj = getattr(origin, item)
return obj
httpserver = _pycompatstub()
urlreq = _pycompatstub()
urlerr = _pycompatstub()
if not ispy3:
import BaseHTTPServer
import CGIHTTPServer
import SimpleHTTPServer
import urllib2
import urllib
import urlparse
urlreq._registeraliases(urllib, (
"addclosehook",
"addinfourl",
"ftpwrapper",
"pathname2url",
"quote",
"splitattr",
"splitpasswd",
"splitport",
"splituser",
"unquote",
"url2pathname",
"urlencode",
))
urlreq._registeraliases(urllib2, (
"AbstractHTTPHandler",
"BaseHandler",
"build_opener",
"FileHandler",
"FTPHandler",
"HTTPBasicAuthHandler",
"HTTPDigestAuthHandler",
"HTTPHandler",
"HTTPPasswordMgrWithDefaultRealm",
"HTTPSHandler",
"install_opener",
"ProxyHandler",
"Request",
"urlopen",
))
urlreq._registeraliases(urlparse, (
"urlparse",
"urlunparse",
))
urlerr._registeraliases(urllib2, (
"HTTPError",
"URLError",
))
httpserver._registeraliases(BaseHTTPServer, (
"HTTPServer",
"BaseHTTPRequestHandler",
))
httpserver._registeraliases(SimpleHTTPServer, (
"SimpleHTTPRequestHandler",
))
httpserver._registeraliases(CGIHTTPServer, (
"CGIHTTPRequestHandler",
))
else:
import urllib.parse
urlreq._registeraliases(urllib.parse, (
"splitattr",
"splitpasswd",
"splitport",
"splituser",
"urlparse",
"urlunparse",
))
urlreq._registeralias(urllib.parse, "unquote_to_bytes", "unquote")
import urllib.request
urlreq._registeraliases(urllib.request, (
"AbstractHTTPHandler",
"BaseHandler",
"build_opener",
"FileHandler",
"FTPHandler",
"ftpwrapper",
"HTTPHandler",
"HTTPSHandler",
"install_opener",
"pathname2url",
"HTTPBasicAuthHandler",
"HTTPDigestAuthHandler",
"HTTPPasswordMgrWithDefaultRealm",
"ProxyHandler",
"Request",
"url2pathname",
"urlopen",
))
import urllib.response
urlreq._registeraliases(urllib.response, (
"addclosehook",
"addinfourl",
))
import urllib.error
urlerr._registeraliases(urllib.error, (
"HTTPError",
"URLError",
))
import http.server
httpserver._registeraliases(http.server, (
"HTTPServer",
"BaseHTTPRequestHandler",
"SimpleHTTPRequestHandler",
"CGIHTTPRequestHandler",
))
# urllib.parse.quote() accepts both str and bytes, decodes bytes
# (if necessary), and returns str. This is wonky. We provide a custom
# implementation that only accepts bytes and emits bytes.
def quote(s, safe=r'/'):
s = urllib.parse.quote_from_bytes(s, safe=safe)
return s.encode('ascii', 'strict')
# urllib.parse.urlencode() returns str. We use this function to make
# sure we return bytes.
def urlencode(query, doseq=False):
s = urllib.parse.urlencode(query, doseq=doseq)
return s.encode('ascii')
urlreq.quote = quote
urlreq.urlencode = urlencode

mercurial/urllibcompat.py

# urllibcompat.py - adapters to ease using urllib2 on Py2 and urllib on Py3 # urllibcompat.py - adapters to ease using urllib2 on Py2 and urllib on Py3
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from . import pycompat from . import pycompat
_sysstr = pycompat.sysstr
class _pycompatstub(object):
def __init__(self):
self._aliases = {}
def _registeraliases(self, origin, items):
"""Add items that will be populated at the first access"""
items = map(_sysstr, items)
self._aliases.update(
(item.replace(_sysstr('_'), _sysstr('')).lower(), (origin, item))
for item in items)
def _registeralias(self, origin, attr, name):
"""Alias ``origin``.``attr`` as ``name``"""
self._aliases[_sysstr(name)] = (origin, _sysstr(attr))
def __getattr__(self, name):
try:
origin, item = self._aliases[name]
except KeyError:
raise AttributeError(name)
self.__dict__[name] = obj = getattr(origin, item)
return obj
httpserver = _pycompatstub()
urlreq = _pycompatstub()
urlerr = _pycompatstub()
if pycompat.ispy3: if pycompat.ispy3:
import urllib.parse
urlreq._registeraliases(urllib.parse, (
"splitattr",
"splitpasswd",
"splitport",
"splituser",
"urlparse",
"urlunparse",
))
urlreq._registeralias(urllib.parse, "unquote_to_bytes", "unquote")
import urllib.request
urlreq._registeraliases(urllib.request, (
"AbstractHTTPHandler",
"BaseHandler",
"build_opener",
"FileHandler",
"FTPHandler",
"ftpwrapper",
"HTTPHandler",
"HTTPSHandler",
"install_opener",
"pathname2url",
"HTTPBasicAuthHandler",
"HTTPDigestAuthHandler",
"HTTPPasswordMgrWithDefaultRealm",
"ProxyHandler",
"Request",
"url2pathname",
"urlopen",
))
import urllib.response
urlreq._registeraliases(urllib.response, (
"addclosehook",
"addinfourl",
))
import urllib.error
urlerr._registeraliases(urllib.error, (
"HTTPError",
"URLError",
))
import http.server
httpserver._registeraliases(http.server, (
"HTTPServer",
"BaseHTTPRequestHandler",
"SimpleHTTPRequestHandler",
"CGIHTTPRequestHandler",
))
# urllib.parse.quote() accepts both str and bytes, decodes bytes
# (if necessary), and returns str. This is wonky. We provide a custom
# implementation that only accepts bytes and emits bytes.
def quote(s, safe=r'/'):
s = urllib.parse.quote_from_bytes(s, safe=safe)
return s.encode('ascii', 'strict')
# urllib.parse.urlencode() returns str. We use this function to make
# sure we return bytes.
def urlencode(query, doseq=False):
s = urllib.parse.urlencode(query, doseq=doseq)
return s.encode('ascii')
urlreq.quote = quote
urlreq.urlencode = urlencode
def getfullurl(req): def getfullurl(req):
return req.full_url return req.full_url
def gethost(req): def gethost(req):
return req.host return req.host
def getselector(req): def getselector(req):
return req.selector return req.selector
def getdata(req): def getdata(req):
return req.data return req.data
def hasdata(req): def hasdata(req):
return req.data is not None return req.data is not None
else: else:
import BaseHTTPServer
import CGIHTTPServer
import SimpleHTTPServer
import urllib2
import urllib
import urlparse
urlreq._registeraliases(urllib, (
"addclosehook",
"addinfourl",
"ftpwrapper",
"pathname2url",
"quote",
"splitattr",
"splitpasswd",
"splitport",
"splituser",
"unquote",
"url2pathname",
"urlencode",
))
urlreq._registeraliases(urllib2, (
"AbstractHTTPHandler",
"BaseHandler",
"build_opener",
"FileHandler",
"FTPHandler",
"HTTPBasicAuthHandler",
"HTTPDigestAuthHandler",
"HTTPHandler",
"HTTPPasswordMgrWithDefaultRealm",
"HTTPSHandler",
"install_opener",
"ProxyHandler",
"Request",
"urlopen",
))
urlreq._registeraliases(urlparse, (
"urlparse",
"urlunparse",
))
urlerr._registeraliases(urllib2, (
"HTTPError",
"URLError",
))
httpserver._registeraliases(BaseHTTPServer, (
"HTTPServer",
"BaseHTTPRequestHandler",
))
httpserver._registeraliases(SimpleHTTPServer, (
"SimpleHTTPRequestHandler",
))
httpserver._registeraliases(CGIHTTPServer, (
"CGIHTTPRequestHandler",
))
def gethost(req): def gethost(req):
return req.get_host() return req.get_host()
def getselector(req): def getselector(req):
return req.get_selector() return req.get_selector()
def getfullurl(req): def getfullurl(req):
return req.get_full_url() return req.get_full_url()
def getdata(req): def getdata(req):
return req.get_data() return req.get_data()
def hasdata(req): def hasdata(req):
return req.has_data() return req.has_data()

mercurial/util.py

import zlib import zlib
from . import ( from . import (
encoding, encoding,
error, error,
i18n, i18n,
policy, policy,
pycompat, pycompat,
urllibcompat,
) )
base85 = policy.importmod(r'base85') base85 = policy.importmod(r'base85')
osutil = policy.importmod(r'osutil') osutil = policy.importmod(r'osutil')
parsers = policy.importmod(r'parsers') parsers = policy.importmod(r'parsers')
b85decode = base85.b85decode b85decode = base85.b85decode
b85encode = base85.b85encode b85encode = base85.b85encode
cookielib = pycompat.cookielib cookielib = pycompat.cookielib
empty = pycompat.empty empty = pycompat.empty
httplib = pycompat.httplib httplib = pycompat.httplib
httpserver = pycompat.httpserver
pickle = pycompat.pickle pickle = pycompat.pickle
queue = pycompat.queue queue = pycompat.queue
socketserver = pycompat.socketserver socketserver = pycompat.socketserver
stderr = pycompat.stderr stderr = pycompat.stderr
stdin = pycompat.stdin stdin = pycompat.stdin
stdout = pycompat.stdout stdout = pycompat.stdout
stringio = pycompat.stringio stringio = pycompat.stringio
urlerr = pycompat.urlerr
urlreq = pycompat.urlreq
xmlrpclib = pycompat.xmlrpclib xmlrpclib = pycompat.xmlrpclib
httpserver = urllibcompat.httpserver
urlerr = urllibcompat.urlerr
urlreq = urllibcompat.urlreq
# workaround for win32mbcs # workaround for win32mbcs
_filenamebytestr = pycompat.bytestr _filenamebytestr = pycompat.bytestr
def isatty(fp): def isatty(fp):
try: try:
return fp.isatty() return fp.isatty()
except AttributeError: except AttributeError:
return False return False