from __future__ import annotations

from contextlib import contextmanager

import io

import logging

import os

import signal

from subprocess import (

call,

Popen,

PIPE,

DEVNULL

)

import subprocess

import threading

from textwrap import dedent

from git.compat import (

defenc,

force_bytes,

safe_decode,

is_posix,

is_win,

)

from git.exc import CommandError

from git.util import is_cygwin_git, cygpath, expand_path, remove_password_if_present

from .exc import (

GitCommandError,

GitCommandNotFound

)

from .util import (

LazyMixin,

stream_copy,

)

from typing import (Any, AnyStr, BinaryIO, Callable, Dict, IO, Iterator, List, Mapping,

Sequence, TYPE_CHECKING, TextIO, Tuple, Union, cast, overload)

from git.types import PathLike, Literal, TBD

if TYPE_CHECKING:

from git.repo.base import Repo

from git.diff import DiffIndex

execute_kwargs = {'istream', 'with_extended_output',

'with_exceptions', 'as_process', 'stdout_as_string',

'output_stream', 'with_stdout', 'kill_after_timeout',

'universal_newlines', 'shell', 'env', 'max_chunk_size'}

log = logging.getLogger(__name__)

log.addHandler(logging.NullHandler())

__all__ = ('Git',)

def handle_process_output(process: 'Git.AutoInterrupt' | Popen,

return None

def dashify(string: str) -> str:

return string.replace('_', '-')

def slots_to_dict(self: object, exclude: Sequence[str] = ()) -> Dict[str, Any]:

return {s: getattr(self, s) for s in self.__slots__ if s not in exclude}

def dict_to_slots_and__excluded_are_none(self: object, d: Mapping[str, Any], excluded: Sequence[str] = ()) -> None:

setattr(self, k, None)

CREATE_NO_WINDOW = 0x08000000

PROC_CREATIONFLAGS = (CREATE_NO_WINDOW | subprocess.CREATE_NEW_PROCESS_GROUP # type: ignore[attr-defined]

if is_win else 0) # mypy error if not windows

class Git(LazyMixin):