pycompat: remove large Python 2 block

We no longer support Python 2. So we can delete its compatibility
code and remove the conditional and dedent the Python 3 code.

In order to make the linter happy, we had to inline imports in the
stanza at the top of the file.

Differential Revision: https://phab.mercurial-scm.org/D12250

mercurial/pycompat.py

@@ -11,21 +11,26 b' This contains aliases to hide python ver'
 from __future__ import absolute_import
 
 import builtins
+import codecs
 import concurrent.futures as futures
+import functools
 import getopt
 import http.client as httplib
 import http.cookiejar as cookielib
 import inspect
+import io
 import json
 import os
 import pickle
 import queue
 import shlex
 import socketserver
+import struct
 import sys
 import tempfile
 import xmlrpc.client as xmlrpclib
 
+
 ispy3 = sys.version_info[0] >= 3
 ispypy = '__pypy__' in sys.builtin_module_names
 TYPE_CHECKING = False
@@ -82,13 +87,6 b' def rapply(f, xs):'
     return _rapply(f, xs)
 
 
-if ispy3:
-    import builtins
-    import codecs
-    import functools
-    import io
-    import struct
-
     if os.name == r'nt' and sys.version_info >= (3, 6):
         # MBCS (or ANSI) filesystem encoding must be used as before.
         # Otherwise non-ASCII filenames in existing repositories would be
@@ -117,15 +115,19 b' if ispy3:'
     # TODO deprecate stringio name, as it is a lie on Python 3.
     stringio = bytesio
 
+
     def maplist(*args):
         return list(map(*args))
 
+
     def rangelist(*args):
         return list(range(*args))
 
+
     def ziplist(*args):
         return list(zip(*args))
 
+
     rawinput = input
     getargspec = inspect.getfullargspec
 
@@ -154,6 +156,7 b' if ispy3:'
     bytechr = struct.Struct('>B').pack
     byterepr = b'%r'.__mod__
 
+
     class bytestr(bytes):
         """A bytes which mostly acts as a Python 2 str
 
@@ -239,16 +242,19 b' if ispy3:'
         def __repr__(self):
             return bytes.__repr__(self)[1:]  # drop b''
 
+
     def iterbytestr(s):
         """Iterate bytes as if it were a str object of Python 2"""
         return map(bytechr, s)
 
+
     def maybebytestr(s):
         """Promote bytes to bytestr"""
         if isinstance(s, bytes):
             return bytestr(s)
         return s
 
+
     def sysbytes(s):
         """Convert an internal str (e.g. keyword, __doc__) back to bytes
 
@@ -259,6 +265,7 b' if ispy3:'
             return s
         return s.encode('utf-8')
 
+
     def sysstr(s):
         """Return a keyword str to be passed to Python functions such as
         getattr() and str.encode()
@@ -271,22 +278,26 b' if ispy3:'
             return s
         return s.decode('latin-1')
 
+
     def strurl(url):
         """Converts a bytes url back to str"""
         if isinstance(url, bytes):
             return url.decode('ascii')
         return url
 
+
     def bytesurl(url):
         """Converts a str url to bytes by encoding in ascii"""
         if isinstance(url, str):
             return url.encode('ascii')
         return url
 
+
     def raisewithtb(exc, tb):
         """Raise exception with the given traceback"""
         raise exc.with_traceback(tb)
 
+
     def getdoc(obj):
         """Get docstring as bytes; may be None so gettext() won't confuse it
         with _('')"""
@@ -295,6 +306,7 b' if ispy3:'
             return doc
         return sysbytes(doc)
 
+
     def _wrapattrfunc(f):
         @functools.wraps(f)
         def w(object, name, *args):
@@ -302,6 +314,7 b' if ispy3:'
 
         return w
 
+
     # these wrappers are automagically imported by hgloader
     delattr = _wrapattrfunc(builtins.delattr)
     getattr = _wrapattrfunc(builtins.getattr)
@@ -310,11 +323,14 b' if ispy3:'
     xrange = builtins.range
     unicode = str
 
+
     def open(name, mode=b'r', buffering=-1, encoding=None):
         return builtins.open(name, sysstr(mode), buffering, encoding)
 
+
     safehasattr = _wrapattrfunc(builtins.hasattr)
 
+
     def _getoptbwrapper(orig, args, shortlist, namelist):
         """
         Takes bytes arguments, converts them to unicode, pass them to
@@ -330,6 +346,7 b' if ispy3:'
         args = [a.encode('latin-1') for a in args]
         return opts, args
 
+
     def strkwargs(dic):
         """
         Converts the keys of a python dictonary to str i.e. unicodes so that
@@ -339,6 +356,7 b' if ispy3:'
         dic = {k.decode('latin-1'): v for k, v in dic.items()}
         return dic
 
+
     def byteskwargs(dic):
         """
         Converts keys of python dictionaries to bytes as they were converted to
@@ -347,6 +365,7 b' if ispy3:'
         dic = {k.encode('latin-1'): v for k, v in dic.items()}
         return dic
 
+
     # TODO: handle shlex.shlex().
     def shlexsplit(s, comments=False, posix=True):
         """
@@ -357,6 +376,7 b' if ispy3:'
         ret = shlex.split(s.decode('latin-1'), comments, posix)
         return [a.encode('latin-1') for a in ret]
 
+
     iteritems = lambda x: x.items()
     itervalues = lambda x: x.values()
 
@@ -399,84 +419,8 b' if ispy3:'
 
             return json.loads(s, *args, **kwargs)
 
-    else:
-        json_loads = json.loads
 
 else:
-    import cStringIO
-
-    xrange = xrange
-    unicode = unicode
-    bytechr = chr
-    byterepr = repr
-    bytestr = str
-    iterbytestr = iter
-    maybebytestr = identity
-    sysbytes = identity
-    sysstr = identity
-    strurl = identity
-    bytesurl = identity
-    open = open
-    delattr = delattr
-    getattr = getattr
-    hasattr = hasattr
-    setattr = setattr
-
-    # this can't be parsed on Python 3
-    exec(b'def raisewithtb(exc, tb):\n    raise exc, None, tb\n')
-
-    def fsencode(filename):
-        """
-        Partial backport from os.py in Python 3, which only accepts bytes.
-        In Python 2, our paths should only ever be bytes, a unicode path
-        indicates a bug.
-        """
-        if isinstance(filename, str):
-            return filename
-        else:
-            raise TypeError("expect str, not %s" % type(filename).__name__)
-
-    # In Python 2, fsdecode() has a very chance to receive bytes. So it's
-    # better not to touch Python 2 part as it's already working fine.
-    fsdecode = identity
-
-    def getdoc(obj):
-        return getattr(obj, '__doc__', None)
-
-    _notset = object()
-
-    def safehasattr(thing, attr):
-        return getattr(thing, attr, _notset) is not _notset
-
-    def _getoptbwrapper(orig, args, shortlist, namelist):
-        return orig(args, shortlist, namelist)
-
-    strkwargs = identity
-    byteskwargs = identity
-
-    oscurdir = os.curdir
-    oslinesep = os.linesep
-    osname = os.name
-    ospathsep = os.pathsep
-    ospardir = os.pardir
-    ossep = os.sep
-    osaltsep = os.altsep
-    osdevnull = os.devnull
-    long = long
-    if getattr(sys, 'argv', None) is not None:
-        sysargv = sys.argv
-    sysplatform = sys.platform
-    sysexecutable = sys.executable
-    shlexsplit = shlex.split
-    bytesio = cStringIO.StringIO
-    stringio = bytesio
-    maplist = map
-    rangelist = range
-    ziplist = zip
-    rawinput = raw_input
-    getargspec = inspect.getargspec
-    iteritems = lambda x: x.iteritems()
-    itervalues = lambda x: x.itervalues()
     json_loads = json.loads
 
 isjython = sysplatform.startswith(b'java')