[fix] ruff linter - rewrite map comprehensions for improved readability

Author: c-rosenberg

src/xspct_db/routes.py

@@ -963,9 +963,7 @@ async def post(self) -> r200[QueryResponse] | r401[ErrorResponse] | r500[ErrorRe
         # Apply rewrite rules then prefilter on the canonical (rewritten) addresses.
         # rewrite_map: original -> canonical; originals are the response keys.
         rewrite_rules = self.request.app.get("rewrite_rules", [])
-        rewrite_map: dict[str, str] = {
-            u: rewrite.apply_rewrite_rules(u, rewrite_rules) for u in query_req.users
-        }
+        rewrite_map: dict[str, str] = {u: rewrite.apply_rewrite_rules(u, rewrite_rules) for u in query_req.users}
         # Deduplicated canonical addresses passed through prefilter.
         canonical_users = list(dict.fromkeys(rewrite_map.values()))
         filtered_canonical = prefilter.filter_addresses(s, canonical_users, self.request.app)
@@ -1043,9 +1041,7 @@ async def _qj_task() -> tuple[bytes, str, str | bool]:
                 if missing:
                     # Map each missing original address to the wildcard key
                     # derived from its canonical rewritten address.
-                    addr_to_wks = {
-                        u: _compute_wildcard_keys(rewrite_map[u], wildcard_queries) for u in missing
-                    }
+                    addr_to_wks = {u: _compute_wildcard_keys(rewrite_map[u], wildcard_queries) for u in missing}
                     addr_to_wks = {u: wks for u, wks in addr_to_wks.items() if wks}
                     unique_domain_keys = list(dict.fromkeys(dk for wks in addr_to_wks.values() for dk in wks))
                     dom_users = [
@@ -1208,9 +1204,7 @@ async def post(self) -> r200[RspamdSettingsResponse] | r401[ErrorResponse]:
         # the canonical address.  Original addresses are kept as response keys.
         raw_addresses = list(dict.fromkeys(addr for addr in ([rspamd_req.from_addr] + rspamd_req.rcpts) if addr))
         rs_rewrite_rules = self.request.app.get("rewrite_rules", [])
-        rs_rewrite_map: dict[str, str] = {
-            addr: rewrite.apply_rewrite_rules(addr, rs_rewrite_rules) for addr in raw_addresses
-        }
+        rs_rewrite_map: dict[str, str] = {addr: rewrite.apply_rewrite_rules(addr, rs_rewrite_rules) for addr in raw_addresses}
         canonical_addresses = list(dict.fromkeys(rs_rewrite_map.values()))
         canonical_addresses = prefilter.filter_addresses(s, canonical_addresses, self.request.app)
         filtered_canonical_set = set(canonical_addresses)
@@ -1255,10 +1249,7 @@ async def _rs_task() -> tuple[bytes, str]:
                 if wildcard_queries:
                     missing = [addr for addr in addresses if addr not in user_to_pkey]
                     if missing:
-                        addr_to_wks = {
-                            addr: _compute_wildcard_keys(rs_rewrite_map[addr], wildcard_queries)
-                            for addr in missing
-                        }
+                        addr_to_wks = {addr: _compute_wildcard_keys(rs_rewrite_map[addr], wildcard_queries) for addr in missing}
                         addr_to_wks = {addr: wks for addr, wks in addr_to_wks.items() if wks}
                         unique_domain_keys = list(dict.fromkeys(dk for wks in addr_to_wks.values() for dk in wks))
                         dom_users = [

tests/conftest.py

@@ -320,9 +320,7 @@ async def rewrite_yaml_app_client(rewrite_yaml_cfg: dict[str, Any], aiohttp_clie
 
 
 @pytest.fixture
-async def rewrite_wildcard_yaml_app_client(
-    rewrite_wildcard_yaml_cfg: dict[str, Any], aiohttp_client: Any
-) -> TestClient:
+async def rewrite_wildcard_yaml_app_client(rewrite_wildcard_yaml_cfg: dict[str, Any], aiohttp_client: Any) -> TestClient:
     """Return an aiohttp test client with both rewrite rules and wildcard lookup enabled."""
     stats.reset()
     app = create_app(rewrite_wildcard_yaml_cfg)

tests/test_rewrite.py

@@ -83,21 +83,25 @@ def test_apply_non_matching_rule_returns_original():
 
 
 def test_apply_first_match_wins():
-    rules = compile_rules([
-        {"pattern": r"^(.+)@relay\.example\.com$", "replacement": r"\1@first.example.com"},
-        {"pattern": r"^(.+)@relay\.example\.com$", "replacement": r"\1@second.example.com"},
-    ])
+    rules = compile_rules(
+        [
+            {"pattern": r"^(.+)@relay\.example\.com$", "replacement": r"\1@first.example.com"},
+            {"pattern": r"^(.+)@relay\.example\.com$", "replacement": r"\1@second.example.com"},
+        ]
+    )
     result = apply_rewrite_rules("alice@relay.example.com", rules)
     assert result == "alice@first.example.com"
 
 
 def test_apply_non_changing_rule_does_not_count_as_match():
     """A rule that produces the identical string is not treated as a match."""
-    rules = compile_rules([
-        # This pattern matches but replacement produces the same string.
-        {"pattern": r"^(.+)@example\.com$", "replacement": r"\1@example.com"},
-        {"pattern": r"^(.+)@example\.com$", "replacement": r"\1@canonical.example.com"},
-    ])
+    rules = compile_rules(
+        [
+            # This pattern matches but replacement produces the same string.
+            {"pattern": r"^(.+)@example\.com$", "replacement": r"\1@example.com"},
+            {"pattern": r"^(.+)@example\.com$", "replacement": r"\1@canonical.example.com"},
+        ]
+    )
     result = apply_rewrite_rules("alice@example.com", rules)
     assert result == "alice@canonical.example.com"