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

equal deleted inserted replaced

-:81224afd938d
+:f15cb5111a1e
 umask = platform.umask
 unlink = platform.unlink
 username = platform.username
-def setumask(val):
+def setumask(val: int) -> None:
-# type: (int) -> None
 '''updates the umask. used by chg server'''
 if pycompat.iswindows:
 return
 os.umask(val)
 global umask
 if pycompat.ispypy:
 # PyPy runs slower with gc disabled
 nogc = lambda x: x
-def pathto(root, n1, n2):
+def pathto(root: bytes, n1: bytes, n2: bytes) -> bytes:
-# type: (bytes, bytes, bytes) -> bytes
 """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
 n2 should use "/" to separate directories
 returns an os.sep-separated path.
 b'lpt9',
 }
 _winreservedchars = b':*?"<>|'
-def checkwinfilename(path):
+def checkwinfilename(path: bytes) -> Optional[bytes]:
-# type: (bytes) -> Optional[bytes]
 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")
 >>> checkwinfilename(b"foo/bar/con.xml")
 ld = os.open(pathname, flags)
 os.write(ld, info)
 os.close(ld)
-def readlock(pathname):
+def readlock(pathname: bytes) -> bytes:
-# type: (bytes) -> bytes
 try:
 return readlink(pathname)
 except OSError as why:
 if why.errno not in (errno.EINVAL, errno.ENOSYS):
 raise
 # File system features
-def fscasesensitive(path):
+def fscasesensitive(path: bytes) -> bool:
-# type: (bytes) -> bool
 """
 Return true if the given path is on a case-sensitive filesystem
 Requires a path (like /foo/.hg) ending with a foldable final
 directory component.
 re = _re()
 _fspathcache = {}
-def fspath(name, root):
+def fspath(name: bytes, root: bytes) -> bytes:
-# type: (bytes, bytes) -> bytes
 """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
 dir = os.path.join(dir, part)
 return b''.join(result)
-def checknlink(testfile):
+def checknlink(testfile: bytes) -> bool:
-# type: (bytes) -> bool
 '''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
 os.unlink(f)
 except OSError:
 pass
-def endswithsep(path):
+def endswithsep(path: bytes) -> bool:
-# type: (bytes) -> bool
 '''Check path ends with os.sep or os.altsep.'''
 return bool(  # help pytype
 path.endswith(pycompat.ossep)
 or pycompat.osaltsep
 and path.endswith(pycompat.osaltsep)
 )
-def splitpath(path):
+def splitpath(path: bytes) -> List[bytes]:
-# type: (bytes) -> List[bytes]
 """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."""
 except OSError as e:
 if e.errno != errno.ENOENT and e.errno != errno.ENOTEMPTY:
 raise
-def unlinkpath(f, ignoremissing=False, rmdir=True):
+def unlinkpath(
-# type: (bytes, bool, bool) -> None
+f: bytes, ignoremissing: bool = False, rmdir: bool = True
+) -> None:
 """unlink and remove the directory if it is empty"""
 if ignoremissing:
 tryunlink(f)
 else:
 unlink(f)
 removedirs(os.path.dirname(f))
 except OSError:
 pass
-def tryunlink(f):
+def tryunlink(f: bytes) -> None:
-# type: (bytes) -> None
 """Attempt to remove a file, ignoring FileNotFoundError."""
 try:
 unlink(f)
 except FileNotFoundError:
 pass
-def makedirs(name, mode=None, notindexed=False):
+def makedirs(
-# type: (bytes, Optional[int], bool) -> None
+name: bytes, mode: Optional[int] = None, notindexed: bool = False
+) -> None:
 """recursive directory creation with parent mode inheritance
 Newly created directories are marked as "not to be indexed by
 the content indexing service", if ``notindexed`` is specified
 for "write" mode access.
 raise
 if mode is not None:
 os.chmod(name, mode)
-def readfile(path):
+def readfile(path: bytes) -> bytes:
-# type: (bytes) -> bytes
 with open(path, b'rb') as fp:
 return fp.read()
-def writefile(path, text):
+def writefile(path: bytes, text: bytes) -> None:
-# type: (bytes, bytes) -> None
 with open(path, b'wb') as fp:
 fp.write(text)
-def appendfile(path, text):
+def appendfile(path: bytes, text: bytes) -> None:
-# type: (bytes, bytes) -> None
 with open(path, b'ab') as fp:
 fp.write(text)
 class chunkbuffer:
 return unittable[-1][2] % count
 return go
-def processlinerange(fromline, toline):
+def processlinerange(fromline: int, toline: int) -> Tuple[int, int]:
-# type: (int, int) -> Tuple[int, int]
 """Check that linerange <fromline>:<toline> makes sense and return a
 0-based range.
 >>> processlinerange(10, 20)
 (9, 20)
 # 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):
+def tolf(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 return _eolre.sub(b'\n', s)
-def tocrlf(s):
+def tocrlf(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 return _eolre.sub(b'\r\n', s)
 def _crlfwriter(fp):
 return transformingwriter(fp, tocrlf)
 # TODO delete since workaround variant for Python 2 no longer needed.
 def iterfile(fp):
 return fp
-def iterlines(iterator):
+def iterlines(iterator: Iterable[bytes]) -> Iterator[bytes]:
-# type: (Iterable[bytes]) -> Iterator[bytes]
 for chunk in iterator:
 for line in chunk.splitlines():
 yield line
-def expandpath(path):
+def expandpath(path: bytes) -> bytes:
-# type: (bytes) -> bytes
 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.
 (b'gb', 2 ** 30),
 (b'b', 1),
 )
-def sizetoint(s):
+def sizetoint(s: bytes) -> int:
-# type: (bytes) -> int
 """Convert a space specifier to a byte count.
 >>> sizetoint(b'30')
 30
 >>> sizetoint(b'2.2kb')
 locale.setlocale(locale.LC_CTYPE, oldloc)
 else:
 yield
-def _estimatememory():
+def _estimatememory() -> Optional[int]:
-# type: () -> Optional[int]
 """Provide an estimate for the available system memory in Bytes.
 If no estimate can be provided on the platform, returns None.
 """
 if pycompat.sysplatform.startswith(b'win'):

changeset 51284	f15cb5111a1e
parent 51282	9d3721552b6c
child 51291	7d3b92e8df13