repeaterbook 0.3.0__tar.gz → 0.4.0__tar.gz

{repeaterbook-0.3.0 → repeaterbook-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repeaterbook
-Version: 0.3.0
+Version: 0.4.0
 Summary: Python utility to work with data from RepeaterBook.
 Project-URL: homepage, https://github.com/MicaelJarniac/repeaterbook
 Project-URL: source, https://github.com/MicaelJarniac/repeaterbook

{repeaterbook-0.3.0 → repeaterbook-0.4.0}/docs/CHANGELOG.md

@@ -1,6 +1,57 @@
 # CHANGELOG
 
 
+## v0.4.0 (2026-02-04)
+
+### Features
+
+- Comprehensive codebase improvements ([#8](https://github.com/MicaelJarniac/repeaterbook/pull/8),
+  [`c893c4b`](https://github.com/MicaelJarniac/repeaterbook/commit/c893c4b39125d4f843d11cb06f633122b809b769))
+
+* feat: comprehensive codebase improvements
+
+- Add custom exception classes (RepeaterBookError, RepeaterBookAPIError, RepeaterBookCacheError,
+  RepeaterBookValidationError) - Enable North America endpoint in urls_export() - Fix cache race
+  conditions with atomic write pattern - Add model validation for latitude, longitude, and frequency
+  fields - Replace MD5 with SHA256 for cache key generation - Make configuration injectable
+  (max_cache_age, max_count) - Remove commented-out operating_mode field - Improve type safety with
+  explanatory comments for casts - Optimize cache stat calls (single stat instead of exists + stat)
+
+Test suite expansion: - Add test_exceptions.py for exception hierarchy - Add test_services.py for
+  services module - Add test_models.py for model validation - Add test_queries.py for query builders
+  - Add test_database.py for database operations - Add test_utils.py for utility functions - Expand
+  test_repeaterbook.py for public API
+
+Total: 108 tests passing
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+
+* feat: add smart routing for NA/ROW endpoints
+
+Implement intelligent endpoint routing in urls_export(): - NA-specific fields (state_id, county,
+  emcomm, stype) route to NA only - ROW-specific fields (region) route to ROW only - NA countries
+  (US, Canada, Mexico) route to NA only - ROW countries route to ROW only - Mixed or common-only
+  queries route to both
+
+This prevents redundant API calls and avoids unfiltered queries that could return thousands of
+  irrelevant results.
+
+Added tests for all routing scenarios.
+
+* test: add comprehensive smart routing integration tests
+
+Add live API integration tests to verify smart routing behavior: - NA-only queries (state_id) route
+  to export.php only - ROW-only queries (region) route to exportROW.php only - NA country queries
+  route to NA endpoint - ROW country queries route to ROW endpoint - Mixed country queries route to
+  both endpoints - Empty queries route to both endpoints - Mode-only queries route to both endpoints
+
+Also fix linting warnings (use next(iter()) instead of list()[0]).
+
+---------
+
+Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
+
+
 ## v0.3.0 (2026-02-03)
 
 ### Chores

{repeaterbook-0.3.0 → repeaterbook-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "repeaterbook"
-version = "0.3.0"
+version = "0.4.0"
 description = "Python utility to work with data from RepeaterBook."
 authors = [
   {name = "Micael Jarniac", email = "micael@jarniac.dev"},
@@ -110,7 +110,7 @@ ignore = [
 unfixable = ["ERA001"]
 
 [tool.ruff.lint.per-file-ignores]
-"tests/*" = ["S101"]
+"tests/*" = ["S101", "PLR2004"]
 
 [tool.ruff.lint.flake8-builtins]
 builtins-ignorelist = ["id", "type"]

repeaterbook-0.4.0/src/repeaterbook/__init__.py

@@ -0,0 +1,21 @@
+"""Python utility to work with data from RepeaterBook."""
+
+from __future__ import annotations
+
+__all__: tuple[str, ...] = (
+    "Repeater",
+    "RepeaterBook",
+    "RepeaterBookAPIError",
+    "RepeaterBookCacheError",
+    "RepeaterBookError",
+    "RepeaterBookValidationError",
+)
+
+from repeaterbook.database import RepeaterBook
+from repeaterbook.exceptions import (
+    RepeaterBookAPIError,
+    RepeaterBookCacheError,
+    RepeaterBookError,
+    RepeaterBookValidationError,
+)
+from repeaterbook.models import Repeater

repeaterbook-0.4.0/src/repeaterbook/exceptions.py

@@ -0,0 +1,44 @@
+"""Custom exceptions for RepeaterBook library."""
+
+from __future__ import annotations
+
+__all__: tuple[str, ...] = (
+    "RepeaterBookAPIError",
+    "RepeaterBookCacheError",
+    "RepeaterBookError",
+    "RepeaterBookValidationError",
+)
+
+
+class RepeaterBookError(Exception):
+    """Base exception for RepeaterBook library.
+
+    All RepeaterBook-specific exceptions inherit from this class,
+    making it easy to catch all library errors with a single except clause.
+    """
+
+
+class RepeaterBookAPIError(RepeaterBookError):
+    """Error returned by the RepeaterBook API.
+
+    Raised when the API returns an error response (status: "error").
+    The error message from the API is preserved in the exception message.
+    """
+
+
+class RepeaterBookCacheError(RepeaterBookError):
+    """Error during cache operations.
+
+    Raised when reading from or writing to the cache fails,
+    such as file permission issues or disk full errors.
+    """
+
+
+class RepeaterBookValidationError(RepeaterBookError):
+    """Invalid data or response format.
+
+    Raised when:
+    - API response is not in expected format (not a dict)
+    - Required fields are missing from the response
+    - Data values fail validation (e.g., invalid coordinates)
+    """

{repeaterbook-0.3.0 → repeaterbook-0.4.0}/src/repeaterbook/models.py

@@ -34,6 +34,7 @@ from typing import Literal, TypeAlias, TypedDict
 
 import attrs
 from pycountry.db import Country  # noqa: TC002
+from pydantic import field_validator
 from sqlmodel import Field, SQLModel
 
 
@@ -103,7 +104,6 @@ class Repeater(SQLModel, table=True):
     races: str | None
     skywarn: str | None
     canwarn: str | None
-    #' operating_mode: str
     allstar_node: str | None
     echolink_node: str | None
     irlp_node: str | None
@@ -129,6 +129,33 @@ class Repeater(SQLModel, table=True):
     notes: str | None
     last_update: date
 
+    @field_validator("latitude")
+    @classmethod
+    def validate_latitude(cls, v: Decimal) -> Decimal:
+        """Validate latitude is within valid range."""
+        if not Decimal(-90) <= v <= Decimal(90):
+            msg = f"Latitude must be between -90 and 90, got {v}"
+            raise ValueError(msg)
+        return v
+
+    @field_validator("longitude")
+    @classmethod
+    def validate_longitude(cls, v: Decimal) -> Decimal:
+        """Validate longitude is within valid range."""
+        if not Decimal(-180) <= v <= Decimal(180):
+            msg = f"Longitude must be between -180 and 180, got {v}"
+            raise ValueError(msg)
+        return v
+
+    @field_validator("frequency", "input_frequency")
+    @classmethod
+    def validate_frequency(cls, v: Decimal) -> Decimal:
+        """Validate frequency is positive."""
+        if v <= 0:
+            msg = f"Frequency must be positive, got {v}"
+            raise ValueError(msg)
+        return v
+
 
 ZeroOneJSON: TypeAlias = Literal[
     0,

{repeaterbook-0.3.0 → repeaterbook-0.4.0}/src/repeaterbook/services.py

@@ -16,7 +16,7 @@ import hashlib
 import json
 import time
 from datetime import date, timedelta
-from typing import Any, ClassVar, Final, cast
+from typing import Any, Final, cast
 
 import aiohttp
 import attrs
@@ -25,6 +25,10 @@ from loguru import logger
 from tqdm import tqdm
 from yarl import URL
 
+from repeaterbook.exceptions import (
+    RepeaterBookAPIError,
+    RepeaterBookValidationError,
+)
 from repeaterbook.models import (
     Emergency,
     EmergencyJSON,
@@ -51,7 +55,7 @@ async def fetch_json(
     cache_dir: Path | None = None,
     max_cache_age: timedelta = timedelta(seconds=3600),
     chunk_size: int = 1024,
-) -> Any:  # noqa: ANN401
+) -> Any:  # noqa: ANN401 - json.loads() returns Any; validation done by callers
     """Fetches JSON data from the specified URL using a streaming response.
 
     - If a cached copy exists and is recent (not older than max_cache_age seconds) and
@@ -62,17 +66,19 @@ async def fetch_json(
     # Create a unique filename for caching based on the URL hash.
     if cache_dir is None:
         cache_dir = Path()
-    hashed_url = hashlib.md5(str(url).encode("utf-8")).hexdigest()  # noqa: S324
+    hashed_url = hashlib.sha256(str(url).encode("utf-8")).hexdigest()
     cache_file = cache_dir / f"api_cache_{hashed_url}.json"
+    temp_file = cache_dir / f"api_cache_{hashed_url}.tmp"
 
-    # Check if fresh cached data exists.
-    if await cache_file.exists():
-        file_age = time.time() - (await cache_file.stat()).st_mtime
+    # Check if fresh cached data exists using a single stat call.
+    try:
+        stat = await cache_file.stat()
+        file_age = time.time() - stat.st_mtime
         if file_age < max_cache_age.total_seconds():
             logger.info("Using cached data.")
             return json.loads(await cache_file.read_text(encoding="utf-8"))
-
-    await cache_file.unlink(missing_ok=True)
+    except FileNotFoundError:
+        pass  # Cache doesn't exist, continue to fetch
 
     logger.info("Fetching new data from API...")
     async with (
@@ -80,8 +86,8 @@ async def fetch_json(
         session.get(url, headers=headers) as response,
     ):
         response.raise_for_status()
-        # Open file for writing in binary mode and stream content into it.
-        async with await cache_file.open("wb") as f:
+        # Write to temp file first for atomic cache updates.
+        async with await temp_file.open("wb") as f:
             with tqdm(
                 total=response.content_length,
                 unit="B",
@@ -91,6 +97,11 @@ async def fetch_json(
                     await f.write(chunk)
                     progress.update(len(chunk))
 
+    # Atomic rename from temp file to cache file.
+    # This prevents race conditions where concurrent requests might read
+    # a partially written cache file.
+    await temp_file.rename(cache_file)
+
     # After saving the file, load and parse the JSON data.
     return json.loads(await cache_file.read_text(encoding="utf-8"))
 
@@ -209,6 +220,16 @@ class RepeaterBookAPI:
     """RepeaterBook API client.
 
     Must read https://www.repeaterbook.com/wiki/doku.php?id=api before using.
+
+    Attributes:
+        base_url: The RepeaterBook API base URL.
+        app_name: Application name for User-Agent header.
+        app_email: Contact email for User-Agent header.
+        working_dir: Directory for cache and database files.
+        max_cache_age: Maximum age of cached API responses before refresh.
+            Defaults to 1 hour.
+        max_count: Maximum expected results per API request. Used to warn
+            when response may have been trimmed. Defaults to 3500.
     """
 
     base_url: URL = attrs.Factory(lambda: URL("https://repeaterbook.com"))
@@ -217,7 +238,8 @@ class RepeaterBookAPI:
 
     working_dir: Path = attrs.Factory(Path)
 
-    MAX_COUNT: ClassVar[int] = 3500
+    max_cache_age: timedelta = timedelta(hours=1)
+    max_count: int = 3500
 
     async def cache_dir(self) -> Path:
         """Cache directory for API responses."""
@@ -246,11 +268,26 @@ class RepeaterBookAPI:
         """Rest of world (not north-america) export URL."""
         return self.url_api / "exportROW.php"
 
+    # North America countries served by export.php endpoint
+    NA_COUNTRIES: frozenset[str] = frozenset({
+        "United States",
+        "Canada",
+        "Mexico",
+    })
+
     def urls_export(
         self,
         query: ExportQuery,
     ) -> set[URL]:
-        """Generate export URLs for given query."""
+        """Generate export URLs for given query.
+
+        Smart routing logic:
+        - If NA-specific fields are used (state_id, county, emcomm, stype),
+          only query the NA endpoint
+        - If ROW-specific fields are used (region), only query the ROW endpoint
+        - If countries are specified, route based on whether they're NA or ROW
+        - If no routing hints, query both endpoints
+        """
         mode_map: dict[Mode, ModeJSON] = {
             Mode.ANALOG: "analog",
             Mode.DMR: "DMR",
@@ -268,6 +305,33 @@ class RepeaterBookAPI:
             ServiceType.GMRS: "GMRS",
         }
 
+        # Determine which endpoints to query based on the query parameters
+        has_na_specific = bool(
+            query.state_ids or query.counties or
+            query.emergency_services or query.service_types
+        )
+        has_row_specific = bool(query.regions)
+
+        # Check if countries are specified and categorize them
+        query_countries = {country.name for country in query.countries}
+        has_na_countries = bool(query_countries & self.NA_COUNTRIES)
+        has_row_countries = bool(query_countries - self.NA_COUNTRIES)
+
+        # Determine which endpoints to query
+        query_na_endpoint = True
+        query_row_endpoint = True
+
+        if has_na_specific and not has_row_specific:
+            # NA-specific fields used, only query NA
+            query_row_endpoint = False
+        elif has_row_specific and not has_na_specific:
+            # ROW-specific fields used, only query ROW
+            query_na_endpoint = False
+        elif query_countries:
+            # Countries specified - route based on country location
+            query_na_endpoint = has_na_countries
+            query_row_endpoint = has_row_countries
+
         query_na = ExportNorthAmericaQuery(
             callsign=list(query.callsigns),
             city=list(query.cities),
@@ -280,6 +344,8 @@ class RepeaterBookAPI:
             emcomm=[emergency_map[emergency] for emergency in query.emergency_services],
             stype=[type_map[service_type] for service_type in query.service_types],
         )
+        # Safe cast: dict comprehension preserves TypedDict structure, only removes
+        # empty values (which are optional in ExportNorthAmericaQuery).
         query_na = cast(
             "ExportNorthAmericaQuery", {k: v for k, v in query_na.items() if v}
         )
@@ -293,14 +359,22 @@ class RepeaterBookAPI:
             mode=[mode_map[mode] for mode in query.modes],
             region=list(query.regions),
         )
+        # Safe cast: dict comprehension preserves TypedDict structure, only removes
+        # empty values (which are optional in ExportWorldQuery).
         query_world = cast(
             "ExportWorldQuery", {k: v for k, v in query_world.items() if v}
         )
 
-        return {
-            #' self.url_export_north_america % cast("dict[str, str]", query_na),
-            self.url_export_rest_of_world % cast("dict[str, str]", query_world),
-        }
+        # Safe casts: URL % operator expects dict[str, str], and TypedDict values
+        # are all list[str] which serialize correctly for query parameters.
+        urls: set[URL] = set()
+        if query_na_endpoint:
+            na_params = cast("dict[str, str]", query_na)
+            urls.add(self.url_export_north_america % na_params)
+        if query_row_endpoint:
+            row_params = cast("dict[str, str]", query_world)
+            urls.add(self.url_export_rest_of_world % row_params)
+        return urls
 
     async def export_json(self, url: URL) -> ExportJSON:
         """Export data for given URL."""
@@ -308,20 +382,23 @@ class RepeaterBookAPI:
             url,
             headers={"User-Agent": f"{self.app_name} <{self.app_email}>"},
             cache_dir=await self.cache_dir(),
+            max_cache_age=self.max_cache_age,
         )
 
         if not isinstance(data, dict):
-            raise TypeError
+            msg = f"Expected dict response from API, got {type(data).__name__}"
+            raise RepeaterBookValidationError(msg)
 
         if data.get("status") == "error":
-            raise ValueError(data.get("message"))
+            raise RepeaterBookAPIError(data.get("message", "Unknown API error"))
 
         if "count" not in data or "results" not in data:
-            raise ValueError
+            msg = "API response missing required 'count' or 'results' field"
+            raise RepeaterBookValidationError(msg)
 
         data = cast("ExportJSON", data)
 
-        if data["count"] >= self.MAX_COUNT:
+        if data["count"] >= self.max_count:
             logger.warning(
                 "Reached max count for API response. Response may have been trimmed."
             )

repeaterbook-0.4.0/tests/integration/test_live_api.py

@@ -0,0 +1,250 @@
+"""Live API integration tests.
+
+These hit repeaterbook.com over the network, so they are disabled by default.
+
+Enable with:
+
+  REPEATERBOOK_LIVE=1 uv run pytest -q -m integration
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+import pycountry
+import pytest
+
+if TYPE_CHECKING:
+    from pathlib import Path as StdPath
+
+from anyio import Path
+from yarl import URL
+
+from repeaterbook.models import ExportQuery, Mode
+from repeaterbook.services import RepeaterBookAPI, json_to_model
+
+# Limit parsed rows in NA test to keep runtime reasonable.
+_NA_SAMPLE_SIZE = 200
+
+
+def _live_enabled() -> bool:
+    return os.environ.get("REPEATERBOOK_LIVE", "").lower() in {"1", "true", "yes"}
+
+
+pytestmark = pytest.mark.skipif(
+    not _live_enabled(), reason="Set REPEATERBOOK_LIVE=1 to run live integration tests"
+)
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_live_export_row_brazil_downloads_and_parses(
+    tmp_path: StdPath,
+) -> None:
+    """Brazil repeaters download and parse correctly from ROW endpoint."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    # Brazil is served by ROW endpoint.
+    q = ExportQuery(countries=frozenset({pycountry.countries.lookup("Brazil")}))
+    reps = await api.download(q)
+
+    assert len(reps) > 0
+    assert all(r.country for r in reps)
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_live_export_north_america_payload_parses_first_rows(
+    tmp_path: StdPath,
+) -> None:
+    """NA payload shape differs; ensure json_to_model handles it.
+
+    We don't route NA through urls_export() yet, so we call export.php directly.
+    """
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    url = URL("https://repeaterbook.com/api/export.php") % {
+        "state_id": "06",  # California
+        "country": "United States",
+    }
+
+    payload = await api.export_json(url)
+    assert payload["count"] == len(payload["results"])
+    assert payload["count"] > 0
+
+    # Parse a small sample so the test stays fast.
+    for row in payload["results"][:_NA_SAMPLE_SIZE]:
+        rep = json_to_model(row)
+        assert rep.country in {"United States", "USA", "United States of America"}
+
+
+# Smart routing tests
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_na_only_via_state_id(tmp_path: StdPath) -> None:
+    """Query with state_id routes only to NA endpoint."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    # state_id is NA-specific, so only NA endpoint should be queried
+    q = ExportQuery(state_ids=frozenset({"06"}))  # California
+    urls = api.urls_export(q)
+
+    assert len(urls) == 1
+    url_str = str(next(iter(urls)))
+    assert "export.php" in url_str
+    assert "exportROW" not in url_str
+    assert "state_id=06" in url_str
+
+    # Verify it actually works
+    reps = await api.download(q)
+    assert len(reps) > 0
+    # All results should be from California
+    assert all(r.state_id == "06" for r in reps)
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_row_only_via_region(tmp_path: StdPath) -> None:
+    """Query with region routes only to ROW endpoint."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    # region is ROW-specific, so only ROW endpoint should be queried
+    q = ExportQuery(regions=frozenset({"South America"}))
+    urls = api.urls_export(q)
+
+    assert len(urls) == 1
+    url_str = str(next(iter(urls)))
+    assert "exportROW.php" in url_str
+    assert "export.php?" not in url_str  # not confused with exportROW.php
+    assert "South+America" in url_str
+
+    # Verify it actually works
+    reps = await api.download(q)
+    assert len(reps) > 0
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_na_country_only(tmp_path: StdPath) -> None:
+    """Query with NA country routes only to NA endpoint."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    us = pycountry.countries.lookup("United States")
+    q = ExportQuery(
+        countries=frozenset({us}),
+        state_ids=frozenset({"48"}),  # Texas - smaller result set
+    )
+    urls = api.urls_export(q)
+
+    assert len(urls) == 1
+    url_str = str(next(iter(urls)))
+    assert "export.php" in url_str
+    assert "exportROW" not in url_str
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_row_country_only(tmp_path: StdPath) -> None:
+    """Query with ROW country routes only to ROW endpoint."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    germany = pycountry.countries.lookup("Germany")
+    q = ExportQuery(countries=frozenset({germany}))
+    urls = api.urls_export(q)
+
+    assert len(urls) == 1
+    url_str = str(next(iter(urls)))
+    assert "exportROW.php" in url_str
+
+    # Verify it actually works
+    reps = await api.download(q)
+    assert len(reps) > 0
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_mixed_countries_both_endpoints(tmp_path: StdPath) -> None:
+    """Query with both NA and ROW countries routes to both endpoints."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    us = pycountry.countries.lookup("United States")
+    germany = pycountry.countries.lookup("Germany")
+    q = ExportQuery(countries=frozenset({us, germany}))
+    urls = api.urls_export(q)
+
+    # Should route to both endpoints
+    assert len(urls) == 2
+    url_strs = [str(url) for url in urls]
+    assert any("export.php" in u and "exportROW" not in u for u in url_strs)
+    assert any("exportROW.php" in u for u in url_strs)
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_empty_query_both_endpoints(tmp_path: StdPath) -> None:
+    """Empty query routes to both endpoints."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    q = ExportQuery()  # Empty query
+    urls = api.urls_export(q)
+
+    # Should query both endpoints
+    assert len(urls) == 2
+    url_strs = [str(url) for url in urls]
+    assert any("export.php" in u and "exportROW" not in u for u in url_strs)
+    assert any("exportROW.php" in u for u in url_strs)
+
+
+@pytest.mark.integration
+@pytest.mark.anyio
+async def test_smart_routing_mode_filter_both_endpoints(tmp_path: StdPath) -> None:
+    """Query with only mode (common filter) routes to both endpoints."""
+    api = RepeaterBookAPI(
+        app_name="repeaterbook-live-test",
+        app_email="micael@jarniac.dev",
+        working_dir=Path(tmp_path),
+    )
+
+    # Mode is a common filter, not NA or ROW-specific
+    q = ExportQuery(modes=frozenset({Mode.DMR}))
+    urls = api.urls_export(q)
+
+    # Should query both endpoints since mode is common
+    assert len(urls) == 2
+    url_strs = [str(url) for url in urls]
+    assert all("DMR" in u for u in url_strs)