This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12366

pycompat: add return type annotations
Needs RevisionPublic

Authored by indygreg on Mar 9 2022, 8:07 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Summary

Now that we're using Python 3.6+, we can start using inline type
annotations.

I figured a good a place as any to start would be pycompat. So this
commit defines type annotations throughout the file.

Because we can't use deferred annotations parsing (since this feature
requires Python 3.7), complex types relying on symbols from the typing
module use quoted expressions. This achieves some of the benefit of
deferred parsing without compromising the ability for type checkers to
infer things.

When annotating open() as part of this change, pytype started
complaining about a type mismatch in profiling.py. This turned out
to be a false positive. So the error was suppressed.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Mar 9 2022, 8:07 PM
Alphare requested changes to this revision.Mar 14 2022, 6:15 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
mercurial/profiling.py
275

I think we should instead add an assert that self._fp is the right type, which would satisfy Pytype without disabling it and be more regression-proof.

This revision now requires changes to proceed.Mar 14 2022, 6:15 AM

Revision Contents
Changeset List

PathPackages
Mmercurial/profiling.py (5 lines)
Mmercurial/pycompat.py (54 lines)

Diff 32620

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:
self._uiflush() self._uiflush()
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':
# We always use io.BytesIO if self._output == b"blackbox". But
AlphareUnsubmitted
Not Done

I think we should instead add an assert that self._fp is the right type, which would satisfy Pytype without disabling it and be more regression-proof.

Alphare: I think we should instead add an `assert` that `self._fp` is the right type, which would…
# pytype doesn't realize this and thinks we're attempting to
# access .getvalue() on an IO type.
# pytype: disable=attribute-error
val = b'Profile:\n%s' % self._fp.getvalue() val = b'Profile:\n%s' % self._fp.getvalue()
# pytype: enable=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()
def _uiflush(self): def _uiflush(self):
if self._flushfp: if self._flushfp:
self._flushfp.flush() self._flushfp.flush()

mercurial/pycompat.py

ispy3 = sys.version_info[0] >= 3 ispy3 = sys.version_info[0] >= 3
ispypy = '__pypy__' in sys.builtin_module_names ispypy = '__pypy__' in sys.builtin_module_names
TYPE_CHECKING = False TYPE_CHECKING = False
if not globals(): # hide this from non-pytype users if not globals(): # hide this from non-pytype users
import typing import typing
from typing import (
Any,
AnyStr,
Dict,
IO,
Iterator,
List,
NoReturn,
Tuple,
)
TYPE_CHECKING = typing.TYPE_CHECKING TYPE_CHECKING = typing.TYPE_CHECKING
def future_set_exception_info(f, exc_info): def future_set_exception_info(f, exc_info):
f.set_exception(exc_info[0]) f.set_exception(exc_info[0])
osdevnull = os.devnull.encode('ascii') osdevnull = os.devnull.encode('ascii')
sysplatform = sys.platform.encode('ascii') sysplatform = sys.platform.encode('ascii')
sysexecutable = sys.executable sysexecutable = sys.executable
if sysexecutable: if sysexecutable:
sysexecutable = os.fsencode(sysexecutable) sysexecutable = os.fsencode(sysexecutable)
def maplist(*args): def maplist(*args) -> 'List[Any]':
return list(map(*args)) return list(map(*args))
def rangelist(*args): def rangelist(*args) -> 'List[int]':
return list(range(*args)) return list(range(*args))
def ziplist(*args): def ziplist(*args) -> 'List[Any]':
return list(zip(*args)) return list(zip(*args))
rawinput = input rawinput = input
getargspec = inspect.getfullargspec getargspec = inspect.getfullargspec
long = int long = int
if not isinstance( if not isinstance(
s, (bytes, bytearray) s, (bytes, bytearray)
) and not hasattr( # hasattr-py3-only ) and not hasattr( # hasattr-py3-only
s, u'__bytes__' s, u'__bytes__'
): ):
s = str(s).encode('ascii') s = str(s).encode('ascii')
return bytes.__new__(cls, s) return bytes.__new__(cls, s)
def __getitem__(self, key): def __getitem__(self, key) -> bytes:
s = bytes.__getitem__(self, key) s = bytes.__getitem__(self, key)
if not isinstance(s, bytes): if not isinstance(s, bytes):
s = bytechr(s) s = bytechr(s)
return s return s
def __iter__(self): def __iter__(self) -> 'Iterator[bytes]':
return iterbytestr(bytes.__iter__(self)) return iterbytestr(bytes.__iter__(self))
def __repr__(self): def __repr__(self) -> str:
return bytes.__repr__(self)[1:] # drop b'' return bytes.__repr__(self)[1:] # drop b''
def iterbytestr(s): def iterbytestr(s) -> 'Iterator[bytes]':
"""Iterate bytes as if it were a str object of Python 2""" """Iterate bytes as if it were a str object of Python 2"""
return map(bytechr, s) return map(bytechr, s)
def maybebytestr(s): def maybebytestr(s):
"""Promote bytes to bytestr""" """Promote bytes to bytestr"""
if isinstance(s, bytes): if isinstance(s, bytes):
return bytestr(s) return bytestr(s)
return s return s
def sysbytes(s): def sysbytes(s) -> bytes:
"""Convert an internal str (e.g. keyword, __doc__) back to bytes """Convert an internal str (e.g. keyword, __doc__) back to bytes
This never raises UnicodeEncodeError, but only ASCII characters This never raises UnicodeEncodeError, but only ASCII characters
can be round-trip by sysstr(sysbytes(s)). can be round-trip by sysstr(sysbytes(s)).
""" """
if isinstance(s, bytes): if isinstance(s, bytes):
return s return s
return s.encode('utf-8') return s.encode('utf-8')
def sysstr(s): def sysstr(s) -> str:
"""Return a keyword str to be passed to Python functions such as """Return a keyword str to be passed to Python functions such as
getattr() and str.encode() getattr() and str.encode()
This never raises UnicodeDecodeError. Non-ascii characters are This never raises UnicodeDecodeError. Non-ascii characters are
considered invalid and mapped to arbitrary but unique code points considered invalid and mapped to arbitrary but unique code points
such that 'sysstr(a) != sysstr(b)' for all 'a != b'. such that 'sysstr(a) != sysstr(b)' for all 'a != b'.
""" """
if isinstance(s, builtins.str): if isinstance(s, builtins.str):
return s return s
return s.decode('latin-1') return s.decode('latin-1')
def strurl(url): def strurl(url) -> str:
"""Converts a bytes url back to str""" """Converts a bytes url back to str"""
if isinstance(url, bytes): if isinstance(url, bytes):
return url.decode('ascii') return url.decode('ascii')
return url return url
def bytesurl(url): def bytesurl(url) -> bytes:
"""Converts a str url to bytes by encoding in ascii""" """Converts a str url to bytes by encoding in ascii"""
if isinstance(url, str): if isinstance(url, str):
return url.encode('ascii') return url.encode('ascii')
return url return url
def raisewithtb(exc, tb): def raisewithtb(exc, tb) -> 'NoReturn':
"""Raise exception with the given traceback""" """Raise exception with the given traceback"""
raise exc.with_traceback(tb) raise exc.with_traceback(tb)
def getdoc(obj): def getdoc(obj) -> bytes:
"""Get docstring as bytes; may be None so gettext() won't confuse it """Get docstring as bytes; may be None so gettext() won't confuse it
with _('')""" with _('')"""
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)
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)
xrange = builtins.range xrange = builtins.range
unicode = str unicode = str
def open(name, mode=b'r', buffering=-1, encoding=None): def open(name, mode=b'r', buffering=-1, encoding=None) -> 'IO[AnyStr]':
return builtins.open(name, sysstr(mode), buffering, encoding) return builtins.open(name, sysstr(mode), buffering, encoding)
safehasattr = _wrapattrfunc(builtins.hasattr) safehasattr = _wrapattrfunc(builtins.hasattr)
def _getoptbwrapper(orig, args, shortlist, namelist): def _getoptbwrapper(
orig, args, shortlist, namelist
) -> 'Tuple[List[Tuple[bytes, bytes]], List[bytes]]':
""" """
Takes bytes arguments, converts them to unicode, pass them to Takes bytes arguments, converts them to unicode, pass them to
getopt.getopt(), convert the returned values back to bytes and then getopt.getopt(), convert the returned values back to bytes and then
return them for Python 3 compatibility as getopt.getopt() don't accepts return them for Python 3 compatibility as getopt.getopt() don't accepts
bytes on Python 3. bytes on Python 3.
""" """
args = [a.decode('latin-1') for a in args] args = [a.decode('latin-1') for a in args]
shortlist = shortlist.decode('latin-1') shortlist = shortlist.decode('latin-1')
namelist = [a.decode('latin-1') for a in namelist] namelist = [a.decode('latin-1') for a in namelist]
opts, args = orig(args, shortlist, namelist) opts, args = orig(args, shortlist, namelist)
opts = [(a[0].encode('latin-1'), a[1].encode('latin-1')) for a in opts] opts = [(a[0].encode('latin-1'), a[1].encode('latin-1')) for a in opts]
args = [a.encode('latin-1') for a in args] args = [a.encode('latin-1') for a in args]
return opts, args return opts, args
def strkwargs(dic): def strkwargs(dic) -> 'Dict[str, Any]':
""" """
Converts the keys of a python dictonary to str i.e. unicodes so that Converts the keys of a python dictonary to str i.e. unicodes so that
they can be passed as keyword arguments as dictionaries with bytes keys they can be passed as keyword arguments as dictionaries with bytes keys
can't be passed as keyword arguments to functions on Python 3. can't be passed as keyword arguments to functions on Python 3.
""" """
dic = {k.decode('latin-1'): v for k, v in dic.items()} dic = {k.decode('latin-1'): v for k, v in dic.items()}
return dic return dic
def byteskwargs(dic): def byteskwargs(dic) -> 'Dict[bytes, Any]':
""" """
Converts keys of python dictionaries to bytes as they were converted to Converts keys of python dictionaries to bytes as they were converted to
str to pass that dictonary as a keyword argument on Python 3. str to pass that dictonary as a keyword argument on Python 3.
""" """
dic = {k.encode('latin-1'): v for k, v in dic.items()} dic = {k.encode('latin-1'): v for k, v in dic.items()}
return dic return dic
# TODO: handle shlex.shlex(). # TODO: handle shlex.shlex().
def shlexsplit(s, comments=False, posix=True): def shlexsplit(s, comments=False, posix=True) -> 'List[bytes]':
""" """
Takes bytes argument, convert it to str i.e. unicodes, pass that into Takes bytes argument, convert it to str i.e. unicodes, pass that into
shlex.split(), convert the returned value to bytes and return that for shlex.split(), convert the returned value to bytes and return that for
Python 3 compatibility as shelx.split() don't accept bytes on Python 3. Python 3 compatibility as shelx.split() don't accept bytes on Python 3.
""" """
ret = shlex.split(s.decode('latin-1'), comments, posix) ret = shlex.split(s.decode('latin-1'), comments, posix)
return [a.encode('latin-1') for a in ret] return [a.encode('latin-1') for a in ret]
def getoptb(args, shortlist, namelist): def getoptb(args, shortlist, namelist):
return _getoptbwrapper(getopt.getopt, args, shortlist, namelist) return _getoptbwrapper(getopt.getopt, args, shortlist, namelist)
def gnugetoptb(args, shortlist, namelist): def gnugetoptb(args, shortlist, namelist):
return _getoptbwrapper(getopt.gnu_getopt, args, shortlist, namelist) return _getoptbwrapper(getopt.gnu_getopt, args, shortlist, namelist)
def mkdtemp(suffix=b'', prefix=b'tmp', dir=None): def mkdtemp(suffix=b'', prefix=b'tmp', dir=None) -> 'AnyStr':
return tempfile.mkdtemp(suffix, prefix, dir) return tempfile.mkdtemp(suffix, prefix, dir)
# text=True is not supported; use util.from/tonativeeol() instead # text=True is not supported; use util.from/tonativeeol() instead
def mkstemp(suffix=b'', prefix=b'tmp', dir=None): def mkstemp(suffix=b'', prefix=b'tmp', dir=None) -> 'Tuple[int, AnyStr]':
return tempfile.mkstemp(suffix, prefix, dir) return tempfile.mkstemp(suffix, prefix, dir)
# TemporaryFile does not support an "encoding=" argument on python2. # TemporaryFile does not support an "encoding=" argument on python2.
# This wrapper file are always open in byte mode. # This wrapper file are always open in byte mode.
def unnamedtempfile(mode=None, *args, **kwargs): def unnamedtempfile(mode=None, *args, **kwargs) -> 'IO[AnyStr]':
if mode is None: if mode is None:
mode = 'w+b' mode = 'w+b'
else: else:
mode = sysstr(mode) mode = sysstr(mode)
assert 'b' in mode assert 'b' in mode
return tempfile.TemporaryFile(mode, *args, **kwargs) return tempfile.TemporaryFile(mode, *args, **kwargs)