--- a/mercurial/win32.py	Sat Oct 05 10:29:34 2019 -0400
+++ b/mercurial/win32.py	Sun Oct 06 09:45:02 2019 -0400
@@ -55,21 +55,25 @@
     _WPARAM = ctypes.c_ulonglong
     _LPARAM = ctypes.c_longlong
 
+
 class _FILETIME(ctypes.Structure):
-    _fields_ = [(r'dwLowDateTime', _DWORD),
-                (r'dwHighDateTime', _DWORD)]
+    _fields_ = [(r'dwLowDateTime', _DWORD), (r'dwHighDateTime', _DWORD)]
+
 
 class _BY_HANDLE_FILE_INFORMATION(ctypes.Structure):
-    _fields_ = [(r'dwFileAttributes', _DWORD),
-                (r'ftCreationTime', _FILETIME),
-                (r'ftLastAccessTime', _FILETIME),
-                (r'ftLastWriteTime', _FILETIME),
-                (r'dwVolumeSerialNumber', _DWORD),
-                (r'nFileSizeHigh', _DWORD),
-                (r'nFileSizeLow', _DWORD),
-                (r'nNumberOfLinks', _DWORD),
-                (r'nFileIndexHigh', _DWORD),
-                (r'nFileIndexLow', _DWORD)]
+    _fields_ = [
+        (r'dwFileAttributes', _DWORD),
+        (r'ftCreationTime', _FILETIME),
+        (r'ftLastAccessTime', _FILETIME),
+        (r'ftLastWriteTime', _FILETIME),
+        (r'dwVolumeSerialNumber', _DWORD),
+        (r'nFileSizeHigh', _DWORD),
+        (r'nFileSizeLow', _DWORD),
+        (r'nNumberOfLinks', _DWORD),
+        (r'nFileIndexHigh', _DWORD),
+        (r'nFileIndexLow', _DWORD),
+    ]
+
 
 # CreateFile
 _FILE_SHARE_READ = 0x00000001
@@ -90,51 +94,65 @@
 # GetExitCodeProcess
 _STILL_ACTIVE = 259
 
+
 class _STARTUPINFO(ctypes.Structure):
-    _fields_ = [(r'cb', _DWORD),
-                (r'lpReserved', _LPSTR),
-                (r'lpDesktop', _LPSTR),
-                (r'lpTitle', _LPSTR),
-                (r'dwX', _DWORD),
-                (r'dwY', _DWORD),
-                (r'dwXSize', _DWORD),
-                (r'dwYSize', _DWORD),
-                (r'dwXCountChars', _DWORD),
-                (r'dwYCountChars', _DWORD),
-                (r'dwFillAttribute', _DWORD),
-                (r'dwFlags', _DWORD),
-                (r'wShowWindow', _WORD),
-                (r'cbReserved2', _WORD),
-                (r'lpReserved2', ctypes.c_char_p),
-                (r'hStdInput', _HANDLE),
-                (r'hStdOutput', _HANDLE),
-                (r'hStdError', _HANDLE)]
+    _fields_ = [
+        (r'cb', _DWORD),
+        (r'lpReserved', _LPSTR),
+        (r'lpDesktop', _LPSTR),
+        (r'lpTitle', _LPSTR),
+        (r'dwX', _DWORD),
+        (r'dwY', _DWORD),
+        (r'dwXSize', _DWORD),
+        (r'dwYSize', _DWORD),
+        (r'dwXCountChars', _DWORD),
+        (r'dwYCountChars', _DWORD),
+        (r'dwFillAttribute', _DWORD),
+        (r'dwFlags', _DWORD),
+        (r'wShowWindow', _WORD),
+        (r'cbReserved2', _WORD),
+        (r'lpReserved2', ctypes.c_char_p),
+        (r'hStdInput', _HANDLE),
+        (r'hStdOutput', _HANDLE),
+        (r'hStdError', _HANDLE),
+    ]
+
 
 class _PROCESS_INFORMATION(ctypes.Structure):
-    _fields_ = [(r'hProcess', _HANDLE),
-                (r'hThread', _HANDLE),
-                (r'dwProcessId', _DWORD),
-                (r'dwThreadId', _DWORD)]
+    _fields_ = [
+        (r'hProcess', _HANDLE),
+        (r'hThread', _HANDLE),
+        (r'dwProcessId', _DWORD),
+        (r'dwThreadId', _DWORD),
+    ]
+
 
 _CREATE_NO_WINDOW = 0x08000000
 _SW_HIDE = 0
 
+
 class _COORD(ctypes.Structure):
-    _fields_ = [(r'X', ctypes.c_short),
-                (r'Y', ctypes.c_short)]
+    _fields_ = [(r'X', ctypes.c_short), (r'Y', ctypes.c_short)]
+
 
 class _SMALL_RECT(ctypes.Structure):
-    _fields_ = [(r'Left', ctypes.c_short),
-                (r'Top', ctypes.c_short),
-                (r'Right', ctypes.c_short),
-                (r'Bottom', ctypes.c_short)]
+    _fields_ = [
+        (r'Left', ctypes.c_short),
+        (r'Top', ctypes.c_short),
+        (r'Right', ctypes.c_short),
+        (r'Bottom', ctypes.c_short),
+    ]
+
 
 class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
-    _fields_ = [(r'dwSize', _COORD),
-                (r'dwCursorPosition', _COORD),
-                (r'wAttributes', _WORD),
-                (r'srWindow', _SMALL_RECT),
-                (r'dwMaximumWindowSize', _COORD)]
+    _fields_ = [
+        (r'dwSize', _COORD),
+        (r'dwCursorPosition', _COORD),
+        (r'wAttributes', _WORD),
+        (r'srWindow', _SMALL_RECT),
+        (r'dwMaximumWindowSize', _COORD),
+    ]
+
 
 _STD_OUTPUT_HANDLE = _DWORD(-11).value
 _STD_ERROR_HANDLE = _DWORD(-12).value
@@ -150,11 +168,9 @@
 class CERT_CHAIN_CONTEXT(ctypes.Structure):
     _fields_ = (
         (r"cbSize", _DWORD),
-
         # CERT_TRUST_STATUS struct
         (r"dwErrorStatus", _DWORD),
         (r"dwInfoStatus", _DWORD),
-
         (r"cChain", _DWORD),
         (r"rgpChain", ctypes.c_void_p),
         (r"cLowerQualityChainContext", _DWORD),
@@ -163,15 +179,16 @@
         (r"dwRevocationFreshnessTime", _DWORD),
     )
 
+
 class CERT_USAGE_MATCH(ctypes.Structure):
     _fields_ = (
         (r"dwType", _DWORD),
-
-         # CERT_ENHKEY_USAGE struct
+        # CERT_ENHKEY_USAGE struct
         (r"cUsageIdentifier", _DWORD),
-        (r"rgpszUsageIdentifier", ctypes.c_void_p), # LPSTR *
+        (r"rgpszUsageIdentifier", ctypes.c_void_p),  # LPSTR *
     )
 
+
 class CERT_CHAIN_PARA(ctypes.Structure):
     _fields_ = (
         (r"cbSize", _DWORD),
@@ -180,35 +197,45 @@
         (r"dwUrlRetrievalTimeout", _DWORD),
         (r"fCheckRevocationFreshnessTime", _BOOL),
         (r"dwRevocationFreshnessTime", _DWORD),
-        (r"pftCacheResync", ctypes.c_void_p), # LPFILETIME
-        (r"pStrongSignPara", ctypes.c_void_p), # PCCERT_STRONG_SIGN_PARA
+        (r"pftCacheResync", ctypes.c_void_p),  # LPFILETIME
+        (r"pStrongSignPara", ctypes.c_void_p),  # PCCERT_STRONG_SIGN_PARA
         (r"dwStrongSignFlags", _DWORD),
     )
 
+
 # types of parameters of C functions used (required by pypy)
 
-_crypt32.CertCreateCertificateContext.argtypes = [_DWORD, # cert encoding
-                                                  ctypes.c_char_p, # cert
-                                                  _DWORD] # cert size
+_crypt32.CertCreateCertificateContext.argtypes = [
+    _DWORD,  # cert encoding
+    ctypes.c_char_p,  # cert
+    _DWORD,
+]  # cert size
 _crypt32.CertCreateCertificateContext.restype = _PCCERT_CONTEXT
 
 _crypt32.CertGetCertificateChain.argtypes = [
-        ctypes.c_void_p, # HCERTCHAINENGINE
-        _PCCERT_CONTEXT,
-        ctypes.c_void_p, # LPFILETIME
-        ctypes.c_void_p, # HCERTSTORE
-        ctypes.c_void_p, # PCERT_CHAIN_PARA
-        _DWORD,
-        ctypes.c_void_p, # LPVOID
-        ctypes.c_void_p  # PCCERT_CHAIN_CONTEXT *
-    ]
+    ctypes.c_void_p,  # HCERTCHAINENGINE
+    _PCCERT_CONTEXT,
+    ctypes.c_void_p,  # LPFILETIME
+    ctypes.c_void_p,  # HCERTSTORE
+    ctypes.c_void_p,  # PCERT_CHAIN_PARA
+    _DWORD,
+    ctypes.c_void_p,  # LPVOID
+    ctypes.c_void_p,  # PCCERT_CHAIN_CONTEXT *
+]
 _crypt32.CertGetCertificateChain.restype = _BOOL
 
 _crypt32.CertFreeCertificateContext.argtypes = [_PCCERT_CONTEXT]
 _crypt32.CertFreeCertificateContext.restype = _BOOL
 
-_kernel32.CreateFileA.argtypes = [_LPCSTR, _DWORD, _DWORD, ctypes.c_void_p,
-    _DWORD, _DWORD, _HANDLE]
+_kernel32.CreateFileA.argtypes = [
+    _LPCSTR,
+    _DWORD,
+    _DWORD,
+    ctypes.c_void_p,
+    _DWORD,
+    _DWORD,
+    _HANDLE,
+]
 _kernel32.CreateFileA.restype = _HANDLE
 
 _kernel32.GetFileInformationByHandle.argtypes = [_HANDLE, ctypes.c_void_p]
@@ -237,8 +264,16 @@
 _kernel32.GetDriveTypeA.argtypes = [_LPCSTR]
 _kernel32.GetDriveTypeA.restype = _UINT
 
-_kernel32.GetVolumeInformationA.argtypes = [_LPCSTR, ctypes.c_void_p, _DWORD,
-    ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, _DWORD]
+_kernel32.GetVolumeInformationA.argtypes = [
+    _LPCSTR,
+    ctypes.c_void_p,
+    _DWORD,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    _DWORD,
+]
 _kernel32.GetVolumeInformationA.restype = _BOOL
 
 _kernel32.GetVolumePathNameA.argtypes = [_LPCSTR, ctypes.c_void_p, _DWORD]
@@ -256,9 +291,18 @@
 _kernel32.GetModuleFileNameA.argtypes = [_HANDLE, ctypes.c_void_p, _DWORD]
 _kernel32.GetModuleFileNameA.restype = _DWORD
 
-_kernel32.CreateProcessA.argtypes = [_LPCSTR, _LPCSTR, ctypes.c_void_p,
-    ctypes.c_void_p, _BOOL, _DWORD, ctypes.c_void_p, _LPCSTR, ctypes.c_void_p,
-    ctypes.c_void_p]
+_kernel32.CreateProcessA.argtypes = [
+    _LPCSTR,
+    _LPCSTR,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    _BOOL,
+    _DWORD,
+    ctypes.c_void_p,
+    _LPCSTR,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+]
 _kernel32.CreateProcessA.restype = _BOOL
 
 _kernel32.ExitProcess.argtypes = [_UINT]
@@ -296,24 +340,39 @@
 _user32.EnumWindows.argtypes = [_WNDENUMPROC, _LPARAM]
 _user32.EnumWindows.restype = _BOOL
 
-_kernel32.PeekNamedPipe.argtypes = [_HANDLE, ctypes.c_void_p, _DWORD,
-    ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+_kernel32.PeekNamedPipe.argtypes = [
+    _HANDLE,
+    ctypes.c_void_p,
+    _DWORD,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+]
 _kernel32.PeekNamedPipe.restype = _BOOL
 
+
 def _raiseoserror(name):
     # Force the code to a signed int to avoid an 'int too large' error.
     # See https://bugs.python.org/issue28474
     code = _kernel32.GetLastError()
-    if code > 0x7fffffff:
-        code -= 2**32
+    if code > 0x7FFFFFFF:
+        code -= 2 ** 32
     err = ctypes.WinError(code=code)
-    raise OSError(err.errno, r'%s: %s' % (encoding.strfromlocal(name),
-                                          err.strerror))
+    raise OSError(
+        err.errno, r'%s: %s' % (encoding.strfromlocal(name), err.strerror)
+    )
+
 
 def _getfileinfo(name):
-    fh = _kernel32.CreateFileA(name, 0,
-            _FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE,
-            None, _OPEN_EXISTING, _FILE_FLAG_BACKUP_SEMANTICS, None)
+    fh = _kernel32.CreateFileA(
+        name,
+        0,
+        _FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE,
+        None,
+        _OPEN_EXISTING,
+        _FILE_FLAG_BACKUP_SEMANTICS,
+        None,
+    )
     if fh == _INVALID_HANDLE_VALUE:
         _raiseoserror(name)
     try:
@@ -324,6 +383,7 @@
     finally:
         _kernel32.CloseHandle(fh)
 
+
 def checkcertificatechain(cert, build=True):
     '''Tests the given certificate to see if there is a complete chain to a
        trusted root certificate.  As a side effect, missing certificates are
@@ -336,11 +396,13 @@
     chainctxptr = ctypes.POINTER(CERT_CHAIN_CONTEXT)
 
     pchainctx = chainctxptr()
-    chainpara = CERT_CHAIN_PARA(cbSize=ctypes.sizeof(CERT_CHAIN_PARA),
-                                RequestedUsage=CERT_USAGE_MATCH())
+    chainpara = CERT_CHAIN_PARA(
+        cbSize=ctypes.sizeof(CERT_CHAIN_PARA), RequestedUsage=CERT_USAGE_MATCH()
+    )
 
-    certctx = _crypt32.CertCreateCertificateContext(X509_ASN_ENCODING, cert,
-                                                    len(cert))
+    certctx = _crypt32.CertCreateCertificateContext(
+        X509_ASN_ENCODING, cert, len(cert)
+    )
     if certctx is None:
         _raiseoserror('CertCreateCertificateContext')
 
@@ -351,14 +413,16 @@
 
     try:
         # Building the certificate chain will update root certs as necessary.
-        if not _crypt32.CertGetCertificateChain(None,      # hChainEngine
-                                                certctx,   # pCertContext
-                                                None,      # pTime
-                                                None,      # hAdditionalStore
-                                                ctypes.byref(chainpara),
-                                                flags,
-                                                None,      # pvReserved
-                                                ctypes.byref(pchainctx)):
+        if not _crypt32.CertGetCertificateChain(
+            None,  # hChainEngine
+            certctx,  # pCertContext
+            None,  # pTime
+            None,  # hAdditionalStore
+            ctypes.byref(chainpara),
+            flags,
+            None,  # pvReserved
+            ctypes.byref(pchainctx),
+        ):
             _raiseoserror('CertGetCertificateChain')
 
         chainctx = pchainctx.contents
@@ -369,24 +433,30 @@
             _crypt32.CertFreeCertificateChain(pchainctx)
         _crypt32.CertFreeCertificateContext(certctx)
 
+
 def oslink(src, dst):
     try:
         if not _kernel32.CreateHardLinkA(dst, src, None):
             _raiseoserror(src)
-    except AttributeError: # Wine doesn't support this function
+    except AttributeError:  # Wine doesn't support this function
         _raiseoserror(src)
 
+
 def nlinks(name):
     '''return number of hardlinks for the given file'''
     return _getfileinfo(name).nNumberOfLinks
 
+
 def samefile(path1, path2):
     '''Returns whether path1 and path2 refer to the same file or directory.'''
     res1 = _getfileinfo(path1)
     res2 = _getfileinfo(path2)
-    return (res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber
+    return (
+        res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber
         and res1.nFileIndexHigh == res2.nFileIndexHigh
-        and res1.nFileIndexLow == res2.nFileIndexLow)
+        and res1.nFileIndexLow == res2.nFileIndexLow
+    )
+
 
 def samedevice(path1, path2):
     '''Returns whether path1 and path2 are on the same device.'''
@@ -394,12 +464,14 @@
     res2 = _getfileinfo(path2)
     return res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber
 
+
 def peekpipe(pipe):
     handle = msvcrt.get_osfhandle(pipe.fileno())
     avail = _DWORD()
 
-    if not _kernel32.PeekNamedPipe(handle, None, 0, None, ctypes.byref(avail),
-                                   None):
+    if not _kernel32.PeekNamedPipe(
+        handle, None, 0, None, ctypes.byref(avail), None
+    ):
         err = _kernel32.GetLastError()
         if err == _ERROR_BROKEN_PIPE:
             return 0
@@ -407,12 +479,14 @@
 
     return avail.value
 
+
 def lasterrorwaspipeerror(err):
     if err.errno != errno.EINVAL:
         return False
     err = _kernel32.GetLastError()
     return err == _ERROR_BROKEN_PIPE or err == _ERROR_NO_DATA
 
+
 def testpid(pid):
     '''return True if pid is still running or unable to
     determine, False otherwise'''
@@ -426,17 +500,19 @@
             _kernel32.CloseHandle(h)
     return _kernel32.GetLastError() != _ERROR_INVALID_PARAMETER
 
+
 def executablepath():
     '''return full path of hg.exe'''
     size = 600
     buf = ctypes.create_string_buffer(size + 1)
     len = _kernel32.GetModuleFileNameA(None, ctypes.byref(buf), size)
     if len == 0:
-        raise ctypes.WinError() # Note: WinError is a function
+        raise ctypes.WinError()  # Note: WinError is a function
     elif len == size:
         raise ctypes.WinError(_ERROR_INSUFFICIENT_BUFFER)
     return buf.value
 
+
 def getvolumename(path):
     """Get the mount point of the filesystem from a directory or file
     (best-effort)
@@ -452,10 +528,11 @@
     buf = ctypes.create_string_buffer(size)
 
     if not _kernel32.GetVolumePathNameA(realpath, ctypes.byref(buf), size):
-        raise ctypes.WinError() # Note: WinError is a function
+        raise ctypes.WinError()  # Note: WinError is a function
 
     return buf.value
 
+
 def getfstype(path):
     """Get the filesystem type name from a directory or file (best-effort)
 
@@ -467,19 +544,25 @@
 
     if t == _DRIVE_REMOTE:
         return 'cifs'
-    elif t not in (_DRIVE_REMOVABLE, _DRIVE_FIXED, _DRIVE_CDROM,
-                   _DRIVE_RAMDISK):
+    elif t not in (
+        _DRIVE_REMOVABLE,
+        _DRIVE_FIXED,
+        _DRIVE_CDROM,
+        _DRIVE_RAMDISK,
+    ):
         return None
 
     size = _MAX_PATH + 1
     name = ctypes.create_string_buffer(size)
 
-    if not _kernel32.GetVolumeInformationA(volume, None, 0, None, None, None,
-                                           ctypes.byref(name), size):
-        raise ctypes.WinError() # Note: WinError is a function
+    if not _kernel32.GetVolumeInformationA(
+        volume, None, 0, None, None, None, ctypes.byref(name), size
+    ):
+        raise ctypes.WinError()  # Note: WinError is a function
 
     return name.value
 
+
 def getuser():
     '''return name of current user'''
     size = _DWORD(300)
@@ -488,36 +571,40 @@
         raise ctypes.WinError()
     return buf.value
 
+
 _signalhandler = []
 
+
 def setsignalhandler():
     '''Register a termination handler for console events including
     CTRL+C. python signal handlers do not work well with socket
     operations.
     '''
+
     def handler(event):
         _kernel32.ExitProcess(1)
 
     if _signalhandler:
-        return # already registered
+        return  # already registered
     h = _SIGNAL_HANDLER(handler)
-    _signalhandler.append(h) # needed to prevent garbage collection
+    _signalhandler.append(h)  # needed to prevent garbage collection
     if not _kernel32.SetConsoleCtrlHandler(h, True):
         raise ctypes.WinError()
 
+
 def hidewindow():
-
     def callback(hwnd, pid):
         wpid = _DWORD()
         _user32.GetWindowThreadProcessId(hwnd, ctypes.byref(wpid))
         if pid == wpid.value:
             _user32.ShowWindow(hwnd, _SW_HIDE)
-            return False # stop enumerating windows
+            return False  # stop enumerating windows
         return True
 
     pid = _kernel32.GetCurrentProcessId()
     _user32.EnumWindows(_WNDENUMPROC(callback), pid)
 
+
 def termsize():
     # cmd.exe does not handle CR like a unix console, the CR is
     # counted in the line length. On 80 columns consoles, if 80
@@ -527,24 +614,27 @@
     height = 25
     # Query stderr to avoid problems with redirections
     screenbuf = _kernel32.GetStdHandle(
-                  _STD_ERROR_HANDLE) # don't close the handle returned
+        _STD_ERROR_HANDLE
+    )  # don't close the handle returned
     if screenbuf is None or screenbuf == _INVALID_HANDLE_VALUE:
         return width, height
     csbi = _CONSOLE_SCREEN_BUFFER_INFO()
-    if not _kernel32.GetConsoleScreenBufferInfo(
-                        screenbuf, ctypes.byref(csbi)):
+    if not _kernel32.GetConsoleScreenBufferInfo(screenbuf, ctypes.byref(csbi)):
         return width, height
     width = csbi.srWindow.Right - csbi.srWindow.Left  # don't '+ 1'
     height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1
     return width, height
 
+
 def enablevtmode():
     '''Enable virtual terminal mode for the associated console.  Return True if
     enabled, else False.'''
 
     ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4
 
-    handle = _kernel32.GetStdHandle(_STD_OUTPUT_HANDLE) # don't close the handle
+    handle = _kernel32.GetStdHandle(
+        _STD_OUTPUT_HANDLE
+    )  # don't close the handle
     if handle == _INVALID_HANDLE_VALUE:
         return False
 
@@ -561,6 +651,7 @@
 
     return True
 
+
 def spawndetached(args):
     # No standard library function really spawns a fully detached
     # process under win32 because they allocate pipes or other objects
@@ -583,8 +674,17 @@
 
     # TODO: CreateProcessW on py3?
     res = _kernel32.CreateProcessA(
-        None, encoding.strtolocal(args), None, None, False, _CREATE_NO_WINDOW,
-        env, encoding.getcwd(), ctypes.byref(si), ctypes.byref(pi))
+        None,
+        encoding.strtolocal(args),
+        None,
+        None,
+        False,
+        _CREATE_NO_WINDOW,
+        env,
+        encoding.getcwd(),
+        ctypes.byref(si),
+        ctypes.byref(pi),
+    )
     if not res:
         raise ctypes.WinError()
 
@@ -593,15 +693,18 @@
 
     return pi.dwProcessId
 
+
 def unlink(f):
     '''try to implement POSIX' unlink semantics on Windows'''
 
     if os.path.isdir(f):
         # use EPERM because it is POSIX prescribed value, even though
         # unlink(2) on directories returns EISDIR on Linux
-        raise IOError(errno.EPERM,
-                      r"Unlinking directory not permitted: '%s'"
-                      % encoding.strfromlocal(f))
+        raise IOError(
+            errno.EPERM,
+            r"Unlinking directory not permitted: '%s'"
+            % encoding.strfromlocal(f),
+        )
 
     # POSIX allows to unlink and rename open files. Windows has serious
     # problems with doing that:
@@ -621,7 +724,7 @@
     # implicit zombie filename blocking on a temporary name.
 
     for tries in pycompat.xrange(10):
-        temp = '%s-%08x' % (f, random.randint(0, 0xffffffff))
+        temp = '%s-%08x' % (f, random.randint(0, 0xFFFFFFFF))
         try:
             os.rename(f, temp)  # raises OSError EEXIST if temp exists
             break
@@ -646,6 +749,7 @@
             # leaving some potentially serious inconsistencies.
             pass
 
+
 def makedir(path, notindexed):
     os.mkdir(path)
     if notindexed: