This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7515

pytype: [WIP] suppress various warnings inline to get a clean run
Changes PlannedPublic

Authored by mharbison72 on Nov 23 2019, 7:47 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

This depends on D7295 and D7384, which in turn was applied to 4222b9d5d4fb. I
made no attempt to keep it under 80 columns or blacken it. But it seems useful
to share now, because it is so time consuming to get this far, and presumably
much of this will entail actual fixes. These things were flagged by pytype
2019.12.06 under WSL.

The following bundlerepo warnings were fixed with assertions, but those
assertions fire when running the testsuite for some reason:

line 256, in __init__: No attribute 'ui' on bundlerepository [attribute-error]
line 260, in __init__: No attribute 'ui' on bundlerepository [attribute-error]
line 292, in __init__: No attribute 'ui' on bundlerepository [attribute-error]
line 292, in __init__: No attribute 'vfs' on bundlerepository [attribute-error]
line 330, in _writetempbundle: No attribute 'vfs' on bundlerepository [attribute-error]
  Called from (traceback):
    line 290, in __init__
line 341, in _writetempbundle: No attribute 'vfs' on bundlerepository [attribute-error]
  Called from (traceback):
    line 290, in __init__
line 378, in _consumemanifest: No attribute '_cgunpacker' on bundlerepository [attribute-error]
line 379, in _consumemanifest: No attribute '_cgunpacker' on bundlerepository [attribute-error]
line 380, in _consumemanifest: No attribute '_cgunpacker' on bundlerepository [attribute-error]
line 382, in _consumemanifest: No attribute '_cgunpacker' on bundlerepository [attribute-error]
line 406, in file: No attribute '_cgfilespos' on bundlerepository [attribute-error]
line 412, in file: No attribute 'unfiltered' on bundlerepository [attribute-error]
line 413, in file: No attribute 'svfs' on bundlerepository [attribute-error]
line 413, in file: No attribute 'file' on super [attribute-error]
line 420, in close: No attribute '_bundlefile' on bundlerepository [attribute-error]
line 422, in close: No attribute 'vfs' on bundlerepository [attribute-error]
line 441, in setparents: No attribute 'setparents' on super [attribute-error]
line 441, in setparents: No attribute 'ui' on bundlerepository [attribute-error]
line 443, in setparents: No attribute 'ui' on bundlerepository [attribute-error]

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

mharbison72 created this revision.Nov 23 2019, 7:47 PM
mharbison72 planned changes to this revision.Nov 23 2019, 7:54 PM

Adjusting this to stay out of the review queue. While most of the files only had a handful of errors (and a few could be removed from the blacklist), the few added had a bunch of errors. I didn't see any obvious fixes, and ran out of time Friday to individually suppress them.

I'm assuming we will fix the problems, and then apply the suppressions in narrow categories rather than a monolithic commit like this.

mharbison72 edited the summary of this revision. (Show Details)Dec 17 2019, 12:43 PM
mharbison72 updated this revision to Diff 18818.
mharbison72 planned changes to this revision.Dec 17 2019, 12:52 PM

Still not a queue-able thing. But this adds in the errors that are being suppressed so others can try to fix some of this without the ~10-15minute wait for failures. It looks like there is a recurring issue with converting exceptions to bytes for printing. Also, a few things seem to have gotten fixed in logcmdutil and patch since last time, though I'm slightly concerned that it missed issues that it previously flagged in hgweb/server.py. The only difference I'm aware of is running a new version of pytype, and running under WSL instead of on a Mac.

Revision Contents
Changeset List

Diff 18818

mercurial/bundlerepo.py

pathutil, pathutil,
phases, phases,
pycompat, pycompat,
revlog, revlog,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .interfaces import (
repository,
)
class bundlerevlog(revlog.revlog): class bundlerevlog(revlog.revlog):
def __init__(self, opener, indexfile, cgunpacker, linkmapper): def __init__(self, opener, indexfile, cgunpacker, linkmapper):
# How it works: # How it works:
# To retrieve a revision, we need to know the offset of the revision in # To retrieve a revision, we need to know the offset of the revision in
# the bundle (an unbundle object). We store this offset in the index # the bundle (an unbundle object). We store this offset in the index
# (start). The base of the delta is stored in the base field. # (start). The base of the delta is stored in the base field.
# #
``hg unbundle`` operation. However, the contents of the bundle are never ``hg unbundle`` operation. However, the contents of the bundle are never
applied to the actual base repository. applied to the actual base repository.
Instances constructed directly are not usable as repository objects. Instances constructed directly are not usable as repository objects.
Use instance() or makebundlerepository() to create instances. Use instance() or makebundlerepository() to create instances.
""" """
def __init__(self, bundlepath, url, tempparent): def __init__(self, bundlepath, url, tempparent):
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
self._tempparent = tempparent self._tempparent = tempparent
self._url = url self._url = url
self.ui.setconfig(b'phases', b'publish', False, b'bundlerepo') self.ui.setconfig(b'phases', b'publish', False, b'bundlerepo')
self.tempfile = None self.tempfile = None
f = util.posixfile(bundlepath, b"rb") f = util.posixfile(bundlepath, b"rb")
bundle = exchange.readbundle(self.ui, f, bundlepath) bundle = exchange.readbundle(self.ui, f, bundlepath)
phases.retractboundary( phases.retractboundary(
self, self,
None, None,
phases.draft, phases.draft,
[ctx.node() for ctx in self[self.firstnewrev :]], [ctx.node() for ctx in self[self.firstnewrev :]],
) )
def _handlebundle2part(self, bundle, part): def _handlebundle2part(self, bundle, part):
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
if part.type != b'changegroup': if part.type != b'changegroup':
return return
cgstream = part cgstream = part
version = part.params.get(b'version', b'01') version = part.params.get(b'version', b'01')
legalcgvers = changegroup.supportedincomingversions(self) legalcgvers = changegroup.supportedincomingversions(self)
if version not in legalcgvers: if version not in legalcgvers:
msg = _(b'Unsupported changegroup version: %s') msg = _(b'Unsupported changegroup version: %s')
raise error.Abort(msg % version) raise error.Abort(msg % version)
if bundle.compressed(): if bundle.compressed():
cgstream = self._writetempbundle(part.read, b'.cg%sun' % version) cgstream = self._writetempbundle(part.read, b'.cg%sun' % version)
self._cgunpacker = changegroup.getunbundler(version, cgstream, b'UN') self._cgunpacker = changegroup.getunbundler(version, cgstream, b'UN')
def _writetempbundle(self, readfn, suffix, header=b''): def _writetempbundle(self, readfn, suffix, header=b''):
"""Write a temporary file to disk """Write a temporary file to disk
""" """
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
fdtemp, temp = self.vfs.mkstemp(prefix=b"hg-bundle-", suffix=suffix) fdtemp, temp = self.vfs.mkstemp(prefix=b"hg-bundle-", suffix=suffix)
self.tempfile = temp self.tempfile = temp
with os.fdopen(fdtemp, 'wb') as fptemp: with os.fdopen(fdtemp, 'wb') as fptemp:
fptemp.write(header) fptemp.write(header)
while True: while True:
chunk = readfn(2 ** 18) chunk = readfn(2 ** 18)
if not chunk: if not chunk:
return manifest.manifestlog( return manifest.manifestlog(
self.svfs, self, rootstore, self.narrowmatch() self.svfs, self, rootstore, self.narrowmatch()
) )
def _consumemanifest(self): def _consumemanifest(self):
"""Consumes the manifest portion of the bundle, setting filestart so the """Consumes the manifest portion of the bundle, setting filestart so the
file portion can be read.""" file portion can be read."""
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
self._cgunpacker.seek(self.manstart) self._cgunpacker.seek(self.manstart)
self._cgunpacker.manifestheader() self._cgunpacker.manifestheader()
for delta in self._cgunpacker.deltaiter(): for delta in self._cgunpacker.deltaiter():
pass pass
self.filestart = self._cgunpacker.tell() self.filestart = self._cgunpacker.tell()
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def manstart(self): def manstart(self):
# changegroup (ex: it might be consuming trees from a separate bundle2 # changegroup (ex: it might be consuming trees from a separate bundle2
# part instead). So we need to manually consume it. # part instead). So we need to manually consume it.
if 'filestart' not in self.__dict__: if 'filestart' not in self.__dict__:
self._consumemanifest() self._consumemanifest()
return self.filestart return self.filestart
def url(self): def url(self):
return self._url # TODO: figure out why pytype doesn't see this attribute that's set in
# the constructor.
return self._url # pytype: disable=attribute-error
def file(self, f): def file(self, f):
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
if not self._cgfilespos: if not self._cgfilespos:
self._cgunpacker.seek(self.filestart) self._cgunpacker.seek(self.filestart)
self._cgfilespos = _getfilestarts(self._cgunpacker) self._cgfilespos = _getfilestarts(self._cgunpacker)
if f in self._cgfilespos: if f in self._cgfilespos:
self._cgunpacker.seek(self._cgfilespos[f]) self._cgunpacker.seek(self._cgfilespos[f])
linkmapper = self.unfiltered().changelog.rev linkmapper = self.unfiltered().changelog.rev
return bundlefilelog(self.svfs, f, self._cgunpacker, linkmapper) return bundlefilelog(self.svfs, f, self._cgunpacker, linkmapper)
else: else:
return super(bundlerepository, self).file(f) return super(bundlerepository, self).file(f)
def close(self): def close(self):
"""Close assigned bundle file immediately.""" """Close assigned bundle file immediately."""
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
self._bundlefile.close() self._bundlefile.close()
if self.tempfile is not None: if self.tempfile is not None:
self.vfs.unlink(self.tempfile) self.vfs.unlink(self.tempfile)
if self._tempparent: if self._tempparent:
shutil.rmtree(self._tempparent, True) shutil.rmtree(self._tempparent, True)
def cancopy(self): def cancopy(self):
return False return False
def peer(self): def peer(self):
return bundlepeer(self) return bundlepeer(self)
def getcwd(self): def getcwd(self):
return encoding.getcwd() # always outside the repo return encoding.getcwd() # always outside the repo
# Check if parents exist in localrepo before setting # Check if parents exist in localrepo before setting
def setparents(self, p1, p2=nullid): def setparents(self, p1, p2=nullid):
assert isinstance(self, repository.ilocalrepositorymain) # help pytype
p1rev = self.changelog.rev(p1) p1rev = self.changelog.rev(p1)
p2rev = self.changelog.rev(p2) p2rev = self.changelog.rev(p2)
msg = _(b"setting parent to node %s that only exists in the bundle\n") msg = _(b"setting parent to node %s that only exists in the bundle\n")
if self.changelog.repotiprev < p1rev: if self.changelog.repotiprev < p1rev:
self.ui.warn(msg % nodemod.hex(p1)) self.ui.warn(msg % nodemod.hex(p1))
if self.changelog.repotiprev < p2rev: if self.changelog.repotiprev < p2rev:
self.ui.warn(msg % nodemod.hex(p2)) self.ui.warn(msg % nodemod.hex(p2))
return super(bundlerepository, self).setparents(p1, p2) return super(bundlerepository, self).setparents(p1, p2)

mercurial/commands.py

opts[b'rev'] = [b'wdir()'] opts[b'rev'] = [b'wdir()']
reflags = re.M reflags = re.M
if opts.get(b'ignore_case'): if opts.get(b'ignore_case'):
reflags |= re.I reflags |= re.I
try: try:
regexp = util.re.compile(pattern, reflags) regexp = util.re.compile(pattern, reflags)
except re.error as inst: except re.error as inst:
# line 3403, in grep: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: re.error)
# + The following methods aren't implemented on re.error:
# + __iter__
ui.warn( ui.warn(
_(b"grep: invalid match pattern: %s\n") % pycompat.bytestr(inst) _(b"grep: invalid match pattern: %s\n") % pycompat.bytestr(inst # pytype: disable=wrong-arg-types
)
) )
return 1 return 1
sep, eol = b':', b'\n' sep, eol = b':', b'\n'
if opts.get(b'print0'): if opts.get(b'print0'):
sep = eol = b'\0' sep = eol = b'\0'
getfile = util.lrucachefunc(repo.file) getfile = util.lrucachefunc(repo.file)

mercurial/dagparser.py

>>> try: list(parsedag(b'+1 bad')) >>> try: list(parsedag(b'+1 bad'))
... except Exception as e: print(pycompat.sysstr(bytes(e))) ... except Exception as e: print(pycompat.sysstr(bytes(e)))
invalid character in dag description: bad... invalid character in dag description: bad...
''' '''
if not desc: if not desc:
return return
# line 172, in parsedag: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
wordchars = pycompat.bytestr( wordchars = pycompat.bytestr(
string.ascii_letters + string.digits string.ascii_letters + string.digits # pytype: disable=wrong-arg-types
) # pytype: disable=wrong-arg-types )
labels = {} labels = {}
p1 = -1 p1 = -1
r = 0 r = 0
def resolve(ref): def resolve(ref):
if not ref: if not ref:
return p1 return p1
# line 183, in resolve: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
elif ref[0] in pycompat.bytestr( elif ref[0] in pycompat.bytestr(
string.digits string.digits # pytype: disable=wrong-arg-types
): # pytype: disable=wrong-arg-types ):
return r - int(ref) return r - int(ref)
else: else:
return labels[ref] return labels[ref]
chiter = pycompat.iterbytestr(desc) chiter = pycompat.iterbytestr(desc)
def nextch(): def nextch():
return next(chiter, b'\0') return next(chiter, b'\0')
def nextstring(c): def nextstring(c):
if c == b'"': if c == b'"':
return nextdelimited(nextch(), b'"', b'\\') return nextdelimited(nextch(), b'"', b'\\')
else: else:
return nextrun(c, wordchars) return nextrun(c, wordchars)
c = nextch() c = nextch()
while c != b'\0': while c != b'\0':
# line 219, in parsedag: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
while c in pycompat.bytestr( while c in pycompat.bytestr(
string.whitespace string.whitespace # pytype: disable=wrong-arg-types
): # pytype: disable=wrong-arg-types ):
c = nextch() c = nextch()
if c == b'.': if c == b'.':
yield b'n', (r, [p1]) yield b'n', (r, [p1])
p1 = r p1 = r
r += 1 r += 1
c = nextch() c = nextch()
elif c == b'+': elif c == b'+':
# line 229, in parsedag: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
c, digs = nextrun( c, digs = nextrun(
nextch(), pycompat.bytestr(string.digits) nextch(), pycompat.bytestr(string.digits) # pytype: disable=wrong-arg-types
) # pytype: disable=wrong-arg-types )
n = int(digs) n = int(digs)
for i in pycompat.xrange(0, n): for i in pycompat.xrange(0, n):
yield b'n', (r, [p1]) yield b'n', (r, [p1])
p1 = r p1 = r
r += 1 r += 1
elif c in b'*/': elif c in b'*/':
if c == b'*': if c == b'*':
c = nextch() c = nextch()

mercurial/debugcommands.py

ui.write(b'%s %s\n' % (hex(head), phases.phasenames[phase])) ui.write(b'%s %s\n' % (hex(head), phases.phasenames[phase]))
def _quasirepr(thing): def _quasirepr(thing):
if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)): if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
return b'{%s}' % ( return b'{%s}' % (
b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing)) b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing))
) )
return pycompat.bytestr(repr(thing)) # line 389, in _quasirepr: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
return pycompat.bytestr(repr(thing) # pytype: disable=wrong-arg-types
)
def _debugbundle2(ui, gen, all=None, **opts): def _debugbundle2(ui, gen, all=None, **opts):
"""lists the contents of a bundle2""" """lists the contents of a bundle2"""
if not isinstance(gen, bundle2.unbundle20): if not isinstance(gen, bundle2.unbundle20):
raise error.Abort(_(b'not a bundle2 file')) raise error.Abort(_(b'not a bundle2 file'))
ui.write((b'Stream params: %s\n' % _quasirepr(gen.params))) ui.write((b'Stream params: %s\n' % _quasirepr(gen.params)))
parttypes = opts.get('part_type', []) parttypes = opts.get('part_type', [])
opts[b'flags'], opts[b'flags'],
parents=parents, parents=parents,
date=date, date=date,
metadata=metadata, metadata=metadata,
ui=ui, ui=ui,
) )
tr.close() tr.close()
except ValueError as exc: except ValueError as exc:
# line 2183, in debugobsolete: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: ValueError)
# + The following methods aren't implemented on ValueError:
# + __iter__
raise error.Abort( raise error.Abort(
_(b'bad obsmarker input: %s') % pycompat.bytestr(exc) _(b'bad obsmarker input: %s') % pycompat.bytestr(exc # pytype: disable=wrong-arg-types
)
) )
finally: finally:
tr.release() tr.release()
finally: finally:
l.release() l.release()
else: else:
if opts[b'rev']: if opts[b'rev']:
revs = scmutil.revrange(repo, opts[b'rev']) revs = scmutil.revrange(repo, opts[b'rev'])
(b' lvl-%-3d : ' % depth) (b' lvl-%-3d : ' % depth)
+ fmt % pcfmt(snaptotal[depth], totalsize) + fmt % pcfmt(snaptotal[depth], totalsize)
) )
ui.writenoi18n(b' deltas : ' + fmt % pcfmt(deltatotal, totalsize)) ui.writenoi18n(b' deltas : ' + fmt % pcfmt(deltatotal, totalsize))
def fmtchunktype(chunktype): def fmtchunktype(chunktype):
if chunktype == b'empty': if chunktype == b'empty':
return b' %s : ' % chunktype return b' %s : ' % chunktype
elif chunktype in pycompat.bytestr(string.ascii_letters): # line 2864, in fmtchunktype: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
elif chunktype in pycompat.bytestr(string.ascii_letters # pytype: disable=wrong-arg-types
):
return b' 0x%s (%s) : ' % (hex(chunktype), chunktype) return b' 0x%s (%s) : ' % (hex(chunktype), chunktype)
else: else:
return b' 0x%s : ' % hex(chunktype) return b' 0x%s : ' % hex(chunktype)
ui.write(b'\n') ui.write(b'\n')
ui.writenoi18n(b'chunks : ' + fmt2 % numrevs) ui.writenoi18n(b'chunks : ' + fmt2 % numrevs)
for chunktype in sorted(chunktypecounts): for chunktype in sorted(chunktypecounts):
ui.write(fmtchunktype(chunktype)) ui.write(fmtchunktype(chunktype))

mercurial/error.py

"""Mix-in to provide a hint of an error """Mix-in to provide a hint of an error
This should come first in the inheritance list to consume a hint and This should come first in the inheritance list to consume a hint and
pass remaining arguments to the exception class. pass remaining arguments to the exception class.
""" """
def __init__(self, *args, **kw): def __init__(self, *args, **kw):
self.hint = kw.pop('hint', None) self.hint = kw.pop('hint', None)
super(Hint, self).__init__(*args, **kw) # line 38, in __init__: Function AmbiguousPrefixLookupError.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 76, in __init__
# line 38, in __init__: Function CensoredNodeError.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 384, in __init__
# line 38, in __init__: Function FilteredLookupError.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 76, in __init__
# line 38, in __init__: Function LookupError.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 76, in __init__
# line 38, in __init__: Function ManifestLookupError.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 76, in __init__
# line 38, in __init__: Function ProgrammingError.__init__ expects 1 arg(s), got 3 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _, _)
# Called from (traceback):
# line 309, in __init__
# line 38, in __init__: Function PushkeyFailed.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 371, in __init__
# line 38, in __init__: Function ResponseExpected.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 161, in __init__
# line 38, in __init__: Function UnknownIdentifier.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 186, in __init__
# line 38, in __init__: Function UnknownVersion.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 242, in __init__
# line 38, in __init__: Function UnsupportedMergeRecords.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
# Called from (traceback):
# line 230, in __init__
super(Hint, self).__init__(*args, **kw) # pytype: disable=wrong-arg-count
class StorageError(Hint, Exception): class StorageError(Hint, Exception):
"""Raised when an error occurs in a storage layer. """Raised when an error occurs in a storage layer.
Usually subclassed by a storage-specific exception. Usually subclassed by a storage-specific exception.
""" """

mercurial/exchange.py

kwargs[b'bookmarks'] = True kwargs[b'bookmarks'] = True
bookmarksrequested = True bookmarksrequested = True
if b'listkeys' in pullop.remotebundle2caps: if b'listkeys' in pullop.remotebundle2caps:
if b'request-bookmarks' not in pullop.stepsdone: if b'request-bookmarks' not in pullop.stepsdone:
# make sure to always includes bookmark data when migrating # make sure to always includes bookmark data when migrating
# `hg incoming --bundle` to using this function. # `hg incoming --bundle` to using this function.
pullop.stepsdone.add(b'request-bookmarks') pullop.stepsdone.add(b'request-bookmarks')
kwargs.setdefault(b'listkeys', []).append(b'bookmarks') # line 1944, in _pullbundle2: No attribute 'append' on bool [attribute-error]
# + In Union[Any, List[bytes], List[nothing], bool]
# + Called from (traceback):
# + line 1673, in _fullpullbundle2
# line 1944, in _pullbundle2: No attribute 'append' on Set[bytes] [attribute-error]
# + In Union[Any, List[bytes], List[nothing], Set[bytes], bool]
# line 1944, in _pullbundle2: No attribute 'append' on bool [attribute-error]
# + In Union[Any, List[bytes], List[nothing], Set[bytes], bool]
kwargs.setdefault(b'listkeys', []).append(b'bookmarks') # pytype: disable=attribute-error
# If this is a full pull / clone and the server supports the clone bundles # If this is a full pull / clone and the server supports the clone bundles
# feature, tell the server whether we attempted a clone bundle. The # feature, tell the server whether we attempted a clone bundle. The
# presence of this flag indicates the client supports clone bundles. This # presence of this flag indicates the client supports clone bundles. This
# will enable the server to treat clients that support clone bundles # will enable the server to treat clients that support clone bundles
# differently from those that don't. # differently from those that don't.
if ( if (
pullop.remote.capable(b'clonebundles') pullop.remote.capable(b'clonebundles')
try: try:
def gettransaction(): def gettransaction():
if not lockandtr[2]: if not lockandtr[2]:
if not bookmod.bookmarksinstore(repo): if not bookmod.bookmarksinstore(repo):
lockandtr[0] = repo.wlock() lockandtr[0] = repo.wlock()
lockandtr[1] = repo.lock() lockandtr[1] = repo.lock()
lockandtr[2] = repo.transaction(source) lockandtr[2] = repo.transaction(source)
lockandtr[2].hookargs[b'source'] = source # line 2748, in gettransaction: No attribute 'hookargs' on None [attribute-error]
lockandtr[2].hookargs[b'url'] = url # + In Optional[Any]
lockandtr[2].hookargs[b'bundle2'] = b'1' # line 2749, in gettransaction: No attribute 'hookargs' on None [attribute-error]
# + In Optional[Any]
# line 2750, in gettransaction: No attribute 'hookargs' on None [attribute-error]
# + In Optional[Any]
lockandtr[2].hookargs[b'source'] = source # pytype: disable=attribute-error
lockandtr[2].hookargs[b'url'] = url # pytype: disable=attribute-error
lockandtr[2].hookargs[b'bundle2'] = b'1' # pytype: disable=attribute-error
return lockandtr[2] return lockandtr[2]
# Do greedy locking by default until we're satisfied with lazy # Do greedy locking by default until we're satisfied with lazy
# locking. # locking.
if not repo.ui.configbool( if not repo.ui.configbool(
b'experimental', b'bundle2lazylocking' b'experimental', b'bundle2lazylocking'
): ):
gettransaction() gettransaction()

mercurial/hg.py

def _local(path): def _local(path):
path = util.expandpath(util.urllocalpath(path)) path = util.expandpath(util.urllocalpath(path))
try: try:
isfile = os.path.isfile(path) isfile = os.path.isfile(path)
# Python 2 raises TypeError, Python 3 ValueError. # Python 2 raises TypeError, Python 3 ValueError.
except (TypeError, ValueError) as e: except (TypeError, ValueError) as e:
raise error.Abort( raise error.Abort(
_(b'invalid path %s: %s') % (path, pycompat.bytestr(e)) # line 68, in _local: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: Union[TypeError, ValueError])
_(b'invalid path %s: %s') % (path, pycompat.bytestr(e # pytype: disable=wrong-arg-types
))
) )
return isfile and bundlerepo or localrepo return isfile and bundlerepo or localrepo
def addbranchrevs(lrepo, other, branches, revs): def addbranchrevs(lrepo, other, branches, revs):
peer = other.peer() # a courtesy to callers using a localrepo for other peer = other.peer() # a courtesy to callers using a localrepo for other
hashbranch, branches = branches hashbranch, branches = branches

mercurial/hgweb/server.py

sys.argv # unwrap demand-loader so that reload() works sys.argv # unwrap demand-loader so that reload() works
# resurrect sys.setdefaultencoding() # resurrect sys.setdefaultencoding()
try: try:
importlib.reload(sys) importlib.reload(sys)
except AttributeError: except AttributeError:
reload(sys) reload(sys)
oldenc = sys.getdefaultencoding() oldenc = sys.getdefaultencoding()
sys.setdefaultencoding(b"latin1") # or any full 8-bit encoding
# Note: none of this was detected with pytype 2019.12.06. It was
# flagged in the past with an older version, on a Mac.
# or any full 8-bit encoding
sys.setdefaultencoding(b"latin1") # pytype: disable=module-attr
import mimetypes
mimetypes.init() mimetypes.init()
sys.setdefaultencoding(oldenc) sys.setdefaultencoding(oldenc) # pytype: disable=module-attr
address = ui.config(b'web', b'address') address = ui.config(b'web', b'address')
port = util.getport(ui.config(b'web', b'port')) port = util.getport(ui.config(b'web', b'port'))
try: try:
return cls(ui, app, (address, port), handler) return cls(ui, app, (address, port), handler)
except socket.error as inst: except socket.error as inst:
raise error.Abort( raise error.Abort(
_(b"cannot start server at '%s:%d': %s") _(b"cannot start server at '%s:%d': %s")
% (address, port, encoding.strtolocal(inst.args[1])) % (address, port, encoding.strtolocal(inst.args[1]))
) )

mercurial/hgweb/webcommands.py

linerange = None linerange = None
if lrange is not None: if lrange is not None:
linerange = webutil.formatlinerange(*lrange) linerange = webutil.formatlinerange(*lrange)
# deactivate numeric nav links when linerange is specified as this # deactivate numeric nav links when linerange is specified as this
# would required a dedicated "revnav" class # would required a dedicated "revnav" class
nav = templateutil.mappinglist([]) nav = templateutil.mappinglist([])
if descend: if descend:
it = dagop.blockdescendants(fctx, *lrange) # line 1165, in filelog: Missing parameter 'toline' in call to function mercurial.dagop.blockdescendants [missing-parameter]
else: # + Expected: (fctx, fromline, toline)
it = dagop.blockancestors(fctx, *lrange) # + Actually passed: (fctx, fromline)
# XXX: This seems correct, because lrange is a tuple of 2.
# Why not complain about formatlinerange() below?
it = dagop.blockdescendants(fctx, *lrange) # pytype: disable=missing-parameter
else:
# line 1167, in filelog: Missing parameter 'toline' in call to function mercurial.dagop.blockancestors [missing-parameter]
# + Expected: (fctx, fromline, toline, followfirst)
# + Actually passed: (fctx, fromline)
it = dagop.blockancestors(fctx, *lrange) # pytype: disable=missing-parameter
for i, (c, lr) in enumerate(it, 1): for i, (c, lr) in enumerate(it, 1):
diffs = None diffs = None
if patch: if patch:
diffs = diff(c, linerange=lr) diffs = diff(c, linerange=lr)
# follow renames accross filtered (not in range) revisions # follow renames accross filtered (not in range) revisions
path = c.path() path = c.path()
lm = webutil.commonentry(repo, c) lm = webutil.commonentry(repo, c)
lm.update( lm.update(

mercurial/manifest.py

return (data[pos:zeropos], hashval, flags) return (data[pos:zeropos], hashval, flags)
__next__ = next __next__ = next
def unhexlify(data, extra, pos, length): def unhexlify(data, extra, pos, length):
s = bin(data[pos : pos + length]) s = bin(data[pos : pos + length])
if extra: if extra:
s += chr(extra & 0xFF) # line 128, in unhexlify: unsupported operand type(s) for +: 'bytes' and 'str' [unsupported-operands]
# + Function __add__ on bytes expects bytes
s += chr(extra & 0xFF) # pytype: disable=unsupported-operands
return s return s
def _cmp(a, b): def _cmp(a, b):
return (a > b) - (a < b) return (a > b) - (a < b)
class _lazymanifest(object): class _lazymanifest(object):
# If our first parent is in the manifest cache, we can # If our first parent is in the manifest cache, we can
# compute a delta here using properties we know about the # compute a delta here using properties we know about the
# manifest up-front, which may save time later for the # manifest up-front, which may save time later for the
# revlog layer. # revlog layer.
_checkforbidden(added) _checkforbidden(added)
# combine the changed lists into one sorted iterator # combine the changed lists into one sorted iterator
work = heapq.merge( work = heapq.merge(
[(x, False) for x in sorted(added)], # line 1631, in add: Built-in function sorted was called with the wrong arguments [wrong-arg-types]
[(x, True) for x in sorted(removed)], # + Expected: (iterable: Iterable, ...)
# + Actually passed: (iterable: None)
# + The following methods aren't implemented on None:
# + __iter__
# + Called from (traceback):
# + line 1684, in writesubtree
# line 1632, in add: Built-in function sorted was called with the wrong arguments [wrong-arg-types]
# + Expected: (iterable: Iterable, ...)
# + Actually passed: (iterable: None)
# + The following methods aren't implemented on None:
# + __iter__
# + Called from (traceback):
# + line 1684, in writesubtree
# XXX: writesubtree() below passes None. Not clear if this
# branch can't happen because of `if` test above.
[(x, False) for x in sorted(added)], # pytype: disable=wrong-arg-types
[(x, True) for x in sorted(removed)], # pytype: disable=wrong-arg-types
) )
arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work) arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
cachedelta = self._revlog.rev(p1), deltatext cachedelta = self._revlog.rev(p1), deltatext
text = util.buffer(arraytext) text = util.buffer(arraytext)
n = self._revlog.addrevision( n = self._revlog.addrevision(
text, transaction, link, p1, p2, cachedelta text, transaction, link, p1, p2, cachedelta
) )

mercurial/namespaces.py

"""register a namespace """register a namespace
namespace: the name to be registered (in plural form) namespace: the name to be registered (in plural form)
order: optional argument to specify the order of namespaces order: optional argument to specify the order of namespaces
(e.g. 'branches' should be listed before 'bookmarks') (e.g. 'branches' should be listed before 'bookmarks')
""" """
if order is not None: if order is not None:
self._names.insert(order, namespace.name, namespace) # XXX: This is a bug!
# No attribute 'insert' on mercurial.util.sortdict [attribute-error]
self._names.insert(order, namespace.name, namespace) # pytype: disable=attribute-error
else: else:
self._names[namespace.name] = namespace self._names[namespace.name] = namespace
# we only generate a template keyword if one does not already exist # we only generate a template keyword if one does not already exist
if namespace.name not in templatekw.keywords: if namespace.name not in templatekw.keywords:
templatekeyword = registrar.templatekeyword(templatekw.keywords) templatekeyword = registrar.templatekeyword(templatekw.keywords)
@templatekeyword(namespace.name, requires={b'repo', b'ctx'}) @templatekeyword(namespace.name, requires={b'repo', b'ctx'})

mercurial/obsutil.py

sset = _succs() sset = _succs()
sset.markers.add(mark) sset.markers.add(mark)
fullsuccessorsets.append(sset) fullsuccessorsets.append(sset)
if not foundany: if not foundany:
fullsuccessorsets.append(_succs()) fullsuccessorsets.append(_succs())
values = [] values = []
for sset in fullsuccessorsets: for sset in fullsuccessorsets:
values.append({b'successors': sset, b'markers': sset.markers}) # line 803, in successorsandmarkers: No attribute 'markers' on List[nothing] [attribute-error]
# + In Union[Any, List[nothing], _succs]
values.append({b'successors': sset, b'markers': sset.markers}) # pytype: disable=attribute-error
return values return values
def _getobsfate(successorssets): def _getobsfate(successorssets):
""" Compute a changeset obsolescence fate based on its successorssets. """ Compute a changeset obsolescence fate based on its successorssets.
Successors can be the tipmost ones or the immediate ones. This function Successors can be the tipmost ones or the immediate ones. This function
return values are not meant to be shown directly to users, it is meant to return values are not meant to be shown directly to users, it is meant to

mercurial/patch.py

if cur: if cur:
for c in split(chunk(cur[1:])): for c in split(chunk(cur[1:])):
yield c yield c
def mimesplit(stream, cur): def mimesplit(stream, cur):
def msgfp(m): def msgfp(m):
fp = stringio() fp = stringio()
g = mail.Generator(fp, mangle_from_=False) # Function Generator.__init__ was called with the wrong arguments [wrong-arg-types]
# Expected: (self, outfp: TextIO, ...)
# Actually passed: (self, outfp: io.BytesIO, ...)
g = mail.Generator(fp, mangle_from_=False) # pytype: disable=wrong-arg-types
g.flatten(m) g.flatten(m)
fp.seek(0) fp.seek(0)
return fp return fp
for line in stream: for line in stream:
cur.append(line) cur.append(line)
c = chunk(cur) c = chunk(cur)
subject = re.sub(br'\n[ \t]+', b' ', subject) subject = re.sub(br'\n[ \t]+', b' ', subject)
ui.debug(b'Subject: %s\n' % subject) ui.debug(b'Subject: %s\n' % subject)
if data[b'user']: if data[b'user']:
ui.debug(b'From: %s\n' % data[b'user']) ui.debug(b'From: %s\n' % data[b'user'])
diffs_seen = 0 diffs_seen = 0
ok_types = (b'text/plain', b'text/x-diff', b'text/x-patch') ok_types = (b'text/plain', b'text/x-diff', b'text/x-patch')
message = b'' message = b''
for part in msg.walk(): for part in msg.walk():
content_type = pycompat.bytestr(part.get_content_type()) # line 279, in _extract: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
content_type = pycompat.bytestr(part.get_content_type()) # pytype: disable=wrong-arg-types
ui.debug(b'Content-Type: %s\n' % content_type) ui.debug(b'Content-Type: %s\n' % content_type)
if content_type not in ok_types: if content_type not in ok_types:
continue continue
payload = part.get_payload(decode=True) payload = part.get_payload(decode=True)
m = diffre.search(payload) m = diffre.search(payload)
if m: if m:
hgpatch = False hgpatch = False
hgpatchheader = False hgpatchheader = False

mercurial/profiling.py

def __exit__(self, exception_type, exception_value, traceback): def __exit__(self, exception_type, exception_value, traceback):
propagate = None propagate = None
if self._profiler is not None: if self._profiler is not None:
propagate = self._profiler.__exit__( propagate = self._profiler.__exit__(
exception_type, exception_value, traceback exception_type, exception_value, traceback
) )
if self._output == b'blackbox': if self._output == b'blackbox':
val = b'Profile:\n%s' % self._fp.getvalue() # line 274, in __exit__: No attribute 'getvalue' on IO[Union[bytes, str]] [attribute-error]
# + In Union[Any, IO[Union[bytes, str]], io.BytesIO]
val = b'Profile:\n%s' % self._fp.getvalue() # pytype: disable=attribute-error
# ui.log treats the input as a format string, # ui.log treats the input as a format string,
# so we need to escape any % signs. # so we need to escape any % signs.
val = val.replace(b'%', b'%%') val = val.replace(b'%', b'%%')
self._ui.log(b'profile', val) self._ui.log(b'profile', val)
self._closefp() self._closefp()
return propagate return propagate
def _closefp(self): def _closefp(self):
if self._fpdoclose and self._fp is not None: if self._fpdoclose and self._fp is not None:
self._fp.close() self._fp.close()

mercurial/pycompat.py

doc = getattr(obj, '__doc__', None) doc = getattr(obj, '__doc__', None)
if doc is None: if doc is None:
return doc return doc
return sysbytes(doc) return sysbytes(doc)
def _wrapattrfunc(f): def _wrapattrfunc(f):
@functools.wraps(f) @functools.wraps(f)
def w(object, name, *args): def w(object, name, *args):
return f(object, sysstr(name), *args) # Function builtins.delattr expects 2 arg(s), got 3 [wrong-arg-count]
# Expected: (object, name)
# Actually passed: (object, name, _)
return f(object, sysstr(name), *args) # pytype: disable=wrong-arg-count
return w return w
# these wrappers are automagically imported by hgloader # these wrappers are automagically imported by hgloader
delattr = _wrapattrfunc(builtins.delattr) delattr = _wrapattrfunc(builtins.delattr)
getattr = _wrapattrfunc(builtins.getattr) getattr = _wrapattrfunc(builtins.getattr)
hasattr = _wrapattrfunc(builtins.hasattr) hasattr = _wrapattrfunc(builtins.hasattr)
setattr = _wrapattrfunc(builtins.setattr) setattr = _wrapattrfunc(builtins.setattr)

mercurial/shelve.py

try: try:
d[b'originalwctx'] = nodemod.bin(d[b'originalwctx']) d[b'originalwctx'] = nodemod.bin(d[b'originalwctx'])
d[b'pendingctx'] = nodemod.bin(d[b'pendingctx']) d[b'pendingctx'] = nodemod.bin(d[b'pendingctx'])
d[b'parents'] = [nodemod.bin(h) for h in d[b'parents'].split(b' ')] d[b'parents'] = [nodemod.bin(h) for h in d[b'parents'].split(b' ')]
d[b'nodestoremove'] = [ d[b'nodestoremove'] = [
nodemod.bin(h) for h in d[b'nodestoremove'].split(b' ') nodemod.bin(h) for h in d[b'nodestoremove'].split(b' ')
] ]
except (ValueError, TypeError, KeyError) as err: except (ValueError, TypeError, KeyError) as err:
raise error.CorruptedState(pycompat.bytestr(err)) # line 205, in _verifyandtransform: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: Union[KeyError, TypeError, ValueError])
raise error.CorruptedState(pycompat.bytestr(err)) # pytype: disable=wrong-arg-types
@classmethod @classmethod
def _getversion(cls, repo): def _getversion(cls, repo):
"""Read version information from shelvestate file""" """Read version information from shelvestate file"""
fp = repo.vfs(cls._filename) fp = repo.vfs(cls._filename)
try: try:
version = int(fp.readline().strip()) version = int(fp.readline().strip())
except ValueError as err: except ValueError as err:
raise error.CorruptedState(pycompat.bytestr(err)) # line 214, in _getversion: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: ValueError)
# + The following methods aren't implemented on ValueError:
# + __iter__
raise error.CorruptedState(pycompat.bytestr(err)) # pytype: disable=wrong-arg-types
finally: finally:
fp.close() fp.close()
return version return version
@classmethod @classmethod
def _readold(cls, repo): def _readold(cls, repo):
"""Read the old position-based version of a shelvestate file""" """Read the old position-based version of a shelvestate file"""
# Order is important, because old shelvestate file uses it # Order is important, because old shelvestate file uses it

mercurial/subrepo.py

if info.isdir(): if info.isdir():
continue continue
bname = pycompat.fsencode(info.name) bname = pycompat.fsencode(info.name)
if match and not match(bname): if match and not match(bname):
continue continue
if info.issym(): if info.issym():
data = info.linkname data = info.linkname
else: else:
data = tar.extractfile(info).read() # line 1866, in archive: No attribute 'read' on None [attribute-error]
# + In Optional[IO[bytes]]
data = tar.extractfile(info).read() # pytype: disable=attribute-error
archiver.addfile(prefix + bname, info.mode, info.issym(), data) archiver.addfile(prefix + bname, info.mode, info.issym(), data)
total += 1 total += 1
progress.increment() progress.increment()
progress.complete() progress.complete()
return total return total
@annotatesubrepoerror @annotatesubrepoerror
def cat(self, match, fm, fntemplate, prefix, **opts): def cat(self, match, fm, fntemplate, prefix, **opts):

mercurial/ui.py

""" """
# Sadly, the prompt string may have been built with a filename # Sadly, the prompt string may have been built with a filename
# containing "$$" so let's try to find the first valid-looking # containing "$$" so let's try to find the first valid-looking
# prompt to start parsing. Sadly, we also can't rely on # prompt to start parsing. Sadly, we also can't rely on
# choices containing spaces, ASCII, or basically anything # choices containing spaces, ASCII, or basically anything
# except an ampersand followed by a character. # except an ampersand followed by a character.
m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt) m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt)
msg = m.group(1) # line 1630, in extractchoices: No attribute 'group' on None [attribute-error]
choices = [p.strip(b' ') for p in m.group(2).split(b'$$')] # + In Optional[Match[bytes]]
msg = m.group(1) # pytype: disable=attribute-error
# line 1631, in extractchoices: No attribute 'group' on None [attribute-error]
# + In Optional[Match[bytes]]
choices = [p.strip(b' ') for p in m.group(2).split(b'$$')] # pytype: disable=attribute-error
def choicetuple(s): def choicetuple(s):
ampidx = s.index(b'&') ampidx = s.index(b'&')
return s[ampidx + 1 : ampidx + 2].lower(), s.replace(b'&', b'', 1) return s[ampidx + 1 : ampidx + 2].lower(), s.replace(b'&', b'', 1)
return (msg, [choicetuple(s) for s in choices]) return (msg, [choicetuple(s) for s in choices])
def promptchoice(self, prompt, default=0): def promptchoice(self, prompt, default=0):

mercurial/unionrepo.py

Instances are not usable if constructed directly. Use ``instance()`` Instances are not usable if constructed directly. Use ``instance()``
or ``makeunionrepository()`` to create a usable instance. or ``makeunionrepository()`` to create a usable instance.
""" """
def __init__(self, repo2, url): def __init__(self, repo2, url):
self.repo2 = repo2 self.repo2 = repo2
self._url = url self._url = url
self.ui.setconfig(b'phases', b'publish', False, b'unionrepo') # in __init__: No attribute 'ui' on unionrepository [attribute-error]
self.ui.setconfig(b'phases', b'publish', False, b'unionrepo') # pytype: disable=attribute-error
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def changelog(self): def changelog(self):
return unionchangelog(self.svfs, self.repo2.svfs) return unionchangelog(self.svfs, self.repo2.svfs)
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def manifestlog(self): def manifestlog(self):
rootstore = unionmanifest( rootstore = unionmanifest(
self.svfs, self.repo2.svfs, self.unfiltered()._clrev self.svfs, self.repo2.svfs, self.unfiltered()._clrev
) )
return manifest.manifestlog( return manifest.manifestlog(
self.svfs, self, rootstore, self.narrowmatch() self.svfs, self, rootstore, self.narrowmatch()
) )
def _clrev(self, rev2): def _clrev(self, rev2):
"""map from repo2 changelog rev to temporary rev in self.changelog""" """map from repo2 changelog rev to temporary rev in self.changelog"""
node = self.repo2.changelog.node(rev2) node = self.repo2.changelog.node(rev2)
return self.changelog.rev(node) return self.changelog.rev(node)
def url(self): def url(self):
return self._url return self._url
def file(self, f): def file(self, f):
return unionfilelog( return unionfilelog(
self.svfs, f, self.repo2.svfs, self.unfiltered()._clrev, self # line 222, in file: No attribute 'svfs' on unionrepository [attribute-error]
# line 222, in file: No attribute 'unfiltered' on unionrepository [attribute-error]
self.svfs, # pytype: disable=attribute-error
f,
self.repo2.svfs,
self.unfiltered()._clrev, # pytype: disable=attribute-error
self
) )
def close(self): def close(self):
self.repo2.close() self.repo2.close()
def cancopy(self): def cancopy(self):
return False return False

mercurial/upgrade.py

_(b'migrating %s in store; %s tracked data\n') _(b'migrating %s in store; %s tracked data\n')
% ((util.bytecount(srcsize), util.bytecount(srcrawsize))) % ((util.bytecount(srcsize), util.bytecount(srcrawsize)))
) )
# Used to keep track of progress. # Used to keep track of progress.
progress = None progress = None
def oncopiedrevision(rl, rev, node): def oncopiedrevision(rl, rev, node):
progress.increment() # XXX: It looks like there is no `else` where this is set, and it ends
# up calling progress.complete() at the end of the loop (not
# detected).
# line 821, in oncopiedrevision: No attribute 'increment' on None [attribute-error]
# + In Optional[Any]
progress.increment() # pytype: disable=attribute-error
sidedatacompanion = getsidedatacompanion(srcrepo, dstrepo) sidedatacompanion = getsidedatacompanion(srcrepo, dstrepo)
# Do the actual copying. # Do the actual copying.
# FUTURE this operation can be farmed off to worker processes. # FUTURE this operation can be farmed off to worker processes.
seen = set() seen = set()
for unencoded, encoded, size in alldatafiles: for unencoded, encoded, size in alldatafiles:
if unencoded.endswith(b'.d'): if unencoded.endswith(b'.d'):

mercurial/util.py

# i18n: first parameter is a digest name # i18n: first parameter is a digest name
raise error.Abort( raise error.Abort(
_(b'%s mismatch: expected %s, got %s') _(b'%s mismatch: expected %s, got %s')
% (k, v, self._digester[k]) % (k, v, self._digester[k])
) )
try: try:
buffer = buffer # Name 'buffer' is not defined [name-error]
buffer = buffer # pytype: disable=name-error
except NameError: except NameError:
def buffer(sliceable, offset=0, length=None): def buffer(sliceable, offset=0, length=None):
if length is not None: if length is not None:
return memoryview(sliceable)[offset : offset + length] return memoryview(sliceable)[offset : offset + length]
return memoryview(sliceable)[offset:] return memoryview(sliceable)[offset:]
Call preparewrite before doing any writes. Call preparewrite before doing any writes.
""" """
def preparewrite(self): def preparewrite(self):
"""call this before writes, return self or a copied new object""" """call this before writes, return self or a copied new object"""
if getattr(self, '_copied', 0): if getattr(self, '_copied', 0):
self._copied -= 1 self._copied -= 1
return self.__class__(self) # Function cow.__init__ expects 1 arg(s), got 2 [wrong-arg-count]
# Expected: (self)
# Actually passed: (self, _)
return self.__class__(self) # pytype: disable=wrong-arg-count
return self return self
def copy(self): def copy(self):
"""always do a cheap copy""" """always do a cheap copy"""
self._copied = getattr(self, '_copied', 0) + 1 self._copied = getattr(self, '_copied', 0) + 1
return self return self

mercurial/verify.py

msg = b"%s: %s" % (linkrev, msg) msg = b"%s: %s" % (linkrev, msg)
if filename: if filename:
msg = b"%s@%s" % (filename, msg) msg = b"%s@%s" % (filename, msg)
self.ui.warn(b" " + msg + b"\n") self.ui.warn(b" " + msg + b"\n")
self.errors += 1 self.errors += 1
def _exc(self, linkrev, msg, inst, filename=None): def _exc(self, linkrev, msg, inst, filename=None):
"""record exception raised during the verify process""" """record exception raised during the verify process"""
fmsg = pycompat.bytestr(inst) # line 84, in _exc: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: Exception)
# + The following methods aren't implemented on Exception:
# + __iter__
# + Called from (traceback):
# + line 172, in _checkentry
# line 84, in _exc: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: Exception)
# + The following methods aren't implemented on Exception:
# + __iter__
# + Called from (traceback):
# + line 275, in _verifychangelog
# line 84, in _exc: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: Exception)
# + The following methods aren't implemented on Exception:
# + __iter__
# + Called from (traceback):
# + line 606, in _verifyfiles
fmsg = pycompat.bytestr(inst) # pytype: disable=wrong-arg-types
if not fmsg: if not fmsg:
fmsg = pycompat.byterepr(inst) fmsg = pycompat.byterepr(inst)
self._err(linkrev, b"%s: %s" % (msg, fmsg), filename) self._err(linkrev, b"%s: %s" % (msg, fmsg), filename)
def _checkrevlog(self, obj, name, linkrev): def _checkrevlog(self, obj, name, linkrev):
"""verify high level property of a revlog """verify high level property of a revlog
- revlog is present, - revlog is present,
for subdir, linkrevs in pycompat.iteritems(subdirnodes): for subdir, linkrevs in pycompat.iteritems(subdirnodes):
subdirfilenodes = self._verifymanifest( subdirfilenodes = self._verifymanifest(
linkrevs, subdir, storefiles, subdirprogress linkrevs, subdir, storefiles, subdirprogress
) )
for f, onefilenodes in pycompat.iteritems(subdirfilenodes): for f, onefilenodes in pycompat.iteritems(subdirfilenodes):
filenodes.setdefault(f, {}).update(onefilenodes) filenodes.setdefault(f, {}).update(onefilenodes)
if not dir and subdirnodes: if not dir and subdirnodes:
subdirprogress.complete() # line 434, in _verifymanifest: No attribute 'complete' on None [attribute-error]
# + In Optional[Any]
# + Called from (traceback):
# + line 202, in verify
subdirprogress.complete() # pytype: disable=attribute-error
if self.warnorphanstorefiles: if self.warnorphanstorefiles:
for f in sorted(storefiles): for f in sorted(storefiles):
self._warn(_(b"warning: orphan data file '%s'") % f) self._warn(_(b"warning: orphan data file '%s'") % f)
return filenodes return filenodes
def _crosscheckfiles(self, filelinkrevs, filenodes): def _crosscheckfiles(self, filelinkrevs, filenodes):
repo = self.repo repo = self.repo

mercurial/wireprotoframing.py

'size', 'size',
'fullhashes', 'fullhashes',
'fullhashseed', 'fullhashseed',
'serverdercerts', 'serverdercerts',
'servercadercerts', 'servercadercerts',
): ):
value = getattr(location, a) value = getattr(location, a)
if value is not None: if value is not None:
data[b'location'][pycompat.bytestr(a)] = value # line 471, in createalternatelocationresponseframe: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: str)
# line 471, in createalternatelocationresponseframe: unsupported operand type(s) for item assignment: 'bytes' [unsupported-operands]
# + No attribute '__setitem__' on bytes
data[b'location'][pycompat.bytestr(a
)] = value # pytype: disable=unsupported-operands,wrong-arg-types
payload = b''.join(cborutil.streamencode(data)) payload = b''.join(cborutil.streamencode(data))
if stream.streamsettingssent: if stream.streamsettingssent:
payload = stream.encode(payload) payload = stream.encode(payload)
encoded = True encoded = True
else: else:
encoded = False encoded = False
return stream.makeframe( return stream.makeframe(
requestid=requestid, requestid=requestid,
typeid=FRAME_TYPE_COMMAND_RESPONSE, typeid=FRAME_TYPE_COMMAND_RESPONSE,
flags=FLAG_COMMAND_RESPONSE_CONTINUATION, flags=FLAG_COMMAND_RESPONSE_CONTINUATION,
payload=payload, payload=payload,
encoded=encoded, encoded=encoded,
) )
def createcommanderrorresponse(stream, requestid, message, args=None): def createcommanderrorresponse(stream, requestid, message, args=None):
# TODO should this be using a list of {'msg': ..., 'args': {}} so atom # TODO should this be using a list of {'msg': ..., 'args': {}} so atom
# formatting works consistently? # formatting works consistently?
m = {b'status': b'error', b'error': {b'message': message,}} m = {b'status': b'error', b'error': {b'message': message,}}
if args: if args:
m[b'error'][b'args'] = args # line 496, in createcommanderrorresponse: unsupported operand type(s) for item assignment: 'bytes' [unsupported-operands]
# + No attribute '__setitem__' on bytes
m[b'error'][b'args'] = args # pytype: disable=unsupported-operands
overall = b''.join(cborutil.streamencode(m)) overall = b''.join(cborutil.streamencode(m))
yield stream.makeframe( yield stream.makeframe(
requestid=requestid, requestid=requestid,
typeid=FRAME_TYPE_COMMAND_RESPONSE, typeid=FRAME_TYPE_COMMAND_RESPONSE,
flags=FLAG_COMMAND_RESPONSE_EOS, flags=FLAG_COMMAND_RESPONSE_EOS,
payload=overall, payload=overall,
if not pycompat.ispy3 and isinstance(data, bytearray): if not pycompat.ispy3 and isinstance(data, bytearray):
data = bytes(data) data = bytes(data)
return self._decompressor.decompress(data) return self._decompressor.decompress(data)
class zstdbaseencoder(object): class zstdbaseencoder(object):
def __init__(self, level): def __init__(self, level):
from . import zstd # line 762, in __init__: Can't find module 'mercurial.zstd'. [import-error]
from . import zstd # pytype: disable=import-error
self._zstd = zstd self._zstd = zstd
cctx = zstd.ZstdCompressor(level=level) cctx = zstd.ZstdCompressor(level=level)
self._compressor = cctx.compressobj() self._compressor = cctx.compressobj()
def encode(self, data): def encode(self, data):
return self._compressor.compress(data) return self._compressor.compress(data)
class zstd8mbencoder(zstdbaseencoder): class zstd8mbencoder(zstdbaseencoder):
def __init__(self, ui): def __init__(self, ui):
super(zstd8mbencoder, self).__init__(3) super(zstd8mbencoder, self).__init__(3)
class zstdbasedecoder(object): class zstdbasedecoder(object):
def __init__(self, maxwindowsize): def __init__(self, maxwindowsize):
from . import zstd # line 790, in __init__: Can't find module 'mercurial.zstd'. [import-error]
from . import zstd # pytype: disable=import-error
dctx = zstd.ZstdDecompressor(max_window_size=maxwindowsize) dctx = zstd.ZstdDecompressor(max_window_size=maxwindowsize)
self._decompressor = dctx.decompressobj() self._decompressor = dctx.decompressobj()
def decode(self, data): def decode(self, data):
return self._decompressor.decompress(data) return self._decompressor.decompress(data)
STREAM_ENCODERS_ORDER = [] STREAM_ENCODERS_ORDER = []
def populatestreamencoders(): def populatestreamencoders():
if STREAM_ENCODERS: if STREAM_ENCODERS:
return return
try: try:
from . import zstd # line 820, in populatestreamencoders: Can't find module 'mercurial.zstd'. [import-error]
from . import zstd # pytype: disable=import-error
zstd.__version__ zstd.__version__
except ImportError: except ImportError:
zstd = None zstd = None
# zstandard is fastest and is preferred. # zstandard is fastest and is preferred.
if zstd: if zstd:
STREAM_ENCODERS[b'zstd-8mb'] = (zstd8mbencoder, zstd8mbdecoder) STREAM_ENCODERS[b'zstd-8mb'] = (zstd8mbencoder, zstd8mbdecoder)
del self._receivingcommands[requestid] del self._receivingcommands[requestid]
if self._receivingcommands: if self._receivingcommands:
self._state = b'command-receiving' self._state = b'command-receiving'
else: else:
self._state = b'idle' self._state = b'idle'
# Decode the payloads as CBOR. # Decode the payloads as CBOR.
entry[b'payload'].seek(0) # line 1373, in _makeruncommandresult: No attribute 'seek' on bool [attribute-error]
request = cborutil.decodeall(entry[b'payload'].getvalue())[0] # + In Optional[Union[bool, io.BytesIO]]
# + Called from (traceback):
# + line 1568, in _onframeidle
entry[b'payload'].seek(0) # pytype: disable=attribute-error
# line 1374, in _makeruncommandresult: No attribute 'getvalue' on bool [attribute-error]
# + In Optional[Union[bool, io.BytesIO]]
# + Called from (traceback):
# + line 1568, in _onframeidle
request = cborutil.decodeall(entry[b'payload'].getvalue())[0] # pytype: disable=attribute-error
if b'name' not in request: if b'name' not in request:
self._state = b'errored' self._state = b'errored'
return self._makeerrorresult( return self._makeerrorresult(
_(b'command request missing "name" field') _(b'command request missing "name" field')
) )
if b'args' not in request: if b'args' not in request:
request[b'args'] = {} request[b'args'] = {}
assert requestid not in self._activecommands assert requestid not in self._activecommands
self._activecommands.add(requestid) self._activecommands.add(requestid)
return ( return (
b'runcommand', b'runcommand',
{ {
b'requestid': requestid, b'requestid': requestid,
b'command': request[b'name'], b'command': request[b'name'],
b'args': request[b'args'], b'args': request[b'args'],
b'redirect': request.get(b'redirect'), b'redirect': request.get(b'redirect'),
b'data': entry[b'data'].getvalue() if entry[b'data'] else None, # line 1395, in _makeruncommandresult: No attribute 'getvalue' on bool [attribute-error]
# + In Optional[Union[bool, io.BytesIO]]
# + Called from (traceback):
# + line 1568, in _onframeidle
b'data': entry[b'data'].getvalue() if entry[b'data'] else None, # pytype: disable=attribute-error
}, },
) )
def _makewantframeresult(self): def _makewantframeresult(self):
return b'wantframe', {b'state': self._state,} return b'wantframe', {b'state': self._state,}
def _validatecommandrequestframe(self, frame): def _validatecommandrequestframe(self, frame):
new = frame.flags & FLAG_COMMAND_REQUEST_NEW new = frame.flags & FLAG_COMMAND_REQUEST_NEW
) )
if expectingdata != entry[b'expectingdata']: if expectingdata != entry[b'expectingdata']:
self._state = b'errored' self._state = b'errored'
return self._makeerrorresult( return self._makeerrorresult(
_(b'mismatch between expect data flag and previous frame') _(b'mismatch between expect data flag and previous frame')
) )
entry[b'payload'].write(frame.payload) # line 1621, in _onframecommandreceiving: No attribute 'write' on bool [attribute-error]
# + In Optional[Union[bool, io.BytesIO]]
# + Called from (traceback):
# + line 1135, in onframerecv
# line 1621, in _onframecommandreceiving: No attribute 'write' on None [attribute-error]
# + In Optional[Union[bool, io.BytesIO]]
# + Called from (traceback):
# + line 1135, in onframerecv
entry[b'payload'].write(frame.payload) # pytype: disable=attribute-error
if not moreframes: if not moreframes:
entry[b'requestdone'] = True entry[b'requestdone'] = True
if not moreframes and not expectingdata: if not moreframes and not expectingdata:
return self._makeruncommandresult(frame.requestid) return self._makeruncommandresult(frame.requestid)
return self._makewantframeresult() return self._makewantframeresult()

mercurial/wireprotoserver.py

# ErrorResponse. It is kind of a layer violation to catch an hgweb # ErrorResponse. It is kind of a layer violation to catch an hgweb
# exception here. So consider refactoring into a exception type that # exception here. So consider refactoring into a exception type that
# is associated with the wire protocol. # is associated with the wire protocol.
try: try:
_callhttp(repo, req, res, proto, cmd) _callhttp(repo, req, res, proto, cmd)
except hgwebcommon.ErrorResponse as e: except hgwebcommon.ErrorResponse as e:
for k, v in e.headers: for k, v in e.headers:
res.headers[k] = v res.headers[k] = v
res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e)) # line 237, in handlewsgirequest: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: mercurial.hgweb.common.ErrorResponse)
# + The following methods aren't implemented on mercurial.hgweb.common.ErrorResponse:
# + __iter__
res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e)) # pytype: disable=wrong-arg-types
# TODO This response body assumes the failed command was # TODO This response body assumes the failed command was
# "unbundle." That assumption is not always valid. # "unbundle." That assumption is not always valid.
res.setbodybytes(b'0\n%s\n' % pycompat.bytestr(e))
# line 240, in handlewsgirequest: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: mercurial.hgweb.common.ErrorResponse)
# + The following methods aren't implemented on mercurial.hgweb.common.ErrorResponse:
# + __iter__
res.setbodybytes(b'0\n%s\n' % pycompat.bytestr(e)) # pytype: disable=wrong-arg-types
return True return True
def _availableapis(repo): def _availableapis(repo):
apis = set() apis = set()
# Registered APIs are made available via config options of the name of # Registered APIs are made available via config options of the name of
# the protocol. # the protocol.
for k, v in API_HANDLERS.items(): for k, v in API_HANDLERS.items():
section, option = v[b'config'] # line 251, in _availableapis: No attribute '__iter__' on Callable[[Any, Any, Any, Any, Any], None] [attribute-error]
# + In Union[Callable[[Any, Any, Any, Any, Any], None], Callable[[Any, Any], Any]]
# line 251, in _availableapis: No attribute '__iter__' on Callable[[Any, Any], Any] [attribute-error]
# + In Union[Callable[[Any, Any, Any, Any, Any], None], Callable[[Any, Any], Any]]
section, option = v[b'config'] # pytype: disable=attribute-error
if repo.ui.configbool(section, option): if repo.ui.configbool(section, option):
apis.add(k) apis.add(k)
return apis return apis
def handlewsgiapirequest(rctx, req, res, checkperm): def handlewsgiapirequest(rctx, req, res, checkperm):
"""Handle requests to /api/*.""" """Handle requests to /api/*."""

mercurial/wireprotov1peer.py

The decorator returns a function which wraps this coroutine as a plain The decorator returns a function which wraps this coroutine as a plain
method, but adds the original method as an attribute called "batchable", method, but adds the original method as an attribute called "batchable",
which is used by remotebatch to split the call into separate encoding and which is used by remotebatch to split the call into separate encoding and
decoding phases. decoding phases.
''' '''
def plain(*args, **opts): def plain(*args, **opts):
batchable = f(*args, **opts) batchable = f(*args, **opts)
encargsorres, encresref = next(batchable) # line 63, in plain: No attribute '__iter__' on bool [attribute-error]
encargsorres, encresref = next(batchable) # pytype: disable=attribute-error
if not encresref: if not encresref:
return encargsorres # a local result in this case return encargsorres # a local result in this case
self = args[0] self = args[0]
cmd = pycompat.bytesurl(f.__name__) # ensure cmd is ascii bytestr cmd = pycompat.bytesurl(f.__name__) # ensure cmd is ascii bytestr
encresref.set(self._submitone(cmd, encargsorres)) # line 68, in plain: No attribute 'set' on bytes [attribute-error]
# + In Union[bytes, future]
# line 68, in plain: No attribute 'set' on bytes [attribute-error]
# + In Optional[Union[bytes, future]]
# line 68, in plain: No attribute 'set' on int [attribute-error]
# + In Union[future, int]
encresref.set(self._submitone(cmd, encargsorres)) # pytype: disable=attribute-error
return next(batchable) return next(batchable)
setattr(plain, 'batchable', f) setattr(plain, 'batchable', f)
setattr(plain, '__name__', f.__name__) setattr(plain, '__name__', f.__name__)
return plain return plain
class future(object): class future(object):
self.requirecap(b'clonebundles', _(b'clone bundles')) self.requirecap(b'clonebundles', _(b'clone bundles'))
return self._call(b'clonebundles') return self._call(b'clonebundles')
@batchable @batchable
def lookup(self, key): def lookup(self, key):
self.requirecap(b'lookup', _(b'look up remote revision')) self.requirecap(b'lookup', _(b'look up remote revision'))
f = future() f = future()
yield {b'key': encoding.fromlocal(key)}, f yield {b'key': encoding.fromlocal(key)}, f
d = f.value # line 363, in lookup: No attribute 'value' on future [attribute-error]
# + Called from (traceback):
# + line 62, in plain
d = f.value # pytype: disable=attribute-error
success, data = d[:-1].split(b" ", 1) success, data = d[:-1].split(b" ", 1)
if int(success): if int(success):
yield bin(data) yield bin(data)
else: else:
self._abort(error.RepoError(data)) self._abort(error.RepoError(data))
@batchable @batchable
def heads(self): def heads(self):
f = future() f = future()
yield {}, f yield {}, f
d = f.value # line 374, in heads: No attribute 'value' on future [attribute-error]
# + Called from (traceback):
# + line 62, in plain
d = f.value # pytype: disable=attribute-error
try: try:
yield wireprototypes.decodelist(d[:-1]) yield wireprototypes.decodelist(d[:-1])
except ValueError: except ValueError:
self._abort(error.ResponseError(_(b"unexpected response:"), d)) self._abort(error.ResponseError(_(b"unexpected response:"), d))
@batchable @batchable
def known(self, nodes): def known(self, nodes):
f = future() f = future()
yield {b'nodes': wireprototypes.encodelist(nodes)}, f yield {b'nodes': wireprototypes.encodelist(nodes)}, f
d = f.value # line 384, in known: No attribute 'value' on future [attribute-error]
# + Called from (traceback):
# + line 62, in plain
d = f.value # pytype: disable=attribute-error
try: try:
yield [bool(int(b)) for b in pycompat.iterbytestr(d)] yield [bool(int(b)) for b in pycompat.iterbytestr(d)]
except ValueError: except ValueError:
self._abort(error.ResponseError(_(b"unexpected response:"), d)) self._abort(error.ResponseError(_(b"unexpected response:"), d))
@batchable @batchable
def branchmap(self): def branchmap(self):
f = future() f = future()
yield {}, f yield {}, f
d = f.value # line 394, in branchmap: No attribute 'value' on future [attribute-error]
# + Called from (traceback):
# + line 62, in plain
d = f.value # pytype: disable=attribute-error
try: try:
branchmap = {} branchmap = {}
for branchpart in d.splitlines(): for branchpart in d.splitlines():
branchname, branchheads = branchpart.split(b' ', 1) branchname, branchheads = branchpart.split(b' ', 1)
branchname = encoding.tolocal(urlreq.unquote(branchname)) branchname = encoding.tolocal(urlreq.unquote(branchname))
branchheads = wireprototypes.decodelist(branchheads) branchheads = wireprototypes.decodelist(branchheads)
branchmap[branchname] = branchheads branchmap[branchname] = branchheads
yield branchmap yield branchmap
except TypeError: except TypeError:
self._abort(error.ResponseError(_(b"unexpected response:"), d)) self._abort(error.ResponseError(_(b"unexpected response:"), d))
@batchable @batchable
def listkeys(self, namespace): def listkeys(self, namespace):
if not self.capable(b'pushkey'): if not self.capable(b'pushkey'):
yield {}, None yield {}, None
f = future() f = future()
self.ui.debug(b'preparing listkeys for "%s"\n' % namespace) self.ui.debug(b'preparing listkeys for "%s"\n' % namespace)
yield {b'namespace': encoding.fromlocal(namespace)}, f yield {b'namespace': encoding.fromlocal(namespace)}, f
d = f.value # line 413, in listkeys: No attribute 'value' on future [attribute-error]
# + Called from (traceback):
# + line 62, in plain
d = f.value # pytype: disable=attribute-error
self.ui.debug( self.ui.debug(
b'received listkey for "%s": %i bytes\n' % (namespace, len(d)) b'received listkey for "%s": %i bytes\n' % (namespace, len(d))
) )
yield pushkeymod.decodekeys(d) yield pushkeymod.decodekeys(d)
@batchable @batchable
def pushkey(self, namespace, key, old, new): def pushkey(self, namespace, key, old, new):
if not self.capable(b'pushkey'): if not self.capable(b'pushkey'):
yield False, None yield False, None
f = future() f = future()
self.ui.debug(b'preparing pushkey for "%s:%s"\n' % (namespace, key)) self.ui.debug(b'preparing pushkey for "%s:%s"\n' % (namespace, key))
yield { yield {
b'namespace': encoding.fromlocal(namespace), b'namespace': encoding.fromlocal(namespace),
b'key': encoding.fromlocal(key), b'key': encoding.fromlocal(key),
b'old': encoding.fromlocal(old), b'old': encoding.fromlocal(old),
b'new': encoding.fromlocal(new), b'new': encoding.fromlocal(new),
}, f }, f
d = f.value # line 431, in pushkey: No attribute 'value' on future [attribute-error]
# + Called from (traceback):
# + line 62, in plain
d = f.value # pytype: disable=attribute-error
d, output = d.split(b'\n', 1) d, output = d.split(b'\n', 1)
try: try:
d = bool(int(d)) d = bool(int(d))
except ValueError: except ValueError:
raise error.ResponseError( raise error.ResponseError(
_(b'push failed (unexpected response):'), d _(b'push failed (unexpected response):'), d
) )
for l in output.splitlines(True): for l in output.splitlines(True):

mercurial/wireprotov1server.py

if exc.key is not None: if exc.key is not None:
part.addparam(b'key', exc.key, mandatory=False) part.addparam(b'key', exc.key, mandatory=False)
if exc.new is not None: if exc.new is not None:
part.addparam(b'new', exc.new, mandatory=False) part.addparam(b'new', exc.new, mandatory=False)
if exc.old is not None: if exc.old is not None:
part.addparam(b'old', exc.old, mandatory=False) part.addparam(b'old', exc.old, mandatory=False)
if exc.ret is not None: if exc.ret is not None:
part.addparam(b'ret', exc.ret, mandatory=False) part.addparam(b'ret', exc.ret, mandatory=False)
except error.BundleValueError as exc: except error.BundleValueError as exc: # Should be BundleUnknownFeatureError
errpart = bundler.newpart(b'error:unsupportedcontent') errpart = bundler.newpart(b'error:unsupportedcontent')
if exc.parttype is not None: # TODO: These are bugs!
errpart.addparam(b'parttype', exc.parttype) # line 731, in unbundle: No attribute 'parttype' on mercurial.error.BundleValueError [attribute-error]
if exc.params: if exc.parttype is not None: # pytype: disable=attribute-error
errpart.addparam(b'params', b'\0'.join(exc.params)) # line 732, in unbundle: No attribute 'parttype' on mercurial.error.BundleValueError [attribute-error]
errpart.addparam(b'parttype', exc.parttype) # pytype: disable=attribute-error
# line 733, in unbundle: No attribute 'params' on mercurial.error.BundleValueError [attribute-error]
if exc.params: # pytype: disable=attribute-error
# line 734, in unbundle: No attribute 'params' on mercurial.error.BundleValueError [attribute-error]
errpart.addparam(b'params', b'\0'.join(exc.params)) # pytype: disable=attribute-error
except error.Abort as exc: except error.Abort as exc:
manargs = [(b'message', stringutil.forcebytestr(exc))] manargs = [(b'message', stringutil.forcebytestr(exc))]
advargs = [] advargs = []
if exc.hint is not None: if exc.hint is not None:
advargs.append((b'hint', exc.hint)) advargs.append((b'hint', exc.hint))
bundler.addpart( bundler.addpart(
bundle2.bundlepart(b'error:abort', manargs, advargs) bundle2.bundlepart(b'error:abort', manargs, advargs)
) )
except error.PushRaced as exc: except error.PushRaced as exc:
bundler.newpart( bundler.newpart(
b'error:pushraced', b'error:pushraced',
[(b'message', stringutil.forcebytestr(exc))], [(b'message', stringutil.forcebytestr(exc))],
) )
return wireprototypes.streamreslegacy(gen=bundler.getchunks()) return wireprototypes.streamreslegacy(gen=bundler.getchunks())

mercurial/wireprotov2server.py

# At some point we'll want to use our own API instead of recycling the # At some point we'll want to use our own API instead of recycling the
# behavior of version 1 of the wire protocol... # behavior of version 1 of the wire protocol...
# TODO return reasonable responses - not responses that overload the # TODO return reasonable responses - not responses that overload the
# HTTP status line message for error reporting. # HTTP status line message for error reporting.
try: try:
checkperm(rctx, req, b'pull' if permission == b'ro' else b'push') checkperm(rctx, req, b'pull' if permission == b'ro' else b'push')
except hgwebcommon.ErrorResponse as e: except hgwebcommon.ErrorResponse as e:
res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e)) # line 91, in handlehttpv2request: Function bytestr.__init__ was called with the wrong arguments [wrong-arg-types]
# + Expected: (self, ints: Iterable[int])
# + Actually passed: (self, ints: mercurial.hgweb.common.ErrorResponse)
# + The following methods aren't implemented on mercurial.hgweb.common.ErrorResponse:
# + __iter__
res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e)) # pytype: disable=wrong-arg-types
for k, v in e.headers: for k, v in e.headers:
res.headers[k] = v res.headers[k] = v
res.setbodybytes(b'permission denied') res.setbodybytes(b'permission denied')
return return
# We have a special endpoint to reflect the request back at the client. # We have a special endpoint to reflect the request back at the client.
if command == b'debugreflect': if command == b'debugreflect':
_processhttpv2reflectrequest(rctx.repo.ui, rctx.repo, req, res) _processhttpv2reflectrequest(rctx.repo.ui, rctx.repo, req, res)
if ( if (
command == b'rawstorefiledata' command == b'rawstorefiledata'
and not streamclone.allowservergeneration(repo) and not streamclone.allowservergeneration(repo)
): ):
continue continue
caps[b'commands'][command] = { caps[b'commands'][command] = {
b'args': args, b'args': args,
b'permissions': [entry.permission], # line 585, in _capabilitiesv2: unsupported operand type(s) for item assignment: 'Set[bytes]' [unsupported-operands]
# + No attribute '__setitem__' on Set[bytes]
b'permissions': [entry.permission], # pytype: disable=unsupported-operands
} }
if entry.extracapabilitiesfn: if entry.extracapabilitiesfn:
extracaps = entry.extracapabilitiesfn(repo, proto) extracaps = entry.extracapabilitiesfn(repo, proto)
caps[b'commands'][command].update(extracaps) caps[b'commands'][command].update(extracaps)
caps[b'rawrepoformats'] = sorted(repo.requirements & repo.supportedformats) caps[b'rawrepoformats'] = sorted(repo.requirements & repo.supportedformats)
b'protocol': target[b'protocol'], b'protocol': target[b'protocol'],
b'uris': target[b'uris'], b'uris': target[b'uris'],
} }
for key in (b'snirequired', b'tlsversions'): for key in (b'snirequired', b'tlsversions'):
if key in target: if key in target:
entry[key] = target[key] entry[key] = target[key]
caps[b'redirect'][b'targets'].append(entry) # line 612, in _capabilitiesv2: No attribute 'append' on dict [attribute-error]
# + In Union[List[bytes], List[nothing], dict]
# + Called from (traceback):
# + line 544, in httpv2apidescriptor
caps[b'redirect'][b'targets'].append(entry) # pytype: disable=attribute-error
return proto.addcapabilities(repo, caps) return proto.addcapabilities(repo, caps)
def getadvertisedredirecttargets(repo, proto): def getadvertisedredirecttargets(repo, proto):
"""Obtain a list of content redirect targets. """Obtain a list of content redirect targets.
Returns a list containing potential redirect targets that will be Returns a list containing potential redirect targets that will be

tests/test-check-pytype.t

#require pytype py3 slow #require pytype py3 slow
$ cd $RUNTESTDIR/.. $ cd $RUNTESTDIR/..
Many of the individual files that are excluded here confuse pytype Many of the individual files that are excluded here confuse pytype
because they do a mix of Python 2 and Python 3 things because they do a mix of Python 2 and Python 3 things
conditionally. There's no good way to help it out with that as far as conditionally. There's no good way to help it out with that as far as
I can tell, so let's just hide those files from it for now. We should I can tell, so let's just hide those files from it for now. We should
endeavor to empty this list out over time, as some of these are endeavor to empty this list out over time, as some of these are
probably hiding real problems. probably hiding real problems.
$ pytype -k mercurial \
$ pytype mercurial \
> -x mercurial/bundlerepo.py \
> -x mercurial/chgserver.py \ > -x mercurial/chgserver.py \
> -x mercurial/context.py \ > -x mercurial/context.py \
> -x mercurial/crecord.py \ > -x mercurial/crecord.py \
> -x mercurial/encoding.py \ > -x mercurial/encoding.py \
> -x mercurial/error.py \
> -x mercurial/exchange.py \
> -x mercurial/lsprof.py \ > -x mercurial/lsprof.py \
> -x mercurial/policy.py
> -x mercurial/pycompat.py \
> -x mercurial/urllibcompat.py \ > -x mercurial/urllibcompat.py \
> -x mercurial/i18n.py \ > -x mercurial/i18n.py \
> -x mercurial/sslutil.py \ > -x mercurial/sslutil.py \
> -x mercurial/scmwindows.py \
> -x mercurial/keepalive.py \ > -x mercurial/keepalive.py \
> -x mercurial/windows.py \
> -x mercurial/wireprotoframing.py \
> -x mercurial/utils/stringutil.py \ > -x mercurial/utils/stringutil.py \
> -x mercurial/hgweb/server.py \ > -x mercurial/hgweb/server.py \
> -x mercurial/hgweb/wsgicgi.py \ > -x mercurial/hgweb/wsgicgi.py \
> -x mercurial/minirst.py \ > -x mercurial/minirst.py \
> -x mercurial/interfaces \ > -x mercurial/interfaces \
> -x mercurial/cffi \ > -x mercurial/cffi \
> -x mercurial/pure \ > -x mercurial/pure \
> -x mercurial/thirdparty > -x mercurial/thirdparty \
> -x mercurial/httppeer.py \
> -x mercurial/repoview.py \
> -x mercurial/localrepo.py \
> -x mercurial/revlog.py \
> -x mercurial/merge.py \
> -x mercurial/testing/storage.py