Add a switch for client_variants check

Author: ncloudioj

merino/configs/default.toml

@@ -607,6 +607,10 @@ dummy_engaged_count = 1
 # The dummy candidate for Thompson sampling - attempted count
 dummy_attempted_count = 1000
 
+# MERINO_PROVIDERS__ADM__THOMPSON__CHECK_CLIENT_VARIANTS
+# Whether to check `client_variants` for Thompson sampling
+check_client_variants = true
+
 [default.amo.dynamic]
 # MERINO_AMO__DYNAMIC__API_URL
 # This is the URL for the Addons API to get more information for particular addons.

merino/jobs/cli.py

@@ -18,9 +18,7 @@
 # Include your new jobs module here.
 
 # NOTE: `pretty_exceptions_show_locals` argument is set to False to avoid api_key and secrets exposure.
-cli = typer.Typer(
-    no_args_is_help=True, add_completion=False, pretty_exceptions_show_locals=False
-)
+cli = typer.Typer(no_args_is_help=True, add_completion=False, pretty_exceptions_show_locals=False)
 
 # Add the wikipedia-indexer subcommands
 cli.add_typer(indexer_cmd, no_args_is_help=True)

merino/providers/suggest/adm/provider.py

@@ -83,6 +83,7 @@ class Provider(BaseProvider):
     backend: AdmBackend
     resync_interval_sec: float
     min_attempted_count: int
+    should_check_client_variants: bool
     thompson: ThompsonSampler | None = None
 
     def __init__(
@@ -95,6 +96,7 @@ def __init__(
         enabled_by_default: bool = True,
         min_attempted_count: int = 0,
         thompson: ThompsonSampler | None = None,
+        should_check_client_variants=True,
         **kwargs: Any,
     ) -> None:
         """Store the given Remote Settings backend on the provider."""
@@ -107,6 +109,7 @@ def __init__(
         self._enabled_by_default = enabled_by_default
         self.min_attempted_count = min_attempted_count
         self.thompson = thompson
+        self.should_check_client_variants = should_check_client_variants
         super().__init__(**kwargs)
 
     async def initialize(self) -> None:
@@ -167,7 +170,10 @@ def _select(
             Either a winner `PyAmpResult` or None if the optimizer (e.g. Thompson sampler)
             determines so. Return the first candidate when the optimizer is disabled.
         """
-        if self.thompson and any([cv in CLIENT_VARIANTS_ALLOW_LIST for cv in client_variants]):
+        if self.thompson and (
+            not self.should_check_client_variants
+            or any([cv in CLIENT_VARIANTS_ALLOW_LIST for cv in client_variants])
+        ):
             candidates = [
                 ThompsonCandidate(id=i, metrics=self._fetch_engagement_metrics(suggestion))
                 for i, suggestion in enumerate(suggestions)

merino/providers/suggest/manager.py

@@ -202,6 +202,7 @@ def _create_provider(provider_id: str, setting: Settings) -> BaseProvider:
                 enabled_by_default=setting.enabled_by_default,
                 min_attempted_count=settings.providers.adm.thompson.min_attempted_count,
                 thompson=thompson,
+                should_check_client_variants=settings.providers.adm.thompson.check_client_variants,
             )
         case ProviderType.GEOLOCATION:
             return GeolocationProvider(

tests/unit/providers/suggest/adm/conftest.py

@@ -167,3 +167,18 @@ def fixture_adm_with_thompson_dummy_min_attempted_count(
         thompson=thompson_sampler_with_dummy,
         **adm_parameters,
     )
+
+
+@pytest.fixture(name="adm_with_thompson_skip_client_variants_check")
+def fixture_adm_with_thompson_skip_client_variants_check(
+    backend_mock: Any,
+    adm_parameters: dict[str, Any],
+    thompson_sampler: ThompsonSampler,
+) -> Provider:
+    """Create an AdM Provider with Thompson sampling enabled for testing."""
+    return Provider(
+        backend=backend_mock,
+        thompson=thompson_sampler,
+        should_check_client_variants=False,
+        **adm_parameters,
+    )

tests/unit/providers/suggest/adm/test_provider_thompson.py

@@ -17,6 +17,9 @@
 from tests.unit.types import SuggestionRequestFixture
 
 
+CLIENT_VARIANTS: list[str] = ["engagement_guided_suggestions"]
+
+
 def test_thompson_attribute_is_none_by_default(adm: Provider) -> None:
     """Provider created without a thompson argument should have thompson=None."""
     assert adm.thompson is None
@@ -69,10 +72,10 @@ async def test_query_with_thompson_dummy_suppresses_suggestion(
     await adm_with_thompson_dummy.initialize()
     geolocation = Location(country="US")
     user_agent = UserAgent(form_factor="desktop", browser="firefox", os_family="macos")
-    client_variant = ["engagement_guided_suggestions"]
+    client_variants = CLIENT_VARIANTS
 
     res = await adm_with_thompson_dummy.query(
-        srequest("firefox", geolocation, user_agent, client_variant)
+        srequest("firefox", geolocation, user_agent, client_variants)
     )
 
     assert res == []
@@ -85,7 +88,7 @@ async def test_query_with_thompson_no_match_returns_empty(
 ) -> None:
     """Thompson-enabled provider should return empty list when the query matches nothing."""
     await adm_with_thompson.initialize()
-    client_variants = ["engagement_guided_suggestions"]
+    client_variants = CLIENT_VARIANTS
 
     res = await adm_with_thompson.query(srequest("zzznomatch", None, None, client_variants))
 
@@ -100,8 +103,8 @@ async def test_query_with_thompson_uses_fallback_country_and_form_factor(
 ) -> None:
     """Thompson-enabled provider should apply country/form-factor fallbacks when absent."""
     await adm_with_thompson.initialize()
-    client_variant = ["engagement_guided_suggestions"]
-    res = await adm_with_thompson.query(srequest("firefox", None, None, client_variant))
+    client_variants = CLIENT_VARIANTS
+    res = await adm_with_thompson.query(srequest("firefox", None, None, client_variants))
 
     assert len(res) == 1
     assert res[0].score == adm_parameters["score"]
@@ -119,7 +122,7 @@ async def test_query_with_thompson_min_attempted_count_returns_suggestion(
     await adm_with_thompson_dummy_min_attempted_count.initialize()
     geolocation = Location(country="US")
     user_agent = UserAgent(form_factor="desktop", browser="firefox", os_family="macos")
-    client_variants = ["engagement_guided_suggestions"]
+    client_variants = CLIENT_VARIANTS
 
     res = await adm_with_thompson_dummy_min_attempted_count.query(
         srequest("firefox", geolocation, user_agent, client_variants)
@@ -141,3 +144,39 @@ async def test_query_with_thompson_min_attempted_count_returns_suggestion(
             score=adm_parameters["score"],
         )
     ]
+
+
+@pytest.mark.asyncio
+async def test_query_with_thompson_without_client_variants_check(
+    srequest: SuggestionRequestFixture,
+    adm_with_thompson_skip_client_variants_check: Provider,
+    adm_parameters: dict[str, Any],
+) -> None:
+    """Thompson-enabled provider without the client_variants check should return
+    a suggestion when the sampler picks a winner even if client_variants does
+    not match.
+    """
+    await adm_with_thompson_skip_client_variants_check.initialize()
+    geolocation = Location(country="US")
+    user_agent = UserAgent(form_factor="desktop", browser="firefox", os_family="macos")
+    client_variants: list[str] = []
+    res = await adm_with_thompson_skip_client_variants_check.query(
+        srequest("firefox", geolocation, user_agent, client_variants)
+    )
+
+    assert res == [
+        NonsponsoredSuggestion(
+            block_id=2,
+            full_keyword="firefox accounts",
+            title="Mozilla Firefox Accounts",
+            url=HttpUrl("https://example.org/target/mozfirefoxaccounts"),
+            categories=[],
+            impression_url=HttpUrl("https://example.org/impression/mozilla"),
+            click_url=HttpUrl("https://example.org/click/mozilla"),
+            provider="adm",
+            advertiser="Example.org",
+            is_sponsored=False,
+            icon="attachment-host/main-workspace/quicksuggest/icon-01",
+            score=adm_parameters["score"],
+        )
+    ]