( )⚙ D12252 py3: use io.BytesIO directly

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12252

py3: use io.BytesIO directly
ClosedPublic

Authored by indygreg on Mar 1 2022, 7:35 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG5aafc3c5bdec: py3: use io.BytesIO directly
Summary

Previously, pycompat.bytesio and pycompat.stringio referred to
io.BytesIO. And util.bytesio and util.stringio aliased the pycompat
symbols.

This commit switches everything to use io.BytesIO directly. util.bytesio
and util.stringio still exist to provide backwards compatibility, as
they were the preferred symbols.

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 1 2022, 7:35 PM
Alphare accepted this revision.Mar 2 2022, 5:49 AM
This revision is now accepted and ready to land.Mar 2 2022, 5:49 AM
indygreg updated this revision to Diff 32460.Mar 3 2022, 11:00 AM
indygreg added a commit: rHG5aafc3c5bdec: py3: use io.BytesIO directly.Mar 3 2022, 11:44 AM
Closed by commit rHG5aafc3c5bdec: py3: use io.BytesIO directly (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32489

hgext/phabricator.py

example.phabtoken = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx example.phabtoken = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
""" """
from __future__ import absolute_import from __future__ import absolute_import
import base64 import base64
import contextlib import contextlib
import hashlib import hashlib
import io
import itertools import itertools
import json import json
import mimetypes import mimetypes
import operator import operator
import re import re
import time import time
from mercurial.node import bin, short from mercurial.node import bin, short
def _write(patches): def _write(patches):
parents = repo[None].parents() parents = repo[None].parents()
with repo.wlock(), repo.lock(), repo.transaction(b'phabimport'): with repo.wlock(), repo.lock(), repo.transaction(b'phabimport'):
for drev, contents in patches: for drev, contents in patches:
ui.status(_(b'applying patch from D%s\n') % drev) ui.status(_(b'applying patch from D%s\n') % drev)
with patch.extract(ui, pycompat.bytesio(contents)) as patchdata: with patch.extract(ui, io.BytesIO(contents)) as patchdata:
msg, node, rej = cmdutil.tryimportone( msg, node, rej = cmdutil.tryimportone(
ui, ui,
repo, repo,
patchdata, patchdata,
parents, parents,
opts, opts,
[], [],
None, # Never update wdir to another revision None, # Never update wdir to another revision

mercurial/pure/mpatch.py

# mpatch.py - Python implementation of mpatch.c # mpatch.py - Python implementation of mpatch.c
# #
# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others # Copyright 2009 Olivia Mackall <olivia@selenic.com> and others
# #
# 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
import io
import struct import struct
from .. import pycompat
stringio = pycompat.bytesio stringio = io.BytesIO
class mpatchError(Exception): class mpatchError(Exception):
"""error raised when a delta cannot be decoded""" """error raised when a delta cannot be decoded"""
# This attempts to apply a series of patches in time proportional to # This attempts to apply a series of patches in time proportional to
# the total size of the patches, rather than patches * len(text). This # the total size of the patches, rather than patches * len(text). This

mercurial/pure/parsers.py

# parsers.py - Python implementation of parsers.c # parsers.py - Python implementation of parsers.c
# #
# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others # Copyright 2009 Olivia Mackall <olivia@selenic.com> and others
# #
# 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
import io
import stat import stat
import struct import struct
import zlib import zlib
from ..node import ( from ..node import (
nullrev, nullrev,
sha1nodeconstants, sha1nodeconstants,
) )
from ..thirdparty import attr from ..thirdparty import attr
from .. import ( from .. import (
error, error,
pycompat, pycompat,
revlogutils, revlogutils,
util, util,
) )
from ..revlogutils import nodemap as nodemaputil from ..revlogutils import nodemap as nodemaputil
from ..revlogutils import constants as revlog_constants from ..revlogutils import constants as revlog_constants
stringio = pycompat.bytesio stringio = io.BytesIO
_pack = struct.pack _pack = struct.pack
_unpack = struct.unpack _unpack = struct.unpack
_compress = zlib.compress _compress = zlib.compress
_decompress = zlib.decompress _decompress = zlib.decompress

mercurial/pycompat.py

if osaltsep: if osaltsep:
osaltsep = osaltsep.encode('ascii') osaltsep = osaltsep.encode('ascii')
osdevnull = os.devnull.encode('ascii') osdevnull = os.devnull.encode('ascii')
sysplatform = sys.platform.encode('ascii') sysplatform = sys.platform.encode('ascii')
sysexecutable = sys.executable sysexecutable = sys.executable
if sysexecutable: if sysexecutable:
sysexecutable = os.fsencode(sysexecutable) sysexecutable = os.fsencode(sysexecutable)
bytesio = io.BytesIO
# TODO deprecate stringio name, as it is a lie on Python 3.
stringio = bytesio
def maplist(*args): def maplist(*args):
return list(map(*args)) return list(map(*args))
def rangelist(*args): def rangelist(*args):
return list(range(*args)) return list(range(*args))

mercurial/util.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import abc import abc
import collections import collections
import contextlib import contextlib
import errno import errno
import gc import gc
import hashlib import hashlib
import io
import itertools import itertools
import locale import locale
import mmap import mmap
import os import os
import platform as pyplatform import platform as pyplatform
import re as remod import re as remod
import shutil import shutil
import stat import stat
b85decode = base85.b85decode b85decode = base85.b85decode
b85encode = base85.b85encode b85encode = base85.b85encode
cookielib = pycompat.cookielib cookielib = pycompat.cookielib
httplib = pycompat.httplib httplib = pycompat.httplib
safehasattr = pycompat.safehasattr safehasattr = pycompat.safehasattr
socketserver = pycompat.socketserver socketserver = pycompat.socketserver
bytesio = pycompat.bytesio bytesio = io.BytesIO
# TODO deprecate stringio name, as it is a lie on Python 3. # TODO deprecate stringio name, as it is a lie on Python 3.
stringio = bytesio stringio = bytesio
xmlrpclib = pycompat.xmlrpclib xmlrpclib = pycompat.xmlrpclib
httpserver = urllibcompat.httpserver httpserver = urllibcompat.httpserver
urlerr = urllibcompat.urlerr urlerr = urllibcompat.urlerr
urlreq = urllibcompat.urlreq urlreq = urllibcompat.urlreq

tests/test-basic.t

$ hg log -R t --config ui.message-output=bad $ hg log -R t --config ui.message-output=bad
abort: invalid ui.message-output destination: bad abort: invalid ui.message-output destination: bad
[255] [255]
Underlying message streams should be updated when ui.fout/ferr are set: Underlying message streams should be updated when ui.fout/ferr are set:
$ cat <<'EOF' > capui.py $ cat <<'EOF' > capui.py
> from mercurial import pycompat, registrar > import io
> from mercurial import registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'capui', norepo=True) > @command(b'capui', norepo=True)
> def capui(ui): > def capui(ui):
> out = ui.fout > out = ui.fout
> ui.fout = pycompat.bytesio() > ui.fout = io.BytesIO()
> ui.status(b'status\n') > ui.status(b'status\n')
> ui.ferr = pycompat.bytesio() > ui.ferr = io.BytesIO()
> ui.warn(b'warn\n') > ui.warn(b'warn\n')
> out.write(b'stdout: %s' % ui.fout.getvalue()) > out.write(b'stdout: %s' % ui.fout.getvalue())
> out.write(b'stderr: %s' % ui.ferr.getvalue()) > out.write(b'stderr: %s' % ui.ferr.getvalue())
> EOF > EOF
$ hg --config extensions.capui=capui.py --config ui.message-output=stdio capui $ hg --config extensions.capui=capui.py --config ui.message-output=stdio capui
stdout: status stdout: status
stderr: warn stderr: warn

tests/test-util.py

# unit tests for mercuril.util utilities # unit tests for mercuril.util utilities
from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import io
import itertools import itertools
import unittest import unittest
from mercurial import pycompat, util, utils from mercurial import pycompat, util, utils
@contextlib.contextmanager @contextlib.contextmanager
def mocktimer(incr=0.1, *additional_targets): def mocktimer(incr=0.1, *additional_targets):
# attr.s default factory for util.timedstats.start binds the timer we # attr.s default factory for util.timedstats.start binds the timer we
# need to mock out. # need to mock out.
_start_default = (util.timedcmstats.start.default, 'factory') _start_default = (util.timedcmstats.start.default, 'factory')
@contextlib.contextmanager @contextlib.contextmanager
def capturestderr(): def capturestderr():
"""Replace utils.procutil.stderr with a pycompat.bytesio instance """Replace utils.procutil.stderr with an io.BytesIO instance
The instance is made available as the return value of __enter__. The instance is made available as the return value of __enter__.
This contextmanager is reentrant. This contextmanager is reentrant.
""" """
orig = utils.procutil.stderr orig = utils.procutil.stderr
utils.procutil.stderr = pycompat.bytesio() utils.procutil.stderr = io.BytesIO()
try: try:
yield utils.procutil.stderr yield utils.procutil.stderr
finally: finally:
utils.procutil.stderr = orig utils.procutil.stderr = orig
class timedtests(unittest.TestCase): class timedtests(unittest.TestCase):
def testtimedcmstatsstr(self): def testtimedcmstatsstr(self):