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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 32591

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: