This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12304

worker: remove Python 2 support code
ClosedPublic

Authored by indygreg on Mar 2 2022, 6:31 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGcc0e059d2af8: worker: remove Python 2 support code

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 2 2022, 6:31 PM
Alphare accepted this revision.Mar 3 2022, 5:21 AM
This revision is now accepted and ready to land.Mar 3 2022, 5:21 AM
indygreg updated this revision to Diff 32469.Mar 3 2022, 11:09 AM
indygreg added a commit: rHGcc0e059d2af8: worker: remove Python 2 support code.Mar 3 2022, 11:55 AM
Closed by commit rHGcc0e059d2af8: worker: remove Python 2 support code (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.
Alphare added a comment.Mar 3 2022, 3:30 PM

It appears that this (or maybe another changeset in this series, I'm not sure), broke the pytype tests: https://foss.heptapod.net/mercurial/mercurial-devel/-/jobs/457121

@indygreg could you follow-up?

indygreg added a comment.Mar 3 2022, 4:16 PM
In D12304#188737, @Alphare wrote:

It appears that this (or maybe another changeset in this series, I'm not sure), broke the pytype tests: https://foss.heptapod.net/mercurial/mercurial-devel/-/jobs/457121
@indygreg could you follow-up?

It isn't surprising that pytype broke as a result of this series. I suspect what happened is the removal of a bunch of Python 2 code paths enabled pytype to make different (hopefully more accurate) inferences about types and this resulted in fallout. There's a good chance this will actually reveal legitimate typing bugs in the code base.

I'll try to take a look in a few hours.

Revision Contents
Changeset List

PathPackages
Mmercurial/worker.py (70 lines)

Diff 32517

mercurial/worker.py

n = int(s) n = int(s)
if n >= 1: if n >= 1:
return n return n
except ValueError: except ValueError:
raise error.Abort(_(b'number of cpus must be an integer')) raise error.Abort(_(b'number of cpus must be an integer'))
return min(max(countcpus(), 4), 32) return min(max(countcpus(), 4), 32)
if pycompat.ispy3:
def ismainthread(): def ismainthread():
return threading.current_thread() == threading.main_thread() return threading.current_thread() == threading.main_thread()
class _blockingreader(object): class _blockingreader(object):
def __init__(self, wrapped): def __init__(self, wrapped):
self._wrapped = wrapped self._wrapped = wrapped
# Do NOT implement readinto() by making it delegate to # Do NOT implement readinto() by making it delegate to
# _wrapped.readinto(), since that is unbuffered. The unpickler is fine # _wrapped.readinto(), since that is unbuffered. The unpickler is fine
# with just read() and readline(), so we don't need to implement it. # with just read() and readline(), so we don't need to implement it.
def readline(self): def readline(self):
return self._wrapped.readline() return self._wrapped.readline()
# issue multiple reads until size is fulfilled # issue multiple reads until size is fulfilled
def read(self, size=-1): def read(self, size=-1):
if size < 0: if size < 0:
return self._wrapped.readall() return self._wrapped.readall()
buf = bytearray(size) buf = bytearray(size)
view = memoryview(buf) view = memoryview(buf)
pos = 0 pos = 0
while pos < size: while pos < size:
ret = self._wrapped.readinto(view[pos:]) ret = self._wrapped.readinto(view[pos:])
if not ret: if not ret:
break break
pos += ret pos += ret
del view del view
del buf[pos:] del buf[pos:]
return bytes(buf) return bytes(buf)
else:
def ismainthread():
# pytype: disable=module-attr
return isinstance(threading.current_thread(), threading._MainThread)
# pytype: enable=module-attr
def _blockingreader(wrapped):
return wrapped
if pycompat.isposix or pycompat.iswindows: if pycompat.isposix or pycompat.iswindows:
_STARTUP_COST = 0.01 _STARTUP_COST = 0.01
# The Windows worker is thread based. If tasks are CPU bound, threads # The Windows worker is thread based. If tasks are CPU bound, threads
# in the presence of the GIL result in excessive context switching and # in the presence of the GIL result in excessive context switching and
# this overhead can slow down execution. # this overhead can slow down execution.
_DISALLOW_THREAD_UNSAFE = pycompat.iswindows _DISALLOW_THREAD_UNSAFE = pycompat.iswindows
else: else:
_STARTUP_COST = 1e30 _STARTUP_COST = 1e30