tests broken on Windows

[skshetry]

Some tests on Windows are failing with gitpython backend with permission errors with how it keeps .git/index file descriptor open.

https://github.com/iterative/scmrepo/runs/4759236148?check_suite_focus=true#step:6:857

This was introduced on gitpython-developers/GitPython@d79d20d with v3.1.25. See gitpython-developers/GitPython#1391.

Need to investigate further if it's only the tests, and how it impacts us.

[skshetry]

Traceback:

Expand

================================== FAILURES ===================================
_____________ test_commit_in_root_repo_with_submodule[gitpython] ______________

tmp_dir = TmpDir('C:/Users/runneradmin/AppData/Local/Temp/pytest-of-runneradmin/pytest-0/test_commit_in_root_repo_with_0')
scm = Git: 'C:\Users\runneradmin\AppData\Local\Temp\pytest-of-runneradmin\pytest-0\test_commit_in_root_repo_with_0\.git'
git = Git: 'C:\Users\runneradmin\AppData\Local\Temp\pytest-of-runneradmin\pytest-0\test_commit_in_root_repo_with_0\.git'
submodule_dir = TmpDir('C:/Users/runneradmin/AppData/Local/Temp/pytest-of-runneradmin/pytest-0/test_commit_in_root_repo_with_0/subrepo')

    @pytest.mark.skip_git_backend("pygit2")
    def test_commit_in_root_repo_with_submodule(
        tmp_dir: TmpDir, scm: Git, git: Git, submodule_dir: TmpDir
    ):
        tmp_dir.gen("foo", "foo")
>       git.add(["foo"])

D:\a\scmrepo\scmrepo\tests\test_git.py:95: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
D:\a\scmrepo\scmrepo\scmrepo\git\__init__.py:253: in _backend_func
    return func(*args, **kwargs)
D:\a\scmrepo\scmrepo\scmrepo\git\backend\gitpython.py:239: in add
    self.repo.index.add(paths)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\base.py:823: in add
    self.write(ignore_extension_data=not write_extension_data)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\base.py:221: in write
    lfd.commit()
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\gitdb\util.py:359: in commit
    self._end_writing(successful=True)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\gitdb\util.py:384: in _end_writing
    remove(self._filepath)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\gitdb\util.py:83: in remove
    return _retry(os.remove, *args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

func = <built-in function remove>
args = ('C:\\Users\\runneradmin\\AppData\\Local\\Temp\\pytest-of-runneradmin\\pytest-0\\test_commit_in_root_repo_with_0\\.git\\index',)
kwargs = {}, _ = 9

    def _retry(func, *args, **kwargs):
        # Wrapper around functions, that are problematic on "Windows". Sometimes
        # the OS or someone else has still a handle to the file
        if sys.platform == "win32":
            for _ in range(10):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    time.sleep(0.1)
>           return func(*args, **kwargs)
E           PermissionError: [WinError 32] The process cannot access the file because it is being used by another process: 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\pytest-of-runneradmin\\pytest-0\\test_commit_in_root_repo_with_0\\.git\\index'

D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\gitdb\util.py:77: PermissionError
_______________________ test_is_tracked_func[gitpython] _______________________

tmp_dir = TmpDir('C:/Users/runneradmin/AppData/Local/Temp/pytest-of-runneradmin/pytest-0/test_is_tracked_func_gitpython0')
scm = Git: 'C:\Users\runneradmin\AppData\Local\Temp\pytest-of-runneradmin\pytest-0\test_is_tracked_func_gitpython0\.git'
git = Git: 'C:\Users\runneradmin\AppData\Local\Temp\pytest-of-runneradmin\pytest-0\test_is_tracked_func_gitpython0\.git'

    @pytest.mark.skip_git_backend("pygit2")
    def test_is_tracked_func(tmp_dir, scm, git):
        tmp_dir.gen({"foo": "foo", "\u0442\u0435\u0441\u0442": "\u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0430"})
        scm.add(["foo", "\u0442\u0435\u0441\u0442"])
    
        abs_foo = os.path.abspath("foo")
        assert git.is_tracked(abs_foo)
        assert git.is_tracked("foo")
        assert git.is_tracked("\u0442\u0435\u0441\u0442")
    
        git.commit("add")
        assert git.is_tracked(abs_foo)
        assert git.is_tracked("foo")
    
>       scm.gitpython.repo.index.remove(["foo"], working_tree=True)

D:\a\scmrepo\scmrepo\tests\test_git.py:214: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\util.py:70: in post_clear_cache_if_not_raised
    rval = func(self, *args, **kwargs)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\util.py:88: in check_default_index
    return func(self, *args, **kwargs)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\base.py:893: in remove
    removed_paths = self.repo.git.rm(args, paths, **kwargs).splitlines()
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\cmd.py:638: in <lambda>
    return lambda *args, **kwargs: self._call_process(name, *args, **kwargs)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\cmd.py:1183: in _call_process
    return self.execute(call, **exec_kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <git.cmd.Git object at 0x0000017E458A74C8>
command = ['git', 'rm', '--', 'foo'], istream = None
with_extended_output = False, with_exceptions = True, as_process = False
output_stream = None, stdout_as_string = True, kill_after_timeout = None
with_stdout = True, universal_newlines = False, shell = None
env = {'ALLUSERSPROFILE': 'C:\\ProgramData', 'ANDROID_HOME': 'C:\\Android\\android-sdk', 'ANDROID_NDK_HOME': 'C:\\Android\\android-sdk\\ndk-bundle', 'ANDROID_NDK_LATEST_HOME': 'C:\\Android\\android-sdk\\ndk\\23.1.7779620', ...}
max_chunk_size = 8192, subprocess_kwargs = {}
redacted_command = ['git', 'rm', '--', 'foo']
cwd = 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\pytest-of-runneradmin\\pytest-0\\test_is_tracked_func_gitpython0'
inline_env = None, cmd_not_found_exception = <class 'OSError'>, stdout_sink = -1
istream_ok = 'None', proc = <subprocess.Popen object at 0x0000017E45A64AC8>

    def execute(self,
                command: Union[str, Sequence[Any]],
                istream: Union[None, BinaryIO] = None,
                with_extended_output: bool = False,
                with_exceptions: bool = True,
                as_process: bool = False,
                output_stream: Union[None, BinaryIO] = None,
                stdout_as_string: bool = True,
                kill_after_timeout: Union[None, float] = None,
                with_stdout: bool = True,
                universal_newlines: bool = False,
                shell: Union[None, bool] = None,
                env: Union[None, Mapping[str, str]] = None,
                max_chunk_size: int = io.DEFAULT_BUFFER_SIZE,
                **subprocess_kwargs: Any
                ) -> Union[str, bytes, Tuple[int, Union[str, bytes], str], AutoInterrupt]:
        """Handles executing the command on the shell and consumes and returns
        the returned information (stdout)
    
        :param command:
            The command argument list to execute.
            It should be a string, or a sequence of program arguments. The
            program to execute is the first item in the args sequence or string.
    
        :param istream:
            Standard input filehandle passed to subprocess.Popen.
    
        :param with_extended_output:
            Whether to return a (status, stdout, stderr) tuple.
    
        :param with_exceptions:
            Whether to raise an exception when git returns a non-zero status.
    
        :param as_process:
            Whether to return the created process instance directly from which
            streams can be read on demand. This will render with_extended_output and
            with_exceptions ineffective - the caller will have
            to deal with the details himself.
            It is important to note that the process will be placed into an AutoInterrupt
            wrapper that will interrupt the process once it goes out of scope. If you
            use the command in iterators, you should pass the whole process instance
            instead of a single stream.
    
        :param output_stream:
            If set to a file-like object, data produced by the git command will be
            output to the given stream directly.
            This feature only has any effect if as_process is False. Processes will
            always be created with a pipe due to issues with subprocess.
            This merely is a workaround as data will be copied from the
            output pipe to the given output stream directly.
            Judging from the implementation, you shouldn't use this flag !
    
        :param stdout_as_string:
            if False, the commands standard output will be bytes. Otherwise, it will be
            decoded into a string using the default encoding (usually utf-8).
            The latter can fail, if the output contains binary data.
    
        :param env:
            A dictionary of environment variables to be passed to `subprocess.Popen`.
    
        :param max_chunk_size:
            Maximum number of bytes in one chunk of data passed to the output_stream in
            one invocation of write() method. If the given number is not positive then
            the default value is used.
    
        :param subprocess_kwargs:
            Keyword arguments to be passed to subprocess.Popen. Please note that
            some of the valid kwargs are already set by this method, the ones you
            specify may not be the same ones.
    
        :param with_stdout: If True, default True, we open stdout on the created process
        :param universal_newlines:
            if True, pipes will be opened as text, and lines are split at
            all known line endings.
        :param shell:
            Whether to invoke commands through a shell (see `Popen(..., shell=True)`).
            It overrides :attr:`USE_SHELL` if it is not `None`.
        :param kill_after_timeout:
            To specify a timeout in seconds for the git command, after which the process
            should be killed. This will have no effect if as_process is set to True. It is
            set to None by default and will let the process run until the timeout is
            explicitly specified. This feature is not supported on Windows. It's also worth
            noting that kill_after_timeout uses SIGKILL, which can have negative side
            effects on a repository. For example, stale locks in case of git gc could
            render the repository incapable of accepting changes until the lock is manually
            removed.
    
        :return:
            * str(output) if extended_output = False (Default)
            * tuple(int(status), str(stdout), str(stderr)) if extended_output = True
    
            if output_stream is True, the stdout value will be your output stream:
            * output_stream if extended_output = False
            * tuple(int(status), output_stream, str(stderr)) if extended_output = True
    
            Note git is executed with LC_MESSAGES="C" to ensure consistent
            output regardless of system language.
    
        :raise GitCommandError:
    
        :note:
           If you add additional keyword arguments to the signature of this method,
           you must update the execute_kwargs tuple housed in this module."""
        # Remove password for the command if present
        redacted_command = remove_password_if_present(command)
        if self.GIT_PYTHON_TRACE and (self.GIT_PYTHON_TRACE != 'full' or as_process):
            log.info(' '.join(redacted_command))
    
        # Allow the user to have the command executed in their working dir.
        try:
            cwd = self._working_dir or os.getcwd()  # type: Union[None, str]
            if not os.access(str(cwd), os.X_OK):
                cwd = None
        except FileNotFoundError:
            cwd = None
    
        # Start the process
        inline_env = env
        env = os.environ.copy()
        # Attempt to force all output to plain ascii english, which is what some parsing code
        # may expect.
        # According to stackoverflow (http://goo.gl/l74GC8), we are setting LANGUAGE as well
        # just to be sure.
        env["LANGUAGE"] = "C"
        env["LC_ALL"] = "C"
        env.update(self._environment)
        if inline_env is not None:
            env.update(inline_env)
    
        if is_win:
            cmd_not_found_exception = OSError
            if kill_after_timeout is not None:
                raise GitCommandError(redacted_command, '"kill_after_timeout" feature is not supported on Windows.')
        else:
            cmd_not_found_exception = FileNotFoundError  # NOQA # exists, flake8 unknown @UndefinedVariable
        # end handle
    
        stdout_sink = (PIPE
                       if with_stdout
                       else getattr(subprocess, 'DEVNULL', None) or open(os.devnull, 'wb'))
        istream_ok = "None"
        if istream:
            istream_ok = "<valid stream>"
        log.debug("Popen(%s, cwd=%s, universal_newlines=%s, shell=%s, istream=%s)",
                  redacted_command, cwd, universal_newlines, shell, istream_ok)
        try:
            proc = Popen(command,
                         env=env,
                         cwd=cwd,
                         bufsize=-1,
                         stdin=istream,
                         stderr=PIPE,
                         stdout=stdout_sink,
                         shell=shell is not None and shell or self.USE_SHELL,
                         close_fds=is_posix,  # unsupported on windows
                         universal_newlines=universal_newlines,
                         creationflags=PROC_CREATIONFLAGS,
                         **subprocess_kwargs
                         )
    
        except cmd_not_found_exception as err:
            raise GitCommandNotFound(redacted_command, err) from err
        else:
            # replace with a typeguard for Popen[bytes]?
            proc.stdout = cast(BinaryIO, proc.stdout)
            proc.stderr = cast(BinaryIO, proc.stderr)
    
        if as_process:
            return self.AutoInterrupt(proc, command)
    
        def _kill_process(pid: int) -> None:
            """ Callback method to kill a process. """
            p = Popen(['ps', '--ppid', str(pid)], stdout=PIPE,
                      creationflags=PROC_CREATIONFLAGS)
            child_pids = []
            if p.stdout is not None:
                for line in p.stdout:
                    if len(line.split()) > 0:
                        local_pid = (line.split())[0]
                        if local_pid.isdigit():
                            child_pids.append(int(local_pid))
            try:
                # Windows does not have SIGKILL, so use SIGTERM instead
                sig = getattr(signal, 'SIGKILL', signal.SIGTERM)
                os.kill(pid, sig)
                for child_pid in child_pids:
                    try:
                        os.kill(child_pid, sig)
                    except OSError:
                        pass
                kill_check.set()    # tell the main routine that the process was killed
            except OSError:
                # It is possible that the process gets completed in the duration after timeout
                # happens and before we try to kill the process.
                pass
            return
        # end
    
        if kill_after_timeout is not None:
            kill_check = threading.Event()
            watchdog = threading.Timer(kill_after_timeout, _kill_process, args=(proc.pid,))
    
        # Wait for the process to return
        status = 0
        stdout_value: Union[str, bytes] = b''
        stderr_value: Union[str, bytes] = b''
        newline = "\n" if universal_newlines else b"\n"
        try:
            if output_stream is None:
                if kill_after_timeout is not None:
                    watchdog.start()
                stdout_value, stderr_value = proc.communicate()
                if kill_after_timeout is not None:
                    watchdog.cancel()
                    if kill_check.is_set():
                        stderr_value = ('Timeout: the command "%s" did not complete in %d '
                                        'secs.' % (" ".join(redacted_command), kill_after_timeout))
                        if not universal_newlines:
                            stderr_value = stderr_value.encode(defenc)
                # strip trailing "\n"
                if stdout_value.endswith(newline):  # type: ignore
                    stdout_value = stdout_value[:-1]
                if stderr_value.endswith(newline):  # type: ignore
                    stderr_value = stderr_value[:-1]
    
                status = proc.returncode
            else:
                max_chunk_size = max_chunk_size if max_chunk_size and max_chunk_size > 0 else io.DEFAULT_BUFFER_SIZE
                stream_copy(proc.stdout, output_stream, max_chunk_size)
                stdout_value = proc.stdout.read()
                stderr_value = proc.stderr.read()
                # strip trailing "\n"
                if stderr_value.endswith(newline):   # type: ignore
                    stderr_value = stderr_value[:-1]
                status = proc.wait()
            # END stdout handling
        finally:
            proc.stdout.close()
            proc.stderr.close()
    
        if self.GIT_PYTHON_TRACE == 'full':
            cmdstr = " ".join(redacted_command)
    
            def as_text(stdout_value: Union[bytes, str]) -> str:
                return not output_stream and safe_decode(stdout_value) or '<OUTPUT_STREAM>'
            # end
    
            if stderr_value:
                log.info("%s -> %d; stdout: '%s'; stderr: '%s'",
                         cmdstr, status, as_text(stdout_value), safe_decode(stderr_value))
            elif stdout_value:
                log.info("%s -> %d; stdout: '%s'", cmdstr, status, as_text(stdout_value))
            else:
                log.info("%s -> %d", cmdstr, status)
        # END handle debug printing
    
        if with_exceptions and status != 0:
>           raise GitCommandError(redacted_command, status, stderr_value, stdout_value)
E           git.exc.GitCommandError: Cmd('git') failed due to: exit code(128)
E             cmdline: git rm -- foo
E             stdout: 'rm 'foo''
E             stderr: 'fatal: Unable to write new index file'

D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\cmd.py:983: GitCommandError
_______________________ test_checkout_index[gitpython] ________________________

self = <git.index.base.IndexFile object at 0x0000017E45A6DEF8>
paths = ['foo', 'dir/baz'], force = True
fprogress = <function IndexFile.<lambda> at 0x0000017E451F5948>
kwargs = {'as_process': True, 'istream': -1}
handle_stderr = <function IndexFile.checkout.<locals>.handle_stderr at 0x0000017E4597AE58>
make_exc = <function IndexFile.checkout.<locals>.<lambda> at 0x0000017E457D1A68>
checked_out_files = ['foo', 'dir/baz'], path = 'dir/baz', co_path = 'dir/baz'
path_is_directory = False

    @ default_index
    def checkout(self, paths: Union[None, Iterable[PathLike]] = None, force: bool = False,
                 fprogress: Callable = lambda *args: None, **kwargs: Any
                 ) -> Union[None, Iterator[PathLike], Sequence[PathLike]]:
        """Checkout the given paths or all files from the version known to the index into
        the working tree.
    
        :note: Be sure you have written pending changes using the ``write`` method
            in case you have altered the enties dictionary directly
    
        :param paths:
            If None, all paths in the index will be checked out. Otherwise an iterable
            of relative or absolute paths or a single path pointing to files or directories
            in the index is expected.
    
        :param force:
            If True, existing files will be overwritten even if they contain local modifications.
            If False, these will trigger a CheckoutError.
    
        :param fprogress:
            see :func:`IndexFile.add` for signature and explanation.
            The provided progress information will contain None as path and item if no
            explicit paths are given. Otherwise progress information will be send
            prior and after a file has been checked out
    
        :param kwargs:
            Additional arguments to be passed to git-checkout-index
    
        :return:
            iterable yielding paths to files which have been checked out and are
            guaranteed to match the version stored in the index
    
        :raise exc.CheckoutError:
            If at least one file failed to be checked out. This is a summary,
            hence it will checkout as many files as it can anyway.
            If one of files or directories do not exist in the index
            ( as opposed to the  original git command who ignores them ).
            Raise GitCommandError if error lines could not be parsed - this truly is
            an exceptional state
    
        .. note:: The checkout is limited to checking out the files in the
            index. Files which are not in the index anymore and exist in
            the working tree will not be deleted. This behaviour is fundamentally
            different to *head.checkout*, i.e. if you want git-checkout like behaviour,
            use head.checkout instead of index.checkout.
            """
        args = ["--index"]
        if force:
            args.append("--force")
    
        failed_files = []
        failed_reasons = []
        unknown_lines = []
    
        def handle_stderr(proc: 'Popen[bytes]', iter_checked_out_files: Iterable[PathLike]) -> None:
    
            stderr_IO = proc.stderr
            if not stderr_IO:
                return None  # return early if stderr empty
            else:
                stderr_bytes = stderr_IO.read()
            # line contents:
            stderr = stderr_bytes.decode(defenc)
            # git-checkout-index: this already exists
            endings = (' already exists', ' is not in the cache', ' does not exist at stage', ' is unmerged')
            for line in stderr.splitlines():
                if not line.startswith("git checkout-index: ") and not line.startswith("git-checkout-index: "):
                    is_a_dir = " is a directory"
                    unlink_issue = "unable to unlink old '"
                    already_exists_issue = ' already exists, no checkout'   # created by entry.c:checkout_entry(...)
                    if line.endswith(is_a_dir):
                        failed_files.append(line[:-len(is_a_dir)])
                        failed_reasons.append(is_a_dir)
                    elif line.startswith(unlink_issue):
                        failed_files.append(line[len(unlink_issue):line.rfind("'")])
                        failed_reasons.append(unlink_issue)
                    elif line.endswith(already_exists_issue):
                        failed_files.append(line[:-len(already_exists_issue)])
                        failed_reasons.append(already_exists_issue)
                    else:
                        unknown_lines.append(line)
                    continue
                # END special lines parsing
    
                for e in endings:
                    if line.endswith(e):
                        failed_files.append(line[20:-len(e)])
                        failed_reasons.append(e)
                        break
                    # END if ending matches
                # END for each possible ending
            # END for each line
            if unknown_lines:
                raise GitCommandError(("git-checkout-index",), 128, stderr)
            if failed_files:
                valid_files = list(set(iter_checked_out_files) - set(failed_files))
                raise CheckoutError(
                    "Some files could not be checked out from the index due to local modifications",
                    failed_files, valid_files, failed_reasons)
        # END stderr handler
    
        if paths is None:
            args.append("--all")
            kwargs['as_process'] = 1
            fprogress(None, False, None)
            proc = self.repo.git.checkout_index(*args, **kwargs)
            proc.wait()
            fprogress(None, True, None)
            rval_iter = (e.path for e in self.entries.values())
            handle_stderr(proc, rval_iter)
            return rval_iter
        else:
            if isinstance(paths, str):
                paths = [paths]
    
            # make sure we have our entries loaded before we start checkout_index
            # which will hold a lock on it. We try to get the lock as well during
            # our entries initialization
            self.entries
    
            args.append("--stdin")
            kwargs['as_process'] = True
            kwargs['istream'] = subprocess.PIPE
            proc = self.repo.git.checkout_index(args, **kwargs)
            # FIXME: Reading from GIL!
            make_exc = lambda: GitCommandError(("git-checkout-index",) + tuple(args), 128, proc.stderr.read())
            checked_out_files: List[PathLike] = []
    
            for path in paths:
                co_path = to_native_path_linux(self._to_relative_path(path))
                # if the item is not in the index, it could be a directory
                path_is_directory = False
    
                try:
                    self.entries[(co_path, 0)]
                except KeyError:
                    folder = str(co_path)
                    if not folder.endswith('/'):
                        folder += '/'
                    for entry in self.entries.values():
                        if str(entry.path).startswith(folder):
                            p = entry.path
                            self._write_path_to_stdin(proc, p, p, make_exc,
                                                      fprogress, read_from_stdout=False)
                            checked_out_files.append(p)
                            path_is_directory = True
                        # END if entry is in directory
                    # END for each entry
                # END path exception handlnig
    
                if not path_is_directory:
                    self._write_path_to_stdin(proc, co_path, path, make_exc,
                                              fprogress, read_from_stdout=False)
                    checked_out_files.append(co_path)
                # END path is a file
            # END for each path
            try:
>               self._flush_stdin_and_wait(proc, ignore_stdout=True)

D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\base.py:1182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

cls = <git.index.base.IndexFile object at 0x0000017E45A6DEF8>
proc = <git.cmd.Git.AutoInterrupt object at 0x0000017E455BA048>
ignore_stdout = True

    def _flush_stdin_and_wait(cls, proc: 'Popen[bytes]', ignore_stdout: bool = False) -> bytes:
        stdin_IO = proc.stdin
        if stdin_IO:
            stdin_IO.flush()
            stdin_IO.close()
    
        stdout = b''
        if not ignore_stdout and proc.stdout:
            stdout = proc.stdout.read()
    
        if proc.stdout:
            proc.stdout.close()
>           proc.wait()

D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\base.py:1022: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <git.cmd.Git.AutoInterrupt object at 0x0000017E455BA048>, stderr = b''

    def wait(self, stderr: Union[None, str, bytes] = b'') -> int:
        """Wait for the process and return its status code.
    
        :param stderr: Previously read value of stderr, in case stderr is already closed.
        :warn: may deadlock if output or error pipes are used and not handled separately.
        :raise GitCommandError: if the return status is not 0"""
        if stderr is None:
            stderr_b = b''
        stderr_b = force_bytes(data=stderr, encoding='utf-8')
        status: Union[int, None]
        if self.proc is not None:
            status = self.proc.wait()
            p_stderr = self.proc.stderr
        else:  # Assume the underlying proc was killed earlier or never existed
            status = self.status
            p_stderr = None
    
        def read_all_from_possibly_closed_stream(stream: Union[IO[bytes], None]) -> bytes:
            if stream:
                try:
                    return stderr_b + force_bytes(stream.read())
                except ValueError:
                    return stderr_b or b''
            else:
                return stderr_b or b''
    
        # END status handling
    
        if status != 0:
            errstr = read_all_from_possibly_closed_stream(p_stderr)
            log.debug('AutoInterrupt wait stderr: %r' % (errstr,))
>           raise GitCommandError(remove_password_if_present(self.args), status, errstr)
E           git.exc.GitCommandError: Cmd('git') failed due to: exit code(128)
E             cmdline: git checkout-index --index --force --stdin
E             stderr: 'fatal: Unable to write new index file
E           '

D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\cmd.py:501: GitCommandError

During handling of the above exception, another exception occurred:

tmp_dir = TmpDir('C:/Users/runneradmin/AppData/Local/Temp/pytest-of-runneradmin/pytest-0/test_checkout_index_gitpython_0')
scm = Git: 'C:\Users\runneradmin\AppData\Local\Temp\pytest-of-runneradmin\pytest-0\test_checkout_index_gitpython_0\.git'
git = Git: 'C:\Users\runneradmin\AppData\Local\Temp\pytest-of-runneradmin\pytest-0\test_checkout_index_gitpython_0\.git'

    @pytest.mark.skip_git_backend("dulwich")
    def test_checkout_index(tmp_dir: TmpDir, scm: Git, git: Git):
        files = tmp_dir.gen({"foo": "foo", "bar": "bar", "dir": {"baz": "baz"}})
        scm.add_commit(files, message="init")
        tmp_dir.gen({"foo": "baz", "dir": {"baz": "foo"}})
    
        with (tmp_dir / "dir").chdir():
>           git.checkout_index([os.path.join("..", "foo"), "baz"], force=True)

D:\a\scmrepo\scmrepo\tests\test_git.py:496: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
D:\a\scmrepo\scmrepo\scmrepo\git\__init__.py:253: in _backend_func
    return func(*args, **kwargs)
D:\a\scmrepo\scmrepo\scmrepo\git\backend\gitpython.py:612: in checkout_index
    self.repo.index.checkout(paths=paths_list, force=force)
D:\a\scmrepo\scmrepo\.nox\tests-3-7\lib\site-packages\git\index\util.py:88: in check_default_index
    return func(self, *args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <git.index.base.IndexFile object at 0x0000017E45A6DEF8>
paths = ['foo', 'dir/baz'], force = True
fprogress = <function IndexFile.<lambda> at 0x0000017E451F5948>
kwargs = {'as_process': True, 'istream': -1}
handle_stderr = <function IndexFile.checkout.<locals>.handle_stderr at 0x0000017E4597AE58>
make_exc = <function IndexFile.checkout.<locals>.<lambda> at 0x0000017E457D1A68>
checked_out_files = ['foo', 'dir/baz'], path = 'dir/baz', co_path = 'dir/baz'
path_is_directory = False

    @ default_index
    def checkout(self, paths: Union[None, Iterable[PathLike]] = None, force: bool = False,
                 fprogress: Callable = lambda *args: None, **kwargs: Any
                 ) -> Union[None, Iterator[PathLike], Sequence[PathLike]]:
        """Checkout the given paths or all files from the version known to the index into
        the working tree.
    
        :note: Be sure you have written pending changes using the ``write`` method
            in case you have altered the enties dictionary directly
    
        :param paths:
            If None, all paths in the index will be checked out. Otherwise an iterable
            of relative or absolute paths or a single path pointing to files or directories
            in the index is expected.
    
        :param force:
            If True, existing files will be overwritten even if they contain local modifications.
            If False, these will trigger a CheckoutError.
    
        :param fprogress:
            see :func:`IndexFile.add` for signature and explanation.
            The provided progress information will contain None as path and item if no
            explicit paths are given. Otherwise progress information will be send
            prior and after a file has been checked out
    
        :param kwargs:
            Additional arguments to be passed to git-checkout-index
    
        :return:
            iterable yielding paths to files which have been checked out and are
            guaranteed to match the version stored in the index
    
        :raise exc.CheckoutError:
            If at least one file failed to be checked out. This is a summary,
            hence it will checkout as many files as it can anyway.
            If one of files or directories do not exist in the index
            ( as opposed to the  original git command who ignores them ).
            Raise GitCommandError if error lines could not be parsed - this truly is
            an exceptional state
    
        .. note:: The checkout is limited to checking out the files in the
            index. Files which are not in the index anymore and exist in
            the working tree will not be deleted. This behaviour is fundamentally
            different to *head.checkout*, i.e. if you want git-checkout like behaviour,
            use head.checkout instead of index.checkout.
            """
        args = ["--index"]
        if force:
            args.append("--force")
    
        failed_files = []
        failed_reasons = []
        unknown_lines = []
    
        def handle_stderr(proc: 'Popen[bytes]', iter_checked_out_files: Iterable[PathLike]) -> None:
    
            stderr_IO = proc.stderr
            if not stderr_IO:
                return None  # return early if stderr empty
            else:
                stderr_bytes = stderr_IO.read()
            # line contents:
            stderr = stderr_bytes.decode(defenc)
            # git-checkout-index: this already exists
            endings = (' already exists', ' is not in the cache', ' does not exist at stage', ' is unmerged')
            for line in stderr.splitlines():
                if not line.startswith("git checkout-index: ") and not line.startswith("git-checkout-index: "):
                    is_a_dir = " is a directory"
                    unlink_issue = "unable to unlink old '"
                    already_exists_issue = ' already exists, no checkout'   # created by entry.c:checkout_entry(...)
                    if line.endswith(is_a_dir):
                        failed_files.append(line[:-len(is_a_dir)])
                        failed_reasons.append(is_a_dir)
                    elif line.startswith(unlink_issue):
                        failed_files.append(line[len(unlink_issue):line.rfind("'")])
                        failed_reasons.append(unlink_issue)
                    elif line.endswith(already_exists_issue):
                        failed_files.append(line[:-len(already_exists_issue)])
                        failed_reasons.append(already_exists_issue)
                    else:
                        unknown_lines.append(line)
                    continue
                # END special lines parsing
    
                for e in endings:
                    if line.endswith(e):
                        failed_files.append(line[20:-len(e)])
                        failed_reasons.append(e)
                        break
                    # END if ending matches
                # END for each possible ending
            # END for each line
            if unknown_lines:
                raise GitCommandError(("git-checkout-index",), 128, stderr)
            if failed_files:
                valid_files = list(set(iter_checked_out_files) - set(failed_files))
                raise CheckoutError(
                    "Some files could not be checked out from the index due to local modifications",
                    failed_files, valid_files, failed_reasons)
        # END stderr handler
    
        if paths is None:
            args.append("--all")
            kwargs['as_process'] = 1
            fprogress(None, False, None)
            proc = self.repo.git.checkout_index(*args, **kwargs)
            proc.wait()
            fprogress(None, True, None)
            rval_iter = (e.path for e in self.entries.values())
            handle_stderr(proc, rval_iter)
            return rval_iter
        else:
            if isinstance(paths, str):
                paths = [paths]
    
            # make sure we have our entries loaded before we start checkout_index
            # which will hold a lock on it. We try to get the lock as well during
            # our entries initialization
            self.entries
    
            args.append("--stdin")
            kwargs['as_process'] = True
            kwargs['istream'] = subprocess.PIPE
            proc = self.repo.git.checkout_index(args, **kwargs)
            # FIXME: Reading from GIL!
            make_exc = lambda: GitCommandError(("git-checkout-index",) + tuple(args), 128, proc.stderr.read())
            checked_out_files: List[PathLike] = []
    
            for path in paths:
                co_path = to_native_path_linux(self._to_relative_path(path))
                # if the item is not in the index, it could be a directory
                path_is_directory = False
    
                try:
                    self.entries[(co_path, 0)]
                except KeyError:
                    folder = str(co_path)
                    if not folder.endswith('/'):
                        folder += '/'
                    for entry in self.entries.values():
                        if str(entry.path).startswith(folder):
                            p = entry.path
                            self._write_path_to_stdin(proc, p, p, make_exc,
                                                      fprogress, read_from_stdout=False)
                            checked_out_files.append(p)
                            path_is_directory = True
                        # END if entry is in directory
                    # END for each entry
                # END path exception handlnig
    
                if not path_is_directory:
                    self._write_path_to_stdin(proc, co_path, path, make_exc,
                                              fprogress, read_from_stdout=False)
                    checked_out_files.append(co_path)
                # END path is a file
            # END for each path
            try:
                self._flush_stdin_and_wait(proc, ignore_stdout=True)
            except GitCommandError:
                # Without parsing stdout we don't know what failed.
                raise CheckoutError(
                    "Some files could not be checked out from the index, probably because they didn't exist.",
>                   failed_files, [], failed_reasons)
E               git.exc.CheckoutError: Some files could not be checked out from the index, probably because they didn't exist.:[]

[skshetry]

Closing as it's now fixed in upstream and released in 3.1.26.

See gitpython-developers/GitPython@e16a004.