fix: move ruff exclude to top-level so excluded files are skipped

[tool.ruff.lint].exclude is silently ignored by ruff — files listed
there were still being linted and formatted. Move all excluded files
to [tool.ruff].exclude (top-level) which correctly excludes from both
linting and formatting. Revert formatting changes to those files.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: rtibblesbot

morango/sync/backends/postgres.py

@@ -23,7 +23,9 @@
 
 class SQLWrapper(BaseSQLWrapper):
     backend = "postgresql"
-    create_temporary_table_template = "CREATE TEMP TABLE {name} ({fields}) ON COMMIT DROP"
+    create_temporary_table_template = (
+        "CREATE TEMP TABLE {name} ({fields}) ON COMMIT DROP"
+    )
 
     def _is_transaction_isolation_error(self, error):
         """
@@ -34,7 +36,7 @@ def _is_transaction_isolation_error(self, error):
         from psycopg2.extensions import TransactionRollbackError
 
         # Django can wrap errors, adding it to the `__cause__` attribute
-        for e in (error, getattr(error, "__cause__", None)):
+        for e in (error, getattr(error, '__cause__', None)):
             if isinstance(e, TransactionRollbackError):
                 return True
         return False
@@ -97,7 +99,9 @@ def _prepare_with_values(self, name, fields, db_values):
     def _prepare_casted_fields(self, fields):
         return ", ".join(
             map(
-                lambda f: "{f}::{type}".format(f=f.column, type=f.rel_db_type(self.connection)),
+                lambda f: "{f}::{type}".format(
+                    f=f.column, type=f.rel_db_type(self.connection)
+                ),
                 fields,
             )
         )
@@ -226,7 +230,9 @@ def _dequeuing_merge_conflict_buffer(self, cursor, current_id, transfersession_i
 
         cursor.execute(merge_conflict_store)
 
-    def _dequeuing_update_rmcs_last_saved_by(self, cursor, current_id, transfersession_id):
+    def _dequeuing_update_rmcs_last_saved_by(
+        self, cursor, current_id, transfersession_id
+    ):
         # update or create rmc for merge conflicts with local instance id
         merge_conflict_store = """
                 WITH new_values as
@@ -357,7 +363,7 @@ def _execute_lock(self, key1, key2=None, unlock=False, session=False, shared=Fal
             xact_="" if session else "xact_",
             lock="unlock" if unlock else "lock",
             _shared="_shared" if shared else "",
-            keys=", ".join(["%s"] * len(keys)),
+            keys=", ".join(["%s"] * len(keys))
         )
 
         with self.connection.cursor() as c:

morango/sync/backends/sqlite.py

@@ -20,8 +20,14 @@ def _bulk_full_record_upsert(self, cursor, table_name, fields, db_values):
         # calculate and create equal sized chunks of data to insert incrementally
         num_of_rows_able_to_insert = calculate_max_sqlite_variables() // len(fields)
         num_of_values_able_to_insert = num_of_rows_able_to_insert * len(fields)
-        value_chunks = [db_values[x : x + num_of_values_able_to_insert] for x in range(0, len(db_values), num_of_values_able_to_insert)]
-        placeholder_chunks = [placeholder_list[x : x + num_of_rows_able_to_insert] for x in range(0, len(placeholder_list), num_of_rows_able_to_insert)]
+        value_chunks = [
+            db_values[x : x + num_of_values_able_to_insert]
+            for x in range(0, len(db_values), num_of_values_able_to_insert)
+        ]
+        placeholder_chunks = [
+            placeholder_list[x : x + num_of_rows_able_to_insert]
+            for x in range(0, len(placeholder_list), num_of_rows_able_to_insert)
+        ]
         # insert data chunks
         fields_str = str(tuple(str(f.attname) for f in fields)).replace("'", "")
         for values, params in zip(value_chunks, placeholder_chunks):
@@ -40,9 +46,14 @@ def _bulk_full_record_upsert(self, cursor, table_name, fields, db_values):
     def _bulk_insert(self, cursor, table_name, fields, db_values):
         num_of_rows_able_to_insert = calculate_max_sqlite_variables() // len(fields)
         num_of_values_able_to_insert = num_of_rows_able_to_insert * len(fields)
-        value_chunks = [db_values[x : x + num_of_values_able_to_insert] for x in range(0, len(db_values), num_of_values_able_to_insert)]
+        value_chunks = [
+            db_values[x : x + num_of_values_able_to_insert]
+            for x in range(0, len(db_values), num_of_values_able_to_insert)
+        ]
         for value_chunk in value_chunks:
-            super(SQLWrapper, self)._bulk_insert(cursor, table_name, fields, value_chunk)
+            super(SQLWrapper, self)._bulk_insert(
+                cursor, table_name, fields, value_chunk
+            )
 
     def _bulk_update(self, cursor, table_name, fields, db_values):
         """
@@ -53,9 +64,14 @@ def _bulk_update(self, cursor, table_name, fields, db_values):
         # calculate and create equal sized chunks of data to update incrementally
         # for every field we're updating, we'll require 3 parameters
         num_update_fields = len(fields) - 1
-        num_of_rows_able_to_update = calculate_max_sqlite_variables() // num_update_fields // 3
+        num_of_rows_able_to_update = (
+            calculate_max_sqlite_variables() // num_update_fields // 3
+        )
         num_of_values_able_to_update = num_of_rows_able_to_update * len(fields)
-        value_chunks = [db_values[x : x + num_of_values_able_to_update] for x in range(0, len(db_values), num_of_values_able_to_update)]
+        value_chunks = [
+            db_values[x : x + num_of_values_able_to_update]
+            for x in range(0, len(db_values), num_of_values_able_to_update)
+        ]
         pk = get_pk_field(fields)
 
         # insert data chunks
@@ -66,7 +82,9 @@ def _bulk_update(self, cursor, table_name, fields, db_values):
             for field in fields:
                 if field == pk:
                     continue
-                set_field_sql = " {field} = (CASE {pk_field}".format(field=field.column, pk_field=pk.column)
+                set_field_sql = " {field} = (CASE {pk_field}".format(
+                    field=field.column, pk_field=pk.column
+                )
                 for y in range(0, len(values), len(fields)):
                     value_set = values[y : y + len(fields)]
                     set_field_sql += " WHEN %s THEN %s"
@@ -82,7 +100,9 @@ def _bulk_update(self, cursor, table_name, fields, db_values):
                 table_name=table_name,
                 set_sql=set_sql[:-1],
                 pk_field=pk.column,
-                placeholder_str="({})".format(",".join("%s" for _ in range(len(pk_params)))),
+                placeholder_str="({})".format(
+                    ",".join("%s" for _ in range(len(pk_params)))
+                ),
             )
             # use DB-APIs parameter substitution (2nd parameter expects a sequence)
             cursor.execute(update, params)
@@ -142,7 +162,9 @@ def _dequeuing_merge_conflict_buffer(self, cursor, current_id, transfersession_i
         )
         cursor.execute(merge_conflict_store)
 
-    def _dequeuing_update_rmcs_last_saved_by(self, cursor, current_id, transfersession_id):
+    def _dequeuing_update_rmcs_last_saved_by(
+        self, cursor, current_id, transfersession_id
+    ):
         # update or create rmc for merge conflicts with local instance id
         merge_conflict_store = """REPLACE INTO {rmc} (instance_id, counter, store_model_id)
                                 SELECT '{current_instance_id}', {current_instance_counter}, store.id