⚡️ Speed up function _get_git_remote_for_setup by 33% in PR #1199 (omni-java)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1199

If you approve this dependent PR, these changes will be merged into the original PR branch omni-java.

This PR will be automatically closed if the original PR is merged.

---

📄 33% (0.33x) speedup for _get_git_remote_for_setup in codeflash/cli_cmds/init_java.py

⏱️ Runtime : 19.5 milliseconds → 14.6 milliseconds (best of 15 runs)

📝 Explanation and details

This optimization achieves a 32% runtime improvement (19.5ms → 14.6ms) by eliminating redundant work in the _get_theme() function through memoization with a global cache.

Key Changes:

1. Global theme caching: A module-level _cached_theme variable stores the CodeflashTheme instance after first creation
2. Lazy initialization with cache check: _get_theme() now checks if the theme exists before importing/instantiating, avoiding repeated expensive operations

Why This Speeds Things Up:

The line profiler shows _get_theme() is called 18 times during execution. In the original code, each call:

• Imports CodeflashTheme (~16.3ms per call, 68.5% of function time)
• Creates a new instance (~7.5ms per call, 31.5% of function time)

With caching:

• First call: Pays the full import + instantiation cost once (~17.1ms total)
• Subsequent 17 calls: Return cached instance (~6μs each, effectively free)

This eliminates ~400ms of redundant work across the 18 calls (17 × ~23.8ms saved per avoided re-initialization).

Performance Impact:

The optimization shines when _get_git_remote_for_setup() processes multiple git remotes and prompts users repeatedly. Looking at the line profiler:

• The inquirer.prompt(theme=_get_theme()) line drops from 24.5ms to 17.7ms (28% faster)
• Overall function time improves from 70.2ms to 64.0ms (8.8% faster)

The test cases with multiple remotes (e.g., test_multiple_remotes_user_selects_one, test_large_number_of_remotes_performance_and_selection) benefit most, as they trigger the theme retrieval multiple times during the prompt flow. Single-remote scenarios see minimal change since they skip the prompt path entirely.

Trade-offs:

The global cache introduces state that persists across function calls, which is acceptable here since CodeflashTheme is stateless and immutable after construction. The memory overhead is negligible (one theme object vs. potentially dozens).

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 31 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import os
from pathlib import Path

import git  # GitPython library used by the implementation
import pytest  # used for our unit tests
# import the module and function under test
from codeflash.cli_cmds import init_java
from codeflash.cli_cmds.console import console
from codeflash.cli_cmds.init_java import _get_git_remote_for_setup
from git import InvalidGitRepositoryError
from git import Repo as GitRepo

# NOTE:
# These tests exercise the real implementation of _get_git_remote_for_setup.
# They create real local git repositories using GitPython in temporary directories,
# manipulate remotes, and patch only external interactive/display helpers such as
# inquirer.prompt and the console printer so tests are deterministic and non-interactive.

def _create_repo_with_remotes(tmp_path: Path, remote_names: list[str]) -> GitRepo:
    """
    Helper to create a git repository in tmp_path and add remotes with given names.
    Returns the GitPython Repo object.
    """
    repo = GitRepo.init(tmp_path)
    # Add a dummy commit so the repository is fully initialized.
    # Write a file, stage, and commit.
    dummy_file = tmp_path / "README.md"
    dummy_file.write_text("# temp repo")
    repo.index.add([str(dummy_file)])
    repo.index.commit("initial commit")
    # Create the requested remotes with a placeholder URL.
    for name in remote_names:
        # GitPython's create_remote requires a URL; use an in-memory dummy URL.
        repo.create_remote(name, url=f"https://example.com/{name}.git")
    return repo

def test_returns_empty_when_not_a_git_repo(monkeypatch):
    """
    If Repo(...) raises InvalidGitRepositoryError, the function should catch it
    and return an empty string.
    """
    # Patch the Repo symbol in the module under test to raise the specific exception.
    def _raise_invalid(*args, **kwargs):
        raise InvalidGitRepositoryError("not a git repo")

    monkeypatch.setattr(init_java, "Repo", _raise_invalid)

    # Ensure no interactive prompt gets called - patch just in case.
    monkeypatch.setattr(init_java, "console", init_java.console)

    codeflash_output = _get_git_remote_for_setup(); result = codeflash_output # 12.8μs -> 12.9μs (1.09% slower)

def test_returns_empty_when_repo_has_no_remotes(tmp_path, monkeypatch):
    """
    Create a real git repo with no remotes, chdir into it, and assert the function
    returns an empty string (no remotes configured).
    """
    repo_dir = tmp_path / "repo_no_remotes"
    repo_dir.mkdir()
    # Initialize a real repo with no remotes.
    repo = GitRepo.init(repo_dir)
    # Create an initial commit so Repo is well-formed.
    file = repo_dir / "file.txt"
    file.write_text("hello")
    repo.index.add([str(file)])
    repo.index.commit("init")

    # Ensure any console output is suppressed during the test.
    monkeypatch.setattr(init_java, "console", init_java.console)

    # Change cwd to the repository path so the function's Repo(...) resolves correctly.
    old_cwd = Path.cwd()
    try:
        os.chdir(repo_dir)
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
    finally:
        os.chdir(old_cwd)

def test_single_remote_is_returned(tmp_path, monkeypatch):
    """
    If exactly one remote exists (e.g., 'origin'), the function should return its name
    without prompting the user.
    """
    repo_dir = tmp_path / "repo_single_remote"
    repo_dir.mkdir()
    repo = _create_repo_with_remotes(repo_dir, ["origin"])

    # Suppress console printing; no prompt should be invoked for a single remote.
    monkeypatch.setattr(init_java, "console", init_java.console)

    old_cwd = Path.cwd()
    try:
        os.chdir(repo_dir)
        # Should return the only remote name we added.
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
    finally:
        os.chdir(old_cwd)

def test_multiple_remotes_user_selects_one(monkeypatch, tmp_path):
    """
    When multiple remotes exist, the function will prompt the user. Simulate a user
    selecting 'upstream' and verify that selection is returned.
    """
    repo_dir = tmp_path / "repo_multi_select"
    repo_dir.mkdir()
    # Create three remotes in a defined order.
    repo = _create_repo_with_remotes(repo_dir, ["origin", "upstream", "backup"])

    # Patch console.print to no-op so UI elements don't pollute test output.
    monkeypatch.setattr(init_java, "console", init_java.console)
    monkeypatch.setattr(init_java, "console", init_java.console)
    # Patch inquirer.prompt to simulate user selecting 'upstream'.
    monkeypatch.setattr("inquirer.prompt", lambda questions, theme=None: {"git_remote": "upstream"})

    old_cwd = Path.cwd()
    try:
        os.chdir(repo_dir)
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
    finally:
        os.chdir(old_cwd)

def test_multiple_remotes_user_cancels_prompt_returns_first(monkeypatch, tmp_path):
    """
    If the interactive prompt returns None (user cancelled or no answer),
    the function should fall back to the first remote in the list.
    """
    repo_dir = tmp_path / "repo_multi_cancel"
    repo_dir.mkdir()
    # Create remotes in a specific order; the first should be selected on cancel.
    names = ["first_remote", "second_remote", "third_remote"]
    repo = _create_repo_with_remotes(repo_dir, names)

    # Patch console.print out to avoid UI output during tests.
    monkeypatch.setattr(init_java, "console", init_java.console)
    # Simulate the user cancelling the prompt.
    monkeypatch.setattr("inquirer.prompt", lambda questions, theme=None: None)

    old_cwd = Path.cwd()
    try:
        os.chdir(repo_dir)
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
    finally:
        os.chdir(old_cwd)

def test_remote_names_with_special_characters_and_unicode(monkeypatch, tmp_path):
    """
    Ensure the function correctly handles remote names with special characters and unicode.
    """
    repo_dir = tmp_path / "repo_special_names"
    repo_dir.mkdir()
    # Use a mix of ASCII, punctuation, and unicode names.
    names = ["origin", "weird-remote_123", "úñíçødé"]
    repo = _create_repo_with_remotes(repo_dir, names)

    # Simulate no user answer to force fallback behavior to first remote.
    monkeypatch.setattr("inquirer.prompt", lambda questions, theme=None: None)
    monkeypatch.setattr(init_java, "console", init_java.console)

    old_cwd = Path.cwd()
    try:
        os.chdir(repo_dir)
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
    finally:
        os.chdir(old_cwd)

def test_large_number_of_remotes_performance_and_selection(monkeypatch, tmp_path):
    """
    Create a large (but bounded under 1000) number of remotes and ensure the function
    can handle the list, present it (console suppressed), and return the user's selection.
    This tests scalability with many remotes without exceeding the 1000-element guideline.
    """
    repo_dir = tmp_path / "repo_many_remotes"
    repo_dir.mkdir()
    # Use 200 remotes which is large enough to be meaningful but within the requested limit.
    n_remotes = 200
    names = [f"r{idx}" for idx in range(n_remotes)]
    repo = _create_repo_with_remotes(repo_dir, names)

    # Simulate selecting the last remote to ensure scanning/ordering is correct.
    monkeypatch.setattr("inquirer.prompt", lambda questions, theme=None: {"git_remote": names[-1]})
    monkeypatch.setattr(init_java, "console", init_java.console)

    old_cwd = Path.cwd()
    try:
        os.chdir(repo_dir)
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
    finally:
        os.chdir(old_cwd)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from pathlib import Path
from unittest.mock import MagicMock, Mock, patch

# imports
import pytest
from codeflash.cli_cmds.init_java import _get_git_remote_for_setup
from codeflash.code_utils.git_utils import get_git_remotes
from git import InvalidGitRepositoryError, Repo

def test_single_git_remote_returns_that_remote():
    """Test that when exactly one git remote exists, it is returned immediately."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        # Setup mock repo with single remote
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        # Mock get_git_remotes to return a single remote
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin']
            
            codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
            mock_get_remotes.assert_called_once_with(mock_repo)

def test_no_git_remotes_returns_empty_string():
    """Test that when no git remotes exist, empty string is returned."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = []
            
            codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_invalid_git_repository_returns_empty_string():
    """Test that InvalidGitRepositoryError is caught and empty string is returned."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        # Raise InvalidGitRepositoryError when trying to create repo
        mock_repo_class.side_effect = InvalidGitRepositoryError()
        
        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output # 26.5μs -> 26.2μs (1.11% faster)

def test_multiple_remotes_prompts_user_and_returns_selection():
    """Test that with multiple remotes, user is prompted and selection is returned."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin', 'upstream', 'fork']
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                # User selects 'upstream'
                mock_prompt.return_value = {'git_remote': 'upstream'}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
                # Verify prompt was called with correct choices
                call_args = mock_prompt.call_args

def test_multiple_remotes_first_remote_when_prompt_returns_none():
    """Test that first remote is returned when prompt returns None."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin', 'upstream']
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                # User cancels/closes prompt
                mock_prompt.return_value = None
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_git_remote_with_special_characters():
    """Test handling of git remote names with special characters."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # Remote with special characters (valid in git)
            special_remotes = ['origin-backup', 'fork/main', 'upstream_v2']
            mock_get_remotes.return_value = special_remotes
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': 'fork/main'}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_git_remote_with_numeric_names():
    """Test handling of numeric git remote names."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            numeric_remotes = ['1', '2', '3']
            mock_get_remotes.return_value = numeric_remotes
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': '2'}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_repo_search_parent_directories_parameter():
    """Test that Repo is called with search_parent_directories parameter."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin']
            
            _get_git_remote_for_setup()
            
            # Verify Repo was called with search_parent_directories=True
            mock_repo_class.assert_called_once_with(
                Path.cwd(), 
                search_parent_directories=True
            )

def test_cwd_parameter_in_repo_initialization():
    """Test that Repo is initialized with current working directory."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin']
            
            _get_git_remote_for_setup()
            
            # Verify Path.cwd() is used
            call_args = mock_repo_class.call_args

def test_console_print_called_with_multiple_remotes():
    """Test that console.print is called when multiple remotes exist."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin', 'upstream']
            
            with patch('codeflash.cli_cmds.init_java.console') as mock_console:
                with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                    mock_prompt.return_value = {'git_remote': 'origin'}
                    
                    _get_git_remote_for_setup()

def test_console_not_called_with_single_remote():
    """Test that console.print is not called when only one remote exists."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin']
            
            with patch('codeflash.cli_cmds.init_java.console') as mock_console:
                _get_git_remote_for_setup()
                
                # console.print should not be called
                mock_console.print.assert_not_called()

def test_inquirer_prompt_not_called_with_single_remote():
    """Test that inquirer.prompt is not called when only one remote exists."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin']
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                _get_git_remote_for_setup()
                
                # inquirer.prompt should not be called
                mock_prompt.assert_not_called()

def test_get_git_remotes_called_once():
    """Test that get_git_remotes is called exactly once."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin']
            
            _get_git_remote_for_setup()

def test_empty_string_remote_in_list():
    """Test handling of empty string as a remote name in the list."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # Edge case: empty string in remotes list
            mock_get_remotes.return_value = ['', 'origin']
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': ''}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_whitespace_remote_name():
    """Test handling of remote names with whitespace (edge case)."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            remotes_with_whitespace = ['origin', ' upstream ']
            mock_get_remotes.return_value = remotes_with_whitespace
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': ' upstream '}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_default_value_in_inquirer_list():
    """Test that inquirer.List has 'origin' as default value."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            mock_get_remotes.return_value = ['origin', 'upstream']
            
            with patch('codeflash.cli_cmds.init_java.inquirer.List') as mock_list:
                with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                    mock_prompt.return_value = {'git_remote': 'origin'}
                    
                    _get_git_remote_for_setup()
                    # Check that default='origin' was passed
                    call_kwargs = mock_list.call_args[1]

def test_many_git_remotes_selection():
    """Test function handles selection from a large list of git remotes."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # Create 100 different remotes
            large_remotes = [f'remote_{i}' for i in range(100)]
            mock_get_remotes.return_value = large_remotes
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': 'remote_50'}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
                # Verify all remotes were passed to prompt
                call_args = mock_prompt.call_args

def test_many_git_remotes_returns_all_in_prompt():
    """Test that all remotes are included in the prompt when there are many."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # Create 500 different remotes
            large_remotes = [f'remote_{i:04d}' for i in range(500)]
            mock_get_remotes.return_value = large_remotes
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': 'remote_0499'}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
                # Verify all 500 remotes are in choices
                call_args = mock_prompt.call_args
                choices = call_args[0][0][0].choices

def test_very_long_remote_names():
    """Test handling of very long remote names."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # Create remotes with very long names
            long_remote_names = [
                'origin-' + 'a' * 500,
                'upstream-' + 'b' * 500
            ]
            mock_get_remotes.return_value = long_remote_names
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': long_remote_names[0]}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_many_calls_to_function():
    """Test that function works correctly over multiple consecutive calls."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        results = []
        remotes_list = [['origin'], ['origin', 'upstream'], ['fork']]
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                for i, remotes in enumerate(remotes_list):
                    mock_get_remotes.return_value = remotes
                    if len(remotes) == 1:
                        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
                        results.append(result)
                    else:
                        mock_prompt.return_value = {'git_remote': 'origin'}
                        codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
                        results.append(result)

def test_git_remotes_with_urls():
    """Test handling of remotes with URL-like names."""
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # In real repos, remotes have names like 'origin', not URLs
            # But testing edge case where names could be unusual
            url_like_remotes = [
                'github.com-fork',
                'gitlab.com-upstream',
                'bitbucket.org-mirror'
            ]
            mock_get_remotes.return_value = url_like_remotes
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': 'gitlab.com-upstream'}
                
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output

def test_performance_with_large_remote_count():
    """Test that function completes in reasonable time with many remotes."""
    import time
    
    with patch('codeflash.cli_cmds.init_java.Repo') as mock_repo_class:
        mock_repo = MagicMock()
        mock_repo_class.return_value = mock_repo
        
        with patch('codeflash.cli_cmds.init_java.get_git_remotes') as mock_get_remotes:
            # Create a moderately large list of remotes
            large_remotes = [f'remote_{i}' for i in range(800)]
            mock_get_remotes.return_value = large_remotes
            
            with patch('codeflash.cli_cmds.init_java.inquirer.prompt') as mock_prompt:
                mock_prompt.return_value = {'git_remote': 'remote_400'}
                
                start_time = time.time()
                codeflash_output = _get_git_remote_for_setup(); result = codeflash_output
                elapsed_time = time.time() - start_time
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1199-2026-02-01T22.34.33 and push.