udata 11.1.2.dev8__py3-none-any.whl → 11.1.2.dev11__py3-none-any.whl

udata/harvest/backends/ckan/harvesters.py

@@ -4,19 +4,14 @@ from urllib.parse import urljoin
 from uuid import UUID
 
 from udata import uris
-from udata.harvest.models import HarvestItem
-from udata.i18n import lazy_gettext as _
-
-try:
-    from udata.core.dataset.constants import UPDATE_FREQUENCIES
-except ImportError:
-    # legacy import of constants in udata
-    from udata.models import UPDATE_FREQUENCIES
+from udata.core.dataset.constants import UpdateFrequency
 from udata.core.dataset.models import HarvestDatasetMetadata, HarvestResourceMetadata
 from udata.core.dataset.rdf import frequency_from_rdf
 from udata.frontend.markdown import parse_html
 from udata.harvest.backends.base import BaseBackend, HarvestFilter
 from udata.harvest.exceptions import HarvestException, HarvestSkipException
+from udata.harvest.models import HarvestItem
+from udata.i18n import lazy_gettext as _
 from udata.models import GeoZone, License, Resource, SpatialCoverage, db
 from udata.utils import daterange_end, daterange_start, get_by
 
@@ -193,14 +188,15 @@ class CkanBackend(BaseBackend):
                 log.debug("spatial-uri value not handled: %s", value)
             elif key == "frequency":
                 # Update frequency
-                freq = frequency_from_rdf(value)
-                if freq:
+                if freq := frequency_from_rdf(value):
                     dataset.frequency = freq
-                elif value in UPDATE_FREQUENCIES:
-                    dataset.frequency = value
                 else:
-                    dataset.extras["ckan:frequency"] = value
-                    log.debug("frequency value not handled: %s", value)
+                    # FIXME(python 3.12+): prefer `if value in UpdateFrequency`
+                    try:
+                        dataset.frequency = UpdateFrequency(value)
+                    except ValueError:
+                        dataset.extras["ckan:frequency"] = value
+                        log.debug("frequency value not handled: %s", value)
             # Temporal coverage start
             elif key == "temporal_start":
                 temporal_start = daterange_start(value)

udata/harvest/backends/maaf.py

@@ -7,6 +7,7 @@ from urllib.parse import urljoin
 from lxml import etree, html
 from voluptuous import All, Any, In, Length, Lower, Optional, Schema
 
+from udata.core.dataset.constants import UpdateFrequency
 from udata.harvest.backends import BaseBackend
 from udata.harvest.filters import (
     boolean,
@@ -38,19 +39,19 @@ ZONES = {
 
 
 FREQUENCIES = {
-    "ponctuelle": "punctual",
-    "temps réel": "continuous",
-    "quotidienne": "daily",
-    "hebdomadaire": "weekly",
-    "bimensuelle": "semimonthly",
-    "mensuelle": "monthly",
-    "bimestrielle": "bimonthly",
-    "trimestrielle": "quarterly",
-    "semestrielle": "semiannual",
-    "annuelle": "annual",
-    "triennale": "triennial",
-    "quinquennale": "quinquennial",
-    "aucune": "unknown",
+    "ponctuelle": UpdateFrequency.PUNCTUAL,
+    "temps réel": UpdateFrequency.CONTINUOUS,
+    "quotidienne": UpdateFrequency.DAILY,
+    "hebdomadaire": UpdateFrequency.WEEKLY,
+    "bimensuelle": UpdateFrequency.SEMIMONTHLY,
+    "mensuelle": UpdateFrequency.MONTHLY,
+    "bimestrielle": UpdateFrequency.BIMONTHLY,
+    "trimestrielle": UpdateFrequency.QUARTERLY,
+    "semestrielle": UpdateFrequency.SEMIANNUAL,
+    "annuelle": UpdateFrequency.ANNUAL,
+    "triennale": UpdateFrequency.TRIENNIAL,
+    "quinquennale": UpdateFrequency.QUINQUENNIAL,
+    "aucune": UpdateFrequency.UNKNOWN,
 }
 
 XSD_PATH = os.path.join(os.path.dirname(__file__), "maaf.xsd")
@@ -161,7 +162,7 @@ class MaafBackend(BaseBackend):
         dataset = self.get_dataset(item.remote_id)
 
         dataset.title = metadata["title"]
-        dataset.frequency = FREQUENCIES.get(metadata["frequency"], "unknown")
+        dataset.frequency = FREQUENCIES.get(metadata["frequency"], UpdateFrequency.UNKNOWN)
         dataset.description = metadata["notes"]
         dataset.private = metadata["private"]
         dataset.tags = sorted(set(metadata["tags"]))

udata/harvest/tests/ckan/test_ckan_backend.py

@@ -5,6 +5,7 @@ from datetime import date
 import pytest
 
 from udata.app import create_app
+from udata.core.dataset.constants import UpdateFrequency
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.spatial.factories import GeoZoneFactory
 from udata.harvest import actions
@@ -336,7 +337,7 @@ def frequency_as_rdf_uri(resource_data):
         "resources": [resource_data],
         "extras": [{"key": "frequency", "value": "http://purl.org/cld/freq/daily"}],
     }
-    return data, {"expected": "daily"}
+    return data, {"expected": UpdateFrequency.DAILY}
 
 
 @pytest.fixture
@@ -348,7 +349,7 @@ def frequency_as_exact_match(resource_data):
         "resources": [resource_data],
         "extras": [{"key": "frequency", "value": "daily"}],
     }
-    return data, {"expected": "daily"}
+    return data, {"expected": UpdateFrequency.DAILY}
 
 
 @pytest.fixture
@@ -486,7 +487,7 @@ def test_can_parse_frequency_as_exact_match(result, kwargs):
 
 
 @pytest.mark.ckan_data("frequency_as_unknown_value")
-def test_can_parse_frequency_as_unkown_value(result, kwargs):
+def test_can_parse_frequency_as_unknown_value(result, kwargs):
     dataset = dataset_for(result)
     assert dataset.extras["ckan:frequency"] == kwargs["expected"]
     assert dataset.frequency is None

udata/harvest/tests/test_dcat_backend.py

@@ -10,6 +10,7 @@ from rdflib import Graph
 
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataservices.models import Dataservice
+from udata.core.dataset.constants import UpdateFrequency
 from udata.core.dataset.factories import DatasetFactory, LicenseFactory, ResourceSchemaMockData
 from udata.core.dataset.rdf import dataset_from_rdf
 from udata.core.organization.factories import OrganizationFactory
@@ -560,7 +561,7 @@ class DcatBackendTest:
         assert dataset.harvest.issued_at.date() == date(2016, 12, 14)
         assert dataset.harvest.created_at.date() == date(2016, 12, 12)
         assert dataset.harvest.modified_at.date() == date(2016, 12, 14)
-        assert dataset.frequency == "daily"
+        assert dataset.frequency == UpdateFrequency.DAILY
         assert dataset.description == "Dataset 3 description"
 
         assert dataset.temporal_coverage is not None
@@ -681,7 +682,7 @@ class DcatBackendTest:
         dataset = Dataset.objects.filter(organization=org).first()
 
         assert dataset is not None
-        assert dataset.frequency == "irregular"
+        assert dataset.frequency == UpdateFrequency.IRREGULAR
         assert "gravi" in dataset.tags  # support dcat:keyword
         assert "geodesy" in dataset.tags  # support dcat:theme
         assert dataset.license.id == "fr-lo"

udata/i18n.py

@@ -206,38 +206,13 @@ class I18nBlueprintSetupState(BlueprintSetupState):
         if "defaults" in options:
             defaults = dict(defaults, **options.pop("defaults"))
 
-        if options.pop("localize", True):
-            self.app.add_url_rule(
-                "/<lang:lang_code>" + rule,
-                "%s.%s" % (self.blueprint.name, endpoint),
-                view_func,
-                defaults=defaults,
-                **options,
-            )
-
-            self.app.add_url_rule(
-                rule,
-                "%s.%s_redirect" % (self.blueprint.name, endpoint),
-                redirect_to_lang,
-                defaults=defaults,
-                **options,
-            )
-        else:
-            self.app.add_url_rule(
-                rule,
-                "%s.%s" % (self.blueprint.name, endpoint),
-                view_func,
-                defaults=defaults,
-                **options,
-            )
-
-            self.app.add_url_rule(
-                "/<lang:lang_code>" + rule,
-                "%s.%s_redirect" % (self.blueprint.name, endpoint),
-                redirect_to_unlocalized,
-                defaults=defaults,
-                **options,
-            )
+        self.app.add_url_rule(
+            rule,
+            "%s.%s" % (self.blueprint.name, endpoint),
+            view_func,
+            defaults=defaults,
+            **options,
+        )
 
 
 class I18nBlueprint(Blueprint):

udata/migrations/2025-09-04-update-legacy-frequencies.py

@@ -0,0 +1,36 @@
+"""
+Convert legacy frequencies to latest vocabulary
+"""
+
+import logging
+
+from udata.core.dataset.constants import UpdateFrequency
+from udata.models import Dataset
+
+log = logging.getLogger(__name__)
+
+
+def migrate(db):
+    log.info("Updating datasets legacy frequencies:")
+
+    for legacy_value, frequency in UpdateFrequency._LEGACY_FREQUENCIES.items():
+        count = 0
+        for dataset in Dataset.objects(frequency=legacy_value).no_cache().timeout(False):
+            # Explicitly call update() to force writing the new frequency string to mongo.
+            # We can't rely on save() here because:
+            # 1. save() only writes modified fields to mongo, basically comparing the Dataset's
+            #    object state initially returned by the query with its state when save() is called,
+            #    and only sending the diffset to mongo.
+            # 2. At the ODM layer, the Dataset.frequency field has already been instantiated as an
+            #    UpdateFrequency object, and so legacy frequency strings have already been
+            #    mapped to their new ids (via UpdateFrequency._missing_).
+            # => While the raw frequency string has changed, the save() function sees the same
+            #    UpdateFrequency and therefore ignores the field in is diffset.
+            dataset.update(frequency=frequency.value)
+            # Still call save() afterwards so computed fields like quality_cached are updated if
+            # necessary, e.g. if moving from a predictable timedelta to an unpredictable one.
+            dataset.save()
+            count += 1
+        log.info(f"- {legacy_value} -> {frequency.value}: {count} updated")
+
+    log.info("Completed.")

udata/settings.py

@@ -101,6 +101,24 @@ class Defaults(object):
     SECURITY_RESET_URL = "/reset/"
     SECURITY_CHANGE_EMAIL_URL = "/change-email/"
 
+    # See https://flask-security.readthedocs.io/en/stable/configuration.html#SECURITY_REDIRECT_BEHAVIOR
+    # We do not define all the URLs requested in the documentation because most of the time we do JSON requests in cdata
+    # and catch errors instead of followings the redirects.
+    # The only place where we don't have control over the redirect is when the user is clicking a link directly to udata
+    # (instead of a link to `cdata`) as in /confirm. When the user is clicking on the confirmation link, he's redirected
+    # to `confirm_change_email` endpoint, and then udata redirect him to the homepage of `cdata` with a custom flash message.
+    SECURITY_REDIRECT_BEHAVIOR = "spa"
+    # SECURITY_POST_OAUTH_LOGIN_VIEW = ""    # SECURITY_OAUTH_ENABLE is disabled
+    # SECURITY_LOGIN_ERROR_VIEW = ""         # We don't follow the redirects since we do JSON POST requests during login
+    # SECURITY_CONFIRM_ERROR_VIEW = ""       # Manually changed in `confirm_change_email`
+    # SECURITY_POST_CHANGE_EMAIL_VIEW = ""   # We don't follow the redirects since we do JSON POST requests during change email
+    # SECURITY_CHANGE_EMAIL_ERROR_VIEW = ""  # We don't follow the redirects since we do JSON POST requests during change email
+    # SECURITY_POST_CONFIRM_VIEW = ""        # Set at runtime. See :SecurityPostConfirmViewAtRuntime
+    # SECURITY_RESET_ERROR_VIEW = ""         # We don't follow the redirects since we do JSON POST requests during request reset
+    # SECURITY_RESET_VIEW = ""               # We don't follow the redirects since we do JSON POST requests during request reset
+
+    SECURITY_SPA_ON_SAME_DOMAIN = False
+
     SECURITY_PASSWORD_SALT = "Default uData secret password salt"
     SECURITY_CONFIRM_SALT = "Default uData secret confirm salt"
     SECURITY_RESET_SALT = "Default uData secret reset salt"
@@ -122,6 +140,15 @@ class Defaults(object):
     DAYS_BEFORE_ACCOUNT_INACTIVITY_NOTIFY_DELAY = 30
     MAX_NUMBER_OF_USER_INACTIVITY_NOTIFICATIONS = 200
 
+    # You can activate CaptchEtat, a captcha.com integration by providing
+    # CAPTCHETAT_BASE_URL, CAPTCHETAT_OAUTH_BASE_URL, CAPTCHETAT_CLIENT_ID and CAPTCHETAT_CLIENT_SECRET
+    CAPTCHETAT_BASE_URL = None
+    CAPTCHETAT_OAUTH_BASE_URL = None
+    CAPTCHETAT_CLIENT_ID = None
+    CAPTCHETAT_CLIENT_SECRET = None
+    CAPTCHETAT_TOKEN_CACHE_KEY = "captchetat-bearer-token"
+    CAPTCHETAT_STYLE_NAME = "captchaFR"
+
     # Sentry configuration
     SENTRY_DSN = None
     SENTRY_TAGS = {}

udata/templates/security/email/reset_instructions.html

@@ -16,7 +16,7 @@
         <td align="center">
             {{ mail_button(
                 _('Reset my password'),
-                reset_link
+                cdata_url("/reset/" ~ reset_token) or reset_link
             ) }}
         </td>
     </tr>

udata/templates/security/email/reset_instructions.txt

@@ -4,6 +4,6 @@
 
 {{ _('To reset your password, please confirm your request through the link below:') }}
 
-{{ reset_link }}
+{{ cdata_url("/reset/" ~ reset_token) or reset_link }}
 
 {% endblock %}

udata/tests/api/test_datasets_api.py

@@ -16,12 +16,10 @@ from udata.app import cache
 from udata.core import storages
 from udata.core.badges.factories import badge_factory
 from udata.core.dataset.constants import (
-    DEFAULT_FREQUENCY,
     DEFAULT_LICENSE,
     FULL_OBJECTS_HEADER,
-    LEGACY_FREQUENCIES,
     RESOURCE_TYPES,
-    UPDATE_FREQUENCIES,
+    UpdateFrequency,
 )
 from udata.core.dataset.factories import (
     CommunityResourceFactory,
@@ -531,14 +529,14 @@ class DatasetAPITest(APITestCase):
         other = GeoLevelFactory(id="other", name="Autre")
 
         dataset = DatasetFactory(
-            frequency="monthly",
+            frequency=UpdateFrequency.MONTHLY,
             license=license,
             spatial=SpatialCoverageFactory(zones=[paca.id], granularity=country.id),
         )
 
         response = self.get(url_for("apiv2.dataset", dataset=dataset))
         self.assert200(response)
-        assert response.json["frequency"] == "monthly"
+        assert response.json["frequency"] == UpdateFrequency.MONTHLY.id
         assert response.json["license"] == "lov2"
         assert response.json["spatial"]["zones"][0] == paca.id
         assert response.json["spatial"]["granularity"] == "country"
@@ -550,8 +548,8 @@ class DatasetAPITest(APITestCase):
             },
         )
         self.assert200(response)
-        assert response.json["frequency"]["id"] == "monthly"
-        assert response.json["frequency"]["label"] == "Mensuelle"
+        assert response.json["frequency"]["id"] == UpdateFrequency.MONTHLY.id
+        assert response.json["frequency"]["label"] == UpdateFrequency.MONTHLY.label
         assert response.json["license"]["id"] == "lov2"
         assert response.json["license"]["title"] == license.title
         assert response.json["spatial"]["zones"][0]["id"] == paca.id
@@ -572,8 +570,8 @@ class DatasetAPITest(APITestCase):
             },
         )
         self.assert200(response)
-        assert response.json["frequency"]["id"] == DEFAULT_FREQUENCY
-        assert response.json["frequency"]["label"] == UPDATE_FREQUENCIES.get(DEFAULT_FREQUENCY)
+        assert response.json["frequency"]["id"] == UpdateFrequency.UNKNOWN.id
+        assert response.json["frequency"]["label"] == UpdateFrequency.UNKNOWN.label
         assert response.json["license"]["id"] == DEFAULT_LICENSE["id"]
         assert response.json["license"]["title"] == DEFAULT_LICENSE["title"]
         assert len(response.json["spatial"]["zones"]) == 0
@@ -723,12 +721,12 @@ class DatasetAPITest(APITestCase):
         """It should create a dataset from the API with a legacy frequency"""
         self.login()
 
-        for oldFreq, newFreq in LEGACY_FREQUENCIES.items():
+        for oldFreq, newFreq in UpdateFrequency._LEGACY_FREQUENCIES.items():  # type: ignore[misc]
             data = DatasetFactory.as_dict()
             data["frequency"] = oldFreq
             response = self.post(url_for("api.datasets"), data)
             self.assert201(response)
-            self.assertEqual(response.json["frequency"], newFreq)
+            self.assertEqual(response.json["frequency"], newFreq.id)
 
     def test_dataset_api_update(self):
         """It should update a dataset from the API"""
@@ -741,6 +739,37 @@ class DatasetAPITest(APITestCase):
         self.assertEqual(Dataset.objects.count(), 1)
         self.assertEqual(Dataset.objects.first().description, "new description")
 
+    def test_dataset_api_update_valid_frequency(self):
+        """It should update a dataset from the API"""
+        user = self.login()
+        dataset = DatasetFactory(owner=user)
+        data = dataset.to_dict()
+        data["frequency"] = "monthly"
+        response = self.put(url_for("api.dataset", dataset=dataset), data)
+        self.assert200(response)
+        self.assertEqual(Dataset.objects.count(), 1)
+        self.assertEqual(Dataset.objects.first().frequency, UpdateFrequency.MONTHLY)
+
+    def test_dataset_api_update_invalid_frequency(self):
+        """It should return an error saying the frequency is invalid"""
+        user = self.login()
+        dataset = DatasetFactory(owner=user, frequency=UpdateFrequency.ANNUAL)
+        data = dataset.to_dict()
+
+        data["frequency"] = 1  # invalid type
+        response = self.put(url_for("api.dataset", dataset=dataset), data)
+        self.assert400(response)
+        self.assertEqual(response.json.get("message"), "'1' is not a valid UpdateFrequency")
+        self.assertEqual(Dataset.objects.count(), 1)
+        self.assertEqual(Dataset.objects.first().frequency, UpdateFrequency.ANNUAL)
+
+        data["frequency"] = "foo"  # valid type but invalid term
+        response = self.put(url_for("api.dataset", dataset=dataset), data)
+        self.assert400(response)
+        self.assertEqual(response.json.get("message"), "'foo' is not a valid UpdateFrequency")
+        self.assertEqual(Dataset.objects.count(), 1)
+        self.assertEqual(Dataset.objects.first().frequency, UpdateFrequency.ANNUAL)
+
     def test_cannot_modify_dataset_id(self):
         user = self.login()
         dataset = DatasetFactory(owner=user)
@@ -2044,7 +2073,7 @@ class DatasetReferencesAPITest(APITestCase):
         """It should fetch the dataset frequencies list from the API"""
         response = self.get(url_for("api.dataset_frequencies"))
         self.assert200(response)
-        self.assertEqual(len(response.json), len(UPDATE_FREQUENCIES))
+        self.assertEqual(len(response.json), len(UpdateFrequency))
 
     def test_dataset_allowed_resources_extensions(self):
         """It should fetch the resources allowed extensions list from the API"""

udata/tests/dataset/test_dataset_model.py

@@ -20,7 +20,7 @@ from udata.core.dataset.activities import (
     UserUpdatedDataset,
     UserUpdatedResource,
 )
-from udata.core.dataset.constants import LEGACY_FREQUENCIES, UPDATE_FREQUENCIES
+from udata.core.dataset.constants import UpdateFrequency
 from udata.core.dataset.exceptions import (
     SchemasCacheUnavailableException,
     SchemasCatalogNotFoundException,
@@ -157,49 +157,13 @@ class DatasetModelTest:
         dataset = DatasetFactory()
         assert dataset.next_update is None
 
-    def test_next_update_hourly(self):
-        dataset = DatasetFactory(frequency="hourly")
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(hours=1))
-
-    @pytest.mark.parametrize("freq", ["fourTimesADay", "threeTimesADay", "semidaily", "daily"])
-    def test_next_update_daily(self, freq):
-        dataset = DatasetFactory(frequency=freq)
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=1))
-
-    @pytest.mark.parametrize("freq", ["fourTimesAWeek", "threeTimesAWeek", "semiweekly", "weekly"])
-    def test_next_update_weekly(self, freq):
-        dataset = DatasetFactory(frequency=freq)
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=7))
-
-    def test_next_update_biweekly(self):
-        dataset = DatasetFactory(frequency="biweekly")
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(weeks=2))
-
-    def test_next_update_quarterly(self):
-        dataset = DatasetFactory(frequency="quarterly")
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=365 / 4))
-
-    @pytest.mark.parametrize("freq", ["threeTimesAYear", "semiannual", "annual"])
-    def test_next_update_annual(self, freq):
-        dataset = DatasetFactory(frequency=freq)
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=365))
-
-    def test_next_update_biennial(self):
-        dataset = DatasetFactory(frequency="biennial")
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=365 * 2))
-
-    def test_next_update_triennial(self):
-        dataset = DatasetFactory(frequency="triennial")
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=365 * 3))
-
-    def test_next_update_quinquennial(self):
-        dataset = DatasetFactory(frequency="quinquennial")
-        assert_equal_dates(dataset.next_update, datetime.utcnow() + timedelta(days=365 * 5))
-
-    @pytest.mark.parametrize("freq", ["continuous", "punctual", "irregular", "unknown"])
-    def test_next_update_undefined(self, freq):
+    @pytest.mark.parametrize("freq", list(UpdateFrequency) + [None])
+    def test_next_update(self, freq: UpdateFrequency | None):
         dataset = DatasetFactory(frequency=freq)
-        assert dataset.next_update is None
+        if freq is None or freq.delta is None:
+            assert dataset.next_update is None
+        else:
+            assert_equal_dates(dataset.next_update, freq.next_update(datetime.utcnow()))
 
     def test_quality_default(self):
         dataset = DatasetFactory(description="")
@@ -212,21 +176,21 @@ class DatasetModelTest:
             "score": 0,
         }
 
-    @pytest.mark.parametrize("freq", UPDATE_FREQUENCIES)
-    def test_quality_frequency_update(self, freq):
+    @pytest.mark.parametrize("freq", list(UpdateFrequency) + [None])
+    def test_quality_frequency_update(self, freq: UpdateFrequency | None):
         dataset = DatasetFactory(description="", frequency=freq)
-        if freq == "unknown":
+        if freq in [None, UpdateFrequency.UNKNOWN]:
             assert dataset.quality["update_frequency"] is False
             assert "update_fulfilled_in_time" not in dataset.quality
-            return
-        assert dataset.quality["update_frequency"] is True
-        assert dataset.quality["update_fulfilled_in_time"] is True
-        assert dataset.quality["score"] == Dataset.normalize_score(2)
+        else:
+            assert dataset.quality["update_frequency"] is True
+            assert dataset.quality["update_fulfilled_in_time"] is True
+            assert dataset.quality["score"] == Dataset.normalize_score(2)
 
     def test_quality_frequency_update_one_day_late(self):
         dataset = DatasetFactory(
             description="",
-            frequency="daily",
+            frequency=UpdateFrequency.DAILY,
             last_modified_internal=datetime.utcnow() - timedelta(days=1, hours=1),
         )
         assert dataset.quality["update_frequency"] is True
@@ -236,7 +200,7 @@ class DatasetModelTest:
     def test_quality_frequency_update_two_days_late(self):
         dataset = DatasetFactory(
             description="",
-            frequency="daily",
+            frequency=UpdateFrequency.DAILY,
             last_modified_internal=datetime.utcnow() - timedelta(days=2, hours=1),
         )
         assert dataset.quality["update_frequency"] is True
@@ -309,7 +273,7 @@ class DatasetModelTest:
         assert dataset.tags[1] == "this-is-a-tag"
 
     def test_legacy_frequencies(self):
-        for oldFreq, newFreq in LEGACY_FREQUENCIES.items():
+        for oldFreq, newFreq in UpdateFrequency._LEGACY_FREQUENCIES.items():  # type: ignore[misc]
             dataset = DatasetFactory(frequency=oldFreq)
             assert dataset.frequency == newFreq