Add types to index.typ.py

Author: Yobmod

git/index/base.py

@@ -79,6 +79,8 @@
 StageType = int
 Treeish = Union[Tree, Commit, str, bytes]
 
+# ------------------------------------------------------------------------------------
+
 
 __all__ = ('IndexFile', 'CheckoutError')
 
@@ -287,8 +289,9 @@ def new(cls, repo: 'Repo', *tree_sha: bytes) -> 'IndexFile':
 
         inst = cls(repo)
         # convert to entries dict
-        entries = dict(zip(((e.path, e.stage) for e in base_entries),
-                           (IndexEntry.from_base(e) for e in base_entries)))
+        entries = dict(zip(
+            ((e.path, e.stage) for e in base_entries),
+            (IndexEntry.from_base(e) for e in base_entries)))  # type: Dict[Tuple[PathLike, int], IndexEntry]
 
         inst.entries = entries
         return inst

git/index/typ.py

@@ -8,8 +8,17 @@
 )
 from git.objects import Blob
 
+
+# typing ----------------------------------------------------------------------
+
+from typing import (List, Sequence, TYPE_CHECKING, Tuple, cast)
+
 from git.types import PathLike
 
+if TYPE_CHECKING:
+    from git.repo import Repo
+
+# ---------------------------------------------------------------------------------
 
 __all__ = ('BlobFilter', 'BaseIndexEntry', 'IndexEntry')
 
@@ -33,15 +42,15 @@ class BlobFilter(object):
     """
     __slots__ = 'paths'
 
-    def __init__(self, paths):
+    def __init__(self, paths: Sequence[PathLike]) -> None:
         """
         :param paths:
             tuple or list of paths which are either pointing to directories or
             to files relative to the current repository
         """
         self.paths = paths
 
-    def __call__(self, stage_blob):
+    def __call__(self, stage_blob: Blob) -> bool:
         path = stage_blob[1].path
         for p in self.paths:
             if path.startswith(p):
@@ -59,24 +68,24 @@ class BaseIndexEntry(tuple):
     expecting a BaseIndexEntry can also handle full IndexEntries even if they
     use numeric indices for performance reasons. """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "%o %s %i\t%s" % (self.mode, self.hexsha, self.stage, self.path)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "(%o, %s, %i, %s)" % (self.mode, self.hexsha, self.stage, self.path)
 
     @property
-    def mode(self):
+    def mode(self) -> int:
         """ File Mode, compatible to stat module constants """
         return self[0]
 
     @property
-    def binsha(self):
+    def binsha(self) -> bytes:
         """binary sha of the blob """
         return self[1]
 
     @property
-    def hexsha(self):
+    def hexsha(self) -> str:
         """hex version of our sha"""
         return b2a_hex(self[1]).decode('ascii')
 
@@ -94,21 +103,21 @@ def stage(self) -> int:
         return (self[2] & CE_STAGEMASK) >> CE_STAGESHIFT
 
     @property
-    def path(self) -> PathLike:
+    def path(self) -> str:
         """:return: our path relative to the repository working tree root"""
         return self[3]
 
     @property
-    def flags(self):
+    def flags(self) -> List[str]:
         """:return: flags stored with this entry"""
         return self[2]
 
     @classmethod
-    def from_blob(cls, blob, stage=0):
+    def from_blob(cls, blob: Blob, stage: int = 0) -> 'BaseIndexEntry':
         """:return: Fully equipped BaseIndexEntry at the given stage"""
         return cls((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path))
 
-    def to_blob(self, repo):
+    def to_blob(self, repo: 'Repo') -> Blob:
         """:return: Blob using the information of this index entry"""
         return Blob(repo, self.binsha, self.mode, self.path)
 
@@ -122,40 +131,40 @@ class IndexEntry(BaseIndexEntry):
 
     See the properties for a mapping between names and tuple indices. """
     @property
-    def ctime(self):
+    def ctime(self) -> Tuple[int, int]:
         """
         :return:
             Tuple(int_time_seconds_since_epoch, int_nano_seconds) of the
             file's creation time"""
-        return unpack(">LL", self[4])
+        return cast(Tuple[int, int], unpack(">LL", self[4]))
 
     @property
-    def mtime(self):
+    def mtime(self) -> Tuple[int, int]:
         """See ctime property, but returns modification time """
-        return unpack(">LL", self[5])
+        return cast(Tuple[int, int], unpack(">LL", self[5]))
 
     @property
-    def dev(self):
+    def dev(self) -> int:
         """ Device ID """
         return self[6]
 
     @property
-    def inode(self):
+    def inode(self) -> int:
         """ Inode ID """
         return self[7]
 
     @property
-    def uid(self):
+    def uid(self) -> int:
         """ User ID """
         return self[8]
 
     @property
-    def gid(self):
+    def gid(self) -> int:
         """ Group ID """
         return self[9]
 
     @property
-    def size(self):
+    def size(self) -> int:
         """:return: Uncompressed size of the blob """
         return self[10]
 
@@ -171,7 +180,7 @@ def from_base(cls, base):
         return IndexEntry((base.mode, base.binsha, base.flags, base.path, time, time, 0, 0, 0, 0, 0))
 
     @classmethod
-    def from_blob(cls, blob, stage=0):
+    def from_blob(cls, blob: Blob, stage: int = 0) -> 'IndexEntry':
         """:return: Minimal entry resembling the given blob object"""
         time = pack(">LL", 0, 0)
         return IndexEntry((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path,