move commit. and submodule.traverse() to TraversableIterableObj

MANIFEST.in

@@ -6,6 +6,7 @@ include README.md
 include VERSION
 include requirements.txt
 include test-requirements.txt
+include git/py.typed
 
 recursive-include doc *
 recursive-exclude test *

git/objects/commit.py

@@ -37,13 +37,12 @@
 
 # typing ------------------------------------------------------------------
 
-from typing import Any, Callable, Iterator, List, Sequence, Tuple, Union, TYPE_CHECKING, cast, overload
+from typing import Any, Iterator, List, Sequence, Tuple, Union, TYPE_CHECKING
 
-from git.types import PathLike, Literal
+from git.types import PathLike
 
 if TYPE_CHECKING:
     from git.repo import Repo
-    from .util import TraversedObj, TraversedTup
 
 # ------------------------------------------------------------------------
 
@@ -286,76 +285,6 @@ def iter_parents(self, paths: Union[PathLike, Sequence[PathLike]] = '', **kwargs
 
         return self.iter_items(self.repo, self, paths, **kwargs)
 
-    @overload                     # type: ignore
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[True],
-                 as_edge: Literal[False],  # No Tuple
-                 ) -> Iterator['Commit']:
-        ...
-
-    @overload
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[False],
-                 as_edge: Literal[True],
-                 ) -> Iterator[Tuple[Union[None, 'Commit'], 'Commit']]:
-        ...
-
-    @overload
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[True],
-                 as_edge: Literal[True],
-                 ) -> Iterator[Tuple['Commit', 'Commit']]:
-        ...
-
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool] = lambda i, d: True,
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool] = lambda i, d: False,
-                 depth: int = -1,
-                 branch_first: bool = True,
-                 visit_once: bool = True,
-                 ignore_self: int = 1,
-                 as_edge: bool = False
-                 ) -> Union[Iterator['Commit'],
-                            Iterator[Tuple[Union[None, 'Commit'], 'Commit']]]:
-        """For documentation, see util.Traversable._traverse()"""
-
-        """
-        # To typecheck instead of using cast.
-        import itertools
-        from git.types import TypeGuard
-        def is_commit_traversed(inp: Tuple) -> TypeGuard[Tuple[Iterator[Tuple['Commit', 'Commit']]]]:
-            for x in inp[1]:
-                if not isinstance(x, tuple) and len(x) != 2:
-                    if all(isinstance(inner, Commit) for inner in x):
-                        continue
-            return True
-
-        ret = super(Commit, self).traverse(predicate, prune, depth, branch_first, visit_once, ignore_self, as_edge)
-        ret_tup = itertools.tee(ret, 2)
-        assert is_commit_traversed(ret_tup), f"{[type(x) for x in list(ret_tup[0])]}"
-        return ret_tup[0]
-        """
-        return cast(Union[Iterator['Commit'],
-                          Iterator[Tuple[Union[None, 'Commit'], 'Commit']]],
-                    super(Commit, self).traverse(
-                        predicate, prune, depth, branch_first, visit_once, ignore_self, as_edge
-        ))
-
     @ property
     def stats(self):
         """Create a git stat from changes between this commit and its first parent

git/objects/submodule/base.py

@@ -49,18 +49,14 @@
 
 
 # typing ----------------------------------------------------------------------
-from typing import Dict, TYPE_CHECKING, Tuple
-from typing import Any, Callable, Iterator, Union, cast, overload
+from typing import Dict, TYPE_CHECKING
+from typing import Any, Iterator, Union
 
-from git.types import Commit_ish, PathLike, Literal
+from git.types import Commit_ish, PathLike
 
 if TYPE_CHECKING:
     from git.repo import Repo
-    # from git.objects.util import TraversedObj, TraversedTup
-    # from git.objects.blob import Blob, TagObject, Tree, Commit  # inc. in Commit_ish
-    # from git.refs import SymbolicReference
 
-TraversedSubModuleTup = Tuple[Union['Submodule', None], 'Submodule']
 
 # -----------------------------------------------------------------------------
 
@@ -169,69 +165,6 @@ def _get_intermediate_items(cls, item: 'Submodule') -> IterableList['Submodule']
             return IterableList('')
         # END handle intermediate items
 
-    @overload                     # type: ignore
-    def traverse(self,
-                 predicate: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool],
-                 prune: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[True],
-                 as_edge: Literal[False],
-                 ) -> Iterator['Submodule']:
-        ...
-
-    @overload
-    def traverse(self,
-                 predicate: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool],
-                 prune: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[False],
-                 as_edge: Literal[True],
-                 ) -> Iterator[Tuple[Union[None, 'Submodule'], 'Submodule']]:
-        ...
-
-    @overload
-    def traverse(self,
-                 predicate: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool],
-                 prune: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[True],
-                 as_edge: Literal[True],
-                 ) -> Iterator[Tuple['Submodule', 'Submodule']]:
-        ...
-
-    def traverse(self,
-                 predicate: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool] = lambda i, d: True,
-                 prune: Callable[[Union['Submodule', TraversedSubModuleTup], int], bool] = lambda i, d: False,
-                 depth: int = -1,
-                 branch_first: bool = True,
-                 visit_once: bool = True,
-                 ignore_self: int = 1,
-                 as_edge: bool = False
-                 ) -> Union[Iterator['Submodule'], Iterator[TraversedSubModuleTup]]:
-        """For documentation, see util.Traversable._traverse()"""
-
-        # """ For typechecking instead of cast
-        # import itertools
-        # from git.types import TypeGuard
-
-        # def is_commit_traversed(inp: Tuple) -> TypeGuard[Tuple[Iterator['Submodule']]]:
-        #     return all(isinstance(inner, Submodule) for inner in inp[1])
-
-        # ret = super(Submodule, self).traverse(predicate, prune, depth, branch_first, visit_once, ignore_self, as_edge)
-        # ret_tup = itertools.tee(ret, 2)
-        # assert is_commit_traversed(ret_tup), f"{[type(x) for x in list(ret_tup[0])]}"
-        # return ret_tup[0]  # type: ignore """"
-        return cast(Union[Iterator['Submodule'], Iterator['TraversedSubModuleTup']],
-                    super(Submodule, self).
-                    traverse(predicate, prune, depth, branch_first, visit_once, ignore_self, as_edge)  # type:ignore
-                    )
-
     @classmethod
     def _need_gitfile_submodules(cls, git: Git) -> bool:
         return git.version_info[:3] >= (1, 7, 5)

git/objects/tree.py

@@ -22,13 +22,13 @@
 # typing -------------------------------------------------
 
 from typing import (Callable, Dict, Generic, Iterable, Iterator, List,
-                    Tuple, Type, TypeVar, Union, cast, TYPE_CHECKING, overload)
+                    Tuple, Type, TypeVar, Union, cast, TYPE_CHECKING)
 
-from git.types import PathLike, TypeGuard, Literal
+from git.types import PathLike, TypeGuard
 
 if TYPE_CHECKING:
     from git.repo import Repo
-    from git.objects.util import TraversedObj, TraversedTup
+    from git.objects.util import TraversedTup
     from io import BytesIO
 
 T_Tree_cache = TypeVar('T_Tree_cache', bound=Union[Tuple[bytes, int, str]])
@@ -296,45 +296,10 @@ def cache(self) -> TreeModifier:
             See the ``TreeModifier`` for more information on how to alter the cache"""
         return TreeModifier(self._cache)
 
-    @overload                     # type: ignore
     def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[True],
-                 as_edge: Literal[False],  # No Tuple
-                 ) -> Iterator[Union['Tree', 'Blob', 'Submodule']]:
-        ...
-
-    @overload
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[False],
-                 as_edge: Literal[True],
-                 ) -> Iterator[Tuple[Union[None, 'Tree', 'Submodule'], Union['Tree', 'Blob', 'Submodule']]]:
-        ...
-
-    @overload
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool],
-                 depth: int,
-                 branch_first: bool,
-                 visit_once: bool,
-                 ignore_self: Literal[True],
-                 as_edge: Literal[True],
-                 ) -> Iterator[Tuple[Union['Tree', 'Submodule'], Union['Tree', 'Blob', 'Submodule']]]:
-        ...
-
-    def traverse(self,
-                 predicate: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool] = lambda i, d: True,
-                 prune: Callable[[Union['TraversedObj', 'TraversedTup'], int], bool] = lambda i, d: False,
+                 predicate: Callable[[Union['Tree', 'Submodule', 'Blob',
+                                            'TraversedTup'], int], bool] = lambda i, d: True,
+                 prune: Callable[[Union['Tree', 'Submodule', 'Blob', 'TraversedTup'], int], bool] = lambda i, d: False,
                  depth: int = -1,
                  branch_first: bool = True,
                  visit_once: bool = False,
@@ -357,7 +322,7 @@ def traverse(self,
         # return ret_tup[0]"""
         return cast(Union[Iterator[Union['Tree', 'Blob', 'Submodule']],
                           Iterator[Tuple[Union['Tree', 'Submodule', None], Union['Tree', 'Blob', 'Submodule']]]],
-                    super(Tree, self).traverse(predicate, prune, depth,
+                    super(Tree, self).traverse(predicate, prune, depth,     # type: ignore
                                                branch_first, visit_once, ignore_self))
 
     # List protocol