Re-enable retrieving exact results from the package repository if they weren't in the DB

Author: pelson

simple_repository_browser/_search.py

@@ -51,10 +51,11 @@ def normalise_name(name: str) -> str:
 class SQLBuilder:
     """Immutable SQL WHERE and ORDER BY clauses with parameters."""
 
-    where_clause: str = ""
-    where_params: tuple[typing.Any, ...] = ()
-    order_clause: str = "ORDER BY canonical_name"
-    order_params: tuple[typing.Any, ...] = ()
+    where_clause: str
+    where_params: tuple[typing.Any, ...]
+    order_clause: str
+    order_params: tuple[typing.Any, ...]
+    search_context: SearchContext
 
     @property
     def where_params_count(self) -> int:
@@ -92,24 +93,37 @@ def with_order(self, clause: str, params: tuple[typing.Any, ...]) -> SQLBuilder:
 class SearchContext:
     """Context collected during WHERE clause building."""
 
-    exact_names: set[str] = dataclasses.field(default_factory=set)
-    fuzzy_patterns: set[str] = dataclasses.field(default_factory=set)
+    exact_names: tuple[str, ...] = ()
+    fuzzy_patterns: tuple[str, ...] = ()
 
     def with_exact_name(self, name: str) -> SearchContext:
         """Add an exact name match."""
-        return dataclasses.replace(self, exact_names=self.exact_names | {name})
+        if name in self.exact_names:
+            return self
+        else:
+            return dataclasses.replace(self, exact_names=self.exact_names + (name,))
 
     def with_fuzzy_pattern(self, pattern: str) -> SearchContext:
         """Add a fuzzy search pattern."""
-        return dataclasses.replace(self, fuzzy_patterns=self.fuzzy_patterns | {pattern})
+        if pattern in self.fuzzy_patterns:
+            return self
+        else:
+            return dataclasses.replace(
+                self, fuzzy_patterns=self.fuzzy_patterns + (pattern,)
+            )
 
     def merge(self, other: SearchContext) -> SearchContext:
         """Merge contexts from multiple terms (for OR/AND)."""
-        return dataclasses.replace(
-            self,
-            exact_names=self.exact_names | other.exact_names,
-            fuzzy_patterns=self.fuzzy_patterns | other.fuzzy_patterns,
+        names = self.exact_names + tuple(
+            name for name in other.exact_names if name not in self.exact_names
         )
+        patterns = self.fuzzy_patterns + tuple(
+            pattern
+            for pattern in other.fuzzy_patterns
+            if pattern not in self.fuzzy_patterns
+        )
+
+        return dataclasses.replace(self, exact_names=names, fuzzy_patterns=patterns)
 
 
 class SearchCompiler:
@@ -127,11 +141,16 @@ def compile(cls, terms: Term | tuple[Term, ...]) -> SQLBuilder:
             terms = (terms,) if terms else ()
 
         if len(terms) == 0:
-            return SQLBuilder()
+            return SQLBuilder(
+                where_clause="",
+                where_params=(),
+                order_clause="",
+                order_params=(),
+                search_context=SearchContext(),
+            )
+        assert len(terms) == 1
 
         # Build WHERE clause and collect context
-        # Note: Current grammar only produces single terms
-        # TODO: If this changes, we'll need to handle term combinations
         context = SearchContext()
         where_clause, where_params, final_context = cls._visit_term(terms[0], context)
 
@@ -143,6 +162,7 @@ def compile(cls, terms: Term | tuple[Term, ...]) -> SQLBuilder:
             where_params=where_params,
             order_clause=order_clause,
             order_params=order_params,
+            search_context=final_context,
         )
 
     @classmethod

simple_repository_browser/model.py

@@ -155,21 +155,27 @@ async def project_query(
         # Convert results to SearchResultItem objects
         results = [SearchResultItem(*result) for result in results]
 
-        # TODO: Re-enable package repository lookup for missing exact matches
-        # Check if single_name_proposal is already in the results
-        # if single_name_proposal and page == 1:
-        #     exact_found = any(r.canonical_name == single_name_proposal for r in results)
-        #     if not exact_found:
-        #         # Not in results, check if it exists in repository
-        #         try:
-        #             await self.source.get_project_page(single_name_proposal)
-        #             # Package exists in repository! Add it to the beginning
-        #             results.insert(
-        #                 0, SearchResultItem(canonical_name=single_name_proposal)
-        #             )
-        #             n_results += 1
-        #         except PackageNotFoundError:
-        #             pass
+        # If the search was for a specific name, then make sure we return it if
+        # it is in the package repository.
+        if page == 1:
+            result_names = {r.canonical_name for r in results}
+            missing = tuple(
+                name
+                for name in sql_builder.search_context.exact_names
+                if name not in result_names
+            )
+            if missing:
+                for name_proposal in reversed(missing):
+                    # Not in results, check if it exists in repository
+                    try:
+                        await self.source.get_project_page(name_proposal)
+                        # Package exists in repository! Add it to the beginning
+                        results.insert(
+                            0, SearchResultItem(canonical_name=name_proposal)
+                        )
+                        n_results += 1
+                    except PackageNotFoundError:
+                        pass
 
         return QueryResultModel(
             search_query=query,

simple_repository_browser/tests/test_search.py

@@ -192,9 +192,20 @@ def test_invalid_query(query, expected_exception):
 class MockSimpleRepository:
     """Mock repository for testing search functionality."""
 
+    def __init__(self, available_packages=None):
+        # Packages that exist in the repository but not in the database
+        self.available_packages = available_packages or set()
+
     async def get_project_page(self, name: str):
-        """Mock project page retrieval - not needed for search ordering tests."""
-        raise Exception(f"Project {name} not found")
+        """Mock project page retrieval."""
+        from simple_repository.errors import PackageNotFoundError
+
+        if name in self.available_packages:
+            # Return a mock project detail for testing
+            from simple_repository.model import Meta, ProjectDetail
+
+            return ProjectDetail(meta=Meta("1.0"), name=name, files=())
+        raise PackageNotFoundError(f"Project {name} not found")
 
 
 @pytest.fixture
@@ -386,22 +397,7 @@ async def test_complex_mixed_query(test_model):
     """Test complex mixed query with multiple exact names."""
     result = await test_model.project_query("numpy OR scipy", page_size=10, page=1)
 
-    names = [item.canonical_name for item in result["results"]]
-
-    # Should include both families
-    assert "numpy" in names
-    assert "scipy" in names
-    assert "numpy-image" in names
-    assert "scipy2" in names
-
-    # Exact matches should come before their related packages
-    numpy_idx = names.index("numpy")
-    scipy_idx = names.index("scipy")
-    numpy_image_idx = names.index("numpy-image")
-    scipy2_idx = names.index("scipy2")
-
-    assert numpy_idx < numpy_image_idx
-    assert scipy_idx < scipy2_idx
+    assert_order(["numpy", "scipy", "numpy-image", "scipy2"], result["results"])
 
 
 @pytest.mark.asyncio
@@ -429,3 +425,34 @@ async def test_empty_results(test_model):
 
     assert result["results"] == []
     assert result["results_count"] == 0
+
+
+@pytest.mark.asyncio
+async def test_injected_results_when_not_in_db(test_model):
+    assert isinstance(test_model.source, MockSimpleRepository)
+    test_model.source.available_packages = [
+        "jingo",
+        "wibble",
+        "wibbleof",
+        "bongo",
+        "bongo-bong",
+    ]
+    result = await test_model.project_query(
+        "jingo OR wibble* OR boNgo OR bongo_Bong OR numpy OR totallyMissing",
+        page_size=10,
+        page=1,
+    )
+    # result = await test_model.project_query("jingo OR numpy", page_size=10, page=1)
+
+    names = [item.canonical_name for item in result["results"]]
+
+    assert "wibble" not in names
+    assert_order(
+        ["jingo", "bongo", "bongo-bong", "numpy"],
+        result["results"],
+    )
+    # Check that the one result that came from the db actually has the summary.
+    [numpy_result] = [
+        item for item in result["results"] if item.canonical_name == "numpy"
+    ]
+    assert "Fundamental" in numpy_result.summary