Replace extra occurrences of str with fspath

Author: George-Ogden

git/config.py

@@ -578,7 +578,7 @@ def _included_paths(self) -> List[Tuple[str, str]]:
                         value,
                     )
                 if self._repo.git_dir:
-                    if fnmatch.fnmatchcase(str(self._repo.git_dir), value):
+                    if fnmatch.fnmatchcase(os.fspath(self._repo.git_dir), value):
                         paths += self.items(section)
 
             elif keyword == "onbranch":

git/index/base.py

@@ -404,10 +404,10 @@ def _iter_expand_paths(self: "IndexFile", paths: Sequence[PathLike]) -> Iterator
         def raise_exc(e: Exception) -> NoReturn:
             raise e
 
-        r = str(self.repo.working_tree_dir)
+        r = os.fspath(self.repo.working_tree_dir)
         rs = r + os.sep
         for path in paths:
-            abs_path = str(path)
+            abs_path = os.fspath(path)
             if not osp.isabs(abs_path):
                 abs_path = osp.join(r, path)
             # END make absolute path
@@ -434,7 +434,7 @@ def raise_exc(e: Exception) -> NoReturn:
                 #   characters.
                 if abs_path not in resolved_paths:
                     for f in self._iter_expand_paths(glob.glob(abs_path)):
-                        yield str(f).replace(rs, "")
+                        yield os.fspath(f).replace(rs, "")
                     continue
             # END glob handling
             try:
@@ -569,7 +569,7 @@ def resolve_blobs(self, iter_blobs: Iterator[Blob]) -> "IndexFile":
         for blob in iter_blobs:
             stage_null_key = (blob.path, 0)
             if stage_null_key in self.entries:
-                raise ValueError("Path %r already exists at stage 0" % str(blob.path))
+                raise ValueError("Path %r already exists at stage 0" % os.fspath(blob.path))
             # END assert blob is not stage 0 already
 
             # Delete all possible stages.
@@ -656,10 +656,10 @@ def _to_relative_path(self, path: PathLike) -> PathLike:
             return path
         if self.repo.bare:
             raise InvalidGitRepositoryError("require non-bare repository")
-        if not osp.normpath(str(path)).startswith(str(self.repo.working_tree_dir)):
+        if not osp.normpath(os.fspath(path)).startswith(os.fspath(self.repo.working_tree_dir)):
             raise ValueError("Absolute path %r is not in git repository at %r" % (path, self.repo.working_tree_dir))
         result = os.path.relpath(path, self.repo.working_tree_dir)
-        if str(path).endswith(os.sep) and not result.endswith(os.sep):
+        if os.fspath(path).endswith(os.sep) and not result.endswith(os.sep):
             result += os.sep
         return result
 
@@ -731,7 +731,7 @@ def _entries_for_paths(
             for path in paths:
                 if osp.isabs(path):
                     abspath = path
-                    gitrelative_path = path[len(str(self.repo.working_tree_dir)) + 1 :]
+                    gitrelative_path = path[len(os.fspath(self.repo.working_tree_dir)) + 1 :]
                 else:
                     gitrelative_path = path
                     if self.repo.working_tree_dir:
@@ -1359,11 +1359,11 @@ def make_exc() -> GitCommandError:
                 try:
                     self.entries[(co_path, 0)]
                 except KeyError:
-                    folder = str(co_path)
+                    folder = os.fspath(co_path)
                     if not folder.endswith("/"):
                         folder += "/"
                     for entry in self.entries.values():
-                        if str(entry.path).startswith(folder):
+                        if os.fspath(entry.path).startswith(folder):
                             p = entry.path
                             self._write_path_to_stdin(proc, p, p, make_exc, fprogress, read_from_stdout=False)
                             checked_out_files.append(p)

git/index/fun.py

@@ -87,7 +87,7 @@ def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
         return
 
     env = os.environ.copy()
-    env["GIT_INDEX_FILE"] = safe_decode(str(index.path))
+    env["GIT_INDEX_FILE"] = safe_decode(os.fspath(index.path))
     env["GIT_EDITOR"] = ":"
     cmd = [hp]
     try:
@@ -167,7 +167,7 @@ def write_cache(
         beginoffset = tell()
         write(entry.ctime_bytes)  # ctime
         write(entry.mtime_bytes)  # mtime
-        path_str = str(entry.path)
+        path_str = os.fspath(entry.path)
         path: bytes = force_bytes(path_str, encoding=defenc)
         plen = len(path) & CE_NAMEMASK  # Path length
         assert plen == len(path), "Path %s too long to fit into index" % entry.path

git/index/util.py

@@ -106,7 +106,7 @@ def git_working_dir(func: Callable[..., _T]) -> Callable[..., _T]:
     @wraps(func)
     def set_git_working_dir(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
         cur_wd = os.getcwd()
-        os.chdir(str(self.repo.working_tree_dir))
+        os.chdir(os.fspath(self.repo.working_tree_dir))
         try:
             return func(self, *args, **kwargs)
         finally:

git/objects/blob.py

@@ -6,6 +6,7 @@
 __all__ = ["Blob"]
 
 from mimetypes import guess_type
+import os
 import sys
 
 if sys.version_info >= (3, 8):
@@ -44,5 +45,5 @@ def mime_type(self) -> str:
         """
         guesses = None
         if self.path:
-            guesses = guess_type(str(self.path))
+            guesses = guess_type(os.fspath(self.path))
         return guesses and guesses[0] or self.DEFAULT_MIME_TYPE

git/objects/submodule/base.py

@@ -352,7 +352,7 @@ def _clone_repo(
             module_abspath_dir = osp.dirname(module_abspath)
             if not osp.isdir(module_abspath_dir):
                 os.makedirs(module_abspath_dir)
-            module_checkout_path = osp.join(str(repo.working_tree_dir), path)
+            module_checkout_path = osp.join(os.fspath(repo.working_tree_dir), path)
 
         if url.startswith("../"):
             remote_name = repo.active_branch.tracking_branch().remote_name
@@ -541,7 +541,7 @@ def add(
         if sm.exists():
             # Reretrieve submodule from tree.
             try:
-                sm = repo.head.commit.tree[str(path)]
+                sm = repo.head.commit.tree[os.fspath(path)]
                 sm._name = name
                 return sm
             except KeyError:
@@ -1016,7 +1016,7 @@ def move(self, module_path: PathLike, configuration: bool = True, module: bool =
             return self
         # END handle no change
 
-        module_checkout_abspath = join_path_native(str(self.repo.working_tree_dir), module_checkout_path)
+        module_checkout_abspath = join_path_native(os.fspath(self.repo.working_tree_dir), module_checkout_path)
         if osp.isfile(module_checkout_abspath):
             raise ValueError("Cannot move repository onto a file: %s" % module_checkout_abspath)
         # END handle target files
@@ -1313,7 +1313,7 @@ def set_parent_commit(self, commit: Union[Commit_ish, str, None], check: bool =
         # If check is False, we might see a parent-commit that doesn't even contain the
         # submodule anymore. in that case, mark our sha as being NULL.
         try:
-            self.binsha = pctree[str(self.path)].binsha
+            self.binsha = pctree[os.fspath(self.path)].binsha
         except KeyError:
             self.binsha = self.NULL_BIN_SHA
 
@@ -1395,7 +1395,7 @@ def rename(self, new_name: str) -> "Submodule":
             destination_module_abspath = self._module_abspath(self.repo, self.path, new_name)
             source_dir = mod.git_dir
             # Let's be sure the submodule name is not so obviously tied to a directory.
-            if str(destination_module_abspath).startswith(str(mod.git_dir)):
+            if os.fspath(destination_module_abspath).startswith(os.fspath(mod.git_dir)):
                 tmp_dir = self._module_abspath(self.repo, self.path, str(uuid.uuid4()))
                 os.renames(source_dir, tmp_dir)
                 source_dir = tmp_dir

git/refs/reference.py

@@ -3,6 +3,7 @@
 
 __all__ = ["Reference"]
 
+import os
 from git.util import IterableObj, LazyMixin
 
 from .symbolic import SymbolicReference, T_References
@@ -65,7 +66,7 @@ def __init__(self, repo: "Repo", path: PathLike, check_path: bool = True) -> Non
             If ``False``, you can provide any path.
             Otherwise the path must start with the default path prefix of this type.
         """
-        if check_path and not str(path).startswith(self._common_path_default + "/"):
+        if check_path and not os.fspath(path).startswith(self._common_path_default + "/"):
             raise ValueError(f"Cannot instantiate {self.__class__.__name__!r} from path {path}")
         self.path: str  # SymbolicReference converts to string at the moment.
         super().__init__(repo, path)

git/refs/symbolic.py

@@ -79,7 +79,7 @@ def __init__(self, repo: "Repo", path: PathLike, check_path: bool = False) -> No
         self.path = path
 
     def __str__(self) -> str:
-        return str(self.path)
+        return os.fspath(self.path)
 
     def __repr__(self) -> str:
         return '<git.%s "%s">' % (self.__class__.__name__, self.path)
@@ -103,7 +103,7 @@ def name(self) -> str:
             In case of symbolic references, the shortest assumable name is the path
             itself.
         """
-        return str(self.path)
+        return os.fspath(self.path)
 
     @property
     def abspath(self) -> PathLike:
@@ -178,7 +178,7 @@ def _check_ref_name_valid(ref_path: PathLike) -> None:
         """
         previous: Union[str, None] = None
         one_before_previous: Union[str, None] = None
-        for c in str(ref_path):
+        for c in os.fspath(ref_path):
             if c in " ~^:?*[\\":
                 raise ValueError(
                     f"Invalid reference '{ref_path}': references cannot contain spaces, tildes (~), carets (^),"
@@ -212,7 +212,7 @@ def _check_ref_name_valid(ref_path: PathLike) -> None:
             raise ValueError(f"Invalid reference '{ref_path}': references cannot end with a forward slash (/)")
         elif previous == "@" and one_before_previous is None:
             raise ValueError(f"Invalid reference '{ref_path}': references cannot be '@'")
-        elif any(component.endswith(".lock") for component in str(ref_path).split("/")):
+        elif any(component.endswith(".lock") for component in os.fspath(ref_path).split("/")):
             raise ValueError(
                 f"Invalid reference '{ref_path}': references cannot have slash-separated components that end with"
                 " '.lock'"
@@ -235,7 +235,7 @@ def _get_ref_info_helper(
         tokens: Union[None, List[str], Tuple[str, str]] = None
         repodir = _git_dir(repo, ref_path)
         try:
-            with open(os.path.join(repodir, str(ref_path)), "rt", encoding="UTF-8") as fp:
+            with open(os.path.join(repodir, os.fspath(ref_path)), "rt", encoding="UTF-8") as fp:
                 value = fp.read().rstrip()
             # Don't only split on spaces, but on whitespace, which allows to parse lines like:
             # 60b64ef992065e2600bfef6187a97f92398a9144                branch 'master' of git-server:/path/to/repo
@@ -614,7 +614,7 @@ def to_full_path(cls, path: Union[PathLike, "SymbolicReference"]) -> PathLike:
         full_ref_path = path
         if not cls._common_path_default:
             return full_ref_path
-        if not str(path).startswith(cls._common_path_default + "/"):
+        if not os.fspath(path).startswith(cls._common_path_default + "/"):
             full_ref_path = "%s/%s" % (cls._common_path_default, path)
         return full_ref_path
 
@@ -706,7 +706,7 @@ def _create(
         if not force and os.path.isfile(abs_ref_path):
             target_data = str(target)
             if isinstance(target, SymbolicReference):
-                target_data = str(target.path)
+                target_data = os.fspath(target.path)
             if not resolve:
                 target_data = "ref: " + target_data
             with open(abs_ref_path, "rb") as fd:
@@ -842,7 +842,7 @@ def _iter_items(
 
         # Read packed refs.
         for _sha, rela_path in cls._iter_packed_refs(repo):
-            if rela_path.startswith(str(common_path)):
+            if rela_path.startswith(os.fspath(common_path)):
                 rela_paths.add(rela_path)
             # END relative path matches common path
         # END packed refs reading
@@ -931,4 +931,4 @@ def from_path(cls: Type[T_References], repo: "Repo", path: PathLike) -> T_Refere
 
     def is_remote(self) -> bool:
         """:return: True if this symbolic reference points to a remote branch"""
-        return str(self.path).startswith(self._remote_common_path_default + "/")
+        return os.fspath(self.path).startswith(self._remote_common_path_default + "/")

git/repo/base.py

@@ -554,7 +554,7 @@ def tag(self, path: PathLike) -> TagReference:
 
     @staticmethod
     def _to_full_tag_path(path: PathLike) -> str:
-        path_str = str(path)
+        path_str = os.fspath(path)
         if path_str.startswith(TagReference._common_path_default + "/"):
             return path_str
         if path_str.startswith(TagReference._common_default + "/"):
@@ -959,7 +959,7 @@ def is_dirty(
         if not submodules:
             default_args.append("--ignore-submodules")
         if path:
-            default_args.extend(["--", str(path)])
+            default_args.extend(["--", os.fspath(path)])
         if index:
             # diff index against HEAD.
             if osp.isfile(self.index.path) and len(self.git.diff("--cached", *default_args)):

git/util.py

@@ -272,9 +272,9 @@ def stream_copy(source: BinaryIO, destination: BinaryIO, chunk_size: int = 512 *
 def join_path(a: PathLike, *p: PathLike) -> PathLike:
     R"""Join path tokens together similar to osp.join, but always use ``/`` instead of
     possibly ``\`` on Windows."""
-    path = str(a)
+    path = os.fspath(a)
     for b in p:
-        b = str(b)
+        b = os.fspath(b)
         if not b:
             continue
         if b.startswith("/"):
@@ -290,18 +290,18 @@ def join_path(a: PathLike, *p: PathLike) -> PathLike:
 if sys.platform == "win32":
 
     def to_native_path_windows(path: PathLike) -> PathLike:
-        path = str(path)
+        path = os.fspath(path)
         return path.replace("/", "\\")
 
     def to_native_path_linux(path: PathLike) -> str:
-        path = str(path)
+        path = os.fspath(path)
         return path.replace("\\", "/")
 
     to_native_path = to_native_path_windows
 else:
     # No need for any work on Linux.
     def to_native_path_linux(path: PathLike) -> str:
-        return str(path)
+        return os.fspath(path)
 
     to_native_path = to_native_path_linux
 
@@ -372,7 +372,7 @@ def is_exec(fpath: str) -> bool:
     progs = []
     if not path:
         path = os.environ["PATH"]
-    for folder in str(path).split(os.pathsep):
+    for folder in os.fspath(path).split(os.pathsep):
         folder = folder.strip('"')
         if folder:
             exe_path = osp.join(folder, program)
@@ -397,7 +397,7 @@ def _cygexpath(drive: Optional[str], path: str) -> str:
                 p = cygpath(p)
         elif drive:
             p = "/proc/cygdrive/%s/%s" % (drive.lower(), p)
-    p_str = str(p)  # ensure it is a str and not AnyPath
+    p_str = os.fspath(p)  # ensure it is a str and not AnyPath
     return p_str.replace("\\", "/")
 
 
@@ -418,7 +418,7 @@ def _cygexpath(drive: Optional[str], path: str) -> str:
 
 def cygpath(path: str) -> str:
     """Use :meth:`git.cmd.Git.polish_url` instead, that works on any environment."""
-    path = str(path)  # Ensure is str and not AnyPath.
+    path = os.fspath(path)  # Ensure is str and not AnyPath.
     # Fix to use Paths when 3.5 dropped. Or to be just str if only for URLs?
     if not path.startswith(("/cygdrive", "//", "/proc/cygdrive")):
         for regex, parser, recurse in _cygpath_parsers:
@@ -438,7 +438,7 @@ def cygpath(path: str) -> str:
 
 
 def decygpath(path: PathLike) -> str:
-    path = str(path)
+    path = os.fspath(path)
     m = _decygpath_regex.match(path)
     if m:
         drive, rest_path = m.groups()
@@ -497,7 +497,7 @@ def is_cygwin_git(git_executable: Union[None, PathLike]) -> bool:
     elif git_executable is None:
         return False
     else:
-        return _is_cygwin_git(str(git_executable))
+        return _is_cygwin_git(os.fspath(git_executable))
 
 
 def get_user_id() -> str: