feat(unit): apply delta of stats upon edit

This avoids possibly expensive full stats update on large components and
only applies delta that can be inferred from the current edit. The scope
of delta handling is intentionally narrow to handle only the simple
cases and avoid code complexity. If delta approach cannot be used, it
falls back to standard stats calculation.

Author: nijel

weblate/trans/models/translation.py

@@ -7,7 +7,7 @@
 import codecs
 import os
 import tempfile
-from contextlib import suppress
+from contextlib import contextmanager, suppress
 from datetime import UTC
 from itertools import chain
 from pathlib import Path
@@ -230,6 +230,8 @@ def __init__(self, *args, **kwargs) -> None:
         self.addon_commit_files: list[str] = []
         self.reason = ""
         self._invalidate_scheduled = False
+        self._suppress_cache_invalidation = False
+        self._stats_delta_requires_full_rebuild = False
         self.update_changes: list[Change] = []
         self.pending_unit_changes: list[PendingUnitChange] = []
         # Project backup integration
@@ -1671,12 +1673,31 @@ def _invalidate_trigger(self) -> None:
 
     def invalidate_cache(self) -> None:
         """Invalidate any cached stats."""
+        if self._suppress_cache_invalidation:
+            return
         # Invalidate summary stats
         if self._invalidate_scheduled:
             return
         self._invalidate_scheduled = True
         transaction.on_commit(self._invalidate_trigger)
 
+    @contextmanager
+    def suppress_cache_invalidation(self):
+        self._suppress_cache_invalidation = True
+        try:
+            yield
+        finally:
+            self._suppress_cache_invalidation = False
+
+    def require_full_stats_rebuild(self) -> None:
+        self._stats_delta_requires_full_rebuild = True
+
+    def consume_full_stats_rebuild_requirement(self) -> bool:
+        if not self._stats_delta_requires_full_rebuild:
+            return False
+        self._stats_delta_requires_full_rebuild = False
+        return True
+
     def detect_completed_translation(self, change: Change, old_translated: int) -> None:
         translated = self.stats.translated
         if old_translated < translated and translated == self.stats.all:

weblate/trans/models/unit.py

@@ -6,6 +6,7 @@
 
 import operator
 import re
+import time
 from functools import partial, reduce
 from typing import TYPE_CHECKING, Any, Literal, TypedDict
 
@@ -158,6 +159,7 @@ def prefetch_full(self):
             .prefetch_source()
             .prefetch_related(
                 "labels",
+                "source_unit__labels",
                 models.Prefetch(
                     "suggestion_set",
                     queryset=Suggestion.objects.order(),
@@ -1501,7 +1503,10 @@ def save_backend(
 
         # Generate change and process it
         change = self.post_save(
-            user or author, author, change_action, save=not self.is_batch_update
+            user or author,
+            author,
+            change_action,
+            save=not self.is_batch_update,
         )
         if self.is_batch_update:
             self.translation.update_changes.append(change)
@@ -1532,7 +1537,6 @@ def post_save(
             ActionEvents.BULK_EDIT,
         }:
             old_translated = self.translation.stats.translated
-
             # Update translation stats
             self.translation.invalidate_cache()
 
@@ -1561,46 +1565,19 @@ def update_source_units(
         """
         with sentry_sdk.start_span(op="unit.update_source_units", name=f"{self.pk}"):
             changes = []
+            translation_parent_stats = {}
+            delta_failed = False
+            translation_delta_data = {}
 
             # Find relevant units
             for unit in self.unit_set.exclude(id=self.id).prefetch().prefetch_bulk():
-                # Update source and number of words
-                unit.source = self.target
-                unit.num_words = self.num_words
-                # Find reverted units
-                if (
-                    unit.state in FUZZY_STATES
-                    and unit.previous_source == self.target
-                    and unit.target
-                ):
-                    # Unset fuzzy on reverted
-                    unit.original_state = unit.state = STATE_TRANSLATED
-                    PendingUnitChange.store_unit_change(
-                        unit=unit,
-                        author=author,
-                    )
-                    unit.previous_source = ""
-                elif (
-                    unit.original_state in FUZZY_STATES
-                    and unit.previous_source == self.target
-                    and unit.target
+                if not self.update_source_unit_stats(
+                    unit,
+                    previous_source,
+                    author,
+                    translation_delta_data,
                 ):
-                    # Unset fuzzy on reverted
-                    unit.original_state = STATE_TRANSLATED
-                    unit.previous_source = ""
-                elif unit.state >= STATE_TRANSLATED and unit.target:
-                    # Set fuzzy on changed
-                    unit.original_state = STATE_NEEDS_REWRITING
-                    if unit.state < STATE_READONLY:
-                        unit.state = STATE_NEEDS_REWRITING
-                        PendingUnitChange.store_unit_change(
-                            unit=unit,
-                            author=author,
-                        )
-                    unit.previous_source = previous_source
-
-                # Save unit
-                unit.save()
+                    delta_failed = True
                 # Generate change
                 changes.append(
                     unit.generate_change(
@@ -1613,11 +1590,101 @@ def update_source_units(
                         save=False,
                     )
                 )
+                for stat in unit.translation.stats.get_update_objects(full=False):
+                    translation_parent_stats[stat.cache_key] = stat
             if changes:
                 # Bulk create changes
                 Change.objects.bulk_create(changes)
-                # Invalidate stats
-                self.translation.component.invalidate_cache()
+                if delta_failed:
+                    self.translation.component.invalidate_cache()
+                    return
+
+                def update_source_stats_on_commit() -> None:
+                    for data in translation_delta_data.values():
+                        stats = data["stats"]
+                        stats.apply_source_delta(data["base_data"], data["delta"])
+                        stats.fetch_last_change()
+                        stats.count_changes()
+                        stats.store("stats_timestamp", time.time())
+                        stats.save(update_parents=False)
+                    for stat in translation_parent_stats.values():
+                        stat.update_stats()
+                    self.translation.component.stats.update_stats()
+                    self.translation.component.stats.update_parents()
+
+                transaction.on_commit(update_source_stats_on_commit)
+
+    def update_source_unit_state(
+        self, unit, previous_source: str, author: User | None
+    ) -> None:
+        # Update source and number of words
+        unit.source = self.target
+        unit.num_words = self.num_words
+        # Find reverted units
+        if (
+            unit.state in FUZZY_STATES
+            and unit.previous_source == self.target
+            and unit.target
+        ):
+            # Unset fuzzy on reverted
+            unit.original_state = unit.state = STATE_TRANSLATED
+            PendingUnitChange.store_unit_change(unit=unit, author=author)
+            unit.previous_source = ""
+            return
+        if (
+            unit.original_state in FUZZY_STATES
+            and unit.previous_source == self.target
+            and unit.target
+        ):
+            # Unset fuzzy on reverted
+            unit.original_state = STATE_TRANSLATED
+            unit.previous_source = ""
+            return
+        if unit.state >= STATE_TRANSLATED and unit.target:
+            # Set fuzzy on changed
+            unit.original_state = STATE_NEEDS_REWRITING
+            if unit.state < STATE_READONLY:
+                unit.state = STATE_NEEDS_REWRITING
+                PendingUnitChange.store_unit_change(unit=unit, author=author)
+            unit.previous_source = previous_source
+
+    def update_source_unit_stats(
+        self,
+        unit,
+        previous_source: str,
+        author: User | None,
+        translation_delta_data: dict,
+    ) -> bool:
+        stats = unit.translation.stats
+        old_stats_snapshot = (
+            stats.capture_unit_snapshot(unit) if stats.can_apply_delta() else None
+        )
+
+        self.update_source_unit_state(unit, previous_source, author)
+        with unit.translation.suppress_cache_invalidation():
+            unit.save()
+
+        if unit.translation.consume_full_stats_rebuild_requirement():
+            return False
+        if old_stats_snapshot is None:
+            return False
+
+        new_stats_snapshot = stats.capture_unit_snapshot(unit)
+        entry = translation_delta_data.setdefault(
+            unit.translation_id,
+            {
+                "stats": stats,
+                "base_data": stats.get_data_copy(),
+                "delta": {},
+            },
+        )
+        old_bucket = stats.snapshot_to_bucket(old_stats_snapshot)
+        new_bucket = stats.snapshot_to_bucket(new_stats_snapshot)
+        for key in stats.UNIT_DELTA_KEYS:
+            delta = new_bucket.get(key, 0) - old_bucket.get(key, 0)
+            if delta:
+                entry["delta"][key] = entry["delta"].get(key, 0) + delta
+        return True
 
     def generate_change(
         self,
@@ -1728,6 +1795,11 @@ def unresolved_comments(self) -> list[Comment]:
             if not comment.resolved and comment.unit_id == self.id
         ]
 
+    def get_label_count(self) -> int:
+        if "labels" in self._prefetched_objects_cache:
+            return len(self._prefetched_objects_cache["labels"])
+        return self.labels.count()
+
     def run_checks(  # noqa: C901
         self, *, force_propagate: bool = False, skip_propagate: bool = False
     ) -> None:
@@ -1785,6 +1857,7 @@ def run_checks(  # noqa: C901
                         # Skip disabled/removed checks
                         continue
                     if check_obj.propagates:
+                        self.translation.require_full_stats_rebuild()
                         if check_obj.propagates == "source":
                             propagated_units = self.propagated_units
                             values = set(
@@ -1813,6 +1886,7 @@ def run_checks(  # noqa: C901
 
         # Propagate checks which need it (for example consistency)
         if propagation:
+            self.translation.require_full_stats_rebuild()
             querymap: dict[Literal["source", "target"], UnitQuerySet] = {
                 "source": self.propagated_units,
                 "target": Unit.objects.same_target(self),
@@ -1970,10 +2044,7 @@ def translate(
         if new_state != STATE_READONLY:
             self.original_state = self.state
 
-        if change_action == ActionEvents.AUTO:
-            self.automatically_translated = True
-        else:
-            self.automatically_translated = False
+        self.automatically_translated = change_action == ActionEvents.AUTO
 
         # Save to the database
         saved = self.save_backend(

weblate/trans/tests/test_edit.py

@@ -8,6 +8,7 @@
 
 import time
 from typing import TYPE_CHECKING, cast
+from unittest.mock import patch
 
 from django.urls import reverse
 
@@ -523,6 +524,73 @@ def test_edit(self) -> None:
         self.assertEqual(unit.state, STATE_TRANSLATED)
         self.assert_backend(4, "en")
 
+    def test_edit_does_not_rebuild_component_language_stats(self) -> None:
+        self.assertGreater(self.get_translation().stats.all, 0)
+        with patch(
+            "weblate.trans.models.component.Component.invalidate_cache",
+            autospec=True,
+        ) as invalidate_cache:
+            self.edit_unit("Hello, world!\n", "Nazdar svete!\n", "en")
+        invalidate_cache.assert_not_called()
+
+    def test_source_edit_updates_translation_and_component_stats(self) -> None:
+        translation = self.get_translation()
+        self.edit_unit("Hello, world!\n", "Nazdar svete!\n", "cs")
+        translation = Translation.objects.get(pk=translation.pk)
+        component = Component.objects.get(pk=self.component.pk)
+        unit_before = translation.unit_set.get(context="hello")
+        all_chars_before = translation.stats.all_chars
+        all_words_before = translation.stats.all_words
+        translated_before = translation.stats.translated
+        component_all_chars_before = component.stats.all_chars
+
+        self.edit_unit("Hello, world!\n", "Hello, universe!\n", "en")
+
+        translation = Translation.objects.get(pk=translation.pk)
+        component = Component.objects.get(pk=self.component.pk)
+        unit_after = translation.unit_set.get(context="hello")
+        all_chars_delta = len(unit_after.source) - len(unit_before.source)
+        all_words_delta = unit_after.num_words - unit_before.num_words
+
+        self.assertEqual(
+            translation.stats.all_chars,
+            all_chars_before + all_chars_delta,
+        )
+        self.assertEqual(
+            translation.stats.all_words,
+            all_words_before + all_words_delta,
+        )
+        self.assertEqual(translation.stats.translated, translated_before - 1)
+        self.assertNotEqual(component.stats.all_chars, component_all_chars_before)
+        self.assertEqual(
+            component.stats.all_chars,
+            sum(
+                child.stats.all_chars
+                for child in Component.objects.get(
+                    pk=self.component.pk
+                ).translation_set.all()
+            ),
+        )
+
+    def test_source_edit_falls_back_to_full_recompute_on_nonlocal_checks(self) -> None:
+        def fake_run_checks(unit, *args, **kwargs) -> None:
+            unit.translation.require_full_stats_rebuild()
+
+        with (
+            patch(
+                "weblate.trans.models.unit.Unit.run_checks",
+                autospec=True,
+                side_effect=fake_run_checks,
+            ),
+            patch(
+                "weblate.trans.models.component.Component.invalidate_cache",
+                autospec=True,
+            ) as invalidate_cache,
+        ):
+            self.edit_unit("Hello, world!\n", "Nazdar svete!\n", "en")
+
+        invalidate_cache.assert_called()
+
     def test_edit_revert(self) -> None:
         translation = self.get_translation()
         # Edit translation