( )⚙ D10274 typing: add type hints to mercurial/error.py

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10274

typing: add type hints to mercurial/error.py
ClosedPublic

Authored by mharbison72 on Mar 25 2021, 8:10 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG8b6e36e4b553: typing: add type hints to mercurial/error.py
Summary

The only slightly unusual things here are that location is passed to
ParseError and both bytes and an int (so this accepts both), and the message
passed ProgrammingError is immediately converted to str. Therefore it is
typed as AnyStr, because there are a couple of instances that are already
passed as str.

There are a couple of places where bytes are being passed to builtin exceptions
that might need to be converted to str.

Diff Detail

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

Event Timeline

mharbison72 created this revision.Mar 25 2021, 8:10 PM
pulkit accepted this revision.Apr 11 2021, 5:27 PM
This revision is now accepted and ready to land.Apr 11 2021, 5:27 PM
mharbison72 added a commit: rHG8b6e36e4b553: typing: add type hints to mercurial/error.py.Apr 11 2021, 7:24 PM
Closed by commit rHG8b6e36e4b553: typing: add type hints to mercurial/error.py (authored by mharbison72). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/error.py (29 lines)

Diff 26604

mercurial/error.py

import difflib import difflib
# Do not import anything but pycompat here, please # Do not import anything but pycompat here, please
from . import pycompat from . import pycompat
if pycompat.TYPE_CHECKING: if pycompat.TYPE_CHECKING:
from typing import ( from typing import (
Any,
AnyStr,
Iterable,
List,
Optional, Optional,
Sequence,
Union,
) )
def _tobytes(exc): def _tobytes(exc):
"""Byte-stringify exception in the same way as BaseException_str()""" """Byte-stringify exception in the same way as BaseException_str()"""
if not exc.args: if not exc.args:
return b'' return b''
if len(exc.args) == 1: if len(exc.args) == 1:
class ManifestLookupError(LookupError): class ManifestLookupError(LookupError):
pass pass
class CommandError(Exception): class CommandError(Exception):
"""Exception raised on errors in parsing the command line.""" """Exception raised on errors in parsing the command line."""
def __init__(self, command, message): def __init__(self, command, message):
# type: (bytes, bytes) -> None
self.command = command self.command = command
self.message = message self.message = message
super(CommandError, self).__init__() super(CommandError, self).__init__()
__bytes__ = _tobytes __bytes__ = _tobytes
class UnknownCommand(Exception): class UnknownCommand(Exception):
"""Exception raised if command is not in the command table.""" """Exception raised if command is not in the command table."""
def __init__(self, command, all_commands=None): def __init__(self, command, all_commands=None):
# type: (bytes, Optional[List[bytes]]) -> None
self.command = command self.command = command
self.all_commands = all_commands self.all_commands = all_commands
super(UnknownCommand, self).__init__() super(UnknownCommand, self).__init__()
__bytes__ = _tobytes __bytes__ = _tobytes
class AmbiguousCommand(Exception): class AmbiguousCommand(Exception):
"""Exception raised if command shortcut matches more than one command.""" """Exception raised if command shortcut matches more than one command."""
def __init__(self, prefix, matches): def __init__(self, prefix, matches):
# type: (bytes, List[bytes]) -> None
self.prefix = prefix self.prefix = prefix
self.matches = matches self.matches = matches
super(AmbiguousCommand, self).__init__() super(AmbiguousCommand, self).__init__()
__bytes__ = _tobytes __bytes__ = _tobytes
class WorkerError(Exception): class WorkerError(Exception):
"""Exception raised when a worker process dies.""" """Exception raised when a worker process dies."""
def __init__(self, status_code): def __init__(self, status_code):
# type: (int) -> None
self.status_code = status_code self.status_code = status_code
# Pass status code to superclass just so it becomes part of __bytes__ # Pass status code to superclass just so it becomes part of __bytes__
super(WorkerError, self).__init__(status_code) super(WorkerError, self).__init__(status_code)
__bytes__ = _tobytes __bytes__ = _tobytes
class InterventionRequired(Hint, Exception): class InterventionRequired(Hint, Exception):
"""Exception raised when a command requires human intervention.""" """Exception raised when a command requires human intervention."""
__bytes__ = _tobytes __bytes__ = _tobytes
class ConflictResolutionRequired(InterventionRequired): class ConflictResolutionRequired(InterventionRequired):
"""Exception raised when a continuable command required merge conflict resolution.""" """Exception raised when a continuable command required merge conflict resolution."""
def __init__(self, opname): def __init__(self, opname):
# type: (bytes) -> None
from .i18n import _ from .i18n import _
self.opname = opname self.opname = opname
InterventionRequired.__init__( InterventionRequired.__init__(
self, self,
_( _(
b"unresolved conflicts (see 'hg resolve', then 'hg %s --continue')" b"unresolved conflicts (see 'hg resolve', then 'hg %s --continue')"
) )
def __str__(self): def __str__(self):
# the output would be unreadable if the message was translated, # the output would be unreadable if the message was translated,
# but do not replace it with encoding.strfromlocal(), which # but do not replace it with encoding.strfromlocal(), which
# may raise another exception. # may raise another exception.
return pycompat.sysstr(self.__bytes__()) return pycompat.sysstr(self.__bytes__())
def format(self): def format(self):
# type: () -> bytes
from .i18n import _ from .i18n import _
message = _(b"abort: %s\n") % self.message message = _(b"abort: %s\n") % self.message
if self.hint: if self.hint:
message += _(b"(%s)\n") % self.hint message += _(b"(%s)\n") % self.hint
return message return message
Exists to allow more specialized catching.""" Exists to allow more specialized catching."""
class ConfigError(Abort): class ConfigError(Abort):
"""Exception raised when parsing config files""" """Exception raised when parsing config files"""
def __init__(self, message, location=None, hint=None): def __init__(self, message, location=None, hint=None):
# type: (bytes, Optional[bytes], Optional[bytes]) -> None
super(ConfigError, self).__init__(message, hint=hint) super(ConfigError, self).__init__(message, hint=hint)
self.location = location self.location = location
def format(self): def format(self):
# type: () -> bytes
from .i18n import _ from .i18n import _
if self.location is not None: if self.location is not None:
message = _(b"config error at %s: %s\n") % ( message = _(b"config error at %s: %s\n") % (
pycompat.bytestr(self.location), pycompat.bytestr(self.location),
self.message, self.message,
) )
else: else:
__bytes__ = _tobytes __bytes__ = _tobytes
class ParseError(Abort): class ParseError(Abort):
"""Raised when parsing config files and {rev,file}sets (msg[, pos])""" """Raised when parsing config files and {rev,file}sets (msg[, pos])"""
def __init__(self, message, location=None, hint=None): def __init__(self, message, location=None, hint=None):
# type: (bytes, Optional[Union[bytes, int]], Optional[bytes]) -> None
super(ParseError, self).__init__(message, hint=hint) super(ParseError, self).__init__(message, hint=hint)
self.location = location self.location = location
def format(self): def format(self):
# type: () -> bytes
from .i18n import _ from .i18n import _
if self.location is not None: if self.location is not None:
message = _(b"hg: parse error at %s: %s\n") % ( message = _(b"hg: parse error at %s: %s\n") % (
pycompat.bytestr(self.location), pycompat.bytestr(self.location),
self.message, self.message,
) )
else: else:
message = _(b"hg: parse error: %s\n") % self.message message = _(b"hg: parse error: %s\n") % self.message
if self.hint: if self.hint:
message += _(b"(%s)\n") % self.hint message += _(b"(%s)\n") % self.hint
return message return message
class PatchError(Exception): class PatchError(Exception):
__bytes__ = _tobytes __bytes__ = _tobytes
def getsimilar(symbols, value): def getsimilar(symbols, value):
# type: (Iterable[bytes], bytes) -> List[bytes]
sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio() sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio()
# The cutoff for similarity here is pretty arbitrary. It should # The cutoff for similarity here is pretty arbitrary. It should
# probably be investigated and tweaked. # probably be investigated and tweaked.
return [s for s in symbols if sim(s) > 0.6] return [s for s in symbols if sim(s) > 0.6]
def similarity_hint(similar): def similarity_hint(similar):
# type: (List[bytes]) -> Optional[bytes]
from .i18n import _ from .i18n import _
if len(similar) == 1: if len(similar) == 1:
return _(b"did you mean %s?") % similar[0] return _(b"did you mean %s?") % similar[0]
elif similar: elif similar:
ss = b", ".join(sorted(similar)) ss = b", ".join(sorted(similar))
return _(b"did you mean one of %s?") % ss return _(b"did you mean one of %s?") % ss
else: else:
return None return None
class UnknownIdentifier(ParseError): class UnknownIdentifier(ParseError):
"""Exception raised when a {rev,file}set references an unknown identifier""" """Exception raised when a {rev,file}set references an unknown identifier"""
def __init__(self, function, symbols): def __init__(self, function, symbols):
# type: (bytes, Iterable[bytes]) -> None
from .i18n import _ from .i18n import _
similar = getsimilar(symbols, function) similar = getsimilar(symbols, function)
hint = similarity_hint(similar) hint = similarity_hint(similar)
ParseError.__init__( ParseError.__init__(
self, _(b"unknown identifier: %s") % function, hint=hint self, _(b"unknown identifier: %s") % function, hint=hint
) )
class RequirementError(RepoError): class RequirementError(RepoError):
"""Exception raised if .hg/requires has an unknown entry.""" """Exception raised if .hg/requires has an unknown entry."""
class StdioError(IOError): class StdioError(IOError):
"""Raised if I/O to stdout or stderr fails""" """Raised if I/O to stdout or stderr fails"""
def __init__(self, err): def __init__(self, err):
# type: (IOError) -> None
IOError.__init__(self, err.errno, err.strerror) IOError.__init__(self, err.errno, err.strerror)
# no __bytes__() because error message is derived from the standard IOError # no __bytes__() because error message is derived from the standard IOError
class UnsupportedMergeRecords(Abort): class UnsupportedMergeRecords(Abort):
def __init__(self, recordtypes): def __init__(self, recordtypes):
# type: (Iterable[bytes]) -> None
from .i18n import _ from .i18n import _
self.recordtypes = sorted(recordtypes) self.recordtypes = sorted(recordtypes)
s = b' '.join(self.recordtypes) s = b' '.join(self.recordtypes)
Abort.__init__( Abort.__init__(
self, self,
_(b'unsupported merge state records: %s') % s, _(b'unsupported merge state records: %s') % s,
hint=_( hint=_(
b'see https://mercurial-scm.org/wiki/MergeStateRecords for ' b'see https://mercurial-scm.org/wiki/MergeStateRecords for '
b'more information' b'more information'
), ),
) )
class UnknownVersion(Abort): class UnknownVersion(Abort):
"""generic exception for aborting from an encounter with an unknown version""" """generic exception for aborting from an encounter with an unknown version"""
def __init__(self, msg, hint=None, version=None): def __init__(self, msg, hint=None, version=None):
# type: (bytes, Optional[bytes], Optional[bytes]) -> None
self.version = version self.version = version
super(UnknownVersion, self).__init__(msg, hint=hint) super(UnknownVersion, self).__init__(msg, hint=hint)
class LockError(IOError): class LockError(IOError):
def __init__(self, errno, strerror, filename, desc): def __init__(self, errno, strerror, filename, desc):
# TODO: figure out if this should be bytes or str
# _type: (int, str, str, bytes) -> None
IOError.__init__(self, errno, strerror, filename) IOError.__init__(self, errno, strerror, filename)
self.desc = desc self.desc = desc
# no __bytes__() because error message is derived from the standard IOError # no __bytes__() because error message is derived from the standard IOError
class LockHeld(LockError): class LockHeld(LockError):
def __init__(self, errno, filename, desc, locker): def __init__(self, errno, filename, desc, locker):
__bytes__ = _tobytes __bytes__ = _tobytes
class ProgrammingError(Hint, RuntimeError): class ProgrammingError(Hint, RuntimeError):
"""Raised if a mercurial (core or extension) developer made a mistake""" """Raised if a mercurial (core or extension) developer made a mistake"""
def __init__(self, msg, *args, **kwargs): def __init__(self, msg, *args, **kwargs):
# type: (AnyStr, Any, Any) -> None
# On Python 3, turn the message back into a string since this is # On Python 3, turn the message back into a string since this is
# an internal-only error that won't be printed except in a # an internal-only error that won't be printed except in a
# stack traces. # stack traces.
msg = pycompat.sysstr(msg) msg = pycompat.sysstr(msg)
super(ProgrammingError, self).__init__(msg, *args, **kwargs) super(ProgrammingError, self).__init__(msg, *args, **kwargs)
__bytes__ = _tobytes __bytes__ = _tobytes
for idx, par in enumerate(self.params): for idx, par in enumerate(self.params):
val = self.values[idx] val = self.values[idx]
if val is None: if val is None:
entries.append(val) entries.append(val)
else: else:
entries.append(b"%s=%r" % (par, pycompat.maybebytestr(val))) entries.append(b"%s=%r" % (par, pycompat.maybebytestr(val)))
if entries: if entries:
msg = b'%s - %s' % (msg, b', '.join(entries)) msg = b'%s - %s' % (msg, b', '.join(entries))
ValueError.__init__(self, msg) ValueError.__init__(self, msg) # TODO: convert to str?
class ReadOnlyPartError(RuntimeError): class ReadOnlyPartError(RuntimeError):
"""error raised when code tries to alter a part being generated""" """error raised when code tries to alter a part being generated"""
__bytes__ = _tobytes __bytes__ = _tobytes
class CensoredNodeError(StorageError): class CensoredNodeError(StorageError):
"""error raised when content verification fails on a censored node """error raised when content verification fails on a censored node
Also contains the tombstone data substituted for the uncensored data. Also contains the tombstone data substituted for the uncensored data.
""" """
def __init__(self, filename, node, tombstone): def __init__(self, filename, node, tombstone):
# type: (bytes, bytes, bytes) -> None
from .node import short from .node import short
StorageError.__init__(self, b'%s:%s' % (filename, short(node))) StorageError.__init__(self, b'%s:%s' % (filename, short(node)))
self.tombstone = tombstone self.tombstone = tombstone
class CensoredBaseError(StorageError): class CensoredBaseError(StorageError):
"""error raised when a delta is rejected because its base is censored """error raised when a delta is rejected because its base is censored
"""Represents an error during execution of a wire protocol command. """Represents an error during execution of a wire protocol command.
Should only be thrown by wire protocol version 2 commands. Should only be thrown by wire protocol version 2 commands.
The error is a formatter string and an optional iterable of arguments. The error is a formatter string and an optional iterable of arguments.
""" """
def __init__(self, message, args=None): def __init__(self, message, args=None):
# type: (bytes, Optional[Sequence[bytes]]) -> None
self.message = message self.message = message
self.messageargs = args self.messageargs = args