mercurial: comparison mercurial/util.py

equal deleted inserted replaced

-:e8ea403b1c46
+:288de6f5d724
 This contains helper routines that are independent of the SCM core and
 hide platform-specific details from the core.
 """
-from __future__ import absolute_import, print_function
 import abc
 import collections
 import contextlib
 import errno
 import gc
 import hashlib
+import io
 import itertools
 import locale
 import mmap
 import os
-import platform as pyplatform
+import pickle  # provides util.pickle symbol
 import re as remod
 import shutil
 import stat
 import sys
 import time
 delattr,
 getattr,
 open,
 setattr,
 )
-from .node import hex
 from hgdemandimport import tracing
 from . import (
 encoding,
 error,
 i18n,
 b85decode = base85.b85decode
 b85encode = base85.b85encode
 cookielib = pycompat.cookielib
 httplib = pycompat.httplib
-pickle = pycompat.pickle
 safehasattr = pycompat.safehasattr
 socketserver = pycompat.socketserver
-bytesio = pycompat.bytesio
+bytesio = io.BytesIO
 # TODO deprecate stringio name, as it is a lie on Python 3.
 stringio = bytesio
 xmlrpclib = pycompat.xmlrpclib
 httpserver = urllibcompat.httpserver
 # small compat layer
 compengines = compression.compengines
 SERVERROLE = compression.SERVERROLE
 CLIENTROLE = compression.CLIENTROLE
-try:
-recvfds = osutil.recvfds
-except AttributeError:
-pass
 # Python compatibility
 _notset = object()
 # we cannot set 'mercurial' and have it match eg: 'mercurial.scmutil'. This
 # makes the whole PYTHONWARNINGS thing useless for our usecase.
 warnings.filterwarnings('default', '', DeprecationWarning, 'mercurial')
 warnings.filterwarnings('default', '', DeprecationWarning, 'hgext')
 warnings.filterwarnings('default', '', DeprecationWarning, 'hgext3rd')
-if _dowarn and pycompat.ispy3:
+if _dowarn:
 # silence warning emitted by passing user string to re.sub()
 warnings.filterwarnings(
 'ignore', 'bad escape', DeprecationWarning, 'mercurial'
 )
 warnings.filterwarnings(
 for k in DIGESTS_BY_STRENGTH:
 assert k in DIGESTS
-class digester(object):
+class digester:
 """helper to compute digests.
 This helper can be used to compute one or more digests given their name.
 >>> d = digester([b'md5', b'sha1'])
 if k in supported:
 return k
 return None
-class digestchecker(object):
+class digestchecker:
 """file handle wrapper that additionally checks content against a given
 size and digests.
 d = digestchecker(fh, size, {'md5': '...'})
 _chunksize = 4096
-class bufferedinputpipe(object):
+class bufferedinputpipe:
 """a manually buffered input pipe
 Python will not let us use buffered IO and lazy reading with 'polling' at
 the same time. We cannot probe the buffer state and select will not detect
 that data are ready to read if they are already buffered.
 if os.fstat(fd).st_size == 0:
 return b''
 raise
-class fileobjectproxy(object):
+class fileobjectproxy:
 """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.
 """
 'gettimeout',
 'setsockopt',
 }
-class socketproxy(object):
+class socketproxy:
 """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
 return object.__getattribute__(self, '_observedcall')(
 'setsockopt', *args, **kwargs
 )
-class baseproxyobserver(object):
+class baseproxyobserver:
 def __init__(self, fh, name, logdata, logdataapis):
 self.fh = fh
 self.name = name
 self.logdata = logdata
 self.logdataapis = logdataapis
 return cache[args]
 return f
-class cow(object):
+class cow:
 """helper class to make copy-on-write easier
 Call preparewrite before doing any writes.
 """
 if pycompat.ispypy:
 # __setitem__() isn't called as of PyPy 5.8.0
 def update(self, src, **f):
 if isinstance(src, dict):
-src = pycompat.iteritems(src)
+src = src.items()
 for k, v in src:
 self[k] = v
 for k in f:
 self[k] = f[k]
 Be sure to call d = d.preparewrite() before writing to d.
 """
-class transactional(object):  # pytype: disable=ignored-metaclass
+class transactional:  # pytype: disable=ignored-metaclass
 """Base class for making a transactional type into a context manager."""
 __metaclass__ = abc.ABCMeta
 @abc.abstractmethod
 @contextlib.contextmanager
 def nullcontextmanager(enter_result=None):
 yield enter_result
-class _lrucachenode(object):
+class _lrucachenode:
 """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.
 """
 self.key = _notset
 self.value = None
 self.cost = 0
-class lrucachedict(object):
+class lrucachedict:
 """Dict that caches most recent accesses and sets.
 The dict consists of an actual backing dict - indexed by original
 key - and a doubly linked circular list defining the order of entries in
 the cache.
 return cache[args]
 return f
-class propertycache(object):
+class propertycache:
 def __init__(self, func):
 self.func = func
 self.name = func.__name__
 def __get__(self, obj, type=None):
 _re2 = None
 except ImportError:
 _re2 = False
-class _re(object):
+class _re:
 def _checkre2(self):
 global _re2
 global _re2_input
 check_pattern = br'\[([^\[]+)\]'
 pass
 raise
 return temp
-class filestat(object):
+class filestat:
 """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.
 @classmethod
 def frompath(cls, path):
 try:
 stat = os.stat(path)
-except OSError as err:
+except FileNotFoundError:
-if err.errno != errno.ENOENT:
-raise
 stat = None
 return cls(stat)
 @classmethod
 def fromfp(cls, fp):
 Otherwise, this returns True, as "ambiguity is avoided".
 """
 advanced = (old.stat[stat.ST_MTIME] + 1) & 0x7FFFFFFF
 try:
 os.utime(path, (advanced, advanced))
-except OSError as inst:
+except PermissionError:
-if inst.errno == errno.EPERM:
+# utime() on the file created by another user causes EPERM,
-# utime() on the file created by another user causes EPERM,
+# if a process doesn't have appropriate privileges
-# if a process doesn't have appropriate privileges
+return False
-return False
-raise
 return True
 def __ne__(self, other):
 return not self == other
-class atomictempfile(object):
+class atomictempfile:
 """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
 the temporary copy to the original name, making the changes
 self.discard()
 else:
 self.close()
+def tryrmdir(f):
+try:
+removedirs(f)
+except OSError as e:
+if e.errno != errno.ENOENT and e.errno != errno.ENOTEMPTY:
+raise
 def unlinkpath(f, ignoremissing=False, rmdir=True):
 # type: (bytes, bool, bool) -> None
 """unlink and remove the directory if it is empty"""
 if ignoremissing:
 tryunlink(f)
 pass
 def tryunlink(f):
 # type: (bytes) -> None
-"""Attempt to remove a file, ignoring ENOENT errors."""
+"""Attempt to remove a file, ignoring FileNotFoundError."""
 try:
 unlink(f)
-except OSError as e:
+except FileNotFoundError:
-if e.errno != errno.ENOENT:
+pass
-raise
 def makedirs(name, mode=None, notindexed=False):
 # type: (bytes, Optional[int], bool) -> None
 """recursive directory creation with parent mode inheritance
 # type: (bytes, bytes) -> None
 with open(path, b'ab') as fp:
 fp.write(text)
-class chunkbuffer(object):
+class chunkbuffer:
 """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."""
 if limit:
 limit -= len(s)
 yield s
-class cappedreader(object):
+class cappedreader:
 """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
 limit are treated as EOF.
 (1, 1 << 10, _(b'%.2f KB')),
 (1, 1, _(b'%.0f bytes')),
 )
-class transformingwriter(object):
+class transformingwriter:
 """Writable file wrapper to transform data by function"""
 def __init__(self, fp, encode):
 self._fp = fp
 self._encode = encode
 else:
 tonativeeol = pycompat.identity
 fromnativeeol = pycompat.identity
 nativeeolwriter = pycompat.identity
-if pyplatform.python_implementation() == b'CPython' and sys.version_info < (
-3,
+# TODO delete since workaround variant for Python 2 no longer needed.
-0,
+def iterfile(fp):
-):
+return fp
-# 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
-#   --------------------------------------------------
-#    fp.__iter__ | buggy   | buggy           | okay
-#    fp.read*    | buggy   | okay [1]        | okay
-#
-# [1]: fixed by changeset 67dc99a989cd in the cpython hg repo.
-#
-# Here we workaround the EINTR issue for fileobj.__iter__. Other methods
-# like "read*" work fine, as we do not support Python < 2.7.4.
-#
-# Although we can workaround the EINTR issue for fp.__iter__, it is slower:
-# "for x in fp" is 4x faster than "for x in iter(fp.readline, '')" in
-# CPython 2, because CPython 2 maintains an internal readahead buffer for
-# fp.__iter__ but not other fp.read* methods.
-#
-# On modern systems like Linux, the "read" syscall cannot be interrupted
-# when reading "fast" files like on-disk files. So the EINTR issue only
-# affects things like pipes, sockets, ttys etc. We treat "normal" (S_ISREG)
-# files approximately as "fast" files and use the fast (unsafe) code path,
-# to minimize the performance impact.
-def iterfile(fp):
-fastpath = True
-if type(fp) is file:
-fastpath = stat.S_ISREG(os.fstat(fp.fileno()).st_mode)
-if fastpath:
-return fp
-else:
-# fp.readline deals with EINTR correctly, use it as a workaround.
-return iter(fp.readline, b'')
-else:
-# PyPy and CPython 3 do not have the EINTR issue thus no workaround needed.
-def iterfile(fp):
-return fp
 def iterlines(iterator):
 # type: (Iterator[bytes]) -> Iterator[bytes]
 for chunk in iterator:
 (1, 0.000000001, _(b'%.3f ns')),
 )
 @attr.s
-class timedcmstats(object):
+class timedcmstats:
 """Stats information produced by the timedcm context manager on entering."""
 # the starting value of the timer as a float (meaning and resulution is
 # platform dependent, see util.timer)
 start = attr.ib(default=attr.Factory(lambda: timer()))
 return int(t)
 except ValueError:
 raise error.ParseError(_(b"couldn't parse size: %s") % s)
-class hooks(object):
+class hooks:
 """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."""
 def __init__(self):

branch	stable
changeset 49366	288de6f5d724
parent 49308	d2adebe35635
child 49572	c4f07a011714