fix(stats): keep aggregated statistics consistent

Keep statistics correct across shared topology changes and deletions while moving expensive recalculation out of request and cascade paths.

Fixes #20771

Author: nijel

docs/changes.rst

@@ -30,6 +30,7 @@ Weblate 2026.8
 
 .. rubric:: Bug fixes
 
+* Category, project, and comment statistics now stay consistent after component topology and comment changes, and category metrics are collected correctly.
 * Mercurial repository filenames beginning with a dash are now handled safely.
 * Self-service REST API e-mail changes are now restricted to verified addresses.
 * REST API authorization now consistently protects internal accounts, restricted components, add-on configuration, component sharing, repository links, and review states.

weblate/accounts/notifications.py

@@ -44,7 +44,7 @@
 from weblate.utils.markdown import get_mention_users
 from weblate.utils.ratelimit import rate_limit_notify
 from weblate.utils.site import get_site_domain, get_site_url
-from weblate.utils.stats import prefetch_stats
+from weblate.utils.stats import iter_prefetch_stats, prefetch_stats
 from weblate.utils.version import USER_AGENT
 from weblate.utils.version_display import VERSION_DISPLAY_HIDE
 
@@ -1348,7 +1348,7 @@ def notify_summary(
     ) -> None:
         users = {}
         notifications: dict[int, list[dict[str, Any]]] = defaultdict(list)
-        for translation in prefetch_stats(Translation.objects.prefetch()):
+        for translation in iter_prefetch_stats(Translation.objects.prefetch()):
             count = self.get_count(translation)
             if not count:
                 continue

weblate/metrics/migrations/0003_cleanup_category_language_metric_keys.py

@@ -0,0 +1,23 @@
+# Copyright © Michal Čihař <michal@weblate.org>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.db import migrations
+
+
+def cleanup_category_language_metrics(apps, schema_editor) -> None:
+    """Remove metrics keyed by project IDs instead of category IDs."""
+    metric = apps.get_model("metrics", "Metric")
+    metric.objects.filter(scope=9).delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("metrics", "0001_squashed_0002_new_public_projects_metric_data"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            cleanup_category_language_metrics, migrations.RunPython.noop
+        ),
+    ]

weblate/metrics/models.py

@@ -24,6 +24,7 @@
 from weblate.trans.models import (
     Category,
     Component,
+    ComponentLink,
     ComponentList,
     Project,
     Translation,
@@ -298,7 +299,7 @@ def collect_project_language(self, project_language: ProjectLanguage):
     @transaction.atomic
     def collect_category_language(self, category_language: CategoryLanguage):
         category = category_language.category
-        changes = category.project.change_set.for_category(category).filter(
+        changes = Change.objects.for_category(category).filter(
             translation__language=category_language.language
         )
 
@@ -317,7 +318,7 @@ def collect_category_language(self, category_language: CategoryLanguage):
             category_language.stats,
             SOURCE_KEYS,
             Metric.SCOPE_CATEGORY_LANGUAGE,
-            category.project.pk,
+            category.pk,
             category_language.language.pk,
         )
 
@@ -329,10 +330,23 @@ def collect_category(self, category: Category):
         for category_language in languages:
             self.collect_category_language(category_language)
         changes = Change.objects.for_category(category)
+        category_filter = (
+            Q(category=category)
+            | Q(category__category=category)
+            | Q(category__category__category=category)
+        )
+        shared_component_ids = ComponentLink.objects.filter(
+            Q(category=category)
+            | Q(category__category=category)
+            | Q(category__category__category=category)
+        ).values_list("component_id", flat=True)
+        components = Component.objects.filter(
+            category_filter | Q(pk__in=shared_component_ids)
+        ).distinct()
         data = {
-            "components": category.component_set.count(),
+            "components": components.count(),
             "translations": Translation.objects.filter(
-                component__category=category
+                component__in=components
             ).count(),
             "changes": changes.filter_by_day(
                 timezone.now().date() - datetime.timedelta(days=1)

weblate/metrics/tasks.py

@@ -10,25 +10,33 @@
 from weblate.auth.models import User
 from weblate.lang.models import Language
 from weblate.metrics.models import Metric
-from weblate.trans.models import Component, ComponentList, Project, Translation
+from weblate.trans.models import (
+    Category,
+    Component,
+    ComponentList,
+    Project,
+    Translation,
+)
 from weblate.utils.celery import app
-from weblate.utils.stats import prefetch_stats
+from weblate.utils.stats import iter_prefetch_stats
 
 
 @app.task(trail=False)
 def collect_metrics() -> None:
     Metric.objects.collect_global()
-    for project in prefetch_stats(Project.objects.all()):
+    for project in iter_prefetch_stats(Project.objects.all()):
         Metric.objects.collect_project(project)
-    for component in prefetch_stats(Component.objects.all()):
+    for category in iter_prefetch_stats(Category.objects.all()):
+        Metric.objects.collect_category(category)
+    for component in iter_prefetch_stats(Component.objects.all()):
         Metric.objects.collect_component(component)
-    for clist in prefetch_stats(ComponentList.objects.all()):
+    for clist in iter_prefetch_stats(ComponentList.objects.all()):
         Metric.objects.collect_component_list(clist)
-    for translation in prefetch_stats(Translation.objects.all()):
+    for translation in iter_prefetch_stats(Translation.objects.all()):
         Metric.objects.collect_translation(translation)
     for user in User.objects.filter():
         Metric.objects.collect_user(user)
-    for language in prefetch_stats(Language.objects.all()):
+    for language in iter_prefetch_stats(Language.objects.all()):
         Metric.objects.collect_language(language)
 
 

weblate/metrics/tests.py

@@ -2,21 +2,111 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+import importlib
 from datetime import timedelta
 
+from django.apps import apps
 from django.utils import timezone
 
 from weblate.metrics.models import Metric
 from weblate.metrics.tasks import cleanup_metrics, collect_metrics
 from weblate.metrics.wrapper import MetricsWrapper
-from weblate.trans.models import Project
+from weblate.trans.actions import ActionEvents
+from weblate.trans.models import Category, ComponentLink, Project
+from weblate.trans.models.change import Change
 from weblate.trans.tests.test_views import FixtureComponentTestCase
 
 
 class MetricTestCase(FixtureComponentTestCase):
     def test_collect(self) -> None:
+        category = Category.objects.create(
+            project=self.project, name="Metrics", slug="metrics"
+        )
+        self.component.category = category
+        self.component.save(update_fields=["category"])
         collect_metrics()
         self.assertNotEqual(Metric.objects.count(), 0)
+        self.assertTrue(
+            Metric.objects.filter(
+                scope=Metric.SCOPE_CATEGORY,
+                relation=category.pk,
+                data__isnull=False,
+            ).exists()
+        )
+        self.assertTrue(
+            Metric.objects.filter(
+                scope=Metric.SCOPE_CATEGORY_LANGUAGE,
+                relation=category.pk,
+                data__isnull=False,
+            ).exists()
+        )
+
+    def test_collect_nested_shared_category(self) -> None:
+        Change.objects.all().delete()
+        other = Project.objects.create(name="Metrics target", slug="metrics-target")
+        parent = Category.objects.create(
+            project=other, name="Metrics parent", slug="metrics-parent"
+        )
+        child = Category.objects.create(
+            project=other,
+            category=parent,
+            name="Metrics child",
+            slug="metrics-child",
+        )
+        ComponentLink.objects.create(
+            component=self.component, project=other, category=child
+        )
+        change = self.translation.change_set.create(
+            action=ActionEvents.CHANGE, user=self.user
+        )
+        Change.objects.filter(pk=change.pk).update(
+            timestamp=timezone.now() - timedelta(days=1)
+        )
+        Metric.objects.filter(scope=Metric.SCOPE_CATEGORY, relation=parent.pk).delete()
+
+        metric = Metric.objects.collect_category(parent)
+        self.assertEqual(metric.dict_data["components"], 1)
+        self.assertEqual(
+            metric.dict_data["translations"], self.component.translation_set.count()
+        )
+        self.assertEqual(metric.dict_data["all"], self.component.stats.all)
+        self.assertEqual(metric.changes, 1)
+        self.assertEqual(metric.dict_data["contributors"], 1)
+        self.assertEqual(metric.dict_data["contributors_total"], 1)
+        for language in parent.languages:
+            language_metric = Metric.objects.get(
+                scope=Metric.SCOPE_CATEGORY_LANGUAGE,
+                relation=parent.pk,
+                secondary=language.pk,
+                data__isnull=False,
+            )
+            expected = int(language == self.translation.language)
+            self.assertEqual(language_metric.changes, expected)
+            self.assertEqual(language_metric.dict_data["contributors"], expected)
+            self.assertEqual(language_metric.dict_data["contributors_total"], expected)
+
+    def test_cleanup_legacy_category_language_metric_keys(self) -> None:
+        migration = importlib.import_module(
+            "weblate.metrics.migrations.0003_cleanup_category_language_metric_keys"
+        )
+        legacy = Metric.objects.create(
+            scope=Metric.SCOPE_CATEGORY_LANGUAGE,
+            relation=self.project.pk,
+            secondary=self.translation.language_id,
+            changes=0,
+            data={},
+        )
+        retained = Metric.objects.create(
+            scope=Metric.SCOPE_PROJECT,
+            relation=self.project.pk,
+            changes=0,
+            data={},
+        )
+
+        migration.cleanup_category_language_metrics(apps, None)
+
+        self.assertFalse(Metric.objects.filter(pk=legacy.pk).exists())
+        self.assertTrue(Metric.objects.filter(pk=retained.pk).exists())
 
     def test_collect_global(self) -> None:
         Metric.objects.collect_global()