aller will have to deal with
    the details. It is important to note that the process will be placed
    into an :class:`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
    copied to the given stream instead of being returned as a string.
    This feature only has any effect if `as_process` is ``False``.

:param stdout_as_string:
    If ``False``, the command's 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 kill_after_timeout:
    Specifies 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. Uses of this feature should be
    carefully considered, due to the following limitations:

    1. This feature is not supported at all on Windows.
    2. Effectiveness may vary by operating system. ``ps --ppid`` is used to
       enumerate child processes, which is available on most GNU/Linux systems
       but not most others.
    3. Deeper descendants do not receive signals, though they may sometimes
       terminate as a consequence of their parent processes being killed.
    4. `kill_after_timeout` uses ``SIGKILL``, which can have negative side
       effects on a repository. For example, stale locks in case of
       :manpage:`git-gc(1)` could render the repository incapable of accepting
       changes until the lock is manually removed.

: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 :class:`Popen(..., shell=True) <subprocess.Popen>`).
    If this is not ``None``, it overrides :attr:`USE_SHELL`.

    Passing ``shell=True`` to this or any other GitPython function should be
    avoided, as it is unsafe under most circumstances. This is because it is
    typically not feasible to fully consider and account for the effect of shell
    expansions, especially when passing ``shell=True`` to other methods that
    forward it to :meth:`Git.execute`. Passing ``shell=True`` is also no longer
    needed (nor useful) to work around any known operating system specific
    issues.

:param env:
    A dictionary of environment variables to be passed to
    :class:`subprocess.Popen`.

:param max_chunk_size:
    Maximum number of bytes in one chunk of data passed to the `output_stream`
    in one invocation of its ``write()`` method. If the given number is not
    positive then the default value is used.

:param strip_newline_in_stdout:
    Whether to strip the trailing ``\n`` of the command stdout.

:param subprocess_kwargs:
    Keyword arguments to be passed to :class:`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.

:return:
    * str(output), if `extended_output` is ``False`` (Default)
    * tuple(int(status), str(stdout), str(stderr)),
      if `extended_output` is ``True``

    If `output_stream` is ``True``, the stdout value will be your output stream:

    * output_stream, if `extended_output` is ``False``
    * tuple(int(status), output_stream, str(stderr)),
      if `extended_output` is ``True``

    Note that git is executed with ``LC_MESSAGES="C"`` to ensure consistent
    output regardless of system language.

:raise git.exc.GitCommandError:

:note:
    If you add additional keyword arguments to the signature of this method, you
    must update the ``execute_kwargs`` variable housed in this module.
