hg-stable: comparison mercurial/error.py

equal deleted inserted replaced

-:e1d75c514ced
+:8b6e36e4b553
 # Do not import anything but pycompat here, please
 from . import pycompat
 if pycompat.TYPE_CHECKING:
 from typing import (
+Any,
+AnyStr,
+Iterable,
+List,
 Optional,
+Sequence,
+Union,
 )
 def _tobytes(exc):
 """Byte-stringify exception in the same way as BaseException_str()"""
 class CommandError(Exception):
 """Exception raised on errors in parsing the command line."""
 def __init__(self, command, message):
+# type: (bytes, bytes) -> None
 self.command = command
 self.message = message
 super(CommandError, self).__init__()
 __bytes__ = _tobytes
 class UnknownCommand(Exception):
 """Exception raised if command is not in the command table."""
 def __init__(self, command, all_commands=None):
+# type: (bytes, Optional[List[bytes]]) -> None
 self.command = command
 self.all_commands = all_commands
 super(UnknownCommand, self).__init__()
 __bytes__ = _tobytes
 class AmbiguousCommand(Exception):
 """Exception raised if command shortcut matches more than one command."""
 def __init__(self, prefix, matches):
+# type: (bytes, List[bytes]) -> None
 self.prefix = prefix
 self.matches = matches
 super(AmbiguousCommand, self).__init__()
 __bytes__ = _tobytes
 class WorkerError(Exception):
 """Exception raised when a worker process dies."""
 def __init__(self, status_code):
+# type: (int) -> None
 self.status_code = status_code
 # Pass status code to superclass just so it becomes part of __bytes__
 super(WorkerError, self).__init__(status_code)
 __bytes__ = _tobytes
 class ConflictResolutionRequired(InterventionRequired):
 """Exception raised when a continuable command required merge conflict resolution."""
 def __init__(self, opname):
+# type: (bytes) -> None
 from .i18n import _
 self.opname = opname
 InterventionRequired.__init__(
 self,
 # but do not replace it with encoding.strfromlocal(), which
 # may raise another exception.
 return pycompat.sysstr(self.__bytes__())
 def format(self):
+# type: () -> bytes
 from .i18n import _
 message = _(b"abort: %s\n") % self.message
 if self.hint:
 message += _(b"(%s)\n") % self.hint
 class ConfigError(Abort):
 """Exception raised when parsing config files"""
 def __init__(self, message, location=None, hint=None):
+# type: (bytes, Optional[bytes], Optional[bytes]) -> None
 super(ConfigError, self).__init__(message, hint=hint)
 self.location = location
 def format(self):
+# type: () -> bytes
 from .i18n import _
 if self.location is not None:
 message = _(b"config error at %s: %s\n") % (
 pycompat.bytestr(self.location),
 class ParseError(Abort):
 """Raised when parsing config files and {rev,file}sets (msg[, pos])"""
 def __init__(self, message, location=None, hint=None):
+# type: (bytes, Optional[Union[bytes, int]], Optional[bytes]) -> None
 super(ParseError, self).__init__(message, hint=hint)
 self.location = location
 def format(self):
+# type: () -> bytes
 from .i18n import _
 if self.location is not None:
 message = _(b"hg: parse error at %s: %s\n") % (
 pycompat.bytestr(self.location),
 class PatchError(Exception):
 __bytes__ = _tobytes
 def getsimilar(symbols, value):
+# type: (Iterable[bytes], bytes) -> List[bytes]
 sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio()
 # The cutoff for similarity here is pretty arbitrary. It should
 # probably be investigated and tweaked.
 return [s for s in symbols if sim(s) > 0.6]
 def similarity_hint(similar):
+# type: (List[bytes]) -> Optional[bytes]
 from .i18n import _
 if len(similar) == 1:
 return _(b"did you mean %s?") % similar[0]
 elif similar:
 class UnknownIdentifier(ParseError):
 """Exception raised when a {rev,file}set references an unknown identifier"""
 def __init__(self, function, symbols):
+# type: (bytes, Iterable[bytes]) -> None
 from .i18n import _
 similar = getsimilar(symbols, function)
 hint = similarity_hint(similar)
 class StdioError(IOError):
 """Raised if I/O to stdout or stderr fails"""
 def __init__(self, err):
+# type: (IOError) -> None
 IOError.__init__(self, err.errno, err.strerror)
 # no __bytes__() because error message is derived from the standard IOError
 class UnsupportedMergeRecords(Abort):
 def __init__(self, recordtypes):
+# type: (Iterable[bytes]) -> None
 from .i18n import _
 self.recordtypes = sorted(recordtypes)
 s = b' '.join(self.recordtypes)
 Abort.__init__(
 class UnknownVersion(Abort):
 """generic exception for aborting from an encounter with an unknown version"""
 def __init__(self, msg, hint=None, version=None):
+# type: (bytes, Optional[bytes], Optional[bytes]) -> None
 self.version = version
 super(UnknownVersion, self).__init__(msg, hint=hint)
 class LockError(IOError):
 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)
 self.desc = desc
 # no __bytes__() because error message is derived from the standard IOError
 class ProgrammingError(Hint, RuntimeError):
 """Raised if a mercurial (core or extension) developer made a mistake"""
 def __init__(self, msg, *args, **kwargs):
+# type: (AnyStr, Any, Any) -> None
 # 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
 # stack traces.
 msg = pycompat.sysstr(msg)
 super(ProgrammingError, self).__init__(msg, *args, **kwargs)
 entries.append(val)
 else:
 entries.append(b"%s=%r" % (par, pycompat.maybebytestr(val)))
 if entries:
 msg = b'%s - %s' % (msg, b', '.join(entries))
-ValueError.__init__(self, msg)
+ValueError.__init__(self, msg)  # TODO: convert to str?
 class ReadOnlyPartError(RuntimeError):
 """error raised when code tries to alter a part being generated"""
 Also contains the tombstone data substituted for the uncensored data.
 """
 def __init__(self, filename, node, tombstone):
+# type: (bytes, bytes, bytes) -> None
 from .node import short
 StorageError.__init__(self, b'%s:%s' % (filename, short(node)))
 self.tombstone = tombstone
 The error is a formatter string and an optional iterable of arguments.
 """
 def __init__(self, message, args=None):
+# type: (bytes, Optional[Sequence[bytes]]) -> None
 self.message = message
 self.messageargs = args

changeset 46899	8b6e36e4b553
parent 46819	d4ba4d51f85f
child 46975	14ddb1dca2c0