@@ -3,15 +3,17 @@
 # This module is part of GitPython and is released under the
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
-import gitdb.typ as dbtyp
+__all__ = ("Object", "IndexObject")
+
 import os.path as osp
 
+import gitdb.typ as dbtyp
+
 from git.exc import WorkTreeRepositoryUnsupported
-from git.util import LazyMixin, join_path_native, stream_copy, bin_to_hex
+from git.util import LazyMixin, bin_to_hex, join_path_native, stream_copy
 
 from .util import get_object_type_by_name
 
-
 # typing ------------------------------------------------------------------
 
 from typing import Any, TYPE_CHECKING, Union
@@ -24,16 +26,14 @@
     from git.refs.reference import Reference
     from git.repo import Repo
 
-    from .tree import Tree
     from .blob import Blob
     from .submodule.base import Submodule
+    from .tree import Tree
 
 IndexObjUnion = Union["Tree", "Blob", "Submodule"]
 
 # --------------------------------------------------------------------------
 
-__all__ = ("Object", "IndexObject")
-
 
 class Object(LazyMixin):
     """Base class for classes representing git object types.
 
@@ -3,17 +3,17 @@
 # This module is part of GitPython and is released under the
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
+__all__ = ("Blob",)
+
 from mimetypes import guess_type
 import sys
 
-from . import base
-
 if sys.version_info >= (3, 8):
     from typing import Literal
 else:
     from typing_extensions import Literal
 
-__all__ = ("Blob",)
+from . import base
 
 
 class Blob(base.IndexObject):
 
@@ -3,6 +3,8 @@
 # This module is part of GitPython and is released under the
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
+__all__ = ("Commit",)
+
 from collections import defaultdict
 import datetime
 from io import BytesIO
@@ -14,10 +16,12 @@
 from time import altzone, daylight, localtime, time, timezone
 
 from gitdb import IStream
+
 from git.cmd import Git
 from git.diff import Diffable
-from git.util import hex_to_bin, Actor, Stats, finalize_process
+from git.util import Actor, Stats, finalize_process, hex_to_bin
 
+from . import base
 from .tree import Tree
 from .util import (
     Serializable,
@@ -27,7 +31,6 @@
     parse_actor_and_date,
     parse_date,
 )
-from . import base
 
 # typing ------------------------------------------------------------------
 
@@ -59,8 +62,6 @@
 
 _logger = logging.getLogger(__name__)
 
-__all__ = ("Commit",)
-
 
 class Commit(base.Object, TraversableIterableObj, Diffable, Serializable):
     """Wraps a git commit object.
 
@@ -3,8 +3,14 @@
 
 """Functions that are supposed to be as fast as possible."""
 
-from stat import S_ISDIR
+__all__ = (
+    "tree_to_stream",
+    "tree_entries_from_data",
+    "traverse_trees_recursive",
+    "traverse_tree_recursive",
+)
 
+from stat import S_ISDIR
 
 from git.compat import safe_decode, defenc
 
@@ -23,22 +29,15 @@
 
 if TYPE_CHECKING:
     from _typeshed import ReadableBuffer
+
     from git import GitCmdObjectDB
 
-EntryTup = Tuple[bytes, int, str]  # same as TreeCacheTup in tree.py
+EntryTup = Tuple[bytes, int, str]  # Same as TreeCacheTup in tree.py.
 EntryTupOrNone = Union[EntryTup, None]
 
 # ---------------------------------------------------
 
 
-__all__ = (
-    "tree_to_stream",
-    "tree_entries_from_data",
-    "traverse_trees_recursive",
-    "traverse_tree_recursive",
-)
-
-
 def tree_to_stream(entries: Sequence[EntryTup], write: Callable[["ReadableBuffer"], Union[int, None]]) -> None:
     """Write the given list of entries into a stream using its ``write`` method.
 
 
@@ -23,12 +23,13 @@
 from git.types import PathLike
 
 if TYPE_CHECKING:
-    from .base import Submodule
     from weakref import ReferenceType
+
+    from git.refs import Head, RemoteReference
+    from git.remote import Remote
     from git.repo import Repo
-    from git.refs import Head
-    from git import Remote
-    from git.refs import RemoteReference
+
+    from .base import Submodule
 
 # { Utilities
 
 
@@ -9,12 +9,17 @@
 For lightweight tags, see the :mod:`git.refs.tag` module.
 """
 
+__all__ = ("TagObject",)
+
 import sys
 
+from git.compat import defenc
+from git.util import hex_to_bin
+
 from . import base
 from .util import get_object_type_by_name, parse_actor_and_date
-from ..util import hex_to_bin
-from ..compat import defenc
+
+# typing ----------------------------------------------
 
 from typing import List, TYPE_CHECKING, Union
 
@@ -26,11 +31,12 @@
 if TYPE_CHECKING:
     from git.repo import Repo
     from git.util import Actor
-    from .commit import Commit
+
     from .blob import Blob
+    from .commit import Commit
     from .tree import Tree
 
-__all__ = ("TagObject",)
+# ---------------------------------------------------
 
 
 class TagObject(base.Object):
 
@@ -3,16 +3,18 @@
 # This module is part of GitPython and is released under the
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
+__all__ = ("TreeModifier", "Tree")
+
 import sys
 
 import git.diff as git_diff
 from git.util import IterableList, join_path, to_bin_sha
 
+from . import util
 from .base import IndexObjUnion, IndexObject
 from .blob import Blob
 from .fun import tree_entries_from_data, tree_to_stream
 from .submodule.base import Submodule
-from . import util
 
 # typing -------------------------------------------------
 
@@ -39,23 +41,20 @@
 
 if TYPE_CHECKING:
     from io import BytesIO
+
     from git.repo import Repo
 
 TreeCacheTup = Tuple[bytes, int, str]
 
 TraversedTreeTup = Union[Tuple[Union["Tree", None], IndexObjUnion, Tuple["Submodule", "Submodule"]]]
 
-
 # def is_tree_cache(inp: Tuple[bytes, int, str]) -> TypeGuard[TreeCacheTup]:
 #     return isinstance(inp[0], bytes) and isinstance(inp[1], int) and isinstance([inp], str)
 
 # --------------------------------------------------------
 
-
 cmp: Callable[[str, str], int] = lambda a, b: (a > b) - (a < b)
 
-__all__ = ("TreeModifier", "Tree")
-
 
 class TreeModifier:
     """A utility class providing methods to alter the underlying cache in a list-like
 
@@ -5,46 +5,63 @@
 
 """General utility functions."""
 
+__all__ = (
+    "get_object_type_by_name",
+    "parse_date",
+    "parse_actor_and_date",
+    "ProcessStreamAdapter",
+    "Traversable",
+    "altz_to_utctz_str",
+    "utctz_to_altz",
+    "verify_utctz",
+    "Actor",
+    "tzoffset",
+    "utc",
+)
+
 from abc import ABC, abstractmethod
 import calendar
 from collections import deque
 from datetime import datetime, timedelta, tzinfo
-from string import digits
 import re
+from string import digits
 import time
 import warnings
 
-from git.util import IterableList, IterableObj, Actor
+from git.util import Actor, IterableList, IterableObj
 
 # typing ------------------------------------------------------------
+
 from typing import (
     Any,
     Callable,
     Deque,
-    Iterator,
     # Generic,
+    Iterator,
     NamedTuple,
-    overload,
     Sequence,
     TYPE_CHECKING,
     Tuple,
     Type,
     TypeVar,
     Union,
     cast,
+    overload,
 )
 
 from git.types import Has_id_attribute, Literal  # , _T
 
 if TYPE_CHECKING:
     from io import BytesIO, StringIO
-    from .commit import Commit
-    from .blob import Blob
-    from .tag import TagObject
-    from .tree import Tree, TraversedTreeTup
     from subprocess import Popen
-    from .submodule.base import Submodule
+
     from git.types import Protocol, runtime_checkable
+
+    from .blob import Blob
+    from .commit import Commit
+    from .submodule.base import Submodule
+    from .tag import TagObject
+    from .tree import TraversedTreeTup, Tree
 else:
     # Protocol = Generic[_T]  # Needed for typing bug #572?
     Protocol = ABC
@@ -68,20 +85,6 @@ class TraverseNT(NamedTuple):
 
 # --------------------------------------------------------------------
 
-__all__ = (
-    "get_object_type_by_name",
-    "parse_date",
-    "parse_actor_and_date",
-    "ProcessStreamAdapter",
-    "Traversable",
-    "altz_to_utctz_str",
-    "utctz_to_altz",
-    "verify_utctz",
-    "Actor",
-    "tzoffset",
-    "utc",
-)
-
 ZERO = timedelta(0)
 
 # { Functions