( )⚙ D7297 cleanup: remove now-obsolete wrong-arg-type annotations

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7297

cleanup: remove now-obsolete wrong-arg-type annotations
AbandonedPublic

Authored by durin42 on Nov 6 2019, 6:24 PM.

Details

Reviewers
indygreg
dlax
Group Reviewers
hg-reviewers
Summary

The preceding commit around bytestr indirection resolved all of these.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Nov 6 2019, 6:24 PM
indygreg requested changes to this revision.Nov 8 2019, 11:48 AM
indygreg added a subscriber: indygreg.

Marking for revisions until we know what's going on with D7296.

This revision now requires changes to proceed.Nov 8 2019, 11:48 AM
dlax accepted this revision.Nov 15 2019, 3:08 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/branchmap.py (8 lines)
Mmercurial/bundle2.py (8 lines)
Mmercurial/dagparser.py (16 lines)

Diff 18241

mercurial/branchmap.py

bcache.load(repo, lineiter) bcache.load(repo, lineiter)
except (IOError, OSError): except (IOError, OSError):
return None return None
except Exception as inst: except Exception as inst:
if repo.ui.debugflag: if repo.ui.debugflag:
msg = b'invalid %s: %s\n' msg = b'invalid %s: %s\n'
repo.ui.debug( repo.ui.debug(
msg msg % (_branchcachedesc(repo), pycompat.bytestr(inst))
% (
_branchcachedesc(repo),
pycompat.bytestr(
inst # pytype: disable=wrong-arg-types
),
)
) )
bcache = None bcache = None
finally: finally:
if f: if f:
f.close() f.close()
return bcache return bcache

mercurial/bundle2.py

"""total number of parts added to the bundler""" """total number of parts added to the bundler"""
return len(self._parts) return len(self._parts)
# methods used to defines the bundle2 content # methods used to defines the bundle2 content
def addparam(self, name, value=None): def addparam(self, name, value=None):
"""add a stream level parameter""" """add a stream level parameter"""
if not name: if not name:
raise error.ProgrammingError(b'empty parameter name') raise error.ProgrammingError(b'empty parameter name')
if name[0:1] not in pycompat.bytestr( if name[0:1] not in pycompat.bytestr(string.ascii_letters):
string.ascii_letters # pytype: disable=wrong-arg-types
):
raise error.ProgrammingError( raise error.ProgrammingError(
b'non letter first character: %s' % name b'non letter first character: %s' % name
) )
self._params.append((name, value)) self._params.append((name, value))
def addpart(self, part): def addpart(self, part):
"""add a new part to the bundle2 container """add a new part to the bundle2 container
ignored when unknown. Those starting with an upper case letter are ignored when unknown. Those starting with an upper case letter are
mandatory and will this function will raise a KeyError when unknown. mandatory and will this function will raise a KeyError when unknown.
Note: no option are currently supported. Any input will be either Note: no option are currently supported. Any input will be either
ignored or failing. ignored or failing.
""" """
if not name: if not name:
raise ValueError('empty parameter name') raise ValueError('empty parameter name')
if name[0:1] not in pycompat.bytestr( if name[0:1] not in pycompat.bytestr(string.ascii_letters):
string.ascii_letters # pytype: disable=wrong-arg-types
):
raise ValueError('non letter first character: %s' % name) raise ValueError('non letter first character: %s' % name)
try: try:
handler = b2streamparamsmap[name.lower()] handler = b2streamparamsmap[name.lower()]
except KeyError: except KeyError:
if name[0:1].islower(): if name[0:1].islower():
indebug(self.ui, b"ignoring unknown parameter %s" % name) indebug(self.ui, b"ignoring unknown parameter %s" % name)
else: else:
raise error.BundleUnknownFeatureError(params=(name,)) raise error.BundleUnknownFeatureError(params=(name,))

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
wordchars = pycompat.bytestr( wordchars = pycompat.bytestr(string.ascii_letters + string.digits)
string.ascii_letters + string.digits
) # 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
elif ref[0] in pycompat.bytestr( elif ref[0] in pycompat.bytestr(string.digits):
string.digits
): # 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':
while c in pycompat.bytestr( while c in pycompat.bytestr(string.whitespace):
string.whitespace
): # 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'+':
c, digs = nextrun( c, digs = nextrun(nextch(), pycompat.bytestr(string.digits))
nextch(), pycompat.bytestr(string.digits)
) # 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()