perf(exports): cache results of attachment xpaths in protected property of Asset model DEV-706 (#5925)

### 📣 Summary
Speed up and improve the performance of both sync and async exports

### 📖 Description
This PR introduces a performance optimization for exports by caching the
results of attachment xpaths computation in a protected property on the
Asset model instance.

Previously, the same logic was computed repeatedly, under certain
circumstances, during export processes (both sync and async) , leading
to redundant work and slower execution.

Author: noliveleger

kobo/apps/subsequences/utils/deprecation.py

@@ -23,7 +23,7 @@ def get_sanitized_advanced_features(asset: 'Asset') -> dict | None:
     qual_survey_iter = deepcopy(qual_survey_orig)
     for idx, qual_q in enumerate(qual_survey_iter):
         qpath = qual_survey_orig[idx]['qpath']
-        xpath = qpath_to_xpath(qpath, asset)
+        xpath = asset.get_xpath_from_qpath(qpath)
         del qual_survey_orig[idx]['qpath']
         qual_survey_orig[idx]['xpath'] = xpath
 
@@ -39,7 +39,7 @@ def get_sanitized_dict_keys(dict_to_update: dict, asset: 'Asset') -> dict | None
     changed = False
     for old_xpath, values in dict_to_update.items():
         if '-' in old_xpath and '/' not in old_xpath:
-            xpath = qpath_to_xpath(old_xpath, asset)
+            xpath = asset.get_xpath_from_qpath(old_xpath)
             if xpath == old_xpath:
                 continue
 
@@ -62,7 +62,7 @@ def get_sanitized_known_columns(asset: 'Asset') -> list:
         # it will enter this condition - which is not a problem except extra
         # CPU usage for nothing.
         if '-' in xpath and '/' not in xpath:
-            xpath = qpath_to_xpath(xpath, asset)
+            xpath = asset.get_xpath_from_qpath(xpath)
             rest.insert(0, xpath)
             known_cols[idx] = ':'.join(rest)
 

kpi/models/asset.py

@@ -562,7 +562,7 @@ def analysis_form_json(self, omit_question_types=None):
             try:
                 xpath = qual_question['xpath']
             except KeyError:
-                xpath = qpath_to_xpath(qual_question['qpath'], self)
+                xpath = self.get_xpath_from_qpath(qual_question['qpath'])
 
             field = dict(
                 label=qual_question['labels']['_default'],
@@ -662,15 +662,25 @@ def get_advanced_submission_schema(self, url=None, content=False):
             content, self.advanced_features, url=url
         )
 
-    def get_all_attachment_xpaths(self):
+    def get_all_attachment_xpaths(self) -> list:
+
+        # We previously used `cache_for_request`, but it provides no benefit in Celery
+        # tasks. A "protected" property on the Asset instance now serves the same
+        # purpose during its lifecycle.
+        if (
+            _all_attachment_xpaths := getattr(self, '_all_attachment_xpaths', None)
+        ) is not None:
+            return _all_attachment_xpaths
+
         # return deployed versions first
         versions = self.asset_versions.filter(deployed=True).order_by('-date_modified')
         xpaths = set()
         for version in versions:
             if xpaths_from_version := self.get_attachment_xpaths_from_version(version):
                 xpaths.update(xpaths_from_version)
 
-        return list(xpaths)
+        setattr(self, '_all_attachment_xpaths', list(xpaths))
+        return self._all_attachment_xpaths
 
     def get_attachment_xpaths_from_version(self, version=None) -> Optional[list]:
 
@@ -831,6 +841,23 @@ def get_partial_perms(
 
         return None
 
+    def get_xpath_from_qpath(self, qpath: str) -> str:
+
+        # We could have used `cache_for_request` in the `qpath_to_xpath` utility,
+        # but it provides no benefit in Celery tasks.
+        # Instead, we use a "protected" property on the Asset model to cache the result
+        # during the lifetime of the asset instance.
+        qpaths_xpaths_mapping = getattr(self, '_qpaths_xpaths_mapping', {})
+
+        try:
+            xpath = qpaths_xpaths_mapping[qpath]
+        except KeyError:
+            qpaths_xpaths_mapping[qpath] = qpath_to_xpath(qpath, self)
+            xpath = qpaths_xpaths_mapping[qpath]
+
+        setattr(self, '_qpaths_xpaths_mapping', qpaths_xpaths_mapping)
+        return xpath
+
     @property
     def has_advanced_features(self):
         if self.advanced_features is None:
@@ -910,6 +937,9 @@ def refresh_from_db(self, using=None, fields=None):
         super().refresh_from_db(using=using, fields=fields)
         # Refresh hidden fields too
         self.__copy_hidden_fields(fields)
+        # reset caching fields
+        self._qpaths_xpaths_mapping = {}
+        self._all_attachment_xpaths = None
 
     def rename_translation(self, _from, _to):
         if not self._has_translations(self.content, 2):

kpi/tests/test_asset_content.py

@@ -4,6 +4,7 @@
 from collections import OrderedDict
 from copy import deepcopy
 from functools import reduce
+from unittest.mock import patch
 
 from django.conf import settings
 from django.test import TestCase
@@ -870,10 +871,10 @@ def test_populates_xpath_correctly():
 
 class TestAssetContent(TestCase):
 
-    def test_get_attachment_xpaths_from_all_versions(self):
+    def setUp(self):
         user = baker.make(settings.AUTH_USER_MODEL, username='johndoe')
         # survey with 1 attachment question
-        asset = Asset.objects.create(
+        self.asset = Asset.objects.create(
             owner=user,
             content={
                 'survey': [
@@ -886,7 +887,11 @@ def test_get_attachment_xpaths_from_all_versions(self):
                 ]
             },
         )
-        asset.deploy(backend='mock')
+        self.asset.deploy(backend='mock')
+
+    def test_get_attachment_xpaths_from_all_versions(self):
+
+        asset = self.asset
         # move the attachment question to a group
         asset.content = {
             'survey': [
@@ -931,3 +936,47 @@ def test_get_attachment_xpaths_from_all_versions(self):
         # Validate XPaths can still be retrieved even on old versions
         xpaths = asset.get_all_attachment_xpaths()
         assert sorted(xpaths) == ['Image', 'group_kq1rd43/Image']
+
+    @patch('kpi.models.asset.Asset.get_attachment_xpaths_from_version')
+    def test_xpath_method_called_once_for_single_version(
+        self, mock_get_xpaths_from_version
+    ):
+        """
+        Test `get_attachment_xpaths_from_version()` is called only once
+        for a single deployed version and results are cached
+        """
+        # Simulate return value for a single version
+        mock_get_xpaths_from_version.return_value = ['Image']
+
+        # Call the method twice, should hit cache after first call
+        self.asset.get_all_attachment_xpaths()
+        self.asset.get_all_attachment_xpaths()
+
+        # Confirm that the mock was called only once
+        mock_get_xpaths_from_version.assert_called_once()
+
+    @patch('kpi.models.asset.Asset.get_attachment_xpaths_from_version')
+    def test_xpath_method_called_once_per_version(self, mock_get_xpaths_from_version):
+        """
+        Test `get_attachment_xpaths_from_version()` is called only once per deployed
+        version and results are cached
+        """
+        self.asset.content['survey'].append(
+            {'type': 'image', 'name': 'image2', 'label': ['image2']}
+        )
+        self.asset.save()
+        self.asset.deploy(backend='mock', active=True)
+
+        # Use side_effect to simulate distinct outputs for each version
+        mock_get_xpaths_from_version.side_effect = [
+            ['image'],               # first version
+            ['image', 'image2'],     # second version
+        ]
+
+        # Call multiple times, should hit cache for each version
+        self.asset.get_all_attachment_xpaths()
+        self.asset.get_all_attachment_xpaths()
+        self.asset.get_all_attachment_xpaths()
+
+        # Confirm it was called twice, once for each version
+        self.assertEqual(mock_get_xpaths_from_version.call_count, 2)