Merge pull request #1285 from Yobmod/main

Finish initial typing of Index and Submodule

1 files changed, 31 insertions, 31 deletions

diff --git a/git/index/fun.py b/git/index/fun.py
index ffd109b1..e5e566a0 100644
--- a/git/index/fun.py
+++ b/git/index/fun.py
@@ -57,6 +57,8 @@ from git.types import PathLike, TypeGuard
 
 if TYPE_CHECKING:
     from .base import IndexFile
+    from git.objects.tree import TreeCacheTup
+    # from git.objects.fun import EntryTupOrNone
 
 # ------------------------------------------------------------------------------------
 
@@ -186,16 +188,15 @@ def entry_key(*entry: Union[BaseIndexEntry, PathLike, int]) -> Tuple[PathLike, i
     """:return: Key suitable to be used for the index.entries dictionary
     :param entry: One instance of type BaseIndexEntry or the path and the stage"""
 
-    def is_entry_tuple(entry: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
-        return isinstance(entry, tuple) and len(entry) == 2
-        
+    def is_entry_key_tup(entry_key: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
+        return isinstance(entry_key, tuple) and len(entry_key) == 2
+
     if len(entry) == 1:
         entry_first = entry[0]
         assert isinstance(entry_first, BaseIndexEntry)
         return (entry_first.path, entry_first.stage)
     else:
-        # entry = tuple(entry)
-        assert is_entry_tuple(entry)
+        assert is_entry_key_tup(entry)
         return entry
     # END handle entry
 
@@ -249,7 +250,7 @@ def read_cache(stream: IO[bytes]) -> Tuple[int, Dict[Tuple[PathLike, int], 'Inde
 
 
 def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
-                          ) -> Tuple[bytes, List[Tuple[str, int, str]]]:
+                          ) -> Tuple[bytes, List['TreeCacheTup']]:
     """Create a tree from the given sorted list of entries and put the respective
     trees into the given object database
 
@@ -259,8 +260,8 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
     :param sl: slice indicating the range we should process on the entries list
     :return: tuple(binsha, list(tree_entry, ...)) a tuple of a sha and a list of
         tree entries being a tuple of hexsha, mode, name"""
-    tree_items = []  # type: List[Tuple[Union[bytes, str], int, str]]
-    tree_items_append = tree_items.append
+    tree_items: List['TreeCacheTup'] = []
+
     ci = sl.start
     end = sl.stop
     while ci < end:
@@ -272,7 +273,7 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
         rbound = entry.path.find('/', si)
         if rbound == -1:
             # its not a tree
-            tree_items_append((entry.binsha, entry.mode, entry.path[si:]))
+            tree_items.append((entry.binsha, entry.mode, entry.path[si:]))
         else:
             # find common base range
             base = entry.path[si:rbound]
@@ -289,7 +290,7 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
             # enter recursion
             # ci - 1 as we want to count our current item as well
             sha, _tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1)
-            tree_items_append((sha, S_IFDIR, base))
+            tree_items.append((sha, S_IFDIR, base))
 
             # skip ahead
             ci = xi
@@ -298,15 +299,14 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
 
     # finally create the tree
     sio = BytesIO()
-    tree_to_stream(tree_items, sio.write)  # converts bytes of each item[0] to str
-    tree_items_stringified = cast(List[Tuple[str, int, str]], tree_items)
+    tree_to_stream(tree_items, sio.write)  # writes to stream as bytes, but doesnt change tree_items
     sio.seek(0)
 
     istream = odb.store(IStream(str_tree_type, len(sio.getvalue()), sio))
-    return (istream.binsha, tree_items_stringified)
+    return (istream.binsha, tree_items)
 
 
-def _tree_entry_to_baseindexentry(tree_entry: Tuple[str, int, str], stage: int) -> BaseIndexEntry:
+def _tree_entry_to_baseindexentry(tree_entry: 'TreeCacheTup', stage: int) -> BaseIndexEntry:
     return BaseIndexEntry((tree_entry[1], tree_entry[0], stage << CE_STAGESHIFT, tree_entry[2]))
 
 
@@ -319,14 +319,13 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
     :param tree_shas: 1, 2 or 3 trees as identified by their binary 20 byte shas
         If 1 or two, the entries will effectively correspond to the last given tree
         If 3 are given, a 3 way merge is performed"""
-    out = []  # type: List[BaseIndexEntry]
-    out_append = out.append
+    out: List[BaseIndexEntry] = []
 
     # one and two way is the same for us, as we don't have to handle an existing
     # index, instrea
     if len(tree_shas) in (1, 2):
         for entry in traverse_tree_recursive(odb, tree_shas[-1], ''):
-            out_append(_tree_entry_to_baseindexentry(entry, 0))
+            out.append(_tree_entry_to_baseindexentry(entry, 0))
         # END for each entry
         return out
     # END handle single tree
@@ -347,23 +346,23 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
                     if(base[0] != ours[0] and base[0] != theirs[0] and ours[0] != theirs[0]) or \
                             (base[1] != ours[1] and base[1] != theirs[1] and ours[1] != theirs[1]):
                         # changed by both
-                        out_append(_tree_entry_to_baseindexentry(base, 1))
-                        out_append(_tree_entry_to_baseindexentry(ours, 2))
-                        out_append(_tree_entry_to_baseindexentry(theirs, 3))
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(ours, 2))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
                     elif base[0] != ours[0] or base[1] != ours[1]:
                         # only we changed it
-                        out_append(_tree_entry_to_baseindexentry(ours, 0))
+                        out.append(_tree_entry_to_baseindexentry(ours, 0))
                     else:
                         # either nobody changed it, or they did. In either
                         # case, use theirs
-                        out_append(_tree_entry_to_baseindexentry(theirs, 0))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 0))
                     # END handle modification
                 else:
 
                     if ours[0] != base[0] or ours[1] != base[1]:
                         # they deleted it, we changed it, conflict
-                        out_append(_tree_entry_to_baseindexentry(base, 1))
-                        out_append(_tree_entry_to_baseindexentry(ours, 2))
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(ours, 2))
                     # else:
                     #   we didn't change it, ignore
                     #   pass
@@ -376,8 +375,8 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
                 else:
                     if theirs[0] != base[0] or theirs[1] != base[1]:
                         # deleted in ours, changed theirs, conflict
-                        out_append(_tree_entry_to_baseindexentry(base, 1))
-                        out_append(_tree_entry_to_baseindexentry(theirs, 3))
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
                     # END theirs changed
                     # else:
                     #   theirs didn't change
@@ -388,18 +387,19 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
             # all three can't be None
             if ours is None:
                 # added in their branch
-                out_append(_tree_entry_to_baseindexentry(theirs, 0))
+                assert theirs is not None
+                out.append(_tree_entry_to_baseindexentry(theirs, 0))
             elif theirs is None:
                 # added in our branch
-                out_append(_tree_entry_to_baseindexentry(ours, 0))
+                out.append(_tree_entry_to_baseindexentry(ours, 0))
             else:
                 # both have it, except for the base, see whether it changed
                 if ours[0] != theirs[0] or ours[1] != theirs[1]:
-                    out_append(_tree_entry_to_baseindexentry(ours, 2))
-                    out_append(_tree_entry_to_baseindexentry(theirs, 3))
+                    out.append(_tree_entry_to_baseindexentry(ours, 2))
+                    out.append(_tree_entry_to_baseindexentry(theirs, 3))
                 else:
                     # it was added the same in both
-                    out_append(_tree_entry_to_baseindexentry(ours, 0))
+                    out.append(_tree_entry_to_baseindexentry(ours, 0))
                 # END handle two items
             # END handle heads
         # END handle base exists