fix: exclude DBLP from default sync (#1030)

DBLP venue sync is resource-heavy for routine runs.\n\nMake large datasets opt-in via --include-large-datasets while keeping explicit backend selection unchanged.

Co-authored-by: florath-ai-assistant[bot] <Andreas.Florath@telekom.de>

Author: coding-ai-assistant[bot]

src/aletheia_probe/cli.py

@@ -25,6 +25,9 @@
 from .utils.dead_code import code_is_used
 
 
+LARGE_SYNC_BACKENDS: frozenset[str] = frozenset({"dblp_venues"})
+
+
 # Import cache_sync last: instantiation at module level may raise SchemaVersionError
 # if the database schema is outdated. Caught here for a clean error message.
 _startup_error: SchemaVersionError | None = None
@@ -225,31 +228,54 @@ def config() -> None:
 
 @main.command()
 @click.option("--force", is_flag=True, help="Force sync even if data appears fresh")
+@click.option(
+    "--include-large-datasets",
+    is_flag=True,
+    help=(
+        "Include large datasets in default sync. "
+        f"Currently: {', '.join(sorted(LARGE_SYNC_BACKENDS))}"
+    ),
+)
 @click.argument("backend_names", nargs=-1, required=False)
-def sync(force: bool, backend_names: tuple[str, ...]) -> None:
+def sync(
+    force: bool, include_large_datasets: bool, backend_names: tuple[str, ...]
+) -> None:
     """Manually sync cache with backend configuration.
 
     Optionally specify one or more backend names to sync only those backends.
     Examples:
       aletheia-probe sync              # Sync all backends
+      aletheia-probe sync --include-large-datasets  # Include large datasets
       aletheia-probe sync scopus       # Sync only scopus
       aletheia-probe sync bealls doaj  # Sync only bealls and doaj
 
     Args:
         force: Whether to force sync even if data appears fresh.
+        include_large_datasets: Whether to include large datasets in default sync.
         backend_names: Optional tuple of backend names to sync.
     """
     # Auto-register custom lists before sync
     from .cache.custom_list_manager import auto_register_custom_lists
 
     auto_register_custom_lists()
+    backend_filter: list[str] | None = None
+    if backend_names:
+        backend_filter = list(backend_names)
+    elif not include_large_datasets:
+        from .backends.base import get_backend_registry
+
+        backend_filter = [
+            backend_name
+            for backend_name in get_backend_registry().get_backend_names()
+            if backend_name not in LARGE_SYNC_BACKENDS
+        ]
 
     try:
         # The cache_sync_manager handles all output through the dual logger
         result = asyncio.run(
             cache_sync_manager.sync_cache_with_config(
                 force=force,
-                backend_filter=list(backend_names) if backend_names else None,
+                backend_filter=backend_filter,
                 show_progress=True,
             )
         )

tests/unit/test_cli.py

@@ -221,13 +221,62 @@ def run_coro(coro):
             coro.close()  # Close without running
             return {}
 
-        with patch("aletheia_probe.cli.asyncio.run", side_effect=run_coro) as mock_run:
+        mock_registry = Mock()
+        mock_registry.get_backend_names.return_value = ["bealls", "dblp_venues", "doaj"]
+
+        with (
+            patch(
+                "aletheia_probe.backends.base.get_backend_registry",
+                return_value=mock_registry,
+            ),
+            patch("aletheia_probe.cli.asyncio.run", side_effect=run_coro) as mock_run,
+        ):
             result = runner.invoke(main, ["sync", "--force"])
 
             assert result.exit_code == 0
             # Verify force=True was passed to sync_cache_with_config
             mock_sync.assert_called_once_with(
-                force=True, backend_filter=None, show_progress=True
+                force=True,
+                backend_filter=["bealls", "doaj"],
+                show_progress=True,
+            )
+
+    def test_sync_command_include_large_datasets(self, runner, mock_cache_sync_manager):
+        """Test sync command with include-large-datasets flag."""
+        original_sync = mock_cache_sync_manager.sync_cache_with_config
+        mock_sync = Mock(side_effect=original_sync)
+        mock_cache_sync_manager.sync_cache_with_config = mock_sync
+
+        def run_coro(coro):
+            """Run coroutine and return empty dict."""
+            coro.close()
+            return {}
+
+        with patch("aletheia_probe.cli.asyncio.run", side_effect=run_coro):
+            result = runner.invoke(main, ["sync", "--include-large-datasets"])
+
+            assert result.exit_code == 0
+            mock_sync.assert_called_once_with(
+                force=False, backend_filter=None, show_progress=True
+            )
+
+    def test_sync_command_explicit_backend_names(self, runner, mock_cache_sync_manager):
+        """Test sync command with explicit backend names."""
+        original_sync = mock_cache_sync_manager.sync_cache_with_config
+        mock_sync = Mock(side_effect=original_sync)
+        mock_cache_sync_manager.sync_cache_with_config = mock_sync
+
+        def run_coro(coro):
+            """Run coroutine and return empty dict."""
+            coro.close()
+            return {}
+
+        with patch("aletheia_probe.cli.asyncio.run", side_effect=run_coro):
+            result = runner.invoke(main, ["sync", "dblp_venues"])
+
+            assert result.exit_code == 0
+            mock_sync.assert_called_once_with(
+                force=False, backend_filter=["dblp_venues"], show_progress=True
             )
 
     def test_sync_command_skipped(self, runner):