fix pre-commit things

Author: NicolasIRAGNE

.pre-commit-config.yaml

@@ -117,6 +117,7 @@ repos:
             boto3>=1.28.0,
             click>=8.0.0,
             'fastapi[standard]>=0.109.1',
+            gitpython>=3.1.0,
             httpx,
             loguru>=0.7.0,
             pathspec>=0.12.1,
@@ -144,6 +145,7 @@ repos:
             boto3>=1.28.0,
             click>=8.0.0,
             'fastapi[standard]>=0.109.1',
+            gitpython>=3.1.0,
             httpx,
             loguru>=0.7.0,
             pathspec>=0.12.1,

src/gitingest/clone.py

@@ -47,6 +47,8 @@ async def clone_repo(config: CloneConfig, *, token: str | None = None) -> None:
     ------
     ValueError
         If the repository is not found, if the provided URL is invalid, or if the token format is invalid.
+    RuntimeError
+        If Git operations fail during the cloning process.
 
     """
     # Extract and validate query parameters
@@ -121,7 +123,40 @@ async def clone_repo(config: CloneConfig, *, token: str | None = None) -> None:
         await checkout_partial_clone(config, token=token)
         logger.debug("Partial clone setup completed")
 
-    # Create repo object and perform operations
+    # Perform post-clone operations
+    await _perform_post_clone_operations(config, local_path, url, token, commit)
+
+    logger.info("Git clone operation completed successfully", extra={"local_path": local_path})
+
+
+async def _perform_post_clone_operations(
+    config: CloneConfig,
+    local_path: str,
+    url: str,
+    token: str | None,
+    commit: str,
+) -> None:
+    """Perform post-clone operations like fetching, checkout, and submodule updates.
+
+    Parameters
+    ----------
+    config : CloneConfig
+        The configuration for cloning the repository.
+    local_path : str
+        The local path where the repository was cloned.
+    url : str
+        The repository URL.
+    token : str | None
+        GitHub personal access token (PAT) for accessing private repositories.
+    commit : str
+        The commit SHA to checkout.
+
+    Raises
+    ------
+    RuntimeError
+        If any Git operation fails.
+
+    """
     try:
         repo = create_git_repo(local_path, url, token)
 
@@ -141,5 +176,3 @@ async def clone_repo(config: CloneConfig, *, token: str | None = None) -> None:
     except git.GitCommandError as exc:
         msg = f"Git operation failed: {exc}"
         raise RuntimeError(msg) from exc
-
-    logger.info("Git clone operation completed successfully", extra={"local_path": local_path})

src/gitingest/utils/git_utils.py

@@ -8,7 +8,7 @@
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Final, Iterable
-from urllib.parse import urlparse
+from urllib.parse import urlparse, urlunparse
 
 import git
 import httpx
@@ -226,6 +226,8 @@ async def fetch_remote_branches_or_tags(url: str, *, ref_type: str, token: str |
     ------
     ValueError
         If the ``ref_type`` parameter is not "branches" or "tags".
+    RuntimeError
+        If fetching branches or tags from the remote repository fails.
 
     """
     if ref_type not in ("branches", "tags"):
@@ -238,8 +240,7 @@ async def fetch_remote_branches_or_tags(url: str, *, ref_type: str, token: str |
     try:
         git_cmd = git.Git()
 
-        # Prepare environment with authentication if needed
-        env = None
+        # Prepare authentication if needed
         if token and is_github_host(url):
             auth_url = _add_token_to_url(url, token)
             url = auth_url
@@ -284,6 +285,11 @@ def create_git_repo(local_path: str, url: str, token: str | None = None) -> git.
     git.Repo
         A GitPython Repo object configured with authentication.
 
+    Raises
+    ------
+    ValueError
+        If the local path is not a valid git repository.
+
     """
     try:
         repo = git.Repo(local_path)
@@ -295,11 +301,12 @@ def create_git_repo(local_path: str, url: str, token: str | None = None) -> git.
             key, value = auth_header.split("=", 1)
             repo.git.config(key, value)
 
-        return repo
     except git.InvalidGitRepositoryError as exc:
         msg = f"Invalid git repository at {local_path}"
         raise ValueError(msg) from exc
 
+    return repo
+
 
 def create_git_auth_header(token: str, url: str = "https://github.com") -> str:
     """Create a Basic authentication header for GitHub git operations.
@@ -360,6 +367,11 @@ async def checkout_partial_clone(config: CloneConfig, token: str | None) -> None
     token : str | None
         GitHub personal access token (PAT) for accessing private repositories.
 
+    Raises
+    ------
+    RuntimeError
+        If the sparse-checkout configuration fails.
+
     """
     subpath = config.subpath.lstrip("/")
     if config.blob:
@@ -444,11 +456,12 @@ async def _resolve_ref_to_sha(url: str, pattern: str, token: str | None = None)
             msg = f"{pattern!r} not found in {url}"
             raise ValueError(msg)
 
-        return sha
     except git.GitCommandError as exc:
         msg = f"Failed to resolve {pattern} in {url}: {exc}"
         raise ValueError(msg) from exc
 
+    return sha
+
 
 def _pick_commit_sha(lines: Iterable[str]) -> str | None:
     """Return a commit SHA from ``git ls-remote`` output.
@@ -501,8 +514,6 @@ def _add_token_to_url(url: str, token: str) -> str:
         The URL with embedded authentication.
 
     """
-    from urllib.parse import urlparse, urlunparse
-
     parsed = urlparse(url)
     # Add token as username in URL (GitHub supports this)
     netloc = f"x-oauth-basic:{token}@{parsed.hostname}"

tests/conftest.py

@@ -189,12 +189,12 @@ def _factory(branches: list[str]) -> None:
             new_callable=AsyncMock,
             return_value=branches,
         )
-        
+
         # Patch GitPython's ls_remote method to return the mocked output
         ls_remote_output = "\n".join(f"{DEMO_COMMIT[:12]}{i:02d}\trefs/heads/{b}" for i, b in enumerate(branches))
         mock_git_cmd = mocker.patch("git.Git")
         mock_git_cmd.return_value.ls_remote.return_value = ls_remote_output
-        
+
         # Also patch the git module imports in our utils
         mocker.patch("gitingest.utils.git_utils.git.Git", return_value=mock_git_cmd.return_value)
 
@@ -216,10 +216,10 @@ def run_command_mock(mocker: MockerFixture) -> AsyncMock:
     """
     mock = AsyncMock(side_effect=_fake_run_command)
     mocker.patch("gitingest.utils.git_utils.run_command", mock)
-    
+
     # Mock GitPython components
     _setup_gitpython_mocks(mocker)
-    
+
     return mock
 
 
@@ -238,7 +238,7 @@ def _setup_gitpython_mocks(mocker: MockerFixture) -> dict[str, MagicMock]:
     mock_git_cmd.execute.return_value = f"{DEMO_COMMIT}\trefs/heads/main\n"
     mock_git_cmd.ls_remote.return_value = f"{DEMO_COMMIT}\trefs/heads/main\n"
     mock_git_cmd.clone.return_value = ""
-    
+
     # Mock git.Repo class
     mock_repo = MagicMock()
     mock_repo.git = MagicMock()
@@ -248,21 +248,21 @@ def _setup_gitpython_mocks(mocker: MockerFixture) -> dict[str, MagicMock]:
     mock_repo.git.execute = MagicMock()
     mock_repo.git.config = MagicMock()
     mock_repo.git.sparse_checkout = MagicMock()
-    
+
     # Mock git.Repo.clone_from
     mock_clone_from = MagicMock(return_value=mock_repo)
-    
+
     git_git_mock = mocker.patch("git.Git", return_value=mock_git_cmd)
     git_repo_mock = mocker.patch("git.Repo", return_value=mock_repo)
     mocker.patch("git.Repo.clone_from", mock_clone_from)
-    
+
     # Patch imports in our modules
     mocker.patch("gitingest.utils.git_utils.git.Git", return_value=mock_git_cmd)
     mocker.patch("gitingest.utils.git_utils.git.Repo", return_value=mock_repo)
     mocker.patch("gitingest.clone.git.Git", return_value=mock_git_cmd)
     mocker.patch("gitingest.clone.git.Repo", return_value=mock_repo)
     mocker.patch("gitingest.clone.git.Repo.clone_from", mock_clone_from)
-    
+
     return {
         "git_cmd": mock_git_cmd,
         "repo": mock_repo,

tests/test_clone.py

@@ -6,7 +6,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import sys
 from typing import TYPE_CHECKING
 from unittest.mock import AsyncMock
@@ -17,9 +16,8 @@
 
 from gitingest.clone import clone_repo
 from gitingest.schemas import CloneConfig
-from gitingest.utils.exceptions import AsyncTimeoutError
 from gitingest.utils.git_utils import check_repo_exists
-from tests.conftest import DEMO_COMMIT, DEMO_URL, LOCAL_REPO_PATH
+from tests.conftest import DEMO_URL, LOCAL_REPO_PATH
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -53,26 +51,23 @@ async def test_clone_with_commit(repo_exists_true: AsyncMock, gitpython_mocks: d
     await clone_repo(clone_config)
 
     repo_exists_true.assert_any_call(clone_config.url, token=None)
-    
+
     # Verify GitPython calls were made
     mock_git_cmd = gitpython_mocks["git_cmd"]
     mock_repo = gitpython_mocks["repo"]
     mock_clone_from = gitpython_mocks["clone_from"]
-    
+
     # Should have called version (for ensure_git_installed)
     mock_git_cmd.version.assert_called()
-    
+
     # Should have called clone_from (since partial_clone=False)
     mock_clone_from.assert_called_once()
-    
+
     # Should have called fetch and checkout on the repo
     mock_repo.git.fetch.assert_called()
     mock_repo.git.checkout.assert_called_with(commit_hash)
 
 
-
-
-
 @pytest.mark.asyncio
 async def test_clone_nonexistent_repository(repo_exists_true: AsyncMock) -> None:
     """Test cloning a nonexistent repository URL.
@@ -118,15 +113,6 @@ async def test_check_repo_exists(status_code: int, *, expected: bool, mocker: Mo
     assert result is expected
 
 
-
-
-
-
-
-
-
-
-
 @pytest.mark.asyncio
 async def test_clone_without_commit(repo_exists_true: AsyncMock, gitpython_mocks: dict) -> None:
     """Test cloning a repository when no commit hash is provided.
@@ -140,12 +126,12 @@ async def test_clone_without_commit(repo_exists_true: AsyncMock, gitpython_mocks
     await clone_repo(clone_config)
 
     repo_exists_true.assert_any_call(clone_config.url, token=None)
-    
+
     # Verify GitPython calls were made
     mock_git_cmd = gitpython_mocks["git_cmd"]
     mock_repo = gitpython_mocks["repo"]
     mock_clone_from = gitpython_mocks["clone_from"]
-    
+
     # Should have resolved the commit via ls_remote
     mock_git_cmd.ls_remote.assert_called()
     # Should have cloned the repo
@@ -170,7 +156,7 @@ async def test_clone_creates_parent_directory(tmp_path: Path, gitpython_mocks: d
 
     # Verify parent directories were created
     assert nested_path.parent.exists()
-    
+
     # Verify clone operation happened
     mock_clone_from = gitpython_mocks["clone_from"]
     mock_clone_from.assert_called_once()
@@ -192,7 +178,7 @@ async def test_clone_with_specific_subpath(gitpython_mocks: dict) -> None:
     # Verify partial clone (using git.clone instead of Repo.clone_from)
     mock_git_cmd = gitpython_mocks["git_cmd"]
     mock_git_cmd.clone.assert_called()
-    
+
     # Verify sparse checkout was configured
     mock_repo = gitpython_mocks["repo"]
     mock_repo.git.sparse_checkout.assert_called()
@@ -232,9 +218,3 @@ async def test_check_repo_exists_with_redirect(mocker: MockerFixture) -> None:
     repo_exists = await check_repo_exists(DEMO_URL)
 
     assert repo_exists is False
-
-
-
-
-
-

tests/test_git_utils.py

@@ -82,20 +82,20 @@ def test_create_git_repo(
     local_path: str,
     url: str,
     token: str | None,
-    should_configure_auth: bool,
+    should_configure_auth: bool,  # noqa: FBT001
     mocker: MockerFixture,
 ) -> None:
     """Test that ``create_git_repo`` creates a proper Git repo object."""
     # Mock git.Repo to avoid actual filesystem operations
     mock_repo = mocker.MagicMock()
     mock_repo_class = mocker.patch("git.Repo", return_value=mock_repo)
-    
+
     repo = create_git_repo(local_path, url, token)
-    
+
     # Should create repo with correct path
     mock_repo_class.assert_called_once_with(local_path)
     assert repo == mock_repo
-    
+
     # Check auth configuration
     if should_configure_auth:
         mock_repo.git.config.assert_called_once()
@@ -140,7 +140,7 @@ def test_create_git_repo_helper_calls(
     mock_repo = mocker.MagicMock()
     mocker.patch("git.Repo", return_value=mock_repo)
 
-    repo = create_git_repo(str(work_dir), url, token)
+    create_git_repo(str(work_dir), url, token)
 
     if should_call:
         header_mock.assert_called_once_with(token, url=url)
@@ -241,13 +241,13 @@ def test_create_git_repo_with_ghe_urls(
     """Test that ``create_git_repo`` handles GitHub Enterprise URLs correctly."""
     mock_repo = mocker.MagicMock()
     mocker.patch("git.Repo", return_value=mock_repo)
-    
-    repo = create_git_repo(local_path, url, token)
+
+    create_git_repo(local_path, url, token)
 
     # Should configure auth with the correct hostname
     mock_repo.git.config.assert_called_once()
     auth_config_call = mock_repo.git.config.call_args[0]
-    
+
     # The first argument should contain the hostname
     assert expected_auth_hostname in auth_config_call[0]
 
@@ -270,8 +270,8 @@ def test_create_git_repo_ignores_non_github_urls(
     """Test that ``create_git_repo`` does not configure auth for non-GitHub URLs."""
     mock_repo = mocker.MagicMock()
     mocker.patch("git.Repo", return_value=mock_repo)
-    
-    repo = create_git_repo(local_path, url, token)
+
+    create_git_repo(local_path, url, token)
 
     # Should not configure auth for non-GitHub URLs
     mock_repo.git.config.assert_not_called()