( )⚙ D12340 py3: use str instead of pycompat.unicode

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12340

py3: use str instead of pycompat.unicode
ClosedPublic

Authored by indygreg on Mar 3 2022, 10:30 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG06de08b36c82: py3: use str instead of pycompat.unicode
Summary

pycompat.unicode is an alias to str.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Mar 3 2022, 10:30 PM
Alphare accepted this revision.Mar 8 2022, 4:35 AM
This revision is now accepted and ready to land.Mar 8 2022, 4:35 AM
indygreg added a commit: rHG06de08b36c82: py3: use str instead of pycompat.unicode.Mar 8 2022, 6:01 AM
Closed by commit rHG06de08b36c82: py3: use str instead of pycompat.unicode (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32552

hgext/convert/common.py

Tag names must be UTF-8 strings. Tag names must be UTF-8 strings.
""" """
raise NotImplementedError raise NotImplementedError
def recode(self, s, encoding=None): def recode(self, s, encoding=None):
if not encoding: if not encoding:
encoding = self.encoding or b'utf-8' encoding = self.encoding or b'utf-8'
if isinstance(s, pycompat.unicode): if isinstance(s, str):
return s.encode("utf-8") return s.encode("utf-8")
try: try:
return s.decode(pycompat.sysstr(encoding)).encode("utf-8") return s.decode(pycompat.sysstr(encoding)).encode("utf-8")
except UnicodeError: except UnicodeError:
try: try:
return s.decode("latin-1").encode("utf-8") return s.decode("latin-1").encode("utf-8")
except UnicodeError: except UnicodeError:
return s.decode(pycompat.sysstr(encoding), "replace").encode( return s.decode(pycompat.sysstr(encoding), "replace").encode(

hgext/convert/convcmd.py

continue continue
m = _(b'overriding mapping for author %s, was %s, will be %s\n') m = _(b'overriding mapping for author %s, was %s, will be %s\n')
ui.status(m % (srcauthor, authors[srcauthor], dstauthor)) ui.status(m % (srcauthor, authors[srcauthor], dstauthor))
return authors return authors
def recode(s): def recode(s):
if isinstance(s, pycompat.unicode): if isinstance(s, str):
return s.encode(pycompat.sysstr(orig_encoding), 'replace') return s.encode(pycompat.sysstr(orig_encoding), 'replace')
else: else:
return s.decode('utf-8').encode( return s.decode('utf-8').encode(
pycompat.sysstr(orig_encoding), 'replace' pycompat.sysstr(orig_encoding), 'replace'
) )
def mapbranch(branch, branchmap): def mapbranch(branch, branchmap):

hgext/convert/darcs.py

child = node child = node
self.parents[child] = [] self.parents[child] = []
def after(self): def after(self):
self.ui.debug(b'cleaning up %s\n' % self.tmppath) self.ui.debug(b'cleaning up %s\n' % self.tmppath)
shutil.rmtree(self.tmppath, ignore_errors=True) shutil.rmtree(self.tmppath, ignore_errors=True)
def recode(self, s, encoding=None): def recode(self, s, encoding=None):
if isinstance(s, pycompat.unicode): if isinstance(s, str):
# XMLParser returns unicode objects for anything it can't # XMLParser returns unicode objects for anything it can't
# encode into ASCII. We convert them back to str to get # encode into ASCII. We convert them back to str to get
# recode's normal conversion behavior. # recode's normal conversion behavior.
s = s.encode('latin-1') s = s.encode('latin-1')
return super(darcs_source, self).recode(s, encoding) return super(darcs_source, self).recode(s, encoding)
def xml(self, cmd, **kwargs): def xml(self, cmd, **kwargs):
# NOTE: darcs is currently encoding agnostic and will print # NOTE: darcs is currently encoding agnostic and will print

hgext/lfs/blobstore.py

inst = urlerror.reason inst = urlerror.reason
if util.safehasattr(inst, b'reason'): if util.safehasattr(inst, b'reason'):
try: # usually it is in the form (errno, strerror) try: # usually it is in the form (errno, strerror)
reason = inst.reason.args[1] reason = inst.reason.args[1]
except (AttributeError, IndexError): except (AttributeError, IndexError):
# it might be anything, for example a string # it might be anything, for example a string
reason = inst.reason reason = inst.reason
if isinstance(reason, pycompat.unicode): if isinstance(reason, str):
# SSLError of Python 2.7.9 contains a unicode # SSLError of Python 2.7.9 contains a unicode
reason = encoding.unitolocal(reason) reason = encoding.unitolocal(reason)
return reason return reason
elif getattr(inst, "strerror", None): elif getattr(inst, "strerror", None):
return encoding.strtolocal(inst.strerror) return encoding.strtolocal(inst.strerror)
else: else:
return stringutil.forcebytestr(urlerror) return stringutil.forcebytestr(urlerror)
indent=2, indent=2,
separators=('', ': '), separators=('', ': '),
sort_keys=True, sort_keys=True,
) )
) )
) )
def encodestr(x): def encodestr(x):
if isinstance(x, pycompat.unicode): if isinstance(x, str):
return x.encode('utf-8') return x.encode('utf-8')
return x return x
return pycompat.rapply(encodestr, response) return pycompat.rapply(encodestr, response)
def _checkforservererror(self, pointers, responses, action): def _checkforservererror(self, pointers, responses, action):
"""Scans errors from objects """Scans errors from objects

hgext/phabricator.py

result = False result = False
arcconfig = {} arcconfig = {}
try: try:
# json.loads only accepts bytes from 3.6+ # json.loads only accepts bytes from 3.6+
rawparams = encoding.unifromlocal(wdirvfs.read(b".arcconfig")) rawparams = encoding.unifromlocal(wdirvfs.read(b".arcconfig"))
# json.loads only returns unicode strings # json.loads only returns unicode strings
arcconfig = pycompat.rapply( arcconfig = pycompat.rapply(
lambda x: encoding.unitolocal(x) lambda x: encoding.unitolocal(x) if isinstance(x, str) else x,
if isinstance(x, pycompat.unicode)
else x,
pycompat.json_loads(rawparams), pycompat.json_loads(rawparams),
) )
result = True result = True
except ValueError: except ValueError:
ui.warn(_(b"invalid JSON in %s\n") % wdirvfs.join(b".arcconfig")) ui.warn(_(b"invalid JSON in %s\n") % wdirvfs.join(b".arcconfig"))
except IOError: except IOError:
pass pass
b'Conduit Request failed (try %d/%d): %r\n' b'Conduit Request failed (try %d/%d): %r\n'
% (try_count + 1, max_try, err) % (try_count + 1, max_try, err)
) )
# failing request might come from overloaded server # failing request might come from overloaded server
retry_interval = ui.configint(b'phabricator', b'retry.interval') retry_interval = ui.configint(b'phabricator', b'retry.interval')
time.sleep(retry_interval) time.sleep(retry_interval)
ui.debug(b'Conduit Response: %s\n' % body) ui.debug(b'Conduit Response: %s\n' % body)
parsed = pycompat.rapply( parsed = pycompat.rapply(
lambda x: encoding.unitolocal(x) lambda x: encoding.unitolocal(x) if isinstance(x, str) else x,
if isinstance(x, pycompat.unicode)
else x,
# json.loads only accepts bytes from py3.6+ # json.loads only accepts bytes from py3.6+
pycompat.json_loads(encoding.unifromlocal(body)), pycompat.json_loads(encoding.unifromlocal(body)),
) )
if parsed.get(b'error_code'): if parsed.get(b'error_code'):
msg = _(b'Conduit Error (%s): %s') % ( msg = _(b'Conduit Error (%s): %s') % (
parsed[b'error_code'], parsed[b'error_code'],
parsed[b'error_info'], parsed[b'error_info'],
) )
raise error.Abort(msg) raise error.Abort(msg)
return parsed[b'result'] return parsed[b'result']
@vcrcommand(b'debugcallconduit', [], _(b'METHOD'), optionalrepo=True) @vcrcommand(b'debugcallconduit', [], _(b'METHOD'), optionalrepo=True)
def debugcallconduit(ui, repo, name): def debugcallconduit(ui, repo, name):
"""call Conduit API """call Conduit API
Call parameters are read from stdin as a JSON blob. Result will be written Call parameters are read from stdin as a JSON blob. Result will be written
to stdout as a JSON blob. to stdout as a JSON blob.
""" """
# json.loads only accepts bytes from 3.6+ # json.loads only accepts bytes from 3.6+
rawparams = encoding.unifromlocal(ui.fin.read()) rawparams = encoding.unifromlocal(ui.fin.read())
# json.loads only returns unicode strings # json.loads only returns unicode strings
params = pycompat.rapply( params = pycompat.rapply(
lambda x: encoding.unitolocal(x) lambda x: encoding.unitolocal(x) if isinstance(x, str) else x,
if isinstance(x, pycompat.unicode)
else x,
pycompat.json_loads(rawparams), pycompat.json_loads(rawparams),
) )
# json.dumps only accepts unicode strings # json.dumps only accepts unicode strings
result = pycompat.rapply( result = pycompat.rapply(
lambda x: encoding.unifromlocal(x) if isinstance(x, bytes) else x, lambda x: encoding.unifromlocal(x) if isinstance(x, bytes) else x,
callconduit(ui, name, params), callconduit(ui, name, params),
) )
s = json.dumps(result, sort_keys=True, indent=2, separators=(u',', u': ')) s = json.dumps(result, sort_keys=True, indent=2, separators=(u',', u': '))

hgext/win32mbcs.py

return map(decode, arg) return map(decode, arg)
elif isinstance(arg, dict): elif isinstance(arg, dict):
for k, v in arg.items(): for k, v in arg.items():
arg[k] = decode(v) arg[k] = decode(v)
return arg return arg
def encode(arg): def encode(arg):
if isinstance(arg, pycompat.unicode): if isinstance(arg, str):
return arg.encode(_encoding) return arg.encode(_encoding)
elif isinstance(arg, tuple): elif isinstance(arg, tuple):
return tuple(map(encode, arg)) return tuple(map(encode, arg))
elif isinstance(arg, list): elif isinstance(arg, list):
return map(encode, arg) return map(encode, arg)
elif isinstance(arg, dict): elif isinstance(arg, dict):
for k, v in arg.items(): for k, v in arg.items():
arg[k] = encode(v) arg[k] = encode(v)
except UnicodeError: except UnicodeError:
raise error.Abort( raise error.Abort(
_(b"[win32mbcs] filename conversion failed with %s encoding\n") _(b"[win32mbcs] filename conversion failed with %s encoding\n")
% _encoding % _encoding
) )
def wrapper(func, args, kwds): def wrapper(func, args, kwds):
return basewrapper(func, pycompat.unicode, encode, decode, args, kwds) return basewrapper(func, str, encode, decode, args, kwds)
def reversewrapper(func, args, kwds): def reversewrapper(func, args, kwds):
return basewrapper(func, str, decode, encode, args, kwds) return basewrapper(func, str, decode, encode, args, kwds)
def wrapperforlistdir(func, args, kwds): def wrapperforlistdir(func, args, kwds):
# Ensure 'path' argument ends with os.sep to avoids # Ensure 'path' argument ends with os.sep to avoids

mercurial/hgweb/__init__.py

config can be one of: config can be one of:
- repo object (single repo view) - repo object (single repo view)
- path to repo (single repo view) - path to repo (single repo view)
- path to config file (multi-repo view) - path to config file (multi-repo view)
- dict of virtual:real pairs (multi-repo view) - dict of virtual:real pairs (multi-repo view)
- list of virtual:real tuples (multi-repo view) - list of virtual:real tuples (multi-repo view)
""" """
if isinstance(config, pycompat.unicode): if isinstance(config, str):
raise error.ProgrammingError( raise error.ProgrammingError(
b'Mercurial only supports encoded strings: %r' % config b'Mercurial only supports encoded strings: %r' % config
) )
if ( if (
(isinstance(config, bytes) and not os.path.isdir(config)) (isinstance(config, bytes) and not os.path.isdir(config))
or isinstance(config, dict) or isinstance(config, dict)
or isinstance(config, list) or isinstance(config, list)
): ):

mercurial/i18n.py

""" """
# If message is None, t.ugettext will return u'None' as the # If message is None, t.ugettext will return u'None' as the
# translation whereas our callers expect us to return None. # translation whereas our callers expect us to return None.
if message is None or not _ugettext: if message is None or not _ugettext:
return message return message
cache = _msgcache.setdefault(encoding.encoding, {}) cache = _msgcache.setdefault(encoding.encoding, {})
if message not in cache: if message not in cache:
if type(message) is pycompat.unicode: if type(message) is str:
# goofy unicode docstrings in test # goofy unicode docstrings in test
paragraphs = message.split(u'\n\n') # type: List[pycompat.unicode] paragraphs = message.split(u'\n\n') # type: List[str]
else: else:
# should be ascii, but we have unicode docstrings in test, which # should be ascii, but we have unicode docstrings in test, which
# are converted to utf-8 bytes on Python 3. # are converted to utf-8 bytes on Python 3.
paragraphs = [p.decode("utf-8") for p in message.split(b'\n\n')] paragraphs = [p.decode("utf-8") for p in message.split(b'\n\n')]
# Be careful not to translate the empty string -- it holds the # Be careful not to translate the empty string -- it holds the
# meta data of the .po file. # meta data of the .po file.
u = u'\n\n'.join([p and _ugettext(p) or u'' for p in paragraphs]) u = u'\n\n'.join([p and _ugettext(p) or u'' for p in paragraphs])
try: try:

mercurial/scmutil.py

ui.error(_(b"abort: %s\n") % stringutil.forcebytestr(inst)) ui.error(_(b"abort: %s\n") % stringutil.forcebytestr(inst))
except util.urlerr.urlerror as inst: except util.urlerr.urlerror as inst:
detailed_exit_code = 100 detailed_exit_code = 100
try: # usually it is in the form (errno, strerror) try: # usually it is in the form (errno, strerror)
reason = inst.reason.args[1] reason = inst.reason.args[1]
except (AttributeError, IndexError): except (AttributeError, IndexError):
# it might be anything, for example a string # it might be anything, for example a string
reason = inst.reason reason = inst.reason
if isinstance(reason, pycompat.unicode): if isinstance(reason, str):
# SSLError of Python 2.7.9 contains a unicode # SSLError of Python 2.7.9 contains a unicode
reason = encoding.unitolocal(reason) reason = encoding.unitolocal(reason)
ui.error(_(b"abort: error: %s\n") % stringutil.forcebytestr(reason)) ui.error(_(b"abort: error: %s\n") % stringutil.forcebytestr(reason))
except (IOError, OSError) as inst: except (IOError, OSError) as inst:
if ( if (
util.safehasattr(inst, b"args") util.safehasattr(inst, b"args")
and inst.args and inst.args
and inst.args[0] == errno.EPIPE and inst.args[0] == errno.EPIPE

mercurial/templatefilters.py

return text or b"(none)" return text or b"(none)"
@templatefilter(b'obfuscate', intype=bytes) @templatefilter(b'obfuscate', intype=bytes)
def obfuscate(text): def obfuscate(text):
"""Any text. Returns the input text rendered as a sequence of """Any text. Returns the input text rendered as a sequence of
XML entities. XML entities.
""" """
text = pycompat.unicode( text = str(text, pycompat.sysstr(encoding.encoding), r'replace')
text, pycompat.sysstr(encoding.encoding), r'replace'
)
return b''.join([b'&#%d;' % ord(c) for c in text]) return b''.join([b'&#%d;' % ord(c) for c in text])
@templatefilter(b'permissions', intype=bytes) @templatefilter(b'permissions', intype=bytes)
def permissions(flags): def permissions(flags):
if b"l" in flags: if b"l" in flags:
return b"lrwxrwxrwx" return b"lrwxrwxrwx"
if b"x" in flags: if b"x" in flags: