This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12258

py2: drop some more from __future__ statements
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9987d14ad63f: py2: drop some more from __future__ statements
Summary

These are no longer needed after dropping support for Python 2.

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:36 PM
Alphare accepted this revision.Mar 2 2022, 6:04 AM
This revision is now accepted and ready to land.Mar 2 2022, 6:04 AM
Alphare added a comment.Mar 2 2022, 6:05 AM

Does this need to be queued after the black series?

indygreg updated this revision to Diff 32462.Mar 3 2022, 11:01 AM
indygreg added a commit: rHG9987d14ad63f: py2: drop some more from __future__ statements.Mar 3 2022, 11:49 AM
Closed by commit rHG9987d14ad63f: py2: drop some more from __future__ statements (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32495

contrib/import-checker.py

return cycle[idx:] + cycle[:idx] + [lowest] return cycle[idx:] + cycle[:idx] + [lowest]
def find_cycles(imports): def find_cycles(imports):
"""Find cycles in an already-loaded import graph. """Find cycles in an already-loaded import graph.
All module names recorded in `imports` should be absolute one. All module names recorded in `imports` should be absolute one.
>>> from __future__ import print_function
>>> imports = {'top.foo': ['top.bar', 'os.path', 'top.qux'], >>> imports = {'top.foo': ['top.bar', 'os.path', 'top.qux'],
... 'top.bar': ['top.baz', 'sys'], ... 'top.bar': ['top.baz', 'sys'],
... 'top.baz': ['top.foo'], ... 'top.baz': ['top.foo'],
... 'top.qux': ['top.foo']} ... 'top.qux': ['top.foo']}
>>> print('\\n'.join(sorted(find_cycles(imports)))) >>> print('\\n'.join(sorted(find_cycles(imports))))
top.bar -> top.baz -> top.foo -> top.bar top.bar -> top.baz -> top.foo -> top.bar
top.foo -> top.qux -> top.foo top.foo -> top.qux -> top.foo
""" """

tests/test-commandserver.t

typical client does not want echo-back messages, so test without it: typical client does not want echo-back messages, so test without it:
$ grep -v '^promptecho ' < $HGRCPATH >> $HGRCPATH.new $ grep -v '^promptecho ' < $HGRCPATH >> $HGRCPATH.new
$ mv $HGRCPATH.new $HGRCPATH $ mv $HGRCPATH.new $HGRCPATH
$ hg init repo $ hg init repo
$ cd repo $ cd repo
>>> from __future__ import absolute_import
>>> import os >>> import os
>>> import sys >>> import sys
>>> from hgclient import bprint, check, readchannel, runcommand >>> from hgclient import bprint, check, readchannel, runcommand
>>> @check >>> @check
... def hellomessage(server): ... def hellomessage(server):
... ch, data = readchannel(server) ... ch, data = readchannel(server)
... bprint(b'%c, %r' % (ch, data)) ... bprint(b'%c, %r' % (ch, data))
... # run an arbitrary command to make sure the next thing the server ... # run an arbitrary command to make sure the next thing the server

tests/test-convert-git.t

scanning source... scanning source...
sorting... sorting...
converting... converting...
0 addbinary 0 addbinary
updating bookmarks updating bookmarks
$ cd git-repo3-hg $ cd git-repo3-hg
$ hg up -C $ hg up -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ "$PYTHON" -c 'from __future__ import print_function; print(len(open("b", "rb").read()))' $ "$PYTHON" -c 'print(len(open("b", "rb").read()))'
4096 4096
$ cd .. $ cd ..
test author vs committer test author vs committer
$ mkdir git-repo4 $ mkdir git-repo4
$ cd git-repo4 $ cd git-repo4
$ git init >/dev/null 2>/dev/null $ git init >/dev/null 2>/dev/null

tests/test-generaldelta.t

$ for r in 1 2 3; do $ for r in 1 2 3; do
> echo $r > foo > echo $r > foo
> hg commit -q -m $r > hg commit -q -m $r
> hg up -q -r 0 > hg up -q -r 0
> hg pull . -q -r $r -R ../gdrepo > hg pull . -q -r $r -R ../gdrepo
> done > done
$ cd .. $ cd ..
>>> from __future__ import print_function
>>> import os >>> import os
>>> regsize = os.stat("repo/.hg/store/00manifest.i").st_size >>> regsize = os.stat("repo/.hg/store/00manifest.i").st_size
>>> gdsize = os.stat("gdrepo/.hg/store/00manifest.i").st_size >>> gdsize = os.stat("gdrepo/.hg/store/00manifest.i").st_size
>>> if regsize < gdsize: >>> if regsize < gdsize:
... print('generaldata increased size of manifest') ... print('generaldata increased size of manifest')
Verify rev reordering doesnt create invalid bundles (issue4462) Verify rev reordering doesnt create invalid bundles (issue4462)
This requires a commit tree that when pulled will reorder manifest revs such This requires a commit tree that when pulled will reorder manifest revs such

tests/test-hgrc.t

issue1829: wrong indentation issue1829: wrong indentation
$ echo '[foo]' > $HGRC $ echo '[foo]' > $HGRC
$ echo ' x = y' >> $HGRC $ echo ' x = y' >> $HGRC
$ hg version $ hg version
config error at $TESTTMP/hgrc:2: unexpected leading whitespace: x = y config error at $TESTTMP/hgrc:2: unexpected leading whitespace: x = y
[255] [255]
$ "$PYTHON" -c "from __future__ import print_function; print('[foo]\nbar = a\n b\n c \n de\n fg \nbaz = bif cb \n')" \ $ "$PYTHON" -c "print('[foo]\nbar = a\n b\n c \n de\n fg \nbaz = bif cb \n')" \
> > $HGRC > > $HGRC
$ hg showconfig foo $ hg showconfig foo
foo.bar=a\nb\nc\nde\nfg foo.bar=a\nb\nc\nde\nfg
foo.baz=bif cb foo.baz=bif cb
$ FAKEPATH=/path/to/nowhere $ FAKEPATH=/path/to/nowhere
$ export FAKEPATH $ export FAKEPATH
$ echo '%include $FAKEPATH/no-such-file' > $HGRC $ echo '%include $FAKEPATH/no-such-file' > $HGRC

tests/test-hgweb.t

stop and restart stop and restart
$ killdaemons.py $ killdaemons.py
$ hg serve -p $HGPORT -d --pid-file=hg.pid -A access.log $ hg serve -p $HGPORT -d --pid-file=hg.pid -A access.log
$ cat hg.pid >> $DAEMON_PIDS $ cat hg.pid >> $DAEMON_PIDS
Test the access/error files are opened in append mode Test the access/error files are opened in append mode
$ "$PYTHON" -c "from __future__ import print_function; print(len(open('access.log', 'rb').readlines()), 'log lines written')" $ "$PYTHON" -c "print(len(open('access.log', 'rb').readlines()), 'log lines written')"
14 log lines written 14 log lines written
static file static file
$ get-with-headers.py --twice localhost:$HGPORT 'static/style-gitweb.css' - date etag server $ get-with-headers.py --twice localhost:$HGPORT 'static/style-gitweb.css' - date etag server
200 Script output follows 200 Script output follows
content-length: 9074 content-length: 9074
content-type: text/css content-type: text/css

tests/test-keyword.t

#else #else
$ PYTHONPATH="$TESTDIR/../contrib:$PYTHONPATH" $ PYTHONPATH="$TESTDIR/../contrib:$PYTHONPATH"
#endif #endif
$ export PYTHONPATH $ export PYTHONPATH
$ grep -v '^promptecho ' < $HGRCPATH >> $HGRCPATH.new $ grep -v '^promptecho ' < $HGRCPATH >> $HGRCPATH.new
$ mv $HGRCPATH.new $HGRCPATH $ mv $HGRCPATH.new $HGRCPATH
>>> from __future__ import print_function
>>> from hgclient import check, readchannel, runcommand >>> from hgclient import check, readchannel, runcommand
>>> @check >>> @check
... def check(server): ... def check(server):
... # hello block ... # hello block
... readchannel(server) ... readchannel(server)
... ...
... runcommand(server, [b'cat', b'm']) ... runcommand(server, [b'cat', b'm'])
... runcommand(server, [b'diff', b'-c', b'.', b'm']) ... runcommand(server, [b'diff', b'-c', b'.', b'm'])

tests/test-lfs-serve.t

> EOF > EOF
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
Case #1: client with non-lfs content and the extension disabled; server with Case #1: client with non-lfs content and the extension disabled; server with
non-lfs content, and the extension enabled. non-lfs content, and the extension enabled.
$ cd client $ cd client
$ echo 'non-lfs' > nonlfs.txt $ echo 'non-lfs' > nonlfs.txt
>>> from __future__ import absolute_import
>>> from hgclient import check, readchannel, runcommand >>> from hgclient import check, readchannel, runcommand
>>> @check >>> @check
... def diff(server): ... def diff(server):
... readchannel(server) ... readchannel(server)
... # run an arbitrary command in the repo with the extension loaded ... # run an arbitrary command in the repo with the extension loaded
... runcommand(server, [b'id', b'-R', b'../cmdservelfs']) ... runcommand(server, [b'id', b'-R', b'../cmdservelfs'])
... # now run a command in a repo without the extension to ensure that ... # now run a command in a repo without the extension to ensure that
... # files are added safely.. ... # files are added safely..
Test that the commit/changegroup requirement check hook can be run multiple Test that the commit/changegroup requirement check hook can be run multiple
times. times.
$ hg clone -qr 0 http://localhost:$HGPORT $TESTTMP/cmdserve_client3 $ hg clone -qr 0 http://localhost:$HGPORT $TESTTMP/cmdserve_client3
$ cd ../cmdserve_client3 $ cd ../cmdserve_client3
>>> from __future__ import absolute_import
>>> from hgclient import check, readchannel, runcommand >>> from hgclient import check, readchannel, runcommand
>>> @check >>> @check
... def addrequirement(server): ... def addrequirement(server):
... readchannel(server) ... readchannel(server)
... # change the repo in a way that adds the lfs requirement ... # change the repo in a way that adds the lfs requirement
... runcommand(server, [b'pull', b'-qu']) ... runcommand(server, [b'pull', b'-qu'])
... # Now cause the requirement adding hook to fire again, without going ... # Now cause the requirement adding hook to fire again, without going
... # through reposetup() again. ... # through reposetup() again.
lfs lfs
$ hg identify http://localhost:$HGPORT $ hg identify http://localhost:$HGPORT
c729025cc5e3 c729025cc5e3
$ mv $HGRCPATH $HGRCPATH.tmp $ mv $HGRCPATH $HGRCPATH.tmp
$ cp $HGRCPATH.orig $HGRCPATH $ cp $HGRCPATH.orig $HGRCPATH
>>> from __future__ import absolute_import
>>> from hgclient import bprint, check, readchannel, runcommand, stdout >>> from hgclient import bprint, check, readchannel, runcommand, stdout
>>> @check >>> @check
... def checkflags(server): ... def checkflags(server):
... readchannel(server) ... readchannel(server)
... bprint(b'') ... bprint(b'')
... bprint(b'# LFS required- both lfs and non-lfs revlogs have 0x2000 flag') ... bprint(b'# LFS required- both lfs and non-lfs revlogs have 0x2000 flag')
... stdout.flush() ... stdout.flush()
... runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R', ... runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R',
$ mv $HGRCPATH.tmp $HGRCPATH $ mv $HGRCPATH.tmp $HGRCPATH
$ hg clone $TESTTMP/client $TESTTMP/nonlfs -qr 0 --config extensions.lfs= $ hg clone $TESTTMP/client $TESTTMP/nonlfs -qr 0 --config extensions.lfs=
$ cat >> $TESTTMP/nonlfs/.hg/hgrc <<EOF $ cat >> $TESTTMP/nonlfs/.hg/hgrc <<EOF
> [extensions] > [extensions]
> lfs = ! > lfs = !
> EOF > EOF
>>> from __future__ import absolute_import, print_function
>>> from hgclient import bprint, check, readchannel, runcommand, stdout >>> from hgclient import bprint, check, readchannel, runcommand, stdout
>>> @check >>> @check
... def checkflags2(server): ... def checkflags2(server):
... readchannel(server) ... readchannel(server)
... bprint(b'') ... bprint(b'')
... bprint(b'# LFS enabled- both lfs and non-lfs revlogs have 0x2000 flag') ... bprint(b'# LFS enabled- both lfs and non-lfs revlogs have 0x2000 flag')
... stdout.flush() ... stdout.flush()
... runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R', ... runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R',

tests/test-notify-changegroup.t

commit commit
$ hg --traceback --cwd b commit -Amb $ hg --traceback --cwd b commit -Amb
push push
$ hg --traceback --cwd b push ../a 2>&1 | $ hg --traceback --cwd b push ../a 2>&1 |
> "$PYTHON" $TESTDIR/unwrap-message-id.py | \ > "$PYTHON" $TESTDIR/unwrap-message-id.py | \
> "$PYTHON" -c 'from __future__ import print_function ; import sys,re; print(re.sub("\n\t", " ", sys.stdin.read()), end="")' > "$PYTHON" -c 'import sys,re; print(re.sub("\n\t", " ", sys.stdin.read()), end="")'
pushing to ../a pushing to ../a
searching for changes searching for changes
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 2 changesets with 2 changes to 1 files added 2 changesets with 2 changes to 1 files
MIME-Version: 1.0 MIME-Version: 1.0
Content-Type: text/plain; charset="us-ascii" Content-Type: text/plain; charset="us-ascii"
(run 'hg update' to get a working copy) (run 'hg update' to get a working copy)
$ hg --cwd a rollback $ hg --cwd a rollback
repository tip rolled back to revision -1 (undo unbundle) repository tip rolled back to revision -1 (undo unbundle)
unbundle with correct source unbundle with correct source
$ hg --config notify.sources=unbundle --cwd a unbundle ../test.hg 2>&1 | $ hg --config notify.sources=unbundle --cwd a unbundle ../test.hg 2>&1 |
> "$PYTHON" $TESTDIR/unwrap-message-id.py | \ > "$PYTHON" $TESTDIR/unwrap-message-id.py | \
> "$PYTHON" -c 'from __future__ import print_function ; import sys,re; print(re.sub("\n\t", " ", sys.stdin.read()), end="")' > "$PYTHON" -c 'import sys,re; print(re.sub("\n\t", " ", sys.stdin.read()), end="")'
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 2 changesets with 2 changes to 1 files added 2 changesets with 2 changes to 1 files
new changesets cb9a9f314b8b:ba677d0156c1 (2 drafts) new changesets cb9a9f314b8b:ba677d0156c1 (2 drafts)
MIME-Version: 1.0 MIME-Version: 1.0
Content-Type: text/plain; charset="us-ascii" Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7bit Content-Transfer-Encoding: 7bit
(branch merge, don't forget to commit) (branch merge, don't forget to commit)
$ hg --traceback --cwd b commit -Am "merged" $ hg --traceback --cwd b commit -Am "merged"
push push
$ hg --traceback --cwd b --config notify.fromauthor=True push ../a 2>&1 | $ hg --traceback --cwd b --config notify.fromauthor=True push ../a 2>&1 |
> "$PYTHON" $TESTDIR/unwrap-message-id.py | \ > "$PYTHON" $TESTDIR/unwrap-message-id.py | \
> "$PYTHON" -c 'from __future__ import print_function ; import sys,re; print(re.sub("\n\t", " ", sys.stdin.read()), end="")' > "$PYTHON" -c 'import sys,re; print(re.sub("\n\t", " ", sys.stdin.read()), end="")'
pushing to ../a pushing to ../a
searching for changes searching for changes
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 4 changesets with 4 changes to 1 files added 4 changesets with 4 changes to 1 files
MIME-Version: 1.0 MIME-Version: 1.0
Content-Type: text/plain; charset="us-ascii" Content-Type: text/plain; charset="us-ascii"

tests/test-pull-network.t

#if no-msys #if no-msys
$ hg pull -q file:../test # no-msys $ hg pull -q file:../test # no-msys
#endif #endif
It's tricky to make file:// URLs working on every platform with It's tricky to make file:// URLs working on every platform with
regular shell commands. regular shell commands.
$ URL=`"$PYTHON" -c "from __future__ import print_function; import os; print('file://foobar' + ('/' + os.getcwd().replace(os.sep, '/')).replace('//', '/') + '/../test')"` $ URL=`"$PYTHON" -c "import os; print('file://foobar' + ('/' + os.getcwd().replace(os.sep, '/')).replace('//', '/') + '/../test')"`
$ hg pull -q "$URL" $ hg pull -q "$URL"
abort: file:// URLs can only refer to localhost abort: file:// URLs can only refer to localhost
[255] [255]
$ URL=`"$PYTHON" -c "from __future__ import print_function; import os; print('file://localhost' + ('/' + os.getcwd().replace(os.sep, '/')).replace('//', '/') + '/../test')"` $ URL=`"$PYTHON" -c "import os; print('file://localhost' + ('/' + os.getcwd().replace(os.sep, '/')).replace('//', '/') + '/../test')"`
$ hg pull -q "$URL" $ hg pull -q "$URL"
SEC: check for unsafe ssh url SEC: check for unsafe ssh url
$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [ui] > [ui]
> ssh = sh -c "read l; read l; read l" > ssh = sh -c "read l; read l; read l"
> EOF > EOF

tests/test-rename.t

>>> filename = "mtime/f" >>> filename = "mtime/f"
>>> mtime = 1234567890 >>> mtime = 1234567890
>>> open(filename, "w").close() >>> open(filename, "w").close()
>>> os.utime(filename, (mtime, mtime)) >>> os.utime(filename, (mtime, mtime))
$ hg ci -qAm 'add mtime dir' $ hg ci -qAm 'add mtime dir'
"hg cp" does not preserve the mtime, so it should be newer than the 2009 "hg cp" does not preserve the mtime, so it should be newer than the 2009
timestamp. timestamp.
$ hg cp -q mtime mtime_cp $ hg cp -q mtime mtime_cp
>>> from __future__ import print_function
>>> import os >>> import os
>>> filename = "mtime_cp/f" >>> filename = "mtime_cp/f"
>>> print(os.stat(filename).st_mtime < 1234567999) >>> print(os.stat(filename).st_mtime < 1234567999)
False False
"hg mv" preserves the mtime, so it should be ~equal to the 2009 timestamp "hg mv" preserves the mtime, so it should be ~equal to the 2009 timestamp
(modulo some fudge factor due to not every system supporting 1s-level (modulo some fudge factor due to not every system supporting 1s-level
precision). precision).
$ hg mv -q mtime mtime_mv $ hg mv -q mtime mtime_mv
>>> from __future__ import print_function
>>> import os >>> import os
>>> filename = "mtime_mv/f" >>> filename = "mtime_mv/f"
>>> print(os.stat(filename).st_mtime < 1234567999) >>> print(os.stat(filename).st_mtime < 1234567999)
True True

tests/test-status.t

{ {
"itemtype": "file", "itemtype": "file",
"path": "modified", "path": "modified",
"status": "C" "status": "C"
} }
] ]
$ hg status -A -Tpickle > pickle $ hg status -A -Tpickle > pickle
>>> from __future__ import print_function
>>> import pickle >>> import pickle
>>> from mercurial import util >>> from mercurial import util
>>> data = sorted((x[b'status'].decode(), x[b'path'].decode()) for x in pickle.load(open("pickle", r"rb"))) >>> data = sorted((x[b'status'].decode(), x[b'path'].decode()) for x in pickle.load(open("pickle", r"rb")))
>>> for s, p in data: print("%s %s" % (s, p)) >>> for s, p in data: print("%s %s" % (s, p))
! deleted ! deleted
? pickle ? pickle
? unknown ? unknown
A added A added

tests/test-subrepo-svn.t

revision 3 revision 3
path subdir/s path subdir/s
source file:/*/svn-repo/src (glob) (windows !) source file:/*/svn-repo/src (glob) (windows !)
source file:/*/$TESTTMP/svn-repo/src (glob) (no-windows !) source file:/*/$TESTTMP/svn-repo/src (glob) (no-windows !)
revision 2 revision 2
verify subrepo is contained within the repo directory verify subrepo is contained within the repo directory
$ "$PYTHON" -c "from __future__ import print_function; import os.path; print(os.path.exists('s'))" $ "$PYTHON" -c "import os.path; print(os.path.exists('s'))"
True True
update to nullrev (must delete the subrepo) update to nullrev (must delete the subrepo)
$ hg up null $ hg up null
0 files updated, 0 files merged, 3 files removed, 0 files unresolved 0 files updated, 0 files merged, 3 files removed, 0 files unresolved
$ ls $ ls

tests/test-template-functions.t

1e4e1b8f71e05681d422154f5421e385fec3454f 1e4e1b8f71e05681d422154f5421e385fec3454f
Age filter: Age filter:
$ hg init unstable-hash $ hg init unstable-hash
$ cd unstable-hash $ cd unstable-hash
$ hg log --template '{date|age}\n' > /dev/null || exit 1 $ hg log --template '{date|age}\n' > /dev/null || exit 1
>>> from __future__ import absolute_import
>>> import datetime >>> import datetime
>>> fp = open('a', 'wb') >>> fp = open('a', 'wb')
>>> n = datetime.datetime.now() + datetime.timedelta(366 * 7) >>> n = datetime.datetime.now() + datetime.timedelta(366 * 7)
>>> fp.write(b'%d-%d-%d 00:00' % (n.year, n.month, n.day)) and None >>> fp.write(b'%d-%d-%d 00:00' % (n.year, n.month, n.day)) and None
>>> fp.close() >>> fp.close()
$ hg add a $ hg add a
$ hg commit -m future -d "`cat a`" $ hg commit -m future -d "`cat a`"

tests/test-unified-test.t

Return codes before inline python: Return codes before inline python:
$ sh -c 'exit 1' $ sh -c 'exit 1'
[1] [1]
Doctest commands: Doctest commands:
>>> from __future__ import print_function
>>> print('foo') >>> print('foo')
foo foo
$ echo interleaved $ echo interleaved
interleaved interleaved
>>> for c in 'xyz': >>> for c in 'xyz':
... print(c) ... print(c)
x x
y y

tests/test-upgrade-repo.t

$ hg --config format.usegeneraldelta=false init upgradegd $ hg --config format.usegeneraldelta=false init upgradegd
$ cd upgradegd $ cd upgradegd
$ touch f0 $ touch f0
$ hg -q commit -A -m initial $ hg -q commit -A -m initial
$ mkdir FooBarDirectory.d $ mkdir FooBarDirectory.d
$ touch FooBarDirectory.d/f1 $ touch FooBarDirectory.d/f1
$ hg -q commit -A -m 'add f1' $ hg -q commit -A -m 'add f1'
$ hg -q up -r 0 $ hg -q up -r 0
>>> from __future__ import absolute_import, print_function
>>> import random >>> import random
>>> random.seed(0) # have a reproducible content >>> random.seed(0) # have a reproducible content
>>> with open("f2", "wb") as f: >>> with open("f2", "wb") as f:
... for i in range(100000): ... for i in range(100000):
... f.write(b"%d\n" % random.randint(1000000000, 9999999999)) and None ... f.write(b"%d\n" % random.randint(1000000000, 9999999999)) and None
$ hg -q commit -A -m 'add f2' $ hg -q commit -A -m 'add f2'
make sure we have a .d file make sure we have a .d file