summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--doc/source/changes.rst5
-rw-r--r--git/__init__.py12
-rw-r--r--git/cmd.py13
-rw-r--r--git/compat.py38
-rw-r--r--git/config.py4
-rw-r--r--git/db.py26
-rw-r--r--git/diff.py117
-rw-r--r--git/exc.py44
-rw-r--r--git/refs/symbolic.py2
-rw-r--r--git/remote.py10
-rw-r--r--git/repo/base.py281
-rw-r--r--git/repo/fun.py38
-rw-r--r--git/util.py256
-rw-r--r--requirements.txt1
-rw-r--r--test-requirements.txt2
-rw-r--r--tox.ini3
16 files changed, 524 insertions, 328 deletions
diff --git a/doc/source/changes.rst b/doc/source/changes.rst
index 85f9ef1b..93f65a2f 100644
--- a/doc/source/changes.rst
+++ b/doc/source/changes.rst
@@ -2,6 +2,11 @@
Changelog
=========
+3.1.15 (UNRELEASED)
+===================
+
+* add deprectation warning for python 3.5
+
3.1.14
======
diff --git a/git/__init__.py b/git/__init__.py
index 53440830..ae9254a2 100644
--- a/git/__init__.py
+++ b/git/__init__.py
@@ -5,18 +5,20 @@
# the BSD License: http://www.opensource.org/licenses/bsd-license.php
# flake8: noqa
#@PydevCodeAnalysisIgnore
+from git.exc import * # @NoMove @IgnorePep8
import inspect
import os
import sys
-
import os.path as osp
+from typing import Optional
+from git.types import PathLike
__version__ = 'git'
#{ Initialization
-def _init_externals():
+def _init_externals() -> None:
"""Initialize external projects by putting them into the path"""
if __version__ == 'git' and 'PYOXIDIZER' not in os.environ:
sys.path.insert(1, osp.join(osp.dirname(__file__), 'ext', 'gitdb'))
@@ -29,13 +31,13 @@ def _init_externals():
#} END initialization
+
#################
_init_externals()
#################
#{ Imports
-from git.exc import * # @NoMove @IgnorePep8
try:
from git.config import GitConfigParser # @NoMove @IgnorePep8
from git.objects import * # @NoMove @IgnorePep8
@@ -65,7 +67,8 @@ __all__ = [name for name, obj in locals().items()
#{ Initialize git executable path
GIT_OK = None
-def refresh(path=None):
+
+def refresh(path: Optional[PathLike] = None) -> None:
"""Convenience method for setting the git executable path."""
global GIT_OK
GIT_OK = False
@@ -78,6 +81,7 @@ def refresh(path=None):
GIT_OK = True
#} END initialize git executable path
+
#################
try:
refresh()
diff --git a/git/cmd.py b/git/cmd.py
index 79606607..40e32e37 100644
--- a/git/cmd.py
+++ b/git/cmd.py
@@ -19,6 +19,7 @@ import sys
import threading
from collections import OrderedDict
from textwrap import dedent
+import warnings
from git.compat import (
defenc,
@@ -209,7 +210,7 @@ class Git(LazyMixin):
# - a GitCommandNotFound error is spawned by ourselves
# - a PermissionError is spawned if the git executable provided
# cannot be executed for whatever reason
-
+
has_git = False
try:
cls().version()
@@ -497,7 +498,7 @@ class Git(LazyMixin):
# skipcq: PYL-E0301
def __iter__(self):
return self
-
+
def __next__(self):
return self.next()
@@ -904,8 +905,14 @@ class Git(LazyMixin):
def transform_kwargs(self, split_single_char_options=True, **kwargs):
"""Transforms Python style kwargs into git command line options."""
+ # Python 3.6 preserves the order of kwargs and thus has a stable
+ # order. For older versions sort the kwargs by the key to get a stable
+ # order.
+ if sys.version_info[:2] < (3, 6):
+ kwargs = OrderedDict(sorted(kwargs.items(), key=lambda x: x[0]))
+ warnings.warn("Python 3.5 support is deprecated and will be removed 2021-09-05.\n" +
+ "It does not preserve the order for key-word arguments and enforce lexical sorting instead.")
args = []
- kwargs = OrderedDict(sorted(kwargs.items(), key=lambda x: x[0]))
for k, v in kwargs.items():
if isinstance(v, (list, tuple)):
for value in v:
diff --git a/git/compat.py b/git/compat.py
index de8a238b..a0aea1ac 100644
--- a/git/compat.py
+++ b/git/compat.py
@@ -11,40 +11,50 @@ import locale
import os
import sys
-
from gitdb.utils.encoding import (
force_bytes, # @UnusedImport
force_text # @UnusedImport
)
+# typing --------------------------------------------------------------------
+
+from typing import Any, AnyStr, Dict, Optional, Type
+from git.types import TBD
+
+# ---------------------------------------------------------------------------
-is_win = (os.name == 'nt')
+
+is_win = (os.name == 'nt') # type: bool
is_posix = (os.name == 'posix')
is_darwin = (os.name == 'darwin')
defenc = sys.getfilesystemencoding()
-def safe_decode(s):
+def safe_decode(s: Optional[AnyStr]) -> Optional[str]:
"""Safely decodes a binary string to unicode"""
if isinstance(s, str):
return s
elif isinstance(s, bytes):
return s.decode(defenc, 'surrogateescape')
- elif s is not None:
+ elif s is None:
+ return None
+ else:
raise TypeError('Expected bytes or text, but got %r' % (s,))
-def safe_encode(s):
- """Safely decodes a binary string to unicode"""
+def safe_encode(s: Optional[AnyStr]) -> Optional[bytes]:
+ """Safely encodes a binary string to unicode"""
if isinstance(s, str):
return s.encode(defenc)
elif isinstance(s, bytes):
return s
- elif s is not None:
+ elif s is None:
+ return None
+ else:
raise TypeError('Expected bytes or text, but got %r' % (s,))
-def win_encode(s):
+def win_encode(s: Optional[AnyStr]) -> Optional[bytes]:
"""Encode unicodes for process arguments on Windows."""
if isinstance(s, str):
return s.encode(locale.getpreferredencoding(False))
@@ -52,16 +62,20 @@ def win_encode(s):
return s
elif s is not None:
raise TypeError('Expected bytes or text, but got %r' % (s,))
+ return None
+
-def with_metaclass(meta, *bases):
+def with_metaclass(meta: Type[Any], *bases: Any) -> 'metaclass': # type: ignore ## mypy cannot understand dynamic class creation
"""copied from https://github.com/Byron/bcore/blob/master/src/python/butility/future.py#L15"""
- class metaclass(meta):
+
+ class metaclass(meta): # type: ignore
__call__ = type.__call__
- __init__ = type.__init__
+ __init__ = type.__init__ # type: ignore
- def __new__(cls, name, nbases, d):
+ def __new__(cls, name: str, nbases: Optional[int], d: Dict[str, Any]) -> TBD:
if nbases is None:
return type.__new__(cls, name, (), d)
return meta(name, bases, d)
+
return metaclass(meta.__name__ + 'Helper', None, {})
diff --git a/git/config.py b/git/config.py
index 9f09efe2..aadb0aac 100644
--- a/git/config.py
+++ b/git/config.py
@@ -16,6 +16,8 @@ import re
import fnmatch
from collections import OrderedDict
+from typing_extensions import Literal
+
from git.compat import (
defenc,
force_text,
@@ -194,7 +196,7 @@ class _OMD(OrderedDict):
return [(k, self.getall(k)) for k in self]
-def get_config_path(config_level):
+def get_config_path(config_level: Literal['system', 'global', 'user', 'repository']) -> str:
# we do not support an absolute path of the gitconfig on windows ,
# use the global config instead
diff --git a/git/db.py b/git/db.py
index de2e9991..dc60c555 100644
--- a/git/db.py
+++ b/git/db.py
@@ -7,15 +7,21 @@ from gitdb.base import (
from gitdb.db import GitDB # @UnusedImport
from gitdb.db import LooseObjectDB
-from .exc import (
- GitCommandError,
- BadObject
-)
+from gitdb.exc import BadObject
+from git.exc import GitCommandError
+# typing-------------------------------------------------
-__all__ = ('GitCmdObjectDB', 'GitDB')
+from typing import TYPE_CHECKING, AnyStr
+from git.types import PathLike
+
+if TYPE_CHECKING:
+ from git.cmd import Git
+
-# class GitCmdObjectDB(CompoundDB, ObjectDBW):
+# --------------------------------------------------------
+
+__all__ = ('GitCmdObjectDB', 'GitDB')
class GitCmdObjectDB(LooseObjectDB):
@@ -28,23 +34,23 @@ class GitCmdObjectDB(LooseObjectDB):
have packs and the other implementations
"""
- def __init__(self, root_path, git):
+ def __init__(self, root_path: PathLike, git: 'Git') -> None:
"""Initialize this instance with the root and a git command"""
super(GitCmdObjectDB, self).__init__(root_path)
self._git = git
- def info(self, sha):
+ def info(self, sha: bytes) -> OInfo:
hexsha, typename, size = self._git.get_object_header(bin_to_hex(sha))
return OInfo(hex_to_bin(hexsha), typename, size)
- def stream(self, sha):
+ def stream(self, sha: bytes) -> OStream:
"""For now, all lookup is done by git itself"""
hexsha, typename, size, stream = self._git.stream_object_data(bin_to_hex(sha))
return OStream(hex_to_bin(hexsha), typename, size, stream)
# { Interface
- def partial_to_complete_sha_hex(self, partial_hexsha):
+ def partial_to_complete_sha_hex(self, partial_hexsha: AnyStr) -> bytes:
""":return: Full binary 20 byte sha from the given partial hexsha
:raise AmbiguousObjectName:
:raise BadObject:
diff --git a/git/diff.py b/git/diff.py
index a9dc4b57..129223cb 100644
--- a/git/diff.py
+++ b/git/diff.py
@@ -3,8 +3,8 @@
#
# This module is part of GitPython and is released under
# the BSD License: http://www.opensource.org/licenses/bsd-license.php
-import re
+import re
from git.cmd import handle_process_output
from git.compat import defenc
from git.util import finalize_process, hex_to_bin
@@ -13,22 +13,36 @@ from .objects.blob import Blob
from .objects.util import mode_str_to_int
+# typing ------------------------------------------------------------------
+
+from typing import Any, Iterator, List, Match, Optional, Tuple, Type, Union, TYPE_CHECKING
+from typing_extensions import Final, Literal
+from git.types import TBD
+
+if TYPE_CHECKING:
+ from .objects.tree import Tree
+ from git.repo.base import Repo
+
+Lit_change_type = Literal['A', 'D', 'M', 'R', 'T']
+
+# ------------------------------------------------------------------------
+
__all__ = ('Diffable', 'DiffIndex', 'Diff', 'NULL_TREE')
# Special object to compare against the empty tree in diffs
-NULL_TREE = object()
+NULL_TREE = object() # type: Final[object]
_octal_byte_re = re.compile(b'\\\\([0-9]{3})')
-def _octal_repl(matchobj):
+def _octal_repl(matchobj: Match) -> bytes:
value = matchobj.group(1)
value = int(value, 8)
value = bytes(bytearray((value,)))
return value
-def decode_path(path, has_ab_prefix=True):
+def decode_path(path: bytes, has_ab_prefix: bool = True) -> Optional[bytes]:
if path == b'/dev/null':
return None
@@ -60,7 +74,7 @@ class Diffable(object):
class Index(object):
pass
- def _process_diff_args(self, args):
+ def _process_diff_args(self, args: List[Union[str, 'Diffable', object]]) -> List[Union[str, 'Diffable', object]]:
"""
:return:
possibly altered version of the given args list.
@@ -68,7 +82,9 @@ class Diffable(object):
Subclasses can use it to alter the behaviour of the superclass"""
return args
- def diff(self, other=Index, paths=None, create_patch=False, **kwargs):
+ def diff(self, other: Union[Type[Index], Type['Tree'], object, None, str] = Index,
+ paths: Union[str, List[str], Tuple[str, ...], None] = None,
+ create_patch: bool = False, **kwargs: Any) -> 'DiffIndex':
"""Creates diffs between two items being trees, trees and index or an
index and the working tree. It will detect renames automatically.
@@ -99,7 +115,7 @@ class Diffable(object):
:note:
On a bare repository, 'other' needs to be provided as Index or as
as Tree/Commit, or a git command error will occur"""
- args = []
+ args = [] # type: List[Union[str, Diffable, object]]
args.append("--abbrev=40") # we need full shas
args.append("--full-index") # get full index paths, not only filenames
@@ -117,6 +133,9 @@ class Diffable(object):
if paths is not None and not isinstance(paths, (tuple, list)):
paths = [paths]
+ if hasattr(self, 'repo'): # else raise Error?
+ self.repo = self.repo # type: 'Repo'
+
diff_cmd = self.repo.git.diff
if other is self.Index:
args.insert(0, '--cached')
@@ -163,7 +182,7 @@ class DiffIndex(list):
# T = Changed in the type
change_type = ("A", "C", "D", "R", "M", "T")
- def iter_change_type(self, change_type):
+ def iter_change_type(self, change_type: Lit_change_type) -> Iterator['Diff']:
"""
:return:
iterator yielding Diff instances that match the given change_type
@@ -180,7 +199,7 @@ class DiffIndex(list):
if change_type not in self.change_type:
raise ValueError("Invalid change type: %s" % change_type)
- for diff in self:
+ for diff in self: # type: 'Diff'
if diff.change_type == change_type:
yield diff
elif change_type == "A" and diff.new_file:
@@ -255,22 +274,21 @@ class Diff(object):
"new_file", "deleted_file", "copied_file", "raw_rename_from",
"raw_rename_to", "diff", "change_type", "score")
- def __init__(self, repo, a_rawpath, b_rawpath, a_blob_id, b_blob_id, a_mode,
- b_mode, new_file, deleted_file, copied_file, raw_rename_from,
- raw_rename_to, diff, change_type, score):
-
- self.a_mode = a_mode
- self.b_mode = b_mode
+ def __init__(self, repo: 'Repo',
+ a_rawpath: Optional[bytes], b_rawpath: Optional[bytes],
+ a_blob_id: Union[str, bytes, None], b_blob_id: Union[str, bytes, None],
+ a_mode: Union[bytes, str, None], b_mode: Union[bytes, str, None],
+ new_file: bool, deleted_file: bool, copied_file: bool,
+ raw_rename_from: Optional[bytes], raw_rename_to: Optional[bytes],
+ diff: Union[str, bytes, None], change_type: Optional[str], score: Optional[int]) -> None:
assert a_rawpath is None or isinstance(a_rawpath, bytes)
assert b_rawpath is None or isinstance(b_rawpath, bytes)
self.a_rawpath = a_rawpath
self.b_rawpath = b_rawpath
- if self.a_mode:
- self.a_mode = mode_str_to_int(self.a_mode)
- if self.b_mode:
- self.b_mode = mode_str_to_int(self.b_mode)
+ self.a_mode = mode_str_to_int(a_mode) if a_mode else None
+ self.b_mode = mode_str_to_int(b_mode) if b_mode else None
# Determine whether this diff references a submodule, if it does then
# we need to overwrite "repo" to the corresponding submodule's repo instead
@@ -305,27 +323,27 @@ class Diff(object):
self.change_type = change_type
self.score = score
- def __eq__(self, other):
+ def __eq__(self, other: object) -> bool:
for name in self.__slots__:
if getattr(self, name) != getattr(other, name):
return False
# END for each name
return True
- def __ne__(self, other):
+ def __ne__(self, other: object) -> bool:
return not (self == other)
- def __hash__(self):
+ def __hash__(self) -> int:
return hash(tuple(getattr(self, n) for n in self.__slots__))
- def __str__(self):
- h = "%s"
+ def __str__(self) -> str:
+ h = "%s" # type: str
if self.a_blob:
h %= self.a_blob.path
elif self.b_blob:
h %= self.b_blob.path
- msg = ''
+ msg = '' # type: str
line = None # temp line
line_length = 0 # line length
for b, n in zip((self.a_blob, self.b_blob), ('lhs', 'rhs')):
@@ -354,7 +372,7 @@ class Diff(object):
if self.diff:
msg += '\n---'
try:
- msg += self.diff.decode(defenc)
+ msg += self.diff.decode(defenc) if isinstance(self.diff, bytes) else self.diff
except UnicodeDecodeError:
msg += 'OMITTED BINARY DATA'
# end handle encoding
@@ -368,36 +386,36 @@ class Diff(object):
return res
@property
- def a_path(self):
+ def a_path(self) -> Optional[str]:
return self.a_rawpath.decode(defenc, 'replace') if self.a_rawpath else None
@property
- def b_path(self):
+ def b_path(self) -> Optional[str]:
return self.b_rawpath.decode(defenc, 'replace') if self.b_rawpath else None
@property
- def rename_from(self):
+ def rename_from(self) -> Optional[str]:
return self.raw_rename_from.decode(defenc, 'replace') if self.raw_rename_from else None
@property
- def rename_to(self):
+ def rename_to(self) -> Optional[str]:
return self.raw_rename_to.decode(defenc, 'replace') if self.raw_rename_to else None
@property
- def renamed(self):
+ def renamed(self) -> bool:
""":returns: True if the blob of our diff has been renamed
:note: This property is deprecated, please use ``renamed_file`` instead.
"""
return self.renamed_file
@property
- def renamed_file(self):
+ def renamed_file(self) -> bool:
""":returns: True if the blob of our diff has been renamed
"""
return self.rename_from != self.rename_to
@classmethod
- def _pick_best_path(cls, path_match, rename_match, path_fallback_match):
+ def _pick_best_path(cls, path_match: bytes, rename_match: bytes, path_fallback_match: bytes) -> Optional[bytes]:
if path_match:
return decode_path(path_match)
@@ -410,21 +428,23 @@ class Diff(object):
return None
@classmethod
- def _index_from_patch_format(cls, repo, proc):
+ def _index_from_patch_format(cls, repo: 'Repo', proc: TBD) -> DiffIndex:
"""Create a new DiffIndex from the given text which must be in patch format
:param repo: is the repository we are operating on - it is required
:param stream: result of 'git diff' as a stream (supporting file protocol)
:return: git.DiffIndex """
## FIXME: Here SLURPING raw, need to re-phrase header-regexes linewise.
- text = []
- handle_process_output(proc, text.append, None, finalize_process, decode_streams=False)
+ text_list = [] # type: List[bytes]
+ handle_process_output(proc, text_list.append, None, finalize_process, decode_streams=False)
# for now, we have to bake the stream
- text = b''.join(text)
+ text = b''.join(text_list)
index = DiffIndex()
previous_header = None
header = None
+ a_path, b_path = None, None # for mypy
+ a_mode, b_mode = None, None # for mypy
for _header in cls.re_header.finditer(text):
a_path_fallback, b_path_fallback, \
old_mode, new_mode, \
@@ -464,14 +484,14 @@ class Diff(object):
previous_header = _header
header = _header
# end for each header we parse
- if index:
+ if index and header:
index[-1].diff = text[header.end():]
# end assign last diff
return index
@classmethod
- def _index_from_raw_format(cls, repo, proc):
+ def _index_from_raw_format(cls, repo: 'Repo', proc: TBD) -> DiffIndex:
"""Create a new DiffIndex from the given stream which must be in raw format.
:return: git.DiffIndex"""
# handles
@@ -479,12 +499,13 @@ class Diff(object):
index = DiffIndex()
- def handle_diff_line(lines):
- lines = lines.decode(defenc)
+ def handle_diff_line(lines_bytes: bytes) -> None:
+ lines = lines_bytes.decode(defenc)
for line in lines.split(':')[1:]:
meta, _, path = line.partition('\x00')
path = path.rstrip('\x00')
+ a_blob_id, b_blob_id = None, None # Type: Optional[str]
old_mode, new_mode, a_blob_id, b_blob_id, _change_type = meta.split(None, 4)
# Change type can be R100
# R: status letter
@@ -504,20 +525,20 @@ class Diff(object):
# NOTE: We cannot conclude from the existence of a blob to change type
# as diffs with the working do not have blobs yet
if change_type == 'D':
- b_blob_id = None
+ b_blob_id = None # Optional[str]
deleted_file = True
elif change_type == 'A':
a_blob_id = None
new_file = True
elif change_type == 'C':
copied_file = True
- a_path, b_path = path.split('\x00', 1)
- a_path = a_path.encode(defenc)
- b_path = b_path.encode(defenc)
+ a_path_str, b_path_str = path.split('\x00', 1)
+ a_path = a_path_str.encode(defenc)
+ b_path = b_path_str.encode(defenc)
elif change_type == 'R':
- a_path, b_path = path.split('\x00', 1)
- a_path = a_path.encode(defenc)
- b_path = b_path.encode(defenc)
+ a_path_str, b_path_str = path.split('\x00', 1)
+ a_path = a_path_str.encode(defenc)
+ b_path = b_path_str.encode(defenc)
rename_from, rename_to = a_path, b_path
elif change_type == 'T':
# Nothing to do
diff --git a/git/exc.py b/git/exc.py
index 71a40bdf..c066e5e2 100644
--- a/git/exc.py
+++ b/git/exc.py
@@ -8,6 +8,16 @@
from gitdb.exc import * # NOQA @UnusedWildImport skipcq: PYL-W0401, PYL-W0614
from git.compat import safe_decode
+# typing ----------------------------------------------------
+
+from typing import IO, List, Optional, Tuple, Union, TYPE_CHECKING
+from git.types import PathLike
+
+if TYPE_CHECKING:
+ from git.repo.base import Repo
+
+# ------------------------------------------------------------------
+
class GitError(Exception):
""" Base class for all package exceptions """
@@ -37,7 +47,9 @@ class CommandError(GitError):
#: "'%s' failed%s"
_msg = "Cmd('%s') failed%s"
- def __init__(self, command, status=None, stderr=None, stdout=None):
+ def __init__(self, command: Union[List[str], Tuple[str, ...], str],
+ status: Union[str, None, Exception] = None,
+ stderr: Optional[IO[str]] = None, stdout: Optional[IO[str]] = None) -> None:
if not isinstance(command, (tuple, list)):
command = command.split()
self.command = command
@@ -53,12 +65,12 @@ class CommandError(GitError):
status = "'%s'" % s if isinstance(status, str) else s
self._cmd = safe_decode(command[0])
- self._cmdline = ' '.join(safe_decode(i) for i in command)
+ self._cmdline = ' '.join(str(safe_decode(i)) for i in command)
self._cause = status and " due to: %s" % status or "!"
- self.stdout = stdout and "\n stdout: '%s'" % safe_decode(stdout) or ''
- self.stderr = stderr and "\n stderr: '%s'" % safe_decode(stderr) or ''
+ self.stdout = stdout and "\n stdout: '%s'" % safe_decode(str(stdout)) or ''
+ self.stderr = stderr and "\n stderr: '%s'" % safe_decode(str(stderr)) or ''
- def __str__(self):
+ def __str__(self) -> str:
return (self._msg + "\n cmdline: %s%s%s") % (
self._cmd, self._cause, self._cmdline, self.stdout, self.stderr)
@@ -66,7 +78,8 @@ class CommandError(GitError):
class GitCommandNotFound(CommandError):
"""Thrown if we cannot find the `git` executable in the PATH or at the path given by
the GIT_PYTHON_GIT_EXECUTABLE environment variable"""
- def __init__(self, command, cause):
+
+ def __init__(self, command: Union[List[str], Tuple[str], str], cause: Union[str, Exception]) -> None:
super(GitCommandNotFound, self).__init__(command, cause)
self._msg = "Cmd('%s') not found%s"
@@ -74,7 +87,11 @@ class GitCommandNotFound(CommandError):
class GitCommandError(CommandError):
""" Thrown if execution of the git command fails with non-zero status code. """
- def __init__(self, command, status, stderr=None, stdout=None):
+ def __init__(self, command: Union[List[str], Tuple[str, ...], str],
+ status: Union[str, None, Exception] = None,
+ stderr: Optional[IO[str]] = None,
+ stdout: Optional[IO[str]] = None,
+ ) -> None:
super(GitCommandError, self).__init__(command, status, stderr, stdout)
@@ -92,13 +109,15 @@ class CheckoutError(GitError):
were checked out successfully and hence match the version stored in the
index"""
- def __init__(self, message, failed_files, valid_files, failed_reasons):
+ def __init__(self, message: str, failed_files: List[PathLike], valid_files: List[PathLike],
+ failed_reasons: List[str]) -> None:
+
Exception.__init__(self, message)
self.failed_files = failed_files
self.failed_reasons = failed_reasons
self.valid_files = valid_files
- def __str__(self):
+ def __str__(self) -> str:
return Exception.__str__(self) + ":%s" % self.failed_files
@@ -116,7 +135,8 @@ class HookExecutionError(CommandError):
"""Thrown if a hook exits with a non-zero exit code. It provides access to the exit code and the string returned
via standard output"""
- def __init__(self, command, status, stderr=None, stdout=None):
+ def __init__(self, command: Union[List[str], Tuple[str, ...], str], status: Optional[str],
+ stderr: Optional[IO[str]] = None, stdout: Optional[IO[str]] = None) -> None:
super(HookExecutionError, self).__init__(command, status, stderr, stdout)
self._msg = "Hook('%s') failed%s"
@@ -124,9 +144,9 @@ class HookExecutionError(CommandError):
class RepositoryDirtyError(GitError):
"""Thrown whenever an operation on a repository fails as it has uncommitted changes that would be overwritten"""
- def __init__(self, repo, message):
+ def __init__(self, repo: 'Repo', message: str) -> None:
self.repo = repo
self.message = message
- def __str__(self):
+ def __str__(self) -> str:
return "Operation cannot be performed on %r: %s" % (self.repo, self.message)
diff --git a/git/refs/symbolic.py b/git/refs/symbolic.py
index bd41cb60..22d9c1d5 100644
--- a/git/refs/symbolic.py
+++ b/git/refs/symbolic.py
@@ -513,7 +513,7 @@ class SymbolicReference(object):
return ref
@classmethod
- def create(cls, repo, path, reference='HEAD', force=False, logmsg=None):
+ def create(cls, repo, path, reference='HEAD', force=False, logmsg=None, **kwargs):
"""Create a new symbolic reference, hence a reference pointing to another reference.
:param repo:
diff --git a/git/remote.py b/git/remote.py
index 65916614..4194af1f 100644
--- a/git/remote.py
+++ b/git/remote.py
@@ -34,6 +34,14 @@ from .refs import (
TagReference
)
+# typing-------------------------------------------------------
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from git.repo.base import Repo
+
+# -------------------------------------------------------------
log = logging.getLogger('git.remote')
log.addHandler(logging.NullHandler())
@@ -403,7 +411,7 @@ class Remote(LazyMixin, Iterable):
:param repo: The repository we are a remote of
:param name: the name of the remote, i.e. 'origin'"""
- self.repo = repo
+ self.repo = repo # type: 'Repo'
self.name = name
if is_win:
diff --git a/git/repo/base.py b/git/repo/base.py
index e68bc077..a28c9d28 100644
--- a/git/repo/base.py
+++ b/git/repo/base.py
@@ -4,7 +4,6 @@
# This module is part of GitPython and is released under
# the BSD License: http://www.opensource.org/licenses/bsd-license.php
-from collections import namedtuple
import logging
import os
import re
@@ -33,20 +32,37 @@ from .fun import rev_parse, is_git_dir, find_submodule_git_dir, touch, find_work
import gc
import gitdb
-try:
- import pathlib
-except ImportError:
- pathlib = None
+# typing ------------------------------------------------------
+from git.types import TBD, PathLike
+from typing_extensions import Literal
+from typing import (Any, BinaryIO, Callable, Dict,
+ Iterator, List, Mapping, Optional,
+ TextIO, Tuple, Type, Union,
+ NamedTuple, cast, TYPE_CHECKING)
-log = logging.getLogger(__name__)
+if TYPE_CHECKING: # only needed for types
+ from git.util import IterableList
+ from git.refs.symbolic import SymbolicReference
+ from git.objects import TagObject, Blob, Tree # NOQA: F401
+
+Lit_config_levels = Literal['system', 'global', 'user', 'repository']
-BlameEntry = namedtuple('BlameEntry', ['commit', 'linenos', 'orig_path', 'orig_linenos'])
+# -----------------------------------------------------------
+log = logging.getLogger(__name__)
__all__ = ('Repo',)
+BlameEntry = NamedTuple('BlameEntry', [
+ ('commit', Dict[str, TBD]),
+ ('linenos', range),
+ ('orig_path', Optional[str]),
+ ('orig_linenos', range)]
+)
+
+
class Repo(object):
"""Represents a git repository and allows you to query references,
gather commit information, generate diffs, create and clone repositories query
@@ -63,11 +79,11 @@ class Repo(object):
'git_dir' is the .git repository directory, which is always set."""
DAEMON_EXPORT_FILE = 'git-daemon-export-ok'
- git = None # Must exist, or __del__ will fail in case we raise on `__init__()`
- working_dir = None
- _working_tree_dir = None
- git_dir = None
- _common_dir = None
+ git = cast('Git', None) # Must exist, or __del__ will fail in case we raise on `__init__()`
+ working_dir = None # type: Optional[PathLike]
+ _working_tree_dir = None # type: Optional[PathLike]
+ git_dir = None # type: Optional[PathLike]
+ _common_dir = None # type: Optional[PathLike]
# precompiled regex
re_whitespace = re.compile(r'\s+')
@@ -79,13 +95,14 @@ class Repo(object):
# invariants
# represents the configuration level of a configuration file
- config_level = ("system", "user", "global", "repository")
+ config_level = ("system", "user", "global", "repository") # type: Tuple[Lit_config_levels, ...]
# Subclass configuration
# Subclasses may easily bring in their own custom types by placing a constructor or type here
GitCommandWrapperType = Git
- def __init__(self, path=None, odbt=GitCmdObjectDB, search_parent_directories=False, expand_vars=True):
+ def __init__(self, path: Optional[PathLike] = None, odbt: Type[GitCmdObjectDB] = GitCmdObjectDB,
+ search_parent_directories: bool = False, expand_vars: bool = True) -> None:
"""Create a new Repo instance
:param path:
@@ -126,8 +143,9 @@ class Repo(object):
warnings.warn("The use of environment variables in paths is deprecated" +
"\nfor security reasons and may be removed in the future!!")
epath = expand_path(epath, expand_vars)
- if not os.path.exists(epath):
- raise NoSuchPathError(epath)
+ if epath is not None:
+ if not os.path.exists(epath):
+ raise NoSuchPathError(epath)
## Walk up the path to find the `.git` dir.
#
@@ -178,6 +196,7 @@ class Repo(object):
# END while curpath
if self.git_dir is None:
+ self.git_dir = cast(PathLike, self.git_dir)
raise InvalidGitRepositoryError(epath)
self._bare = False
@@ -190,7 +209,7 @@ class Repo(object):
try:
common_dir = open(osp.join(self.git_dir, 'commondir'), 'rt').readlines()[0].strip()
self._common_dir = osp.join(self.git_dir, common_dir)
- except (OSError, IOError):
+ except OSError:
self._common_dir = None
# adjust the wd in case we are actually bare - we didn't know that
@@ -199,28 +218,29 @@ class Repo(object):
self._working_tree_dir = None
# END working dir handling
- self.working_dir = self._working_tree_dir or self.common_dir
+ self.working_dir = self._working_tree_dir or self.common_dir # type: Optional[PathLike]
self.git = self.GitCommandWrapperType(self.working_dir)
# special handling, in special times
- args = [osp.join(self.common_dir, 'objects')]
+ rootpath = osp.join(self.common_dir, 'objects')
if issubclass(odbt, GitCmdObjectDB):
- args.append(self.git)
- self.odb = odbt(*args)
+ self.odb = odbt(rootpath, self.git)
+ else:
+ self.odb = odbt(rootpath)
- def __enter__(self):
+ def __enter__(self) -> 'Repo':
return self
- def __exit__(self, exc_type, exc_value, traceback):
+ def __exit__(self, exc_type: TBD, exc_value: TBD, traceback: TBD) -> None:
self.close()
- def __del__(self):
+ def __del__(self) -> None:
try:
self.close()
except Exception:
pass
- def close(self):
+ def close(self) -> None:
if self.git:
self.git.clear_cache()
# Tempfiles objects on Windows are holding references to
@@ -235,25 +255,27 @@ class Repo(object):
if is_win:
gc.collect()
- def __eq__(self, rhs):
- if isinstance(rhs, Repo):
+ def __eq__(self, rhs: object) -> bool:
+ if isinstance(rhs, Repo) and self.git_dir:
return self.git_dir == rhs.git_dir
return False
- def __ne__(self, rhs):
+ def __ne__(self, rhs: object) -> bool:
return not self.__eq__(rhs)
- def __hash__(self):
+ def __hash__(self) -> int:
return hash(self.git_dir)
# Description property
- def _get_description(self):
- filename = osp.join(self.git_dir, 'description')
+ def _get_description(self) -> str:
+ if self.git_dir:
+ filename = osp.join(self.git_dir, 'description')
with open(filename, 'rb') as fp:
return fp.read().rstrip().decode(defenc)
- def _set_description(self, descr):
- filename = osp.join(self.git_dir, 'description')
+ def _set_description(self, descr: str) -> None:
+ if self.git_dir:
+ filename = osp.join(self.git_dir, 'description')
with open(filename, 'wb') as fp:
fp.write((descr + '\n').encode(defenc))
@@ -263,25 +285,31 @@ class Repo(object):
del _set_description
@property
- def working_tree_dir(self):
+ def working_tree_dir(self) -> Optional[PathLike]:
""":return: The working tree directory of our git repository. If this is a bare repository, None is returned.
"""
return self._working_tree_dir
@property
- def common_dir(self):
+ def common_dir(self) -> PathLike:
"""
:return: The git dir that holds everything except possibly HEAD,
FETCH_HEAD, ORIG_HEAD, COMMIT_EDITMSG, index, and logs/."""
- return self._common_dir or self.git_dir
+ if self._common_dir:
+ return self._common_dir
+ elif self.git_dir:
+ return self.git_dir
+ else:
+ # or could return ""
+ raise InvalidGitRepositoryError()
@property
- def bare(self):
+ def bare(self) -> bool:
""":return: True if the repository is bare"""
return self._bare
@property
- def heads(self):
+ def heads(self) -> 'IterableList':
"""A list of ``Head`` objects representing the branch heads in
this repo
@@ -289,7 +317,7 @@ class Repo(object):
return Head.list_items(self)
@property
- def references(self):
+ def references(self) -> 'IterableList':
"""A list of Reference objects representing tags, heads and remote references.
:return: IterableList(Reference, ...)"""
@@ -302,24 +330,24 @@ class Repo(object):
branches = heads
@property
- def index(self):
+ def index(self) -> 'IndexFile':
""":return: IndexFile representing this repository's index.
:note: This property can be expensive, as the returned ``IndexFile`` will be
reinitialized. It's recommended to re-use the object."""
return IndexFile(self)
@property
- def head(self):
+ def head(self) -> 'HEAD':
""":return: HEAD Object pointing to the current head reference"""
return HEAD(self, 'HEAD')
@property
- def remotes(self):
+ def remotes(self) -> 'IterableList':
"""A list of Remote objects allowing to access and manipulate remotes
:return: ``git.IterableList(Remote, ...)``"""
return Remote.list_items(self)
- def remote(self, name='origin'):
+ def remote(self, name: str = 'origin') -> 'Remote':
""":return: Remote with the specified name
:raise ValueError: if no remote with such a name exists"""
r = Remote(self, name)
@@ -330,13 +358,13 @@ class Repo(object):
#{ Submodules
@property
- def submodules(self):
+ def submodules(self) -> 'IterableList':
"""
:return: git.IterableList(Submodule, ...) of direct submodules
available from the current head"""
return Submodule.list_items(self)
- def submodule(self, name):
+ def submodule(self, name: str) -> 'IterableList':
""" :return: Submodule with the given name
:raise ValueError: If no such submodule exists"""
try:
@@ -345,7 +373,7 @@ class Repo(object):
raise ValueError("Didn't find submodule named %r" % name) from e
# END exception handling
- def create_submodule(self, *args, **kwargs):
+ def create_submodule(self, *args: Any, **kwargs: Any) -> Submodule:
"""Create a new submodule
:note: See the documentation of Submodule.add for a description of the
@@ -353,13 +381,13 @@ class Repo(object):
:return: created submodules"""
return Submodule.add(self, *args, **kwargs)
- def iter_submodules(self, *args, **kwargs):
+ def iter_submodules(self, *args: Any, **kwargs: Any) -> Iterator:
"""An iterator yielding Submodule instances, see Traversable interface
for a description of args and kwargs
:return: Iterator"""
return RootModule(self).traverse(*args, **kwargs)
- def submodule_update(self, *args, **kwargs):
+ def submodule_update(self, *args: Any, **kwargs: Any) -> Iterator:
"""Update the submodules, keeping the repository consistent as it will
take the previous state into consideration. For more information, please
see the documentation of RootModule.update"""
@@ -368,41 +396,45 @@ class Repo(object):
#}END submodules
@property
- def tags(self):
+ def tags(self) -> 'IterableList':
"""A list of ``Tag`` objects that are available in this repo
:return: ``git.IterableList(TagReference, ...)`` """
return TagReference.list_items(self)
- def tag(self, path):
+ def tag(self, path: PathLike) -> TagReference:
""":return: TagReference Object, reference pointing to a Commit or Tag
:param path: path to the tag reference, i.e. 0.1.5 or tags/0.1.5 """
return TagReference(self, path)
- def create_head(self, path, commit='HEAD', force=False, logmsg=None):
+ def create_head(self, path: PathLike, commit: str = 'HEAD',
+ force: bool = False, logmsg: Optional[str] = None
+ ) -> 'SymbolicReference':
"""Create a new head within the repository.
For more documentation, please see the Head.create method.
:return: newly created Head Reference"""
return Head.create(self, path, commit, force, logmsg)
- def delete_head(self, *heads, **kwargs):
+ def delete_head(self, *heads: 'SymbolicReference', **kwargs: Any) -> None:
"""Delete the given heads
:param kwargs: Additional keyword arguments to be passed to git-branch"""
return Head.delete(self, *heads, **kwargs)
- def create_tag(self, path, ref='HEAD', message=None, force=False, **kwargs):
+ def create_tag(self, path: PathLike, ref: str = 'HEAD',
+ message: Optional[str] = None, force: bool = False, **kwargs: Any
+ ) -> TagReference:
"""Create a new tag reference.
For more documentation, please see the TagReference.create method.
:return: TagReference object """
return TagReference.create(self, path, ref, message, force, **kwargs)
- def delete_tag(self, *tags):
+ def delete_tag(self, *tags: TBD) -> None:
"""Delete the given tag references"""
return TagReference.delete(self, *tags)
- def create_remote(self, name, url, **kwargs):
+ def create_remote(self, name: str, url: PathLike, **kwargs: Any) -> Remote:
"""Create a new remote.
For more information, please see the documentation of the Remote.create
@@ -411,11 +443,11 @@ class Repo(object):
:return: Remote reference"""
return Remote.create(self, name, url, **kwargs)
- def delete_remote(self, remote):
+ def delete_remote(self, remote: 'Remote') -> Type['Remote']:
"""Delete the given remote."""
return Remote.remove(self, remote)
- def _get_config_path(self, config_level):
+ def _get_config_path(self, config_level: Lit_config_levels) -> str:
# we do not support an absolute path of the gitconfig on windows ,
# use the global config instead
if is_win and config_level == "system":
@@ -429,11 +461,15 @@ class Repo(object):
elif config_level == "global":
return osp.normpath(osp.expanduser("~/.gitconfig"))
elif config_level == "repository":
- return osp.normpath(osp.join(self._common_dir or self.git_dir, "config"))
+ repo_dir = self._common_dir or self.git_dir
+ if not repo_dir:
+ raise NotADirectoryError
+ else:
+ return osp.normpath(osp.join(repo_dir, "config"))
raise ValueError("Invalid configuration level: %r" % config_level)
- def config_reader(self, config_level=None):
+ def config_reader(self, config_level: Optional[Lit_config_levels] = None) -> GitConfigParser:
"""
:return:
GitConfigParser allowing to read the full git configuration, but not to write it
@@ -454,7 +490,7 @@ class Repo(object):
files = [self._get_config_path(config_level)]
return GitConfigParser(files, read_only=True, repo=self)
- def config_writer(self, config_level="repository"):
+ def config_writer(self, config_level: Lit_config_levels = "repository") -> GitConfigParser:
"""
:return:
GitConfigParser allowing to write values of the specified configuration file level.
@@ -469,7 +505,8 @@ class Repo(object):
repository = configuration file for this repository only"""
return GitConfigParser(self._get_config_path(config_level), read_only=False, repo=self)
- def commit(self, rev=None):
+ def commit(self, rev: Optional[TBD] = None
+ ) -> Union['SymbolicReference', Commit, 'TagObject', 'Blob', 'Tree']:
"""The Commit object for the specified revision
:param rev: revision specifier, see git-rev-parse for viable options.
@@ -479,12 +516,12 @@ class Repo(object):
return self.head.commit
return self.rev_parse(str(rev) + "^0")
- def iter_trees(self, *args, **kwargs):
+ def iter_trees(self, *args: Any, **kwargs: Any) -> Iterator['Tree']:
""":return: Iterator yielding Tree objects
:note: Takes all arguments known to iter_commits method"""
return (c.tree for c in self.iter_commits(*args, **kwargs))
- def tree(self, rev=None):
+ def tree(self, rev: Union['Commit', 'Tree', None] = None) -> 'Tree':
"""The Tree object for the given treeish revision
Examples::
@@ -501,7 +538,8 @@ class Repo(object):
return self.head.commit.tree
return self.rev_parse(str(rev) + "^{tree}")
- def iter_commits(self, rev=None, paths='', **kwargs):
+ def iter_commits(self, rev: Optional[TBD] = None, paths: Union[PathLike, List[PathLike]] = '',
+ **kwargs: Any) -> Iterator[Commit]:
"""A list of Commit objects representing the history of a given ref/commit
:param rev:
@@ -525,7 +563,8 @@ class Repo(object):
return Commit.iter_items(self, rev, paths, **kwargs)
- def merge_base(self, *rev, **kwargs):
+ def merge_base(self, *rev: TBD, **kwargs: Any
+ ) -> List[Union['SymbolicReference', Commit, 'TagObject', 'Blob', 'Tree', None]]:
"""Find the closest common ancestor for the given revision (e.g. Commits, Tags, References, etc)
:param rev: At least two revs to find the common ancestor for.
@@ -538,9 +577,9 @@ class Repo(object):
raise ValueError("Please specify at least two revs, got only %i" % len(rev))
# end handle input
- res = []
+ res = [] # type: List[Union['SymbolicReference', Commit, 'TagObject', 'Blob', 'Tree', None]]
try:
- lines = self.git.merge_base(*rev, **kwargs).splitlines()
+ lines = self.git.merge_base(*rev, **kwargs).splitlines() # List[str]
except GitCommandError as err:
if err.status == 128:
raise
@@ -556,7 +595,7 @@ class Repo(object):
return res
- def is_ancestor(self, ancestor_rev, rev):
+ def is_ancestor(self, ancestor_rev: 'Commit', rev: 'Commit') -> bool:
"""Check if a commit is an ancestor of another
:param ancestor_rev: Rev which should be an ancestor
@@ -571,12 +610,14 @@ class Repo(object):
raise
return True
- def _get_daemon_export(self):
- filename = osp.join(self.git_dir, self.DAEMON_EXPORT_FILE)
+ def _get_daemon_export(self) -> bool:
+ if self.git_dir:
+ filename = osp.join(self.git_dir, self.DAEMON_EXPORT_FILE)
return osp.exists(filename)
- def _set_daemon_export(self, value):
- filename = osp.join(self.git_dir, self.DAEMON_EXPORT_FILE)
+ def _set_daemon_export(self, value: object) -> None:
+ if self.git_dir:
+ filename = osp.join(self.git_dir, self.DAEMON_EXPORT_FILE)
fileexists = osp.exists(filename)
if value and not fileexists:
touch(filename)
@@ -588,11 +629,12 @@ class Repo(object):
del _get_daemon_export
del _set_daemon_export
- def _get_alternates(self):
+ def _get_alternates(self) -> List[str]:
"""The list of alternates for this repo from which objects can be retrieved
:return: list of strings being pathnames of alternates"""
- alternates_path = osp.join(self.git_dir, 'objects', 'info', 'alternates')
+ if self.git_dir:
+ alternates_path = osp.join(self.git_dir, 'objects', 'info', 'alternates')
if osp.exists(alternates_path):
with open(alternates_path, 'rb') as f:
@@ -600,7 +642,7 @@ class Repo(object):
return alts.strip().splitlines()
return []
- def _set_alternates(self, alts):
+ def _set_alternates(self, alts: List[str]) -> None:
"""Sets the alternates
:param alts:
@@ -622,8 +664,8 @@ class Repo(object):
alternates = property(_get_alternates, _set_alternates,
doc="Retrieve a list of alternates paths or set a list paths to be used as alternates")
- def is_dirty(self, index=True, working_tree=True, untracked_files=False,
- submodules=True, path=None):
+ def is_dirty(self, index: bool = True, working_tree: bool = True, untracked_files: bool = False,
+ submodules: bool = True, path: Optional[PathLike] = None) -> bool:
"""
:return:
``True``, the repository is considered dirty. By default it will react
@@ -639,7 +681,7 @@ class Repo(object):
if not submodules:
default_args.append('--ignore-submodules')
if path:
- default_args.extend(["--", path])
+ default_args.extend(["--", str(path)])
if index:
# diff index against HEAD
if osp.isfile(self.index.path) and \
@@ -658,7 +700,7 @@ class Repo(object):
return False
@property
- def untracked_files(self):
+ def untracked_files(self) -> List[str]:
"""
:return:
list(str,...)
@@ -673,7 +715,7 @@ class Repo(object):
consider caching it yourself."""
return self._get_untracked_files()
- def _get_untracked_files(self, *args, **kwargs):
+ def _get_untracked_files(self, *args: Any, **kwargs: Any) -> List[str]:
# make sure we get all files, not only untracked directories
proc = self.git.status(*args,
porcelain=True,
@@ -697,7 +739,7 @@ class Repo(object):
finalize_process(proc)
return untracked_files
- def ignored(self, *paths):
+ def ignored(self, *paths: PathLike) -> List[PathLike]:
"""Checks if paths are ignored via .gitignore
Doing so using the "git check-ignore" method.
@@ -711,13 +753,13 @@ class Repo(object):
return proc.replace("\\\\", "\\").replace('"', "").split("\n")
@property
- def active_branch(self):
+ def active_branch(self) -> 'SymbolicReference':
"""The name of the currently active branch.
:return: Head to the active branch"""
return self.head.reference
- def blame_incremental(self, rev, file, **kwargs):
+ def blame_incremental(self, rev: TBD, file: TBD, **kwargs: Any) -> Optional[Iterator['BlameEntry']]:
"""Iterator for blame information for the given file at the given revision.
Unlike .blame(), this does not return the actual file's contents, only
@@ -732,7 +774,7 @@ class Repo(object):
should get a continuous range spanning all line numbers in the file.
"""
data = self.git.blame(rev, '--', file, p=True, incremental=True, stdout_as_string=False, **kwargs)
- commits = {}
+ commits = {} # type: Dict[str, TBD]
stream = (line for line in data.split(b'\n') if line)
while True:
@@ -740,10 +782,11 @@ class Repo(object):
line = next(stream) # when exhausted, causes a StopIteration, terminating this function
except StopIteration:
return
- hexsha, orig_lineno, lineno, num_lines = line.split()
- lineno = int(lineno)
- num_lines = int(num_lines)
- orig_lineno = int(orig_lineno)
+ split_line = line.split() # type: Tuple[str, str, str, str]
+ hexsha, orig_lineno_str, lineno_str, num_lines_str = split_line
+ lineno = int(lineno_str)
+ num_lines = int(num_lines_str)
+ orig_lineno = int(orig_lineno_str)
if hexsha not in commits:
# Now read the next few lines and build up a dict of properties
# for this commit
@@ -791,22 +834,24 @@ class Repo(object):
safe_decode(orig_filename),
range(orig_lineno, orig_lineno + num_lines))
- def blame(self, rev, file, incremental=False, **kwargs):
+ def blame(self, rev: TBD, file: TBD, incremental: bool = False, **kwargs: Any
+ ) -> Union[List[List[Union[Optional['Commit'], List[str]]]], Optional[Iterator[BlameEntry]]]:
"""The blame information for the given file at the given revision.
:param rev: revision specifier, see git-rev-parse for viable options.
:return:
list: [git.Commit, list: [<line>]]
- A list of tuples associating a Commit object with a list of lines that
+ A list of lists associating a Commit object with a list of lines that
changed within the given commit. The Commit objects will be given in order
of appearance."""
if incremental:
return self.blame_incremental(rev, file, **kwargs)
data = self.git.blame(rev, '--', file, p=True, stdout_as_string=False, **kwargs)
- commits = {}
- blames = []
- info = None
+ commits = {} # type: Dict[str, Any]
+ blames = [] # type: List[List[Union[Optional['Commit'], List[str]]]]
+
+ info = {} # type: Dict[str, Any] # use Any until TypedDict available
keepends = True
for line in data.splitlines(keepends):
@@ -891,7 +936,8 @@ class Repo(object):
pass
# end handle line contents
blames[-1][0] = c
- blames[-1][1].append(line)
+ if blames[-1][1] is not None:
+ blames[-1][1].append(line)
info = {'id': sha}
# END if we collected commit info
# END distinguish filename,summary,rest
@@ -900,7 +946,8 @@ class Repo(object):
return blames
@classmethod
- def init(cls, path=None, mkdir=True, odbt=GitCmdObjectDB, expand_vars=True, **kwargs):
+ def init(cls, path: PathLike = None, mkdir: bool = True, odbt: Type[GitCmdObjectDB] = GitCmdObjectDB,
+ expand_vars: bool = True, **kwargs: Any) -> 'Repo':
"""Initialize a git repository at the given path if specified
:param path:
@@ -938,9 +985,10 @@ class Repo(object):
return cls(path, odbt=odbt)
@classmethod
- def _clone(cls, git, url, path, odb_default_type, progress, multi_options=None, **kwargs):
- if progress is not None:
- progress = to_progress_instance(progress)
+ def _clone(cls, git: 'Git', url: PathLike, path: PathLike, odb_default_type: Type[GitCmdObjectDB],
+ progress: Optional[Callable], multi_options: Optional[List[str]] = None, **kwargs: Any
+ ) -> 'Repo':
+ progress_checked = to_progress_instance(progress)
odbt = kwargs.pop('odbt', odb_default_type)
@@ -964,9 +1012,10 @@ class Repo(object):
if multi_options:
multi = ' '.join(multi_options).split(' ')
proc = git.clone(multi, Git.polish_url(url), clone_path, with_extended_output=True, as_process=True,
- v=True, universal_newlines=True, **add_progress(kwargs, git, progress))
- if progress:
- handle_process_output(proc, None, progress.new_message_handler(), finalize_process, decode_streams=False)
+ v=True, universal_newlines=True, **add_progress(kwargs, git, progress_checked))
+ if progress_checked:
+ handle_process_output(proc, None, progress_checked.new_message_handler(),
+ finalize_process, decode_streams=False)
else:
(stdout, stderr) = proc.communicate()
cmdline = getattr(proc, 'args', '')
@@ -977,8 +1026,8 @@ class Repo(object):
# our git command could have a different working dir than our actual
# environment, hence we prepend its working dir if required
- if not osp.isabs(path) and git.working_dir:
- path = osp.join(git._working_dir, path)
+ if not osp.isabs(path):
+ path = osp.join(git._working_dir, path) if git._working_dir is not None else path
repo = cls(path, odbt=odbt)
@@ -996,7 +1045,8 @@ class Repo(object):
# END handle remote repo
return repo
- def clone(self, path, progress=None, multi_options=None, **kwargs):
+ def clone(self, path: PathLike, progress: Optional[Callable] = None,
+ multi_options: Optional[List[str]] = None, **kwargs: Any) -> 'Repo':
"""Create a clone from this repository.
:param path: is the full path of the new repo (traditionally ends with ./<name>.git).
@@ -1014,7 +1064,9 @@ class Repo(object):
return self._clone(self.git, self.common_dir, path, type(self.odb), progress, multi_options, **kwargs)
@classmethod
- def clone_from(cls, url, to_path, progress=None, env=None, multi_options=None, **kwargs):
+ def clone_from(cls, url: PathLike, to_path: PathLike, progress: Optional[Callable] = None,
+ env: Optional[Mapping[str, Any]] = None,
+ multi_options: Optional[List[str]] = None, **kwargs: Any) -> 'Repo':
"""Create a clone from the given URL
:param url: valid git url, see http://www.kernel.org/pub/software/scm/git/docs/git-clone.html#URLS
@@ -1034,7 +1086,8 @@ class Repo(object):
git.update_environment(**env)
return cls._clone(git, url, to_path, GitCmdObjectDB, progress, multi_options, **kwargs)
- def archive(self, ostream, treeish=None, prefix=None, **kwargs):
+ def archive(self, ostream: Union[TextIO, BinaryIO], treeish: Optional[str] = None,
+ prefix: Optional[str] = None, **kwargs: Any) -> 'Repo':
"""Archive the tree at the given revision.
:param ostream: file compatible stream object to which the archive will be written as bytes
@@ -1055,14 +1108,14 @@ class Repo(object):
kwargs['prefix'] = prefix
kwargs['output_stream'] = ostream
path = kwargs.pop('path', [])
+ path = cast(Union[PathLike, List[PathLike], Tuple[PathLike, ...]], path)
if not isinstance(path, (tuple, list)):
path = [path]
# end assure paths is list
-
self.git.archive(treeish, *path, **kwargs)
return self
- def has_separate_working_tree(self):
+ def has_separate_working_tree(self) -> bool:
"""
:return: True if our git_dir is not at the root of our working_tree_dir, but a .git file with a
platform agnositic symbolic link. Our git_dir will be wherever the .git file points to
@@ -1070,21 +1123,25 @@ class Repo(object):
"""
if self.bare:
return False
- return osp.isfile(osp.join(self.working_tree_dir, '.git'))
+ if self.working_tree_dir:
+ return osp.isfile(osp.join(self.working_tree_dir, '.git'))
+ else:
+ return False # or raise Error?
rev_parse = rev_parse
- def __repr__(self):
+ def __repr__(self) -> str:
clazz = self.__class__
return '<%s.%s %r>' % (clazz.__module__, clazz.__name__, self.git_dir)
- def currently_rebasing_on(self):
+ def currently_rebasing_on(self) -> Union['SymbolicReference', Commit, 'TagObject', 'Blob', 'Tree', None]:
"""
:return: The commit which is currently being replayed while rebasing.
None if we are not currently rebasing.
"""
- rebase_head_file = osp.join(self.git_dir, "REBASE_HEAD")
+ if self.git_dir:
+ rebase_head_file = osp.join(self.git_dir, "REBASE_HEAD")
if not osp.isfile(rebase_head_file):
return None
return self.commit(open(rebase_head_file, "rt").readline().strip())
diff --git a/git/repo/fun.py b/git/repo/fun.py
index 714d4122..70394081 100644
--- a/git/repo/fun.py
+++ b/git/repo/fun.py
@@ -1,4 +1,5 @@
"""Package with general repository related functions"""
+from git.refs.tag import Tag
import os
import stat
from string import digits
@@ -15,18 +16,28 @@ from gitdb.exc import (
import os.path as osp
from git.cmd import Git
+# Typing ----------------------------------------------------------------------
+
+from typing import AnyStr, Union, Optional, cast, TYPE_CHECKING
+from git.types import PathLike
+if TYPE_CHECKING:
+ from .base import Repo
+ from git.db import GitCmdObjectDB
+ from git.objects import Commit, TagObject, Blob, Tree
+
+# ----------------------------------------------------------------------------
__all__ = ('rev_parse', 'is_git_dir', 'touch', 'find_submodule_git_dir', 'name_to_object', 'short_to_long', 'deref_tag',
'to_commit', 'find_worktree_git_dir')
-def touch(filename):
+def touch(filename: str) -> str:
with open(filename, "ab"):
pass
return filename
-def is_git_dir(d):
+def is_git_dir(d: PathLike) -> bool:
""" This is taken from the git setup.c:is_git_directory
function.
@@ -48,7 +59,7 @@ def is_git_dir(d):
return False
-def find_worktree_git_dir(dotgit):
+def find_worktree_git_dir(dotgit: PathLike) -> Optional[str]:
"""Search for a gitdir for this worktree."""
try:
statbuf = os.stat(dotgit)
@@ -67,7 +78,7 @@ def find_worktree_git_dir(dotgit):
return None
-def find_submodule_git_dir(d):
+def find_submodule_git_dir(d: PathLike) -> Optional[PathLike]:
"""Search for a submodule repo."""
if is_git_dir(d):
return d
@@ -75,7 +86,7 @@ def find_submodule_git_dir(d):
try:
with open(d) as fp:
content = fp.read().rstrip()
- except (IOError, OSError):
+ except IOError:
# it's probably not a file
pass
else:
@@ -92,7 +103,7 @@ def find_submodule_git_dir(d):
return None
-def short_to_long(odb, hexsha):
+def short_to_long(odb: 'GitCmdObjectDB', hexsha: AnyStr) -> Optional[bytes]:
""":return: long hexadecimal sha1 from the given less-than-40 byte hexsha
or None if no candidate could be found.
:param hexsha: hexsha with less than 40 byte"""
@@ -103,14 +114,15 @@ def short_to_long(odb, hexsha):
# END exception handling
-def name_to_object(repo, name, return_ref=False):
+def name_to_object(repo: 'Repo', name: str, return_ref: bool = False
+ ) -> Union[SymbolicReference, 'Commit', 'TagObject', 'Blob', 'Tree']:
"""
:return: object specified by the given name, hexshas ( short and long )
as well as references are supported
:param return_ref: if name specifies a reference, we will return the reference
instead of the object. Otherwise it will raise BadObject or BadName
"""
- hexsha = None
+ hexsha = None # type: Union[None, str, bytes]
# is it a hexsha ? Try the most common ones, which is 7 to 40
if repo.re_hexsha_shortened.match(name):
@@ -150,7 +162,7 @@ def name_to_object(repo, name, return_ref=False):
return Object.new_from_sha(repo, hex_to_bin(hexsha))
-def deref_tag(tag):
+def deref_tag(tag: Tag) -> 'TagObject':
"""Recursively dereference a tag and return the resulting object"""
while True:
try:
@@ -161,7 +173,7 @@ def deref_tag(tag):
return tag
-def to_commit(obj):
+def to_commit(obj: Object) -> Union['Commit', 'TagObject']:
"""Convert the given object to a commit if possible and return it"""
if obj.type == 'tag':
obj = deref_tag(obj)
@@ -172,7 +184,7 @@ def to_commit(obj):
return obj
-def rev_parse(repo, rev):
+def rev_parse(repo: 'Repo', rev: str) -> Union['Commit', 'Tag', 'Tree', 'Blob']:
"""
:return: Object at the given revision, either Commit, Tag, Tree or Blob
:param rev: git-rev-parse compatible revision specification as string, please see
@@ -188,7 +200,7 @@ def rev_parse(repo, rev):
raise NotImplementedError("commit by message search ( regex )")
# END handle search
- obj = None
+ obj = cast(Object, None) # not ideal. Should use guards
ref = None
output_type = "commit"
start = 0
@@ -238,7 +250,7 @@ def rev_parse(repo, rev):
pass # error raised later
# END exception handling
elif output_type in ('', 'blob'):
- if obj.type == 'tag':
+ if obj and obj.type == 'tag':
obj = deref_tag(obj)
else:
# cannot do anything for non-tags
diff --git a/git/util.py b/git/util.py
index d0aec5ae..af499028 100644
--- a/git/util.py
+++ b/git/util.py
@@ -3,6 +3,7 @@
#
# This module is part of GitPython and is released under
# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
import contextlib
from functools import wraps
import getpass
@@ -18,7 +19,19 @@ import time
from unittest import SkipTest
from urllib.parse import urlsplit, urlunsplit
-from gitdb.util import (# NOQA @IgnorePep8
+# typing ---------------------------------------------------------
+
+from typing import (Any, AnyStr, BinaryIO, Callable, Dict, Generator, IO, List,
+ NoReturn, Optional, Pattern, Sequence, Tuple, Union, cast, TYPE_CHECKING)
+if TYPE_CHECKING:
+ from git.remote import Remote
+ from git.repo.base import Repo
+from .types import PathLike, TBD
+
+# ---------------------------------------------------------------------
+
+
+from gitdb.util import ( # NOQA @IgnorePep8
make_sha,
LockedFD, # @UnusedImport
file_contents_ro, # @UnusedImport
@@ -30,7 +43,7 @@ from gitdb.util import (# NOQA @IgnorePep8
hex_to_bin, # @UnusedImport
)
-from git.compat import is_win
+from .compat import is_win
import os.path as osp
from .exc import InvalidGitRepositoryError
@@ -48,6 +61,9 @@ __all__ = ["stream_copy", "join_path", "to_native_path_linux",
log = logging.getLogger(__name__)
+# types############################################################
+
+
#: We need an easy way to see if Appveyor TCs start failing,
#: so the errors marked with this var are considered "acknowledged" ones, awaiting remedy,
#: till then, we wish to hide them.
@@ -57,22 +73,23 @@ HIDE_WINDOWS_FREEZE_ERRORS = is_win and os.environ.get('HIDE_WINDOWS_FREEZE_ERRO
#{ Utility Methods
-def unbare_repo(func):
+def unbare_repo(func: Callable) -> Callable:
"""Methods with this decorator raise InvalidGitRepositoryError if they
encounter a bare repository"""
@wraps(func)
- def wrapper(self, *args, **kwargs):
+ def wrapper(self: 'Remote', *args: Any, **kwargs: Any) -> TBD:
if self.repo.bare:
raise InvalidGitRepositoryError("Method '%s' cannot operate on bare repositories" % func.__name__)
# END bare method
return func(self, *args, **kwargs)
# END wrapper
+
return wrapper
@contextlib.contextmanager
-def cwd(new_dir):
+def cwd(new_dir: PathLike) -> Generator[PathLike, None, None]:
old_dir = os.getcwd()
os.chdir(new_dir)
try:
@@ -81,13 +98,13 @@ def cwd(new_dir):
os.chdir(old_dir)
-def rmtree(path):
+def rmtree(path: PathLike) -> None:
"""Remove the given recursively.
:note: we use shutil rmtree but adjust its behaviour to see whether files that
couldn't be deleted are read-only. Windows will not remove them in that case"""
- def onerror(func, path, exc_info):
+ def onerror(func: Callable, path: PathLike, exc_info: TBD) -> None:
# Is the error an access error ?
os.chmod(path, stat.S_IWUSR)
@@ -101,7 +118,7 @@ def rmtree(path):
return shutil.rmtree(path, False, onerror)
-def rmfile(path):
+def rmfile(path: PathLike) -> None:
"""Ensure file deleted also on *Windows* where read-only files need special treatment."""
if osp.isfile(path):
if is_win:
@@ -109,7 +126,7 @@ def rmfile(path):
os.remove(path)
-def stream_copy(source, destination, chunk_size=512 * 1024):
+def stream_copy(source: BinaryIO, destination: BinaryIO, chunk_size: int = 512 * 1024) -> int:
"""Copy all data from the source stream into the destination stream in chunks
of size chunk_size
@@ -125,11 +142,12 @@ def stream_copy(source, destination, chunk_size=512 * 1024):
return br
-def join_path(a, *p):
+def join_path(a: PathLike, *p: PathLike) -> PathLike:
"""Join path tokens together similar to osp.join, but always use
'/' instead of possibly '\' on windows."""
- path = a
+ path = str(a)
for b in p:
+ b = str(b)
if not b:
continue
if b.startswith('/'):
@@ -143,22 +161,24 @@ def join_path(a, *p):
if is_win:
- def to_native_path_windows(path):
+ def to_native_path_windows(path: PathLike) -> PathLike:
+ path = str(path)
return path.replace('/', '\\')
- def to_native_path_linux(path):
+ def to_native_path_linux(path: PathLike) -> PathLike:
+ path = str(path)
return path.replace('\\', '/')
__all__.append("to_native_path_windows")
to_native_path = to_native_path_windows
else:
# no need for any work on linux
- def to_native_path_linux(path):
+ def to_native_path_linux(path: PathLike) -> PathLike:
return path
to_native_path = to_native_path_linux
-def join_path_native(a, *p):
+def join_path_native(a: PathLike, *p: PathLike) -> PathLike:
"""
As join path, but makes sure an OS native path is returned. This is only
needed to play it safe on my dear windows and to assure nice paths that only
@@ -166,7 +186,7 @@ def join_path_native(a, *p):
return to_native_path(join_path(a, *p))
-def assure_directory_exists(path, is_file=False):
+def assure_directory_exists(path: PathLike, is_file: bool = False) -> bool:
"""Assure that the directory pointed to by path exists.
:param is_file: If True, path is assumed to be a file and handled correctly.
@@ -181,18 +201,18 @@ def assure_directory_exists(path, is_file=False):
return False
-def _get_exe_extensions():
+def _get_exe_extensions() -> Sequence[str]:
PATHEXT = os.environ.get('PATHEXT', None)
- return tuple(p.upper() for p in PATHEXT.split(os.pathsep)) \
- if PATHEXT \
- else (('.BAT', 'COM', '.EXE') if is_win else ())
+ return tuple(p.upper() for p in PATHEXT.split(os.pathsep)) if PATHEXT \
+ else ('.BAT', 'COM', '.EXE') if is_win \
+ else ('')
-def py_where(program, path=None):
+def py_where(program: str, path: Optional[PathLike] = None) -> List[str]:
# From: http://stackoverflow.com/a/377028/548792
winprog_exts = _get_exe_extensions()
- def is_exec(fpath):
+ def is_exec(fpath: str) -> bool:
return osp.isfile(fpath) and os.access(fpath, os.X_OK) and (
os.name != 'nt' or not winprog_exts or any(fpath.upper().endswith(ext)
for ext in winprog_exts))
@@ -200,7 +220,7 @@ def py_where(program, path=None):
progs = []
if not path:
path = os.environ["PATH"]
- for folder in path.split(os.pathsep):
+ for folder in str(path).split(os.pathsep):
folder = folder.strip('"')
if folder:
exe_path = osp.join(folder, program)
@@ -210,11 +230,11 @@ def py_where(program, path=None):
return progs
-def _cygexpath(drive, path):
+def _cygexpath(drive: Optional[str], path: PathLike) -> str:
if osp.isabs(path) and not drive:
## Invoked from `cygpath()` directly with `D:Apps\123`?
# It's an error, leave it alone just slashes)
- p = path
+ p = path # convert to str if AnyPath given
else:
p = path and osp.normpath(osp.expandvars(osp.expanduser(path)))
if osp.isabs(p):
@@ -225,8 +245,8 @@ def _cygexpath(drive, path):
p = cygpath(p)
elif drive:
p = '/cygdrive/%s/%s' % (drive.lower(), p)
-
- return p.replace('\\', '/')
+ p_str = str(p) # ensure it is a str and not AnyPath
+ return p_str.replace('\\', '/')
_cygpath_parsers = (
@@ -238,27 +258,30 @@ _cygpath_parsers = (
),
(re.compile(r"\\\\\?\\(\w):[/\\](.*)"),
- _cygexpath,
+ (_cygexpath),
False
),
(re.compile(r"(\w):[/\\](.*)"),
- _cygexpath,
+ (_cygexpath),
False
),
(re.compile(r"file:(.*)", re.I),
(lambda rest_path: rest_path),
- True),
+ True
+ ),
(re.compile(r"(\w{2,}:.*)"), # remote URL, do nothing
(lambda url: url),
- False),
-)
+ False
+ ),
+) # type: Tuple[Tuple[Pattern[str], Callable, bool], ...]
-def cygpath(path):
+def cygpath(path: PathLike) -> PathLike:
"""Use :meth:`git.cmd.Git.polish_url()` instead, that works on any environment."""
+ path = str(path) # ensure is str and not AnyPath
if not path.startswith(('/cygdrive', '//')):
for regex, parser, recurse in _cygpath_parsers:
match = regex.match(path)
@@ -276,7 +299,8 @@ def cygpath(path):
_decygpath_regex = re.compile(r"/cygdrive/(\w)(/.*)?")
-def decygpath(path):
+def decygpath(path: PathLike) -> str:
+ path = str(path)
m = _decygpath_regex.match(path)
if m:
drive, rest_path = m.groups()
@@ -287,23 +311,23 @@ def decygpath(path):
#: Store boolean flags denoting if a specific Git executable
#: is from a Cygwin installation (since `cache_lru()` unsupported on PY2).
-_is_cygwin_cache = {}
+_is_cygwin_cache = {} # type: Dict[str, Optional[bool]]
-def is_cygwin_git(git_executable):
+def is_cygwin_git(git_executable: PathLike) -> bool:
if not is_win:
return False
#from subprocess import check_output
-
- is_cygwin = _is_cygwin_cache.get(git_executable)
+ git_executable = str(git_executable)
+ is_cygwin = _is_cygwin_cache.get(git_executable) # type: Optional[bool]
if is_cygwin is None:
is_cygwin = False
try:
git_dir = osp.dirname(git_executable)
if not git_dir:
res = py_where(git_executable)
- git_dir = osp.dirname(res[0]) if res else None
+ git_dir = osp.dirname(res[0]) if res else ""
## Just a name given, not a real path.
uname_cmd = osp.join(git_dir, 'uname')
@@ -319,18 +343,18 @@ def is_cygwin_git(git_executable):
return is_cygwin
-def get_user_id():
+def get_user_id() -> str:
""":return: string identifying the currently active system user as name@node"""
return "%s@%s" % (getpass.getuser(), platform.node())
-def finalize_process(proc, **kwargs):
+def finalize_process(proc: TBD, **kwargs: Any) -> None:
"""Wait for the process (clone, fetch, pull or push) and handle its errors accordingly"""
## TODO: No close proc-streams??
proc.wait(**kwargs)
-def expand_path(p, expand_vars=True):
+def expand_path(p: PathLike, expand_vars: bool = True) -> Optional[PathLike]:
try:
p = osp.expanduser(p)
if expand_vars:
@@ -393,13 +417,13 @@ class RemoteProgress(object):
re_op_absolute = re.compile(r"(remote: )?([\w\s]+):\s+()(\d+)()(.*)")
re_op_relative = re.compile(r"(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)")
- def __init__(self):
- self._seen_ops = []
- self._cur_line = None
- self.error_lines = []
- self.other_lines = []
+ def __init__(self) -> None:
+ self._seen_ops = [] # type: List[TBD]
+ self._cur_line = None # type: Optional[str]
+ self.error_lines = [] # type: List[str]
+ self.other_lines = [] # type: List[str]
- def _parse_progress_line(self, line):
+ def _parse_progress_line(self, line: AnyStr) -> None:
"""Parse progress information from the given line as retrieved by git-push
or git-fetch.
@@ -411,7 +435,12 @@ class RemoteProgress(object):
# Compressing objects: 50% (1/2)
# Compressing objects: 100% (2/2)
# Compressing objects: 100% (2/2), done.
- self._cur_line = line = line.decode('utf-8') if isinstance(line, bytes) else line
+ if isinstance(line, bytes): # mypy argues about ternary assignment
+ line_str = line.decode('utf-8')
+ else:
+ line_str = line
+ self._cur_line = line_str
+
if self.error_lines or self._cur_line.startswith(('error:', 'fatal:')):
self.error_lines.append(self._cur_line)
return
@@ -419,25 +448,25 @@ class RemoteProgress(object):
# find escape characters and cut them away - regex will not work with
# them as they are non-ascii. As git might expect a tty, it will send them
last_valid_index = None
- for i, c in enumerate(reversed(line)):
+ for i, c in enumerate(reversed(line_str)):
if ord(c) < 32:
# its a slice index
last_valid_index = -i - 1
# END character was non-ascii
# END for each character in line
if last_valid_index is not None:
- line = line[:last_valid_index]
+ line_str = line_str[:last_valid_index]
# END cut away invalid part
- line = line.rstrip()
+ line_str = line_str.rstrip()
cur_count, max_count = None, None
- match = self.re_op_relative.match(line)
+ match = self.re_op_relative.match(line_str)
if match is None:
- match = self.re_op_absolute.match(line)
+ match = self.re_op_absolute.match(line_str)
if not match:
- self.line_dropped(line)
- self.other_lines.append(line)
+ self.line_dropped(line_str)
+ self.other_lines.append(line_str)
return
# END could not get match
@@ -466,10 +495,10 @@ class RemoteProgress(object):
# This can't really be prevented, so we drop the line verbosely
# to make sure we get informed in case the process spits out new
# commands at some point.
- self.line_dropped(line)
+ self.line_dropped(line_str)
# Note: Don't add this line to the other lines, as we have to silently
# drop it
- return
+ return None
# END handle op code
# figure out stage
@@ -494,21 +523,22 @@ class RemoteProgress(object):
max_count and float(max_count),
message)
- def new_message_handler(self):
+ def new_message_handler(self) -> Callable[[str], None]:
"""
:return:
a progress handler suitable for handle_process_output(), passing lines on to this Progress
handler in a suitable format"""
- def handler(line):
+ def handler(line: AnyStr) -> None:
return self._parse_progress_line(line.rstrip())
# end
return handler
- def line_dropped(self, line):
+ def line_dropped(self, line: str) -> None:
"""Called whenever a line could not be understood and was therefore dropped."""
pass
- def update(self, op_code, cur_count, max_count=None, message=''):
+ def update(self, op_code: int, cur_count: Union[str, float], max_count: Union[str, float, None] = None,
+ message: str = '',) -> None:
"""Called whenever the progress changes
:param op_code:
@@ -539,11 +569,11 @@ class CallableRemoteProgress(RemoteProgress):
"""An implementation forwarding updates to any callable"""
__slots__ = ('_callable')
- def __init__(self, fn):
+ def __init__(self, fn: Callable) -> None:
self._callable = fn
super(CallableRemoteProgress, self).__init__()
- def update(self, *args, **kwargs):
+ def update(self, *args: Any, **kwargs: Any) -> None:
self._callable(*args, **kwargs)
@@ -568,27 +598,27 @@ class Actor(object):
__slots__ = ('name', 'email')
- def __init__(self, name, email):
+ def __init__(self, name: Optional[str], email: Optional[str]) -> None:
self.name = name
self.email = email
- def __eq__(self, other):
+ def __eq__(self, other: Any) -> bool:
return self.name == other.name and self.email == other.email
- def __ne__(self, other):
+ def __ne__(self, other: Any) -> bool:
return not (self == other)
- def __hash__(self):
+ def __hash__(self) -> int:
return hash((self.name, self.email))
- def __str__(self):
- return self.name
+ def __str__(self) -> str:
+ return self.name if self.name else ""
- def __repr__(self):
+ def __repr__(self) -> str:
return '<git.Actor "%s <%s>">' % (self.name, self.email)
@classmethod
- def _from_string(cls, string):
+ def _from_string(cls, string: str) -> 'Actor':
"""Create an Actor from a string.
:param string: is the string, which is expected to be in regular git format
@@ -609,17 +639,17 @@ class Actor(object):
# END handle name/email matching
@classmethod
- def _main_actor(cls, env_name, env_email, config_reader=None):
+ def _main_actor(cls, env_name: str, env_email: str, config_reader: Optional[TBD] = None) -> 'Actor':
actor = Actor('', '')
user_id = None # We use this to avoid multiple calls to getpass.getuser()
- def default_email():
+ def default_email() -> str:
nonlocal user_id
if not user_id:
user_id = get_user_id()
return user_id
- def default_name():
+ def default_name() -> str:
return default_email().split('@')[0]
for attr, evar, cvar, default in (('name', env_name, cls.conf_name, default_name),
@@ -638,7 +668,7 @@ class Actor(object):
return actor
@classmethod
- def committer(cls, config_reader=None):
+ def committer(cls, config_reader: Optional[TBD] = None) -> 'Actor':
"""
:return: Actor instance corresponding to the configured committer. It behaves
similar to the git implementation, such that the environment will override
@@ -649,7 +679,7 @@ class Actor(object):
return cls._main_actor(cls.env_committer_name, cls.env_committer_email, config_reader)
@classmethod
- def author(cls, config_reader=None):
+ def author(cls, config_reader: Optional[TBD] = None) -> 'Actor':
"""Same as committer(), but defines the main author. It may be specified in the environment,
but defaults to the committer"""
return cls._main_actor(cls.env_author_name, cls.env_author_email, config_reader)
@@ -683,16 +713,18 @@ class Stats(object):
files = number of changed files as int"""
__slots__ = ("total", "files")
- def __init__(self, total, files):
+ def __init__(self, total: Dict[str, Dict[str, int]], files: Dict[str, Dict[str, int]]):
self.total = total
self.files = files
@classmethod
- def _list_from_string(cls, repo, text):
+ def _list_from_string(cls, repo: 'Repo', text: str) -> 'Stats':
"""Create a Stat object from output retrieved by git-diff.
:return: git.Stat"""
- hsh = {'total': {'insertions': 0, 'deletions': 0, 'lines': 0, 'files': 0}, 'files': {}}
+ hsh = {'total': {'insertions': 0, 'deletions': 0, 'lines': 0, 'files': 0},
+ 'files': {}
+ } # type: Dict[str, Dict[str, TBD]] ## need typeddict or refactor for mypy
for line in text.splitlines():
(raw_insertions, raw_deletions, filename) = line.split("\t")
insertions = raw_insertions != '-' and int(raw_insertions) or 0
@@ -718,25 +750,25 @@ class IndexFileSHA1Writer(object):
:note: Based on the dulwich project"""
__slots__ = ("f", "sha1")
- def __init__(self, f):
+ def __init__(self, f: IO) -> None:
self.f = f
self.sha1 = make_sha(b"")
- def write(self, data):
+ def write(self, data: AnyStr) -> int:
self.sha1.update(data)
return self.f.write(data)
- def write_sha(self):
+ def write_sha(self) -> bytes:
sha = self.sha1.digest()
self.f.write(sha)
return sha
- def close(self):
+ def close(self) -> bytes:
sha = self.write_sha()
self.f.close()
return sha
- def tell(self):
+ def tell(self) -> int:
return self.f.tell()
@@ -750,23 +782,23 @@ class LockFile(object):
Locks will automatically be released on destruction"""
__slots__ = ("_file_path", "_owns_lock")
- def __init__(self, file_path):
+ def __init__(self, file_path: PathLike) -> None:
self._file_path = file_path
self._owns_lock = False
- def __del__(self):
+ def __del__(self) -> None:
self._release_lock()
- def _lock_file_path(self):
+ def _lock_file_path(self) -> str:
""":return: Path to lockfile"""
return "%s.lock" % (self._file_path)
- def _has_lock(self):
+ def _has_lock(self) -> bool:
""":return: True if we have a lock and if the lockfile still exists
:raise AssertionError: if our lock-file does not exist"""
return self._owns_lock
- def _obtain_lock_or_raise(self):
+ def _obtain_lock_or_raise(self) -> None:
"""Create a lock file as flag for other instances, mark our instance as lock-holder
:raise IOError: if a lock was already present or a lock file could not be written"""
@@ -788,12 +820,12 @@ class LockFile(object):
self._owns_lock = True
- def _obtain_lock(self):
+ def _obtain_lock(self) -> None:
"""The default implementation will raise if a lock cannot be obtained.
Subclasses may override this method to provide a different implementation"""
return self._obtain_lock_or_raise()
- def _release_lock(self):
+ def _release_lock(self) -> None:
"""Release our lock if we have one"""
if not self._has_lock():
return
@@ -818,7 +850,7 @@ class BlockingLockFile(LockFile):
can never be obtained."""
__slots__ = ("_check_interval", "_max_block_time")
- def __init__(self, file_path, check_interval_s=0.3, max_block_time_s=maxsize):
+ def __init__(self, file_path: PathLike, check_interval_s: float = 0.3, max_block_time_s: int = maxsize) -> None:
"""Configure the instance
:param check_interval_s:
@@ -830,7 +862,7 @@ class BlockingLockFile(LockFile):
self._check_interval = check_interval_s
self._max_block_time = max_block_time_s
- def _obtain_lock(self):
+ def _obtain_lock(self) -> None:
"""This method blocks until it obtained the lock, or raises IOError if
it ran out of time or if the parent directory was not available anymore.
If this method returns, you are guaranteed to own the lock"""
@@ -877,14 +909,14 @@ class IterableList(list):
can be left out."""
__slots__ = ('_id_attr', '_prefix')
- def __new__(cls, id_attr, prefix=''):
+ def __new__(cls, id_attr: str, prefix: str = '') -> 'IterableList':
return super(IterableList, cls).__new__(cls)
- def __init__(self, id_attr, prefix=''):
+ def __init__(self, id_attr: str, prefix: str = '') -> None:
self._id_attr = id_attr
self._prefix = prefix
- def __contains__(self, attr):
+ def __contains__(self, attr: object) -> bool:
# first try identity match for performance
try:
rval = list.__contains__(self, attr)
@@ -896,13 +928,13 @@ class IterableList(list):
# otherwise make a full name search
try:
- getattr(self, attr)
+ getattr(self, cast(str, attr)) # use cast to silence mypy
return True
except (AttributeError, TypeError):
return False
# END handle membership
- def __getattr__(self, attr):
+ def __getattr__(self, attr: str) -> Any:
attr = self._prefix + attr
for item in self:
if getattr(item, self._id_attr) == attr:
@@ -910,20 +942,24 @@ class IterableList(list):
# END for each item
return list.__getattribute__(self, attr)
- def __getitem__(self, index):
+ def __getitem__(self, index: Union[int, slice, str]) -> Any:
if isinstance(index, int):
return list.__getitem__(self, index)
-
- try:
- return getattr(self, index)
- except AttributeError as e:
- raise IndexError("No item found with id %r" % (self._prefix + index)) from e
+ elif isinstance(index, slice):
+ raise ValueError("Index should be an int or str")
+ else:
+ try:
+ return getattr(self, index)
+ except AttributeError as e:
+ raise IndexError("No item found with id %r" % (self._prefix + index)) from e
# END handle getattr
- def __delitem__(self, index):
- delindex = index
+ def __delitem__(self, index: Union[int, str, slice]) -> None:
+
+ delindex = cast(int, index)
if not isinstance(index, int):
delindex = -1
+ assert not isinstance(index, slice)
name = self._prefix + index
for i, item in enumerate(self):
if getattr(item, self._id_attr) == name:
@@ -946,7 +982,7 @@ class Iterable(object):
_id_attribute_ = "attribute that most suitably identifies your instance"
@classmethod
- def list_items(cls, repo, *args, **kwargs):
+ def list_items(cls, repo: 'Repo', *args: Any, **kwargs: Any) -> 'IterableList':
"""
Find all items of this type - subclasses can specify args and kwargs differently.
If no args are given, subclasses are obliged to return all items if no additional
@@ -960,7 +996,7 @@ class Iterable(object):
return out_list
@classmethod
- def iter_items(cls, repo, *args, **kwargs):
+ def iter_items(cls, repo: 'Repo', *args: Any, **kwargs: Any) -> NoReturn:
"""For more information about the arguments, see list_items
:return: iterator yielding Items"""
raise NotImplementedError("To be implemented by Subclass")
@@ -969,5 +1005,5 @@ class Iterable(object):
class NullHandler(logging.Handler):
- def emit(self, record):
+ def emit(self, record: object) -> None:
pass
diff --git a/requirements.txt b/requirements.txt
index c4e8340d..626a916a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1 +1,2 @@
gitdb>=4.0.1,<5
+typing-extensions>=3.7.4.0
diff --git a/test-requirements.txt b/test-requirements.txt
index abda95cf..0734820f 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -4,3 +4,5 @@ flake8
tox
virtualenv
nose
+gitdb>=4.0.1,<5
+typing-extensions>=3.7.4.0
diff --git a/tox.ini b/tox.ini
index ad126ed4..d9d1594d 100644
--- a/tox.ini
+++ b/tox.ini
@@ -23,6 +23,7 @@ commands = {posargs}
# E266 = too many leading '#' for block comment
# E731 = do not assign a lambda expression, use a def
# W293 = Blank line contains whitespace
-ignore = E265,W293,E266,E731
+# W504 = Line break after operator
+ignore = E265,W293,E266,E731, W504
max-line-length = 120
exclude = .tox,.venv,build,dist,doc,git/ext/
View Lorry Controller Status