mercurial-scm/hg: comparison mercurial/error.py

equal deleted inserted replaced

-:81224afd938d
+:f15cb5111a1e
 Sequence,
 Union,
 ]
-def _tobytes(exc):
+def _tobytes(exc) -> bytes:
-# type: (...) -> bytes
 """Byte-stringify exception in the same way as BaseException_str()"""
 if not exc.args:
 return b''
 if len(exc.args) == 1:
 return pycompat.bytestr(exc.args[0])
 """Base class for Mercurial errors."""
 coarse_exit_code = None
 detailed_exit_code = None
-def __init__(self, message, hint=None):
+def __init__(self, message: bytes, hint: Optional[bytes] = None) -> None:
-# type: (bytes, Optional[bytes]) -> None
 self.message = message
 self.hint = hint
 # Pass the message into the Exception constructor to help extensions
 # that look for exc.args[0].
 Exception.__init__(self, message)
 def __bytes__(self):
 return self.message
-def __str__(self):
+def __str__(self) -> str:
-# type: () -> str
 # the output would be unreadable if the message was translated,
 # but do not replace it with encoding.strfromlocal(), which
 # may raise another exception.
 return pycompat.sysstr(self.__bytes__())
-def format(self):
+def format(self) -> bytes:
-# type: () -> bytes
 from .i18n import _
 message = _(b"abort: %s\n") % self.message
 if self.hint:
 message += _(b"(%s)\n") % self.hint
 class RevlogError(StorageError):
 pass
 class SidedataHashError(RevlogError):
-def __init__(self, key, expected, got):
+def __init__(self, key: int, expected: bytes, got: bytes) -> None:
-# type: (int, bytes, bytes) -> None
 self.hint = None
 self.sidedatakey = key
 self.expecteddigest = expected
 self.actualdigest = got
 class FilteredIndexError(IndexError):
 __bytes__ = _tobytes
 class LookupError(RevlogError, KeyError):
-def __init__(self, name, index, message):
+def __init__(self, name: bytes, index: bytes, message: bytes) -> None:
-# type: (bytes, bytes, bytes) -> None
 self.name = name
 self.index = index
 # this can't be called 'message' because at least some installs of
 # Python 2.6+ complain about the 'message' property being deprecated
 self.lookupmessage = message
 class CommandError(Exception):
 """Exception raised on errors in parsing the command line."""
-def __init__(self, command, message):
+def __init__(self, command: Optional[bytes], message: bytes) -> None:
-# type: (Optional[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):
+def __init__(
-# type: (bytes, Optional[List[bytes]]) -> None
+self,
+command: bytes,
+all_commands: Optional[List[bytes]] = None,
+) -> 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):
+def __init__(self, prefix: bytes, matches: List[bytes]) -> None:
-# 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):
+def __init__(self, status_code: int) -> None:
-# 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
 """Exception raised when a command requires human intervention."""
 coarse_exit_code = 1
 detailed_exit_code = 240
-def format(self):
+def format(self) -> bytes:
-# type: () -> bytes
 from .i18n import _
 message = _(b"%s\n") % self.message
 if self.hint:
 message += _(b"(%s)\n") % self.hint
 class ConflictResolutionRequired(InterventionRequired):
 """Exception raised when a continuable command required merge conflict resolution."""
-def __init__(self, opname):
+def __init__(self, opname: bytes) -> None:
-# type: (bytes) -> None
 from .i18n import _
 self.opname = opname
 InterventionRequired.__init__(
 self,
 class ConfigError(Abort):
 """Exception raised when parsing config files"""
 detailed_exit_code = 30
-def __init__(self, message, location=None, hint=None):
+def __init__(
-# type: (bytes, Optional[bytes], Optional[bytes]) -> None
+self,
+message: bytes,
+location: Optional[bytes] = None,
+hint: Optional[bytes] = None,
+) -> None:
 super(ConfigError, self).__init__(message, hint=hint)
 self.location = location
-def format(self):
+def format(self) -> bytes:
-# type: () -> bytes
 from .i18n import _
 if self.location is not None:
 message = _(b"config error at %s: %s\n") % (
 pycompat.bytestr(self.location),
 class OutOfBandError(RemoteError):
 """Exception raised when a remote repo reports failure"""
-def __init__(self, message=None, hint=None):
+def __init__(
-# type: (Optional[bytes], Optional[bytes]) -> None
+self,
+message: Optional[bytes] = None,
+hint: Optional[bytes] = None,
+):
 from .i18n import _
 if message:
 # Abort.format() adds a trailing newline
 message = _(b"remote error:\n%s") % message.rstrip(b'\n')
 class ParseError(Abort):
 """Raised when parsing config files and {rev,file}sets (msg[, pos])"""
 detailed_exit_code = 10
-def __init__(self, message, location=None, hint=None):
+def __init__(
-# type: (bytes, Optional[Union[bytes, int]], Optional[bytes]) -> None
+self,
+message: bytes,
+location: Optional[Union[bytes, int]] = None,
+hint: Optional[bytes] = None,
+):
 super(ParseError, self).__init__(message, hint=hint)
 self.location = location
-def format(self):
+def format(self) -> bytes:
-# 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 PatchApplicationError(PatchError):
 __bytes__ = _tobytes
-def getsimilar(symbols, value):
+def getsimilar(symbols: Iterable[bytes], value: bytes) -> List[bytes]:
-# 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):
+def similarity_hint(similar: List[bytes]) -> Optional[bytes]:
-# 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):
+def __init__(self, function: bytes, symbols: Iterable[bytes]) -> None:
-# 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):
+def __init__(self, err: IOError) -> None:
-# 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):
+def __init__(self, recordtypes: Iterable[bytes]) -> None:
-# 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):
+def __init__(
-# type: (bytes, Optional[bytes], Optional[bytes]) -> None
+self,
+msg: bytes,
+hint: Optional[bytes] = None,
+version: Optional[bytes] = None,
+) -> None:
 self.version = version
 super(UnknownVersion, self).__init__(msg, hint=hint)
 class LockError(IOError):
-def __init__(self, errno, strerror, filename, desc):
+def __init__(
-# _type: (int, str, bytes, bytes) -> None
+self,
+errno: int,
+strerror: str,
+filename: bytes,
+desc: Optional[bytes],
+) -> None:
 IOError.__init__(self, errno, strerror, filename)
 self.desc = desc
 # no __bytes__() because error message is derived from the standard IOError
 class LockHeld(LockError):
-def __init__(self, errno, filename, desc, locker):
+def __init__(
+self,
+errno: int,
+filename: bytes,
+desc: Optional[bytes],
+locker,
+):
 LockError.__init__(self, errno, 'Lock held', filename, desc)
+self.filename: bytes = filename
 self.locker = locker
 class LockUnavailable(LockError):
 pass
 class ProgrammingError(Hint, RuntimeError):
 """Raised if a mercurial (core or extension) developer made a mistake"""
-def __init__(self, msg, *args, **kwargs):
+def __init__(self, msg: AnyStr, *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)
 """error raised when content verification fails on a censored node
 Also contains the tombstone data substituted for the uncensored data.
 """
-def __init__(self, filename, node, tombstone):
+def __init__(self, filename: bytes, node: bytes, tombstone: bytes):
-# type: (bytes, bytes, bytes) -> None
 from .node import short
 StorageError.__init__(self, b'%s:%s' % (filename, short(node)))
 self.tombstone = tombstone
 Should only be thrown by wire protocol version 2 commands.
 The error is a formatter string and an optional iterable of arguments.
 """
-def __init__(self, message, args=None):
+def __init__(
-# type: (bytes, Optional[Sequence[bytes]]) -> None
+self,
+message: bytes,
+args: Optional[Sequence[bytes]] = None,
+) -> None:
 self.message = message
 self.messageargs = args

changeset 51284	f15cb5111a1e
parent 51283	81224afd938d
child 51285	8b2ea2246a5f