Reduce code duplication

Author: flodolo

pontoon/base/models/entity.py

@@ -7,7 +7,7 @@
 
 from django.contrib.postgres.fields import ArrayField
 from django.db import models
-from django.db.models import Count, F, Prefetch, Q
+from django.db.models import F, Prefetch, Q
 from django.utils import timezone
 
 from pontoon.base import utils
@@ -283,56 +283,6 @@ class Meta:
     def __str__(self):
         return self.string
 
-    def get_stats(self, locale) -> dict[str, int]:
-        """
-        Get stats for a single (entity, locale) pair.
-
-        :arg Locale locale: filter translations for this locale.
-        :return: a dictionary with stats for the Entity+Locale
-        """
-        stats = self.translation_set.filter(locale=locale).aggregate(
-            approved_count=Count(
-                "pk",
-                filter=Q(approved=True, errors__isnull=True, warnings__isnull=True),
-            ),
-            pretranslated_count=Count(
-                "pk",
-                filter=Q(
-                    pretranslated=True, errors__isnull=True, warnings__isnull=True
-                ),
-            ),
-            errors_count=Count(
-                "pk",
-                distinct=True,
-                filter=Q(
-                    Q(Q(approved=True) | Q(pretranslated=True) | Q(fuzzy=True))
-                    & Q(errors__isnull=False)
-                ),
-            ),
-            warnings_count=Count(
-                "pk",
-                distinct=True,
-                filter=Q(
-                    Q(Q(approved=True) | Q(pretranslated=True) | Q(fuzzy=True))
-                    & Q(warnings__isnull=False)
-                ),
-            ),
-            unreviewed_count=Count(
-                "pk",
-                distinct=True,
-                filter=Q(
-                    approved=False, rejected=False, pretranslated=False, fuzzy=False
-                ),
-            ),
-        )
-        return {
-            "approved": stats["approved_count"],
-            "pretranslated": stats["pretranslated_count"],
-            "errors": stats["errors_count"],
-            "warnings": stats["warnings_count"],
-            "unreviewed": stats["unreviewed_count"],
-        }
-
     def has_changed(self, locale):
         """
         Check if translations in the given locale have changed since the

pontoon/base/models/stats.py

@@ -0,0 +1,47 @@
+from django.db.models import Count, Q
+
+
+def aggregate_translation_stats(queryset) -> dict[str, int]:
+    """
+    Aggregate translation stats for a given Translation queryset.
+
+    :return: a dictionary with approved, pretranslated, errors, warnings,
+             and unreviewed counts.
+    """
+    stats = queryset.aggregate(
+        approved_count=Count(
+            "pk",
+            filter=Q(approved=True, errors__isnull=True, warnings__isnull=True),
+        ),
+        pretranslated_count=Count(
+            "pk",
+            filter=Q(pretranslated=True, errors__isnull=True, warnings__isnull=True),
+        ),
+        errors_count=Count(
+            "pk",
+            distinct=True,
+            filter=Q(
+                Q(Q(approved=True) | Q(pretranslated=True) | Q(fuzzy=True))
+                & Q(errors__isnull=False)
+            ),
+        ),
+        warnings_count=Count(
+            "pk",
+            distinct=True,
+            filter=Q(
+                Q(Q(approved=True) | Q(pretranslated=True) | Q(fuzzy=True))
+                & Q(warnings__isnull=False)
+            ),
+        ),
+        unreviewed_count=Count(
+            "pk",
+            filter=Q(approved=False, rejected=False, pretranslated=False, fuzzy=False),
+        ),
+    )
+    return {
+        "approved": stats["approved_count"],
+        "pretranslated": stats["pretranslated_count"],
+        "errors": stats["errors_count"],
+        "warnings": stats["warnings_count"],
+        "unreviewed": stats["unreviewed_count"],
+    }

pontoon/base/models/translated_resource.py

@@ -1,11 +1,12 @@
 import logging
 
 from django.db import models
-from django.db.models import Count, F, Q, Sum
+from django.db.models import F, Sum
 
 from .locale import Locale
 from .project import Project
 from .resource import Resource
+from .stats import aggregate_translation_stats
 from .translation import Translation
 from .user import User
 
@@ -158,46 +159,13 @@ def calculate_stats(self, save=True):
             locale=self.locale,
         )
 
-        stats = translations.aggregate(
-            approved_count=Count(
-                "pk",
-                filter=Q(approved=True, errors__isnull=True, warnings__isnull=True),
-            ),
-            pretranslated_count=Count(
-                "pk",
-                filter=Q(
-                    pretranslated=True, errors__isnull=True, warnings__isnull=True
-                ),
-            ),
-            errors_count=Count(
-                "pk",
-                distinct=True,
-                filter=Q(
-                    Q(Q(approved=True) | Q(pretranslated=True) | Q(fuzzy=True))
-                    & Q(errors__isnull=False)
-                ),
-            ),
-            warnings_count=Count(
-                "pk",
-                distinct=True,
-                filter=Q(
-                    Q(Q(approved=True) | Q(pretranslated=True) | Q(fuzzy=True))
-                    & Q(warnings__isnull=False)
-                ),
-            ),
-            unreviewed_count=Count(
-                "pk",
-                filter=Q(
-                    approved=False, rejected=False, pretranslated=False, fuzzy=False
-                ),
-            ),
-        )
+        stats = aggregate_translation_stats(translations)
 
-        self.approved_strings = stats["approved_count"]
-        self.pretranslated_strings = stats["pretranslated_count"]
-        self.strings_with_errors = stats["errors_count"]
-        self.strings_with_warnings = stats["warnings_count"]
-        self.unreviewed_strings = stats["unreviewed_count"]
+        self.approved_strings = stats["approved"]
+        self.pretranslated_strings = stats["pretranslated"]
+        self.strings_with_errors = stats["errors"]
+        self.strings_with_warnings = stats["warnings"]
+        self.unreviewed_strings = stats["unreviewed"]
 
         if save:
             self.save(

pontoon/base/models/translation.py

@@ -13,6 +13,7 @@
 from pontoon.base.models.locale import Locale
 from pontoon.base.models.project import Project
 from pontoon.base.models.project_locale import ProjectLocale
+from pontoon.base.models.stats import aggregate_translation_stats
 from pontoon.base.models.user import User
 from pontoon.base.simple_preview import get_simple_preview
 from pontoon.checks import DB_FORMATS
@@ -249,7 +250,9 @@ def save(self, failed_checks=None, *args, **kwargs):
         from pontoon.base.models.translated_resource import TranslatedResource
         from pontoon.base.models.translation_memory import TranslationMemoryEntry
 
-        stats_before = self.entity.get_stats(self.locale)
+        stats_before = aggregate_translation_stats(
+            self.entity.translation_set.filter(locale=self.locale)
+        )
 
         super().save(*args, **kwargs)
 
@@ -324,7 +327,9 @@ def save(self, failed_checks=None, *args, **kwargs):
         # Update stats AFTER changing approval status.
         # Use entity-scoped aggregate delta for performance. Fall back to a
         # full resource recount on IntegrityError.
-        stats_after = self.entity.get_stats(self.locale)
+        stats_after = aggregate_translation_stats(
+            self.entity.translation_set.filter(locale=self.locale)
+        )
         try:
             with transaction.atomic():
                 translatedresource.adjust_stats(stats_before, stats_after, created)