Fix lints

MadLittleMods · MadLittleMods · commit 4a5c2f89c7da · 2025-05-20T14:21:57.000-05:00
diff --git a/synapse/_scripts/synctl.py b/synapse/_scripts/synctl.py
@@ -292,9 +292,9 @@ def main() -> None:
             for key in worker_config:
                 if key == "worker_app":  # But we allow worker_app
                     continue
-                assert not key.startswith("worker_"), (
-                    "Main process cannot use worker_* config"
-                )
+                assert not key.startswith(
+                    "worker_"
+                ), "Main process cannot use worker_* config"
         else:
             worker_pidfile = worker_config["worker_pid_file"]
             worker_cache_factor = worker_config.get("synctl_cache_factor")
diff --git a/synapse/handlers/federation.py b/synapse/handlers/federation.py
@@ -1312,9 +1312,9 @@ async def get_state_ids_for_pdu(self, room_id: str, event_id: str) -> List[str]:
         if state_key is not None:
             # the event was not rejected (get_event raises a NotFoundError for rejected
             # events) so the state at the event should include the event itself.
-            assert state_map.get((event.type, state_key)) == event.event_id, (
-                "State at event did not include event itself"
-            )
+            assert (
+                state_map.get((event.type, state_key)) == event.event_id
+            ), "State at event did not include event itself"
 
             # ... but we need the state *before* that event
             if "replaces_state" in event.unsigned:
diff --git a/synapse/handlers/message.py b/synapse/handlers/message.py
@@ -143,9 +143,9 @@ async def get_room_data(
         elif membership == Membership.LEAVE:
             key = (event_type, state_key)
             # If the membership is not JOIN, then the event ID should exist.
-            assert membership_event_id is not None, (
-                "check_user_in_room_or_world_readable returned invalid data"
-            )
+            assert (
+                membership_event_id is not None
+            ), "check_user_in_room_or_world_readable returned invalid data"
             room_state = await self._state_storage_controller.get_state_for_events(
                 [membership_event_id], StateFilter.from_types([key])
             )
@@ -242,9 +242,9 @@ async def get_state_events(
                 room_state = await self.store.get_events(state_ids.values())
             elif membership == Membership.LEAVE:
                 # If the membership is not JOIN, then the event ID should exist.
-                assert membership_event_id is not None, (
-                    "check_user_in_room_or_world_readable returned invalid data"
-                )
+                assert (
+                    membership_event_id is not None
+                ), "check_user_in_room_or_world_readable returned invalid data"
                 room_state_events = (
                     await self._state_storage_controller.get_state_for_events(
                         [membership_event_id], state_filter=state_filter
@@ -1267,14 +1267,12 @@ async def create_new_client_event(
                 # Allow an event to have empty list of prev_event_ids
                 # only if it has auth_event_ids.
                 or auth_event_ids
-            ), (
-                "Attempting to create a non-m.room.create event with no prev_events or auth_event_ids"
-            )
+            ), "Attempting to create a non-m.room.create event with no prev_events or auth_event_ids"
         else:
             # we now ought to have some prev_events (unless it's a create event).
-            assert builder.type == EventTypes.Create or prev_event_ids, (
-                "Attempting to create a non-m.room.create event with no prev_events"
-            )
+            assert (
+                builder.type == EventTypes.Create or prev_event_ids
+            ), "Attempting to create a non-m.room.create event with no prev_events"
 
         if for_batch:
             assert prev_event_ids is not None
diff --git a/synapse/handlers/sso.py b/synapse/handlers/sso.py
@@ -1192,9 +1192,9 @@ async def revoke_sessions_for_provider_session_id(
         """
 
         # It is expected that this is the main process.
-        assert isinstance(self._device_handler, DeviceHandler), (
-            "revoking SSO sessions can only be called on the main process"
-        )
+        assert isinstance(
+            self._device_handler, DeviceHandler
+        ), "revoking SSO sessions can only be called on the main process"
 
         # Invalidate any running user-mapping sessions
         to_delete = []
diff --git a/synapse/http/matrixfederationclient.py b/synapse/http/matrixfederationclient.py
@@ -426,9 +426,9 @@ def __init__(
             )
         else:
             proxy_authorization_secret = hs.config.worker.worker_replication_secret
-            assert proxy_authorization_secret is not None, (
-                "`worker_replication_secret` must be set when using `outbound_federation_restricted_to` (used to authenticate requests across workers)"
-            )
+            assert (
+                proxy_authorization_secret is not None
+            ), "`worker_replication_secret` must be set when using `outbound_federation_restricted_to` (used to authenticate requests across workers)"
             federation_proxy_credentials = BearerProxyCredentials(
                 proxy_authorization_secret.encode("ascii")
             )
diff --git a/synapse/http/proxyagent.py b/synapse/http/proxyagent.py
@@ -173,9 +173,9 @@ def __init__(
         self._federation_proxy_endpoint: Optional[IStreamClientEndpoint] = None
         self._federation_proxy_credentials: Optional[ProxyCredentials] = None
         if federation_proxy_locations:
-            assert federation_proxy_credentials is not None, (
-                "`federation_proxy_credentials` are required when using `federation_proxy_locations`"
-            )
+            assert (
+                federation_proxy_credentials is not None
+            ), "`federation_proxy_credentials` are required when using `federation_proxy_locations`"
 
             endpoints: List[IStreamClientEndpoint] = []
             for federation_proxy_location in federation_proxy_locations:
@@ -302,9 +302,9 @@ def request(
             parsed_uri.scheme == b"matrix-federation"
             and self._federation_proxy_endpoint
         ):
-            assert self._federation_proxy_credentials is not None, (
-                "`federation_proxy_credentials` are required when using `federation_proxy_locations`"
-            )
+            assert (
+                self._federation_proxy_credentials is not None
+            ), "`federation_proxy_credentials` are required when using `federation_proxy_locations`"
 
             # Set a Proxy-Authorization header
             if headers is None:
diff --git a/synapse/http/servlet.py b/synapse/http/servlet.py
@@ -582,9 +582,9 @@ def parse_enum(
             is not one of those allowed values.
     """
     # Assert the enum values are strings.
-    assert all(isinstance(e.value, str) for e in E), (
-        "parse_enum only works with string values"
-    )
+    assert all(
+        isinstance(e.value, str) for e in E
+    ), "parse_enum only works with string values"
     str_value = parse_string(
         request,
         name,
diff --git a/synapse/module_api/__init__.py b/synapse/module_api/__init__.py
@@ -894,9 +894,9 @@ def invalidate_access_token(
         Raises:
             synapse.api.errors.AuthError: the access token is invalid
         """
-        assert isinstance(self._device_handler, DeviceHandler), (
-            "invalidate_access_token can only be called on the main process"
-        )
+        assert isinstance(
+            self._device_handler, DeviceHandler
+        ), "invalidate_access_token can only be called on the main process"
 
         # see if the access token corresponds to a device
         user_info = yield defer.ensureDeferred(
diff --git a/synapse/replication/http/_base.py b/synapse/replication/http/_base.py
@@ -131,9 +131,9 @@ def __init__(self, hs: "HomeServer"):
 
         # We reserve `instance_name` as a parameter to sending requests, so we
         # assert here that sub classes don't try and use the name.
-        assert "instance_name" not in self.PATH_ARGS, (
-            "`instance_name` is a reserved parameter name"
-        )
+        assert (
+            "instance_name" not in self.PATH_ARGS
+        ), "`instance_name` is a reserved parameter name"
         assert (
             "instance_name"
             not in signature(self.__class__._serialize_payload).parameters
diff --git a/synapse/replication/tcp/streams/events.py b/synapse/replication/tcp/streams/events.py
@@ -200,9 +200,9 @@ async def _update_function(
 
         # we rely on get_all_new_forward_event_rows strictly honouring the limit, so
         # that we know it is safe to just take upper_limit = event_rows[-1][0].
-        assert len(event_rows) <= target_row_count, (
-            "get_all_new_forward_event_rows did not honour row limit"
-        )
+        assert (
+            len(event_rows) <= target_row_count
+        ), "get_all_new_forward_event_rows did not honour row limit"
 
         # if we hit the limit on event_updates, there's no point in going beyond the
         # last stream_id in the batch for the other sources.
diff --git a/synapse/rest/client/rendezvous.py b/synapse/rest/client/rendezvous.py
@@ -44,9 +44,9 @@ def __init__(self, hs: "HomeServer"):
         redirection_target: Optional[str] = (
             hs.config.experimental.msc4108_delegation_endpoint
         )
-        assert redirection_target is not None, (
-            "Servlet is only registered if there is a delegation target"
-        )
+        assert (
+            redirection_target is not None
+        ), "Servlet is only registered if there is a delegation target"
         self.endpoint = redirection_target.encode("utf-8")
 
     async def on_POST(self, request: SynapseRequest) -> None:
diff --git a/synapse/rest/client/transactions.py b/synapse/rest/client/transactions.py
@@ -94,9 +94,9 @@ def _get_transaction_key(self, request: IRequest, requester: Requester) -> Hasha
         # (appservice and guest users), but does not cover access tokens minted
         # by the admin API. Use the access token ID instead.
         else:
-            assert requester.access_token_id is not None, (
-                "Requester must have an access_token_id"
-            )
+            assert (
+                requester.access_token_id is not None
+            ), "Requester must have an access_token_id"
             return (path, "user_admin", requester.access_token_id)
 
     def fetch_or_execute_request(
diff --git a/synapse/storage/background_updates.py b/synapse/storage/background_updates.py
@@ -739,9 +739,9 @@ def runner(conn: Connection) -> None:
             c.execute(sql)
 
         async def updater(progress: JsonDict, batch_size: int) -> int:
-            assert isinstance(self.db_pool.engine, engines.PostgresEngine), (
-                "validate constraint background update registered for non-Postres database"
-            )
+            assert isinstance(
+                self.db_pool.engine, engines.PostgresEngine
+            ), "validate constraint background update registered for non-Postres database"
 
             logger.info("Validating constraint %s to %s", constraint_name, table)
             await self.db_pool.runWithConnection(runner)
@@ -900,9 +900,9 @@ def register_background_validate_constraint_and_delete_rows(
               on the table. Used to iterate over the table.
         """
 
-        assert isinstance(self.db_pool.engine, engines.PostgresEngine), (
-            "validate constraint background update registered for non-Postres database"
-        )
+        assert isinstance(
+            self.db_pool.engine, engines.PostgresEngine
+        ), "validate constraint background update registered for non-Postres database"
 
         async def updater(progress: JsonDict, batch_size: int) -> int:
             return await self.validate_constraint_and_delete_in_background(
diff --git a/synapse/storage/databases/main/client_ips.py b/synapse/storage/databases/main/client_ips.py
@@ -653,9 +653,9 @@ async def insert_client_ip(
 
     @wrap_as_background_process("update_client_ips")
     async def _update_client_ips_batch(self) -> None:
-        assert self._update_on_this_worker, (
-            "This worker is not designated to update client IPs"
-        )
+        assert (
+            self._update_on_this_worker
+        ), "This worker is not designated to update client IPs"
 
         # If the DB pool has already terminated, don't try updating
         if not self.db_pool.is_running():
@@ -674,9 +674,9 @@ def _update_client_ips_batch_txn(
         txn: LoggingTransaction,
         to_update: Mapping[Tuple[str, str, str], Tuple[str, Optional[str], int]],
     ) -> None:
-        assert self._update_on_this_worker, (
-            "This worker is not designated to update client IPs"
-        )
+        assert (
+            self._update_on_this_worker
+        ), "This worker is not designated to update client IPs"
 
         # Keys and values for the `user_ips` upsert.
         user_ips_keys = []
diff --git a/synapse/storage/databases/main/deviceinbox.py b/synapse/storage/databases/main/deviceinbox.py
@@ -203,9 +203,9 @@ async def get_messages_for_user_devices(
             to_stream_id=to_stream_id,
         )
 
-        assert last_processed_stream_id == to_stream_id, (
-            "Expected _get_device_messages to process all to-device messages up to `to_stream_id`"
-        )
+        assert (
+            last_processed_stream_id == to_stream_id
+        ), "Expected _get_device_messages to process all to-device messages up to `to_stream_id`"
 
         return user_id_device_id_to_messages
 
diff --git a/synapse/storage/databases/main/events.py b/synapse/storage/databases/main/events.py
@@ -240,9 +240,9 @@ def __init__(
         self.is_mine_id = hs.is_mine_id
 
         # This should only exist on instances that are configured to write
-        assert hs.get_instance_name() in hs.config.worker.writers.events, (
-            "Can only instantiate EventsStore on master"
-        )
+        assert (
+            hs.get_instance_name() in hs.config.worker.writers.events
+        ), "Can only instantiate EventsStore on master"
 
         # Since we have been configured to write, we ought to have id generators,
         # rather than id trackers.
@@ -471,9 +471,9 @@ async def _calculate_sliding_sync_table_changes(
                     missing_membership_event_ids
                 )
                 # There shouldn't be any missing events
-                assert remaining_events.keys() == missing_membership_event_ids, (
-                    missing_membership_event_ids.difference(remaining_events.keys())
-                )
+                assert (
+                    remaining_events.keys() == missing_membership_event_ids
+                ), missing_membership_event_ids.difference(remaining_events.keys())
                 membership_event_map.update(remaining_events)
 
             for (
@@ -540,9 +540,9 @@ async def _calculate_sliding_sync_table_changes(
                         missing_state_event_ids
                     )
                     # There shouldn't be any missing events
-                    assert remaining_events.keys() == missing_state_event_ids, (
-                        missing_state_event_ids.difference(remaining_events.keys())
-                    )
+                    assert (
+                        remaining_events.keys() == missing_state_event_ids
+                    ), missing_state_event_ids.difference(remaining_events.keys())
                     for event in remaining_events.values():
                         current_state_map[(event.type, event.state_key)] = event
 
@@ -650,9 +650,9 @@ async def _calculate_sliding_sync_table_changes(
             if missing_event_ids:
                 remaining_events = await self.store.get_events(missing_event_ids)
                 # There shouldn't be any missing events
-                assert remaining_events.keys() == missing_event_ids, (
-                    missing_event_ids.difference(remaining_events.keys())
-                )
+                assert (
+                    remaining_events.keys() == missing_event_ids
+                ), missing_event_ids.difference(remaining_events.keys())
                 for event in remaining_events.values():
                     current_state_map[(event.type, event.state_key)] = event
 
diff --git a/synapse/storage/databases/main/events_worker.py b/synapse/storage/databases/main/events_worker.py
@@ -827,9 +827,9 @@ async def get_unredacted_events_from_cache_or_db(
 
         if missing_events_ids:
 
-            async def get_missing_events_from_cache_or_db() -> Dict[
-                str, EventCacheEntry
-            ]:
+            async def get_missing_events_from_cache_or_db() -> (
+                Dict[str, EventCacheEntry]
+            ):
                 """Fetches the events in `missing_event_ids` from the database.
 
                 Also creates entries in `self._current_event_fetches` to allow
diff --git a/synapse/storage/databases/main/monthly_active_users.py b/synapse/storage/databases/main/monthly_active_users.py
@@ -304,9 +304,9 @@ def _initialise_reserved_users(
             txn:
             threepids: List of threepid dicts to reserve
         """
-        assert self._update_on_this_worker, (
-            "This worker is not designated to update MAUs"
-        )
+        assert (
+            self._update_on_this_worker
+        ), "This worker is not designated to update MAUs"
 
         # XXX what is this function trying to achieve?  It upserts into
         # monthly_active_users for each *registered* reserved mau user, but why?
@@ -340,9 +340,9 @@ async def upsert_monthly_active_user(self, user_id: str) -> None:
         Args:
             user_id: user to add/update
         """
-        assert self._update_on_this_worker, (
-            "This worker is not designated to update MAUs"
-        )
+        assert (
+            self._update_on_this_worker
+        ), "This worker is not designated to update MAUs"
 
         # Support user never to be included in MAU stats. Note I can't easily call this
         # from upsert_monthly_active_user_txn because then I need a _txn form of
@@ -379,9 +379,9 @@ def upsert_monthly_active_user_txn(
             txn:
             user_id: user to add/update
         """
-        assert self._update_on_this_worker, (
-            "This worker is not designated to update MAUs"
-        )
+        assert (
+            self._update_on_this_worker
+        ), "This worker is not designated to update MAUs"
 
         # Am consciously deciding to lock the table on the basis that is ought
         # never be a big table and alternative approaches (batching multiple
@@ -409,9 +409,9 @@ async def populate_monthly_active_users(self, user_id: str) -> None:
         Args:
             user_id: the user_id to query
         """
-        assert self._update_on_this_worker, (
-            "This worker is not designated to update MAUs"
-        )
+        assert (
+            self._update_on_this_worker
+        ), "This worker is not designated to update MAUs"
 
         if self._limit_usage_by_mau or self._mau_stats_only:
             # Trial users and guests should not be included as part of MAU group
diff --git a/synapse/storage/databases/main/state_deltas.py b/synapse/storage/databases/main/state_deltas.py
@@ -98,9 +98,9 @@ async def get_partial_current_state_deltas(
         prev_stream_id = int(prev_stream_id)
 
         # check we're not going backwards
-        assert prev_stream_id <= max_stream_id, (
-            f"New stream id {max_stream_id} is smaller than prev stream id {prev_stream_id}"
-        )
+        assert (
+            prev_stream_id <= max_stream_id
+        ), f"New stream id {max_stream_id} is smaller than prev stream id {prev_stream_id}"
 
         if not self._curr_state_delta_stream_cache.has_any_entity_changed(
             prev_stream_id
diff --git a/synapse/storage/databases/main/user_directory.py b/synapse/storage/databases/main/user_directory.py
diff --git a/tests/federation/test_federation_out_of_band_membership.py b/tests/federation/test_federation_out_of_band_membership.py
diff --git a/tests/rest/client/utils.py b/tests/rest/client/utils.py
diff --git a/tests/server.py b/tests/server.py
diff --git a/tests/storage/test_devices.py b/tests/storage/test_devices.py

Original file line number	Diff line number	Diff line change
`@@ -426,9 +426,9 @@ def __init__(`
`426`	`426`	`)`
`427`	`427`	`else:`
`428`	`428`	`proxy_authorization_secret = hs.config.worker.worker_replication_secret`
`429`		`- assert proxy_authorization_secret is not None, (`
`430`		- "`worker_replication_secret` must be set when using `outbound_federation_restricted_to` (used to authenticate requests across workers)"
`431`		`- )`
	`429`	`+ assert (`
	`430`	`+ proxy_authorization_secret is not None`
	`431`	+ ), "`worker_replication_secret` must be set when using `outbound_federation_restricted_to` (used to authenticate requests across workers)"
`432`	`432`	`federation_proxy_credentials = BearerProxyCredentials(`
`433`	`433`	`proxy_authorization_secret.encode("ascii")`
`434`	`434`	`)`