Mercurial: mercurial/util.py comparison

comparison mercurial/util.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	e94c8f584ee2
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 import sys
 import time
 import traceback
 import warnings
-from .thirdparty import (
+from .thirdparty import attr
-attr,
-)
 from hgdemandimport import tracing
 from . import (
 encoding,
 error,
 i18n,
 # Python compatibility
 _notset = object()
 def bitsfrom(container):
 bits = 0
 for bit in container:
 bits |= bit
 return bits
 # python 2.6 still have deprecation warning enabled by default. We do not want
 # to display anything to standard user so detect if we are running test and
 # only use python deprecation warning in this case.
 _dowarn = bool(encoding.environ.get('HGEMITWARNINGS'))
 warnings.filterwarnings(r'default', r'', DeprecationWarning, r'mercurial')
 warnings.filterwarnings(r'default', r'', DeprecationWarning, r'hgext')
 warnings.filterwarnings(r'default', r'', DeprecationWarning, r'hgext3rd')
 if _dowarn and pycompat.ispy3:
 # silence warning emitted by passing user string to re.sub()
-warnings.filterwarnings(r'ignore', r'bad escape', DeprecationWarning,
+warnings.filterwarnings(
-r'mercurial')
+r'ignore', r'bad escape', DeprecationWarning, r'mercurial'
-warnings.filterwarnings(r'ignore', r'invalid escape sequence',
+)
-DeprecationWarning, r'mercurial')
+warnings.filterwarnings(
+r'ignore', r'invalid escape sequence', DeprecationWarning, r'mercurial'
+)
 # TODO: reinvent imp.is_frozen()
-warnings.filterwarnings(r'ignore', r'the imp module is deprecated',
+warnings.filterwarnings(
-DeprecationWarning, r'mercurial')
+r'ignore',
+r'the imp module is deprecated',
+DeprecationWarning,
+r'mercurial',
+)
 def nouideprecwarn(msg, version, stacklevel=1):
 """Issue an python native deprecation warning
 This is a noop outside of tests, use 'ui.deprecwarn' when possible.
 """
 if _dowarn:
-msg += ("\n(compatibility will be dropped after Mercurial-%s,"
+msg += (
-" update your code.)") % version
+"\n(compatibility will be dropped after Mercurial-%s,"
+" update your code.)"
+) % version
 warnings.warn(pycompat.sysstr(msg), DeprecationWarning, stacklevel + 1)
 DIGESTS = {
 'md5': hashlib.md5,
 'sha1': hashlib.sha1,
 'sha512': hashlib.sha512,
 # List of digest types from strongest to weakest
 DIGESTS_BY_STRENGTH = ['sha512', 'sha1', 'md5']
 for k in DIGESTS_BY_STRENGTH:
 assert k in DIGESTS
 class digester(object):
 """helper to compute digests.
 This helper can be used to compute one or more digests given their name.
 for k in DIGESTS_BY_STRENGTH:
 if k in supported:
 return k
 return None
 class digestchecker(object):
 """file handle wrapper that additionally checks content against a given
 size and digests.
 d = digestchecker(fh, size, {'md5': '...'})
 self._got += len(content)
 return content
 def validate(self):
 if self._size != self._got:
-raise error.Abort(_('size mismatch: expected %d, got %d') %
+raise error.Abort(
-(self._size, self._got))
+_('size mismatch: expected %d, got %d')
+% (self._size, self._got)
+)
 for k, v in self._digests.items():
 if v != self._digester[k]:
 # i18n: first parameter is a digest name
-raise error.Abort(_('%s mismatch: expected %s, got %s') %
+raise error.Abort(
-(k, v, self._digester[k]))
+_('%s mismatch: expected %s, got %s')
+% (k, v, self._digester[k])
+)
 try:
 buffer = buffer
 except NameError:
 def buffer(sliceable, offset=0, length=None):
 if length is not None:
-return memoryview(sliceable)[offset:offset + length]
+return memoryview(sliceable)[offset : offset + length]
 return memoryview(sliceable)[offset:]
 _chunksize = 4096
 class bufferedinputpipe(object):
 """a manually buffered input pipe
 Python will not let us use buffered IO and lazy reading with 'polling' at
 empty from the output (allowing collaboration of the buffer with polling).
 This class lives in the 'util' module because it makes use of the 'os'
 module from the python stdlib.
 """
 def __new__(cls, fh):
 # If we receive a fileobjectproxy, we need to use a variation of this
 # class that notifies observers about activity.
 if isinstance(fh, fileobjectproxy):
 cls = observedbufferedinputpipe
 while (not self._eof) and lfi < 0:
 self._fillbuffer()
 if self._buffer:
 lfi = self._buffer[-1].find('\n')
 size = lfi + 1
-if lfi < 0: # end of file
+if lfi < 0:  # end of file
 size = self._lenbuf
 elif len(self._buffer) > 1:
 # we need to take previous chunks into account
 size += self._lenbuf - len(self._buffer[-1])
 return self._frombuffer(size)
 buf = self._buffer[0]
 if len(self._buffer) > 1:
 buf = ''.join(self._buffer)
 data = buf[:size]
-buf = buf[len(data):]
+buf = buf[len(data) :]
 if buf:
 self._buffer = [buf]
 self._lenbuf = len(buf)
 else:
 self._buffer = []
 else:
 self._lenbuf += len(data)
 self._buffer.append(data)
 return data
 def mmapread(fp):
 try:
 fd = getattr(fp, 'fileno', lambda: fp)()
 return mmap.mmap(fd, 0, access=mmap.ACCESS_READ)
 # if the file is empty, and if so, return an empty buffer.
 if os.fstat(fd).st_size == 0:
 return ''
 raise
 class fileobjectproxy(object):
 """A proxy around file objects that tells a watcher when events occur.
 This type is intended to only be used for testing purposes. Think hard
 before using it in important code.
 """
 __slots__ = (
 r'_orig',
 r'_observer',
 )
 object.__setattr__(self, r'_observer', observer)
 def __getattribute__(self, name):
 ours = {
 r'_observer',
 # IOBase
 r'close',
 # closed if a property
 r'fileno',
 r'flush',
 return res
 def close(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'close', *args, **kwargs)
+r'close', *args, **kwargs
+)
 def fileno(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'fileno', *args, **kwargs)
+r'fileno', *args, **kwargs
+)
 def flush(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'flush', *args, **kwargs)
+r'flush', *args, **kwargs
+)
 def isatty(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'isatty', *args, **kwargs)
+r'isatty', *args, **kwargs
+)
 def readable(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'readable', *args, **kwargs)
+r'readable', *args, **kwargs
+)
 def readline(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'readline', *args, **kwargs)
+r'readline', *args, **kwargs
+)
 def readlines(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'readlines', *args, **kwargs)
+r'readlines', *args, **kwargs
+)
 def seek(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'seek', *args, **kwargs)
+r'seek', *args, **kwargs
+)
 def seekable(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'seekable', *args, **kwargs)
+r'seekable', *args, **kwargs
+)
 def tell(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'tell', *args, **kwargs)
+r'tell', *args, **kwargs
+)
 def truncate(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'truncate', *args, **kwargs)
+r'truncate', *args, **kwargs
+)
 def writable(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'writable', *args, **kwargs)
+r'writable', *args, **kwargs
+)
 def writelines(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'writelines', *args, **kwargs)
+r'writelines', *args, **kwargs
+)
 def read(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'read', *args, **kwargs)
+r'read', *args, **kwargs
+)
 def readall(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'readall', *args, **kwargs)
+r'readall', *args, **kwargs
+)
 def readinto(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'readinto', *args, **kwargs)
+r'readinto', *args, **kwargs
+)
 def write(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'write', *args, **kwargs)
+r'write', *args, **kwargs
+)
 def detach(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'detach', *args, **kwargs)
+r'detach', *args, **kwargs
+)
 def read1(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'read1', *args, **kwargs)
+r'read1', *args, **kwargs
+)
 class observedbufferedinputpipe(bufferedinputpipe):
 """A variation of bufferedinputpipe that is aware of fileobjectproxy.
 ``bufferedinputpipe`` makes low-level calls to ``os.read()`` that
 This variation of ``bufferedinputpipe`` can notify observers about
 ``os.read()`` events. It also re-publishes other events, such as
 ``read()`` and ``readline()``.
 """
 def _fillbuffer(self):
 res = super(observedbufferedinputpipe, self)._fillbuffer()
 fn = getattr(self._input._observer, r'osread', None)
 if fn:
 fn = getattr(self._input._observer, r'bufferedreadline', None)
 if fn:
 fn(res)
 return res
 PROXIED_SOCKET_METHODS = {
 r'makefile',
 r'recv',
 r'recvfrom',
 r'settimeout',
 r'gettimeout',
 r'setsockopt',
 }
 class socketproxy(object):
 """A proxy around a socket that tells a watcher when events occur.
 This is like ``fileobjectproxy`` except for sockets.
 This type is intended to only be used for testing purposes. Think hard
 before using it in important code.
 """
 __slots__ = (
 r'_orig',
 r'_observer',
 )
 return res
 def makefile(self, *args, **kwargs):
 res = object.__getattribute__(self, r'_observedcall')(
-r'makefile', *args, **kwargs)
+r'makefile', *args, **kwargs
+)
 # The file object may be used for I/O. So we turn it into a
 # proxy using our observer.
 observer = object.__getattribute__(self, r'_observer')
-return makeloggingfileobject(observer.fh, res, observer.name,
+return makeloggingfileobject(
-reads=observer.reads,
+observer.fh,
-writes=observer.writes,
+res,
-logdata=observer.logdata,
+observer.name,
-logdataapis=observer.logdataapis)
+reads=observer.reads,
+writes=observer.writes,
+logdata=observer.logdata,
+logdataapis=observer.logdataapis,
+)
 def recv(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'recv', *args, **kwargs)
+r'recv', *args, **kwargs
+)
 def recvfrom(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'recvfrom', *args, **kwargs)
+r'recvfrom', *args, **kwargs
+)
 def recvfrom_into(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'recvfrom_into', *args, **kwargs)
+r'recvfrom_into', *args, **kwargs
+)
 def recv_into(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'recv_info', *args, **kwargs)
+r'recv_info', *args, **kwargs
+)
 def send(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'send', *args, **kwargs)
+r'send', *args, **kwargs
+)
 def sendall(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'sendall', *args, **kwargs)
+r'sendall', *args, **kwargs
+)
 def sendto(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'sendto', *args, **kwargs)
+r'sendto', *args, **kwargs
+)
 def setblocking(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'setblocking', *args, **kwargs)
+r'setblocking', *args, **kwargs
+)
 def settimeout(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'settimeout', *args, **kwargs)
+r'settimeout', *args, **kwargs
+)
 def gettimeout(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'gettimeout', *args, **kwargs)
+r'gettimeout', *args, **kwargs
+)
 def setsockopt(self, *args, **kwargs):
 return object.__getattribute__(self, r'_observedcall')(
-r'setsockopt', *args, **kwargs)
+r'setsockopt', *args, **kwargs
+)
 class baseproxyobserver(object):
 def _writedata(self, data):
 if not self.logdata:
 if self.logdataapis:
 # Simple case writes all data on a single line.
 if b'\n' not in data:
 if self.logdataapis:
 self.fh.write(': %s\n' % stringutil.escapestr(data))
 else:
-self.fh.write('%s>     %s\n'
+self.fh.write(
-% (self.name, stringutil.escapestr(data)))
+'%s>     %s\n' % (self.name, stringutil.escapestr(data))
+)
 self.fh.flush()
 return
 # Data with newlines is written to multiple lines.
 if self.logdataapis:
 self.fh.write(':\n')
 lines = data.splitlines(True)
 for line in lines:
-self.fh.write('%s>     %s\n'
+self.fh.write(
-% (self.name, stringutil.escapestr(line)))
+'%s>     %s\n' % (self.name, stringutil.escapestr(line))
+)
 self.fh.flush()
 class fileobjectobserver(baseproxyobserver):
 """Logs file object activity."""
-def __init__(self, fh, name, reads=True, writes=True, logdata=False,
-logdataapis=True):
+def __init__(
+self, fh, name, reads=True, writes=True, logdata=False, logdataapis=True
+):
 self.fh = fh
 self.name = name
 self.logdata = logdata
 self.logdataapis = logdataapis
 self.reads = reads
 def readinto(self, res, dest):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> readinto(%d) -> %r' % (self.name, len(dest),
+self.fh.write(
-res))
+'%s> readinto(%d) -> %r' % (self.name, len(dest), res)
+)
 data = dest[0:res] if res is not None else b''
 # _writedata() uses "in" operator and is confused by memoryview because
 # characters are ints on Python 3.
 def bufferedread(self, res, size):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> bufferedread(%d) -> %d' % (
+self.fh.write(
-self.name, size, len(res)))
+'%s> bufferedread(%d) -> %d' % (self.name, size, len(res))
+)
 self._writedata(res)
 def bufferedreadline(self, res):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> bufferedreadline() -> %d' % (
+self.fh.write(
-self.name, len(res)))
+'%s> bufferedreadline() -> %d' % (self.name, len(res))
+)
 self._writedata(res)
-def makeloggingfileobject(logh, fh, name, reads=True, writes=True,
-logdata=False, logdataapis=True):
+def makeloggingfileobject(
+logh, fh, name, reads=True, writes=True, logdata=False, logdataapis=True
+):
 """Turn a file object into a logging file object."""
-observer = fileobjectobserver(logh, name, reads=reads, writes=writes,
+observer = fileobjectobserver(
-logdata=logdata, logdataapis=logdataapis)
+logh,
+name,
+reads=reads,
+writes=writes,
+logdata=logdata,
+logdataapis=logdataapis,
+)
 return fileobjectproxy(fh, observer)
 class socketobserver(baseproxyobserver):
 """Logs socket activity."""
-def __init__(self, fh, name, reads=True, writes=True, states=True,
-logdata=False, logdataapis=True):
+def __init__(
+self,
+fh,
+name,
+reads=True,
+writes=True,
+states=True,
+logdata=False,
+logdataapis=True,
+):
 self.fh = fh
 self.name = name
 self.reads = reads
 self.writes = writes
 self.states = states
 def makefile(self, res, mode=None, bufsize=None):
 if not self.states:
 return
-self.fh.write('%s> makefile(%r, %r)\n' % (
+self.fh.write('%s> makefile(%r, %r)\n' % (self.name, mode, bufsize))
-self.name, mode, bufsize))
 def recv(self, res, size, flags=0):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> recv(%d, %d) -> %d' % (
+self.fh.write(
-self.name, size, flags, len(res)))
+'%s> recv(%d, %d) -> %d' % (self.name, size, flags, len(res))
+)
 self._writedata(res)
 def recvfrom(self, res, size, flags=0):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> recvfrom(%d, %d) -> %d' % (
+self.fh.write(
-self.name, size, flags, len(res[0])))
+'%s> recvfrom(%d, %d) -> %d'
+% (self.name, size, flags, len(res[0]))
+)
 self._writedata(res[0])
 def recvfrom_into(self, res, buf, size, flags=0):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> recvfrom_into(%d, %d) -> %d' % (
+self.fh.write(
-self.name, size, flags, res[0]))
+'%s> recvfrom_into(%d, %d) -> %d'
+% (self.name, size, flags, res[0])
-self._writedata(buf[0:res[0]])
+)
+self._writedata(buf[0 : res[0]])
 def recv_into(self, res, buf, size=0, flags=0):
 if not self.reads:
 return
 if self.logdataapis:
-self.fh.write('%s> recv_into(%d, %d) -> %d' % (
+self.fh.write(
-self.name, size, flags, res))
+'%s> recv_into(%d, %d) -> %d' % (self.name, size, flags, res)
+)
 self._writedata(buf[0:res])
 def send(self, res, data, flags=0):
 if not self.writes:
 return
-self.fh.write('%s> send(%d, %d) -> %d' % (
+self.fh.write(
-self.name, len(data), flags, len(res)))
+'%s> send(%d, %d) -> %d' % (self.name, len(data), flags, len(res))
+)
 self._writedata(data)
 def sendall(self, res, data, flags=0):
 if not self.writes:
 return
 if self.logdataapis:
 # Returns None on success. So don't bother reporting return value.
-self.fh.write('%s> sendall(%d, %d)' % (
+self.fh.write('%s> sendall(%d, %d)' % (self.name, len(data), flags))
-self.name, len(data), flags))
 self._writedata(data)
 def sendto(self, res, data, flagsoraddress, address=None):
 if not self.writes:
 flags = flagsoraddress
 else:
 flags = 0
 if self.logdataapis:
-self.fh.write('%s> sendto(%d, %d, %r) -> %d' % (
+self.fh.write(
-self.name, len(data), flags, address, res))
+'%s> sendto(%d, %d, %r) -> %d'
+% (self.name, len(data), flags, address, res)
+)
 self._writedata(data)
 def setblocking(self, res, flag):
 if not self.states:
 def setsockopt(self, res, level, optname, value):
 if not self.states:
 return
-self.fh.write('%s> setsockopt(%r, %r, %r) -> %r\n' % (
+self.fh.write(
-self.name, level, optname, value, res))
+'%s> setsockopt(%r, %r, %r) -> %r\n'
+% (self.name, level, optname, value, res)
-def makeloggingsocket(logh, fh, name, reads=True, writes=True, states=True,
+)
-logdata=False, logdataapis=True):
+def makeloggingsocket(
+logh,
+fh,
+name,
+reads=True,
+writes=True,
+states=True,
+logdata=False,
+logdataapis=True,
+):
 """Turn a socket into a logging socket."""
-observer = socketobserver(logh, name, reads=reads, writes=writes,
+observer = socketobserver(
-states=states, logdata=logdata,
+logh,
-logdataapis=logdataapis)
+name,
+reads=reads,
+writes=writes,
+states=states,
+logdata=logdata,
+logdataapis=logdataapis,
+)
 return socketproxy(fh, observer)
 def version():
 """Return version information if available."""
 try:
 from . import __version__
 return __version__.version
 except ImportError:
 return 'unknown'
 def versiontuple(v=None, n=4):
 """Parses a Mercurial version string into an N-tuple.
 The version string to be parsed is specified with the ``v`` argument.
 if n == 3:
 return (vints[0], vints[1], vints[2])
 if n == 4:
 return (vints[0], vints[1], vints[2], extra)
 def cachefunc(func):
 '''cache the result of function calls'''
 # XXX doesn't handle keywords args
 if func.__code__.co_argcount == 0:
 cache = []
 def f():
 if len(cache) == 0:
 cache.append(func())
 return cache[0]
 return f
 cache = {}
 if func.__code__.co_argcount == 1:
 # we gain a small amount of time because
 # we don't need to pack/unpack the list
 def f(arg):
 if arg not in cache:
 cache[arg] = func(arg)
 return cache[arg]
 else:
 def f(*args):
 if args not in cache:
 cache[args] = func(*args)
 return cache[args]
 return f
 class cow(object):
 """helper class to make copy-on-write easier
 Call preparewrite before doing any writes.
 def copy(self):
 """always do a cheap copy"""
 self._copied = getattr(self, '_copied', 0) + 1
 return self
 class sortdict(collections.OrderedDict):
 '''a simple sorted dictionary
 >>> d1 = sortdict([(b'a', 0), (b'b', 1)])
 def update(self, src):
 if isinstance(src, dict):
 src = src.iteritems()
 for k, v in src:
 self[k] = v
 class cowdict(cow, dict):
 """copy-on-write dict
 Be sure to call d = d.preparewrite() before writing to d.
 False
 >>> b is b.preparewrite()
 True
 """
 class cowsortdict(cow, sortdict):
 """copy-on-write sortdict
 Be sure to call d = d.preparewrite() before writing to d.
 """
 class transactional(object):
 """Base class for making a transactional type into a context manager."""
 __metaclass__ = abc.ABCMeta
 @abc.abstractmethod
 def close(self):
 """Successfully closes the transaction."""
 try:
 if exc_type is None:
 self.close()
 finally:
 self.release()
 @contextlib.contextmanager
 def acceptintervention(tr=None):
 """A context manager that closes the transaction on InterventionRequired
 tr.close()
 raise
 finally:
 tr.release()
 @contextlib.contextmanager
 def nullcontextmanager():
 yield
 class _lrucachenode(object):
 """A node in a doubly linked list.
 Holds a reference to nodes on either side as well as a key-value
 pair for the dictionary entry.
 """
 __slots__ = (r'next', r'prev', r'key', r'value', r'cost')
 def __init__(self):
 self.next = None
 self.prev = None
 def markempty(self):
 """Mark the node as emptied."""
 self.key = _notset
 self.value = None
 self.cost = 0
 class lrucachedict(object):
 """Dict that caches most recent accesses and sets.
 The dict consists of an actual backing dict - indexed by original
 cause the total cost of the cache to go beyond the maximum cost limit,
 nodes will be evicted to make room for the new code. This can be used
 to e.g. set a max memory limit and associate an estimated bytes size
 cost to each item in the cache. By default, no maximum cost is enforced.
 """
 def __init__(self, max, maxcost=0):
 self._cache = {}
 self._head = head = _lrucachenode()
 head.prev = head
 del self._cache[n.key]
 self.totalcost -= n.cost
 n.markempty()
 n = n.prev
 def lrucachefunc(func):
 '''cache most recent results of function calls'''
 cache = {}
 order = collections.deque()
 if func.__code__.co_argcount == 1:
 def f(arg):
 if arg not in cache:
 if len(cache) > 20:
 del cache[order.popleft()]
 cache[arg] = func(arg)
 else:
 order.remove(arg)
 order.append(arg)
 return cache[arg]
 else:
 def f(*args):
 if args not in cache:
 if len(cache) > 20:
 del cache[order.popleft()]
 cache[args] = func(*args)
 order.append(args)
 return cache[args]
 return f
 class propertycache(object):
 def __init__(self, func):
 self.func = func
 self.name = func.__name__
 def __get__(self, obj, type=None):
 result = self.func(obj)
 self.cachevalue(obj, result)
 return result
 def cachevalue(self, obj, value):
 # __dict__ assignment required to bypass __setattr__ (eg: repoview)
 obj.__dict__[self.name] = value
 def clearcachedproperty(obj, prop):
 '''clear a cached property value, if one has been set'''
 prop = pycompat.sysstr(prop)
 if prop in obj.__dict__:
 del obj.__dict__[prop]
 def increasingchunks(source, min=1024, max=65536):
 '''return no less than min bytes per chunk while data remains,
 doubling min after each chunk until it reaches max'''
 def log2(x):
 if not x:
 return 0
 i = 0
 while x:
 blen = 0
 buf = []
 if buf:
 yield ''.join(buf)
 def always(fn):
 return True
 def never(fn):
 return False
 def nogc(func):
 """disable garbage collector
 Python's garbage collector triggers a GC each time a certain number of
 containers.
 This garbage collector issue have been fixed in 2.7. But it still affect
 CPython's performance.
 """
 def wrapper(*args, **kwargs):
 gcenabled = gc.isenabled()
 gc.disable()
 try:
 return func(*args, **kwargs)
 finally:
 if gcenabled:
 gc.enable()
 return wrapper
 if pycompat.ispypy:
 # PyPy runs slower with gc disabled
 nogc = lambda x: x
 def pathto(root, n1, n2):
 '''return the relative path from one place to another.
 root should use os.sep to separate directories
 n1 should use os.sep to separate directories
 a.pop()
 b.pop()
 b.reverse()
 return pycompat.ossep.join((['..'] * len(a)) + b) or '.'
 # the location of data files matching the source code
 if procutil.mainfrozen() and getattr(sys, 'frozen', None) != 'macosx_app':
 # executable version (py2exe) doesn't support __file__
 datapath = os.path.dirname(pycompat.sysexecutable)
 else:
 datapath = os.path.dirname(pycompat.fsencode(__file__))
 i18n.setdatapath(datapath)
 def checksignature(func):
 '''wrap a function with code to check for calling errors'''
 def check(*args, **kwargs):
 try:
 return func(*args, **kwargs)
 except TypeError:
 if len(traceback.extract_tb(sys.exc_info()[2])) == 1:
 raise error.SignatureError
 raise
 return check
 # a whilelist of known filesystems where hardlink works reliably
 _hardlinkfswhitelist = {
 'apfs',
 'btrfs',
 'tmpfs',
 'ufs',
 'xfs',
 'zfs',
 }
 def copyfile(src, dest, hardlink=False, copystat=False, checkambig=False):
 '''copy a file, preserving mode and optionally other stat info like
 atime/mtime
 if hardlink:
 try:
 oslink(src, dest)
 return
 except (IOError, OSError):
-pass # fall back to normal copy
+pass  # fall back to normal copy
 if os.path.islink(src):
 os.symlink(os.readlink(src), dest)
 # copytime is ignored for symlinks, but in general copytime isn't needed
 # for them anyway
 else:
 if oldstat and oldstat.stat:
 newstat = filestat.frompath(dest)
 if newstat.isambig(oldstat):
 # stat of copied file is ambiguous to original one
 advanced = (
-oldstat.stat[stat.ST_MTIME] + 1) & 0x7fffffff
+oldstat.stat[stat.ST_MTIME] + 1
+) & 0x7FFFFFFF
 os.utime(dest, (advanced, advanced))
 except shutil.Error as inst:
 raise error.Abort(str(inst))
 def copyfiles(src, dst, hardlink=None, progress=None):
 """Copy a directory tree using hardlinks if possible."""
 num = 0
 def settopic():
 if progress:
 progress.topic = _('linking') if hardlink else _('copying')
 if os.path.isdir(src):
 if hardlink is None:
-hardlink = (os.stat(src).st_dev ==
+hardlink = (
-os.stat(os.path.dirname(dst)).st_dev)
+os.stat(src).st_dev == os.stat(os.path.dirname(dst)).st_dev
+)
 settopic()
 os.mkdir(dst)
 for name, kind in listdir(src):
 srcname = os.path.join(src, name)
 dstname = os.path.join(dst, name)
 hardlink, n = copyfiles(srcname, dstname, hardlink, progress)
 num += n
 else:
 if hardlink is None:
-hardlink = (os.stat(os.path.dirname(src)).st_dev ==
+hardlink = (
-os.stat(os.path.dirname(dst)).st_dev)
+os.stat(os.path.dirname(src)).st_dev
+== os.stat(os.path.dirname(dst)).st_dev
+)
 settopic()
 if hardlink:
 try:
 oslink(src, dst)
 if progress:
 progress.increment()
 return hardlink, num
 _winreservednames = {
-'con', 'prn', 'aux', 'nul',
+'con',
-'com1', 'com2', 'com3', 'com4', 'com5', 'com6', 'com7', 'com8', 'com9',
+'prn',
-'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9',
+'aux',
+'nul',
+'com1',
+'com2',
+'com3',
+'com4',
+'com5',
+'com6',
+'com7',
+'com8',
+'com9',
+'lpt1',
+'lpt2',
+'lpt3',
+'lpt4',
+'lpt5',
+'lpt6',
+'lpt7',
+'lpt8',
+'lpt9',
 }
 _winreservedchars = ':*?"<>|'
 def checkwinfilename(path):
 r'''Check that the base-relative path is a valid filename on Windows.
 Returns None if the path is ok, or a UI string describing the problem.
 >>> checkwinfilename(b"just/a/normal/path")
 for n in path.replace('\\', '/').split('/'):
 if not n:
 continue
 for c in _filenamebytestr(n):
 if c in _winreservedchars:
-return _("filename contains '%s', which is reserved "
+return (
-"on Windows") % c
+_("filename contains '%s', which is reserved " "on Windows")
+% c
+)
 if ord(c) <= 31:
-return _("filename contains '%s', which is invalid "
+return _(
-"on Windows") % stringutil.escapestr(c)
+"filename contains '%s', which is invalid " "on Windows"
+) % stringutil.escapestr(c)
 base = n.split('.')[0]
 if base and base.lower() in _winreservednames:
-return _("filename contains '%s', which is reserved "
+return (
-"on Windows") % base
+_("filename contains '%s', which is reserved " "on Windows")
+% base
+)
 t = n[-1:]
 if t in '. ' and n not in '..':
-return _("filename ends with '%s', which is not allowed "
+return (
-"on Windows") % t
+_("filename ends with '%s', which is not allowed " "on Windows")
+% t
+)
 if pycompat.iswindows:
 checkosfilename = checkwinfilename
 timer = time.clock
 else:
 checkosfilename = platform.checkosfilename
 timer = time.time
 if safehasattr(time, "perf_counter"):
 timer = time.perf_counter
 def makelock(info, pathname):
 """Create a lock file atomically if possible
 This may leave a stale lock file if symlink isn't supported and signal
 try:
 return os.symlink(info, pathname)
 except OSError as why:
 if why.errno == errno.EEXIST:
 raise
-except AttributeError: # no symlink in os
+except AttributeError:  # no symlink in os
 pass
 flags = os.O_CREAT | os.O_WRONLY | os.O_EXCL | getattr(os, 'O_BINARY', 0)
 ld = os.open(pathname, flags)
 os.write(ld, info)
 os.close(ld)
 def readlock(pathname):
 try:
 return readlink(pathname)
 except OSError as why:
 if why.errno not in (errno.EINVAL, errno.ENOSYS):
 raise
-except AttributeError: # no symlink in os
+except AttributeError:  # no symlink in os
 pass
 with posixfile(pathname, 'rb') as fp:
 return fp.read()
 def fstat(fp):
 '''stat file object that may not have fileno method.'''
 try:
 return os.fstat(fp.fileno())
 except AttributeError:
 return os.stat(fp.name)
 # File system features
 def fscasesensitive(path):
 """
 Return true if the given path is on a case-sensitive filesystem
 d, b = os.path.split(path)
 b2 = b.upper()
 if b == b2:
 b2 = b.lower()
 if b == b2:
-return True # no evidence against case sensitivity
+return True  # no evidence against case sensitivity
 p2 = os.path.join(d, b2)
 try:
 s2 = os.lstat(p2)
 if s2 == s1:
 return False
 return True
 except OSError:
 return True
 try:
 import re2
 _re2 = None
 except ImportError:
 _re2 = False
 class _re(object):
 def _checkre2(self):
 global _re2
 try:
 if _re2:
 return re2.escape
 else:
 return remod.escape
 re = _re()
 _fspathcache = {}
 def fspath(name, root):
 '''Get name in the case stored in the filesystem
 The name should be relative to root, and be normcase-ed for efficiency.
 Note that this function is unnecessary, and should not be
 called, for case-sensitive filesystems (simply because it's expensive).
 The root should be normcase-ed, too.
 '''
 def _makefspathcacheentry(dir):
 return dict((normcase(n), n) for n in os.listdir(dir))
 seps = pycompat.ossep
 if pycompat.osaltsep:
 seps = seps + pycompat.osaltsep
 # Protect backslashes. This gets silly very quickly.
-seps.replace('\\','\\\\')
+seps.replace('\\', '\\\\')
 pattern = remod.compile(br'([^%s]+)|([%s]+)' % (seps, seps))
 dir = os.path.normpath(root)
 result = []
 for part, sep in pattern.findall(name):
 if sep:
 result.append(found or part)
 dir = os.path.join(dir, part)
 return ''.join(result)
 def checknlink(testfile):
 '''check whether hardlink count reporting works properly'''
 # testfile may be open, so we need a separate file for checking to
 # work around issue2543 (or testfile may get lost on Samba shares)
 f1, f2, fp = None, None, None
 try:
-fd, f1 = pycompat.mkstemp(prefix='.%s-' % os.path.basename(testfile),
+fd, f1 = pycompat.mkstemp(
-suffix='1~', dir=os.path.dirname(testfile))
+prefix='.%s-' % os.path.basename(testfile),
+suffix='1~',
+dir=os.path.dirname(testfile),
+)
 os.close(fd)
 f2 = '%s2~' % f1[:-2]
 oslink(f1, f2)
 # nlinks() may behave differently for files on Windows shares if
 if f is not None:
 os.unlink(f)
 except OSError:
 pass
 def endswithsep(path):
 '''Check path ends with os.sep or os.altsep.'''
-return (path.endswith(pycompat.ossep)
+return (
-or pycompat.osaltsep and path.endswith(pycompat.osaltsep))
+path.endswith(pycompat.ossep)
+or pycompat.osaltsep
+and path.endswith(pycompat.osaltsep)
+)
 def splitpath(path):
 '''Split path by os.sep.
 Note that this function does not use os.altsep because this is
 an alternative of simple "xxx.split(os.sep)".
 It is recommended to use os.path.normpath() before using this
 function if need.'''
 return path.split(pycompat.ossep)
 def mktempcopy(name, emptyok=False, createmode=None, enforcewritable=False):
 """Create a temporary file with the same contents from name
 The permission bits are copied from the original file.
 ofp = posixfile(temp, "wb")
 for chunk in filechunkiter(ifp):
 ofp.write(chunk)
 ifp.close()
 ofp.close()
-except: # re-raises
+except:  # re-raises
 try:
 os.unlink(temp)
 except OSError:
 pass
 raise
 return temp
 class filestat(object):
 """help to exactly detect change of a file
 'stat' attribute is result of 'os.stat()' if specified 'path'
 exists. Otherwise, it is None. This can avoid preparative
 'exists()' examination on client side of this class.
 """
 def __init__(self, stat):
 self.stat = stat
 @classmethod
 def frompath(cls, path):
 def __eq__(self, old):
 try:
 # if ambiguity between stat of new and old file is
 # avoided, comparison of size, ctime and mtime is enough
 # to exactly detect change of a file regardless of platform
-return (self.stat.st_size == old.stat.st_size and
+return (
-self.stat[stat.ST_CTIME] == old.stat[stat.ST_CTIME] and
+self.stat.st_size == old.stat.st_size
-self.stat[stat.ST_MTIME] == old.stat[stat.ST_MTIME])
+and self.stat[stat.ST_CTIME] == old.stat[stat.ST_CTIME]
+and self.stat[stat.ST_MTIME] == old.stat[stat.ST_MTIME]
+)
 except AttributeError:
 pass
 try:
 return self.stat is None and old.stat is None
 except AttributeError:
 Advancing mtime "if isambig(oldstat)" ensures "S[n-1].mtime !=
 S[n].mtime", even if size of a file isn't changed.
 """
 try:
-return (self.stat[stat.ST_CTIME] == old.stat[stat.ST_CTIME])
+return self.stat[stat.ST_CTIME] == old.stat[stat.ST_CTIME]
 except AttributeError:
 return False
 def avoidambig(self, path, old):
 """Change file stat of specified path to avoid ambiguity
 appropriate privileges for 'path'. This returns False in this
 case.
 Otherwise, this returns True, as "ambiguity is avoided".
 """
-advanced = (old.stat[stat.ST_MTIME] + 1) & 0x7fffffff
+advanced = (old.stat[stat.ST_MTIME] + 1) & 0x7FFFFFFF
 try:
 os.utime(path, (advanced, advanced))
 except OSError as inst:
 if inst.errno == errno.EPERM:
 # utime() on the file created by another user causes EPERM,
 return True
 def __ne__(self, other):
 return not self == other
 class atomictempfile(object):
 '''writable file object that atomically updates a file
 All writes will go to a temporary copy of the original file. Call
 close() when you are done writing, and atomictempfile will rename
 checkambig argument of constructor is used with filestat, and is
 useful only if target file is guarded by any lock (e.g. repo.lock
 or repo.wlock).
 '''
 def __init__(self, name, mode='w+b', createmode=None, checkambig=False):
-self.__name = name      # permanent name
+self.__name = name  # permanent name
-self._tempname = mktempcopy(name, emptyok=('w' in mode),
+self._tempname = mktempcopy(
-createmode=createmode,
+name,
-enforcewritable=('w' in mode))
+emptyok=('w' in mode),
+createmode=createmode,
+enforcewritable=('w' in mode),
+)
 self._fp = posixfile(self._tempname, mode)
 self._checkambig = checkambig
 # delegated methods
 if oldstat and oldstat.stat:
 rename(self._tempname, filename)
 newstat = filestat.frompath(filename)
 if newstat.isambig(oldstat):
 # stat of changed file is ambiguous to original one
-advanced = (oldstat.stat[stat.ST_MTIME] + 1) & 0x7fffffff
+advanced = (oldstat.stat[stat.ST_MTIME] + 1) & 0x7FFFFFFF
 os.utime(filename, (advanced, advanced))
 else:
 rename(self._tempname, filename)
 def discard(self):
 except OSError:
 pass
 self._fp.close()
 def __del__(self):
-if safehasattr(self, '_fp'): # constructor actually did something
+if safehasattr(self, '_fp'):  # constructor actually did something
 self.discard()
 def __enter__(self):
 return self
 def __exit__(self, exctype, excvalue, traceback):
 if exctype is not None:
 self.discard()
 else:
 self.close()
 def unlinkpath(f, ignoremissing=False, rmdir=True):
 """unlink and remove the directory if it is empty"""
 if ignoremissing:
 tryunlink(f)
 try:
 removedirs(os.path.dirname(f))
 except OSError:
 pass
 def tryunlink(f):
 """Attempt to remove a file, ignoring ENOENT errors."""
 try:
 unlink(f)
 except OSError as e:
 if e.errno != errno.ENOENT:
 raise
 def makedirs(name, mode=None, notindexed=False):
 """recursive directory creation with parent mode inheritance
 Newly created directories are marked as "not to be indexed by
 return
 raise
 if mode is not None:
 os.chmod(name, mode)
 def readfile(path):
 with open(path, 'rb') as fp:
 return fp.read()
 def writefile(path, text):
 with open(path, 'wb') as fp:
 fp.write(text)
 def appendfile(path, text):
 with open(path, 'ab') as fp:
 fp.write(text)
 class chunkbuffer(object):
 """Allow arbitrary sized chunks of data to be efficiently read from an
 iterator over chunks of arbitrary size."""
 def __init__(self, in_iter):
 """in_iter is the iterator that's iterating over the input chunks."""
 def splitbig(chunks):
 for chunk in chunks:
-if len(chunk) > 2**20:
+if len(chunk) > 2 ** 20:
 pos = 0
 while pos < len(chunk):
 end = pos + 2 ** 18
 yield chunk[pos:end]
 pos = end
 else:
 yield chunk
 self.iter = splitbig(in_iter)
 self._queue = collections.deque()
 self._chunkoffset = 0
 def read(self, l=None):
 buf = []
 queue = self._queue
 while left > 0:
 # refill the queue
 if not queue:
-target = 2**18
+target = 2 ** 18
 for chunk in self.iter:
 queue.append(chunk)
 target -= len(chunk)
 if target <= 0:
 break
 buf.append(chunk[offset:])
 self._chunkoffset = 0
 # Partial chunk needed.
 else:
-buf.append(chunk[offset:offset + left])
+buf.append(chunk[offset : offset + left])
 self._chunkoffset += left
 left -= chunkremaining
 return ''.join(buf)
 def filechunkiter(f, size=131072, limit=None):
 """Create a generator that produces the data in the file size
 (default 131072) bytes at a time, up to optional limit (default is
 to read all data).  Chunks may be less than size bytes if the
 break
 if limit:
 limit -= len(s)
 yield s
 class cappedreader(object):
 """A file object proxy that allows reading up to N bytes.
 Given a source file object, instances of this type allow reading up to
 N bytes from that source file object. Attempts to read past the allowed
 It is assumed that I/O is not performed on the original file object
 in addition to I/O that is performed by this instance. If there is,
 state tracking will get out of sync and unexpected results will ensue.
 """
 def __init__(self, fh, limit):
 """Allow reading up to <limit> bytes from <fh>."""
 self._fh = fh
 self._left = limit
 def readinto(self, b):
 res = self.read(len(b))
 if res is None:
 return None
-b[0:len(res)] = res
+b[0 : len(res)] = res
 return len(res)
 def unitcountfn(*unittable):
 '''return a function that renders a readable count of some quantity'''
 def go(count):
 if abs(count) >= divisor * multiplier:
 return format % (count / float(divisor))
 return unittable[-1][2] % count
 return go
 def processlinerange(fromline, toline):
 """Check that linerange <fromline>:<toline> makes sense and return a
 0-based range.
 raise error.ParseError(_("line range must be positive"))
 if fromline < 1:
 raise error.ParseError(_("fromline must be strictly positive"))
 return fromline - 1, toline
 bytecount = unitcountfn(
 (100, 1 << 30, _('%.0f GB')),
 (10, 1 << 30, _('%.1f GB')),
 (1, 1 << 30, _('%.2f GB')),
 (100, 1 << 20, _('%.0f MB')),
 (1, 1 << 20, _('%.2f MB')),
 (100, 1 << 10, _('%.0f KB')),
 (10, 1 << 10, _('%.1f KB')),
 (1, 1 << 10, _('%.2f KB')),
 (1, 1, _('%.0f bytes')),
 )
 class transformingwriter(object):
 """Writable file wrapper to transform data by function"""
 def __init__(self, fp, encode):
 def flush(self):
 self._fp.flush()
 def write(self, data):
 return self._fp.write(self._encode(data))
 # Matches a single EOL which can either be a CRLF where repeated CR
 # are removed or a LF. We do not care about old Macintosh files, so a
 # stray CR is an error.
 _eolre = remod.compile(br'\r*\n')
 def tolf(s):
 return _eolre.sub('\n', s)
 def tocrlf(s):
 return _eolre.sub('\r\n', s)
 def _crlfwriter(fp):
 return transformingwriter(fp, tocrlf)
 if pycompat.oslinesep == '\r\n':
 tonativeeol = tocrlf
 fromnativeeol = tolf
 nativeeolwriter = _crlfwriter
 else:
 tonativeeol = pycompat.identity
 fromnativeeol = pycompat.identity
 nativeeolwriter = pycompat.identity
-if (pyplatform.python_implementation() == 'CPython' and
+if pyplatform.python_implementation() == 'CPython' and sys.version_info < (
-sys.version_info < (3, 0)):
+3,
+0,
+):
 # There is an issue in CPython that some IO methods do not handle EINTR
 # correctly. The following table shows what CPython version (and functions)
 # are affected (buggy: has the EINTR bug, okay: otherwise):
 #
 #                | < 2.7.4 | 2.7.4 to 2.7.12 | >= 3.0
 # to minimize the performance impact.
 if sys.version_info >= (2, 7, 4):
 # fp.readline deals with EINTR correctly, use it as a workaround.
 def _safeiterfile(fp):
 return iter(fp.readline, '')
 else:
 # fp.read* are broken too, manually deal with EINTR in a stupid way.
 # note: this may block longer than necessary because of bufsize.
 def _safeiterfile(fp, bufsize=4096):
 fd = fp.fileno()
 fastpath = stat.S_ISREG(os.fstat(fp.fileno()).st_mode)
 if fastpath:
 return fp
 else:
 return _safeiterfile(fp)
 else:
 # PyPy and CPython 3 do not have the EINTR issue thus no workaround needed.
 def iterfile(fp):
 return fp
 def iterlines(iterator):
 for chunk in iterator:
 for line in chunk.splitlines():
 yield line
 def expandpath(path):
 return os.path.expanduser(os.path.expandvars(path))
 def interpolate(prefix, mapping, s, fn=None, escape_prefix=False):
 """Return the result of interpolating items in the mapping into string s.
 prefix is a single character string, or a two character string with
 prefix_char = prefix
 mapping[prefix_char] = prefix_char
 r = remod.compile(br'%s(%s)' % (prefix, patterns))
 return r.sub(lambda x: fn(mapping[x.group()[1:]]), s)
 def getport(port):
 """Return the port for a given network service.
 If port is an integer, it's returned as is. If it's a string, it's
 looked up using socket.getservbyname(). If there's no matching
 pass
 try:
 return socket.getservbyname(pycompat.sysstr(port))
 except socket.error:
-raise error.Abort(_("no port number associated with service '%s'")
+raise error.Abort(
-% port)
+_("no port number associated with service '%s'") % port
+)
 class url(object):
 r"""Reliable URL parser.
 This parses URLs and provides attributes for the following
 self.user, self.passwd = self.user.split(':', 1)
 if not self.host:
 self.host = None
 # Don't split on colons in IPv6 addresses without ports
-if (self.host and ':' in self.host and
+if (
-not (self.host.startswith('[') and self.host.endswith(']'))):
+self.host
+and ':' in self.host
+and not (self.host.startswith('[') and self.host.endswith(']'))
+):
 self._hostport = self.host
 self.host, self.port = self.host.rsplit(':', 1)
 if not self.host:
 self.host = None
-if (self.host and self.scheme == 'file' and
+if (
-self.host not in ('localhost', '127.0.0.1', '[::1]')):
+self.host
+and self.scheme == 'file'
+and self.host not in ('localhost', '127.0.0.1', '[::1]')
+):
 raise error.Abort(_('file:// URLs can only refer to localhost'))
 self.path = path
 # leave the query string escaped
-for a in ('user', 'passwd', 'host', 'port',
+for a in ('user', 'passwd', 'host', 'port', 'path', 'fragment'):
-'path', 'fragment'):
 v = getattr(self, a)
 if v is not None:
 setattr(self, a, urlreq.unquote(v))
 @encoding.strmethod
 def __repr__(self):
 attrs = []
-for a in ('scheme', 'user', 'passwd', 'host', 'port', 'path',
+for a in (
-'query', 'fragment'):
+'scheme',
+'user',
+'passwd',
+'host',
+'port',
+'path',
+'query',
+'fragment',
+):
 v = getattr(self, a)
 if v is not None:
 attrs.append('%s: %r' % (a, pycompat.bytestr(v)))
 return '<url %s>' % ', '.join(attrs)
 return s
 s = self.scheme + ':'
 if self.user or self.passwd or self.host:
 s += '//'
-elif self.scheme and (not self.path or self.path.startswith('/')
+elif self.scheme and (
-or hasdriveletter(self.path)):
+not self.path
+or self.path.startswith('/')
+or hasdriveletter(self.path)
+):
 s += '//'
 if hasdriveletter(self.path):
 s += '/'
 if self.user:
 s += urlreq.quote(self.user, safe=self._safechars)
 return (s, None)
 # authinfo[1] is passed to urllib2 password manager, and its
 # URIs must not contain credentials. The host is passed in the
 # URIs list because Python < 2.4.3 uses only that to search for
 # a password.
-return (s, (None, (s, self.host),
+return (s, (None, (s, self.host), self.user, self.passwd or ''))
-self.user, self.passwd or ''))
 def isabs(self):
 if self.scheme and self.scheme != 'file':
-return True # remote URL
+return True  # remote URL
 if hasdriveletter(self.path):
-return True # absolute for our purposes - can't be joined()
+return True  # absolute for our purposes - can't be joined()
 if self.path.startswith(br'\\'):
-return True # Windows UNC path
+return True  # Windows UNC path
 if self.path.startswith('/'):
-return True # POSIX-style
+return True  # POSIX-style
 return False
 def localpath(self):
 if self.scheme == 'file' or self.scheme == 'bundle':
 path = self.path or '/'
 # For Windows, we need to promote hosts containing drive
 # letters to paths with drive letters.
 if hasdriveletter(self._hostport):
 path = self._hostport + '/' + self.path
-elif (self.host is not None and self.path
+elif (
-and not hasdriveletter(path)):
+self.host is not None and self.path and not hasdriveletter(path)
+):
 path = '/' + path
 return path
 return self._origpath
 def islocal(self):
 '''whether localpath will return something that posixfile can open'''
-return (not self.scheme or self.scheme == 'file'
+return (
-or self.scheme == 'bundle')
+not self.scheme or self.scheme == 'file' or self.scheme == 'bundle'
+)
 def hasscheme(path):
 return bool(url(path).scheme)
 def hasdriveletter(path):
 return path and path[1:2] == ':' and path[0:1].isalpha()
 def urllocalpath(path):
 return url(path, parsequery=False, parsefragment=False).localpath()
 def checksafessh(path):
 """check if a path / url is a potentially unsafe ssh exploit (SEC)
 This is a sanity check for ssh urls. ssh will parse the first item as
 Raises an error.Abort when the url is unsafe.
 """
 path = urlreq.unquote(path)
 if path.startswith('ssh://-') or path.startswith('svn+ssh://-'):
-raise error.Abort(_('potentially unsafe url: %r') %
+raise error.Abort(
-(pycompat.bytestr(path),))
+_('potentially unsafe url: %r') % (pycompat.bytestr(path),)
+)
 def hidepassword(u):
 '''hide user credential in a url string'''
 u = url(u)
 if u.passwd:
 u.passwd = '***'
 return bytes(u)
 def removeauth(u):
 '''remove all authentication information from a url string'''
 u = url(u)
 u.user = u.passwd = None
 return bytes(u)
 timecount = unitcountfn(
 (1, 1e3, _('%.0f s')),
 (100, 1, _('%.1f s')),
 (10, 1, _('%.2f s')),
 (10, 0.000001, _('%.2f us')),
 (1, 0.000001, _('%.3f us')),
 (100, 0.000000001, _('%.1f ns')),
 (10, 0.000000001, _('%.2f ns')),
 (1, 0.000000001, _('%.3f ns')),
 )
 @attr.s
 class timedcmstats(object):
 """Stats information produced by the timedcm context manager on entering."""
 def __bytes__(self):
 return timecount(self.elapsed) if self.elapsed else '<unknown>'
 __str__ = encoding.strmethod(__bytes__)
 @contextlib.contextmanager
 def timedcm(whencefmt, *whenceargs):
 """A context manager that produces timing information for a given context.
 yield timing_stats
 finally:
 timing_stats.elapsed = timer() - timing_stats.start
 timedcm._nested -= 1
 timedcm._nested = 0
 def timed(func):
 '''Report the execution time of a function call to stderr.
 During development, use as a decorator when you need to measure
 def wrapper(*args, **kwargs):
 with timedcm(pycompat.bytestr(func.__name__)) as time_stats:
 result = func(*args, **kwargs)
 stderr = procutil.stderr
-stderr.write('%s%s: %s\n' % (
+stderr.write(
-' ' * time_stats.level * 2, pycompat.bytestr(func.__name__),
+'%s%s: %s\n'
-time_stats))
+% (
+' ' * time_stats.level * 2,
+pycompat.bytestr(func.__name__),
+time_stats,
+)
+)
 return result
 return wrapper
-_sizeunits = (('m', 2**20), ('k', 2**10), ('g', 2**30),
-('kb', 2**10), ('mb', 2**20), ('gb', 2**30), ('b', 1))
+_sizeunits = (
+('m', 2 ** 20),
+('k', 2 ** 10),
+('g', 2 ** 30),
+('kb', 2 ** 10),
+('mb', 2 ** 20),
+('gb', 2 ** 30),
+('b', 1),
+)
 def sizetoint(s):
 '''Convert a space specifier to a byte count.
 >>> sizetoint(b'30')
 '''
 t = s.strip().lower()
 try:
 for k, u in _sizeunits:
 if t.endswith(k):
-return int(float(t[:-len(k)]) * u)
+return int(float(t[: -len(k)]) * u)
 return int(t)
 except ValueError:
 raise error.ParseError(_("couldn't parse size: %s") % s)
 class hooks(object):
 '''A collection of hook functions that can be used to extend a
 function's behavior. Hooks are called in lexicographic order,
 based on the names of their sources.'''
 self._hooks.sort(key=lambda x: x[0])
 results = []
 for source, hook in self._hooks:
 results.append(hook(*args))
 return results
 def getstackframes(skip=0, line=' %-*s in %s\n', fileline='%s:%d', depth=0):
 '''Yields lines for a nicely formatted stacktrace.
 Skips the 'skip' last entries, then return the last 'depth' entries.
 Each file+linenumber is formatted according to fileline.
 filepath+linenumber,
 function
 Not be used in production code but very convenient while developing.
 '''
-entries = [(fileline % (pycompat.sysbytes(fn), ln), pycompat.sysbytes(func))
+entries = [
-for fn, ln, func, _text in traceback.extract_stack()[:-skip - 1]
+(fileline % (pycompat.sysbytes(fn), ln), pycompat.sysbytes(func))
-][-depth:]
+for fn, ln, func, _text in traceback.extract_stack()[: -skip - 1]
+][-depth:]
 if entries:
 fnmax = max(len(entry[0]) for entry in entries)
 for fnln, func in entries:
 if line is None:
 yield (fnmax, fnln, func)
 else:
 yield line % (fnmax, fnln, func)
-def debugstacktrace(msg='stacktrace', skip=0,
-f=procutil.stderr, otherf=procutil.stdout, depth=0):
+def debugstacktrace(
+msg='stacktrace', skip=0, f=procutil.stderr, otherf=procutil.stdout, depth=0
+):
 '''Writes a message to f (stderr) with a nicely formatted stacktrace.
 Skips the 'skip' entries closest to the call, then show 'depth' entries.
 By default it will flush stdout first.
 It can be used everywhere and intentionally does not require an ui object.
 Not be used in production code but very convenient while developing.
 f.write('%s at:\n' % msg.rstrip())
 for line in getstackframes(skip + 1, depth=depth):
 f.write(line)
 f.flush()
 class dirs(object):
 '''a multiset of directory names from a dirstate or manifest'''
 def __init__(self, map, skip=None):
 self._dirs = {}
 if isinstance(map, dict) and skip is not None:
 for f, s in map.iteritems():
 if s[0] != skip:
 addpath(f)
 elif skip is not None:
-raise error.ProgrammingError("skip character is only supported "
+raise error.ProgrammingError(
-"with a dict source")
+"skip character is only supported " "with a dict source"
+)
 else:
 for f in map:
 addpath(f)
 def addpath(self, path):
 return iter(self._dirs)
 def __contains__(self, d):
 return d in self._dirs
 if safehasattr(parsers, 'dirs'):
 dirs = parsers.dirs
 if rustdirs is not None:
 dirs = rustdirs
 def finddirs(path):
 pos = path.rfind('/')
 while pos != -1:
 yield path[:pos]
 yield ''
 # convenient shortcut
 dst = debugstacktrace
 def safename(f, tag, ctx, others=None):
 """
 Generate a name that it is safe to rename f to in the given context.
 for n in itertools.count(1):
 fn = '%s~%s~%s' % (f, tag, n)
 if fn not in ctx and fn not in others:
 return fn
 def readexactly(stream, n):
 '''read n bytes from stream.read and abort if less was available'''
 s = stream.read(n)
 if len(s) < n:
-raise error.Abort(_("stream ended unexpectedly"
+raise error.Abort(
-" (got %d bytes, expected %d)")
+_("stream ended unexpectedly" " (got %d bytes, expected %d)")
-% (len(s), n))
+% (len(s), n)
+)
 return s
 def uvarintencode(value):
 """Encode an unsigned integer value to a varint.
 A varint is a variable length integer of 1 or more bytes. Each byte
 Traceback (most recent call last):
 ...
 ProgrammingError: negative value for uvarint: -1
 """
 if value < 0:
-raise error.ProgrammingError('negative value for uvarint: %d'
+raise error.ProgrammingError('negative value for uvarint: %d' % value)
-% value)
+bits = value & 0x7F
-bits = value & 0x7f
 value >>= 7
 bytes = []
 while value:
 bytes.append(pycompat.bytechr(0x80 | bits))
-bits = value & 0x7f
+bits = value & 0x7F
 value >>= 7
 bytes.append(pycompat.bytechr(bits))
 return ''.join(bytes)
 def uvarintdecodestream(fh):
 """Decode an unsigned variable length integer from a stream.
 The passed argument is anything that has a ``.read(N)`` method.
 """
 result = 0
 shift = 0
 while True:
 byte = ord(readexactly(fh, 1))
-result |= ((byte & 0x7f) << shift)
+result |= (byte & 0x7F) << shift
 if not (byte & 0x80):
 return result
 shift += 7

Mercurial > hg

comparison mercurial/util.py @ 43076:2372284d9457