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

udata/core/dataset/apiv2.py

@@ -30,7 +30,7 @@ from .api_fields import (
     temporal_coverage_fields,
     user_ref_fields,
 )
-from .constants import DEFAULT_FREQUENCY, DEFAULT_LICENSE, FULL_OBJECTS_HEADER, UPDATE_FREQUENCIES
+from .constants import DEFAULT_LICENSE, FULL_OBJECTS_HEADER, UpdateFrequency
 from .models import CommunityResource, Dataset
 from .search import DatasetSearch
 
@@ -157,13 +157,13 @@ dataset_fields = apiv2.model(
         ),
         "frequency": fields.Raw(
             attribute=lambda d: {
-                "id": d.frequency or DEFAULT_FREQUENCY,
-                "label": UPDATE_FREQUENCIES.get(d.frequency or DEFAULT_FREQUENCY),
+                "id": (d.frequency or UpdateFrequency.UNKNOWN).id,
+                "label": (d.frequency or UpdateFrequency.UNKNOWN).label,
             }
             if request.headers.get(FULL_OBJECTS_HEADER, False, bool)
-            else d.frequency,
-            enum=list(UPDATE_FREQUENCIES),
-            default=DEFAULT_FREQUENCY,
+            else (d.frequency or UpdateFrequency.UNKNOWN),
+            enum=list(UpdateFrequency),
+            default=UpdateFrequency.UNKNOWN,
             required=True,
             description="The update frequency (full Frequency object if `X-Get-Datasets-Full-Objects` is set, ID of the frequency otherwise)",
         ),

udata/core/dataset/commands.py

@@ -10,7 +10,6 @@ from udata.core.dataset.constants import DEFAULT_LICENSE
 from udata.models import Dataset, License
 
 from . import actions
-from .tasks import send_frequency_reminder
 
 log = logging.getLogger(__name__)
 
@@ -66,15 +65,6 @@ def licenses(source=DEFAULT_LICENSE_FILE):
     success("Done")
 
 
-@cli.command()
-def frequency_reminder():
-    """Send a unique email per organization to members
-
-    to remind them they have outdated datasets on the website.
-    """
-    send_frequency_reminder()
-
-
 @cli.group("dataset")
 def grp():
     """Dataset related operations"""

udata/core/dataset/constants.py

@@ -1,48 +1,134 @@
 from collections import OrderedDict
+from datetime import datetime, timedelta
+from enum import StrEnum, auto
+
+from flask_babel import LazyString
 
 from udata.i18n import lazy_gettext as _
 
-#: Udata frequencies with their labels
-#:
-#: See: http://dublincore.org/groups/collections/frequency/
-UPDATE_FREQUENCIES = OrderedDict(
-    [  # Dublin core equivalent
-        ("unknown", _("Unknown")),  # N/A
-        ("punctual", _("Punctual")),  # N/A
-        ("continuous", _("Real time")),  # freq:continuous
-        ("hourly", _("Hourly")),  # N/A
-        ("fourTimesADay", _("Four times a day")),  # N/A
-        ("threeTimesADay", _("Three times a day")),  # N/A
-        ("semidaily", _("Semidaily")),  # N/A
-        ("daily", _("Daily")),  # freq:daily
-        ("fourTimesAWeek", _("Four times a week")),  # N/A
-        ("threeTimesAWeek", _("Three times a week")),  # freq:threeTimesAWeek
-        ("semiweekly", _("Semiweekly")),  # freq:semiweekly
-        ("weekly", _("Weekly")),  # freq:weekly
-        ("biweekly", _("Biweekly")),  # freq:bimonthly
-        ("threeTimesAMonth", _("Three times a month")),  # freq:threeTimesAMonth
-        ("semimonthly", _("Semimonthly")),  # freq:semimonthly
-        ("monthly", _("Monthly")),  # freq:monthly
-        ("bimonthly", _("Bimonthly")),  # freq:bimonthly
-        ("quarterly", _("Quarterly")),  # freq:quarterly
-        ("threeTimesAYear", _("Three times a year")),  # freq:threeTimesAYear
-        ("semiannual", _("Biannual")),  # freq:semiannual
-        ("annual", _("Annual")),  # freq:annual
-        ("biennial", _("Biennial")),  # freq:biennial
-        ("triennial", _("Triennial")),  # freq:triennial
-        ("quinquennial", _("Quinquennial")),  # N/A
-        ("irregular", _("Irregular")),  # freq:irregular
-    ]
-)
 
-#: Map legacy frequencies to currents
-LEGACY_FREQUENCIES = {
-    "fortnighly": "biweekly",
-    "biannual": "semiannual",
-    "realtime": "continuous",
+class UpdateFrequency(StrEnum):
+    """
+    Udata frequency vocabulary
+
+    Based on the following vocabularies:
+    - DC: http://dublincore.org/groups/collections/frequency/
+    - EU: https://publications.europa.eu/en/web/eu-vocabularies/at-dataset/-/resource/dataset/frequency
+    """
+
+    CONTINUOUS = auto(), _("Real time"), None  # DC, EU:UPDATE_CONT
+    ONE_MINUTE = "oneMinute", _("Every minute"), timedelta(minutes=1)  # EU:1MIN
+    FIVE_MINUTES = "fiveMinutes", _("Every five minutes"), timedelta(minutes=5)  # EU:5MIN
+    TEN_MINUTES = "tenMinutes", _("Every ten minutes"), timedelta(minutes=10)  # EU:10MIN
+    FIFTEEN_MINUTES = (
+        "fifteenMinutes",
+        _("Every fifteen minutes"),
+        timedelta(minutes=15),
+    )  # EU:15MIN
+    THIRTY_MINUTES = "thirtyMinutes", _("Every thirty minute"), timedelta(minutes=30)  # EU:30MIN
+    HOURLY = auto(), _("Every hour"), timedelta(hours=1)  # EU
+    BIHOURLY = auto(), _("Every two hours"), timedelta(hours=2)  # EU
+    TRIHOURLY = auto(), _("Every three hours"), timedelta(hours=3)  # EU
+    TWELVE_HOURS = "twelveHours", _("Every twelve hours"), timedelta(hours=12)  # EU:12HRS
+    SEVERAL_TIMES_A_DAY = "severalTimesADay", _("Several times a day"), timedelta(days=1)  # EU:CONT
+    THREE_TIMES_A_DAY = "threeTimesADay", _("Three times a day"), timedelta(days=1)  # EU:DAILY_3
+    SEMIDAILY = auto(), _("Twice a day"), timedelta(days=1)  # EU:DAILY_2
+    DAILY = auto(), _("Daily"), timedelta(days=1)  # DC, EU
+    FIVE_TIMES_A_WEEK = "fiveTimesAWeek", _("Five times a week"), timedelta(weeks=1)  # EU:WEEKLY_5
+    THREE_TIMES_A_WEEK = (
+        "threeTimesAWeek",
+        _("Three times a week"),
+        timedelta(weeks=1),
+    )  # DC, EU:WEEKLY_3
+    SEMIWEEKLY = auto(), _("Twice a week"), timedelta(weeks=1)  # DC, EU:WEEKLY_2
+    WEEKLY = auto(), _("Weekly"), timedelta(weeks=1)  # DC, EU
+    BIWEEKLY = auto(), _("Every two weeks"), timedelta(weeks=2)  # DC, EU
+    THREE_TIMES_A_MONTH = (
+        "threeTimesAMonth",
+        _("Three times a month"),
+        timedelta(days=31),
+    )  # DC, EU:MONTHLY_3
+    SEMIMONTHLY = auto(), _("Twice a month"), timedelta(days=31)  # DC, EU:MONTHLY_2
+    MONTHLY = auto(), _("Monthly"), timedelta(days=31)  # DC, EU
+    BIMONTHLY = auto(), _("Every two months"), timedelta(days=31 * 2)  # DC, EU
+    QUARTERLY = auto(), _("Quarterly"), timedelta(days=31 * 3)  # DC, EU
+    THREE_TIMES_A_YEAR = (
+        "threeTimesAYear",
+        _("Three times a year"),
+        timedelta(days=365),
+    )  # DC, EU:ANNUAL_3
+    SEMIANNUAL = auto(), _("Twice a year"), timedelta(days=365)  # DC, EU:ANNUAL_2
+    ANNUAL = auto(), _("Annually"), timedelta(days=365)  # DC, EU
+    BIENNIAL = auto(), _("Every two years"), timedelta(days=365 * 2)  # DC, EU
+    TRIENNIAL = auto(), _("Every three years"), timedelta(days=365 * 3)  # DC, EU
+    QUADRENNIAL = auto(), _("Every four years"), timedelta(days=365 * 4)  # EU
+    QUINQUENNIAL = auto(), _("Every five years"), timedelta(days=365 * 5)  # EU
+    DECENNIAL = auto(), _("Every ten years"), timedelta(days=365 * 10)  # EU
+    BIDECENNIAL = auto(), _("Every twenty years"), timedelta(days=365 * 20)  # EU
+    TRIDECENNIAL = auto(), _("Every thirty years"), timedelta(days=365 * 30)  # EU
+    PUNCTUAL = auto(), _("Punctual"), None  # EU:AS_NEEDED
+    IRREGULAR = auto(), _("Irregular"), None  # DC, EU:IRREG
+    NEVER = auto(), _("Never"), None  # EU
+    NOT_PLANNED = "notPlanned", _("Not planned"), None  # EU:NOT_PLANNED
+    OTHER = auto(), _("Other"), None  # EU
+    UNKNOWN = auto(), _("Unknown"), None  # EU
+
+    def __new__(cls, id: str, label: LazyString, delta: timedelta | None):
+        # Set _value_ so the enum value-based lookup depends only on the id field.
+        # See https://docs.python.org/3/howto/enum.html#when-to-use-new-vs-init
+        obj = str.__new__(cls, id)
+        obj._value_ = id
+        obj._label = label  # type: ignore[misc]
+        obj._delta = delta  # type: ignore[misc]
+        return obj
+
+    @classmethod
+    def _missing_(cls, value) -> "UpdateFrequency | None":
+        if isinstance(value, str):
+            return UpdateFrequency._LEGACY_FREQUENCIES.get(value)  # type: ignore[misc]
+
+    @property
+    def id(self) -> str:
+        return self.value
+
+    @property
+    def label(self) -> LazyString:
+        return self._label  # type: ignore[misc]
+
+    @property
+    def delta(self) -> timedelta | None:
+        return self._delta  # type: ignore[misc]
+
+    def next_update(self, last_update: datetime) -> datetime | None:
+        return last_update + self.delta if self.delta else None
+
+
+# We must declare UpdateFrequency class variables after the Enum magic
+# happens, so outside of class declaration.
+#
+# The alternative method based on _ignore_ breaks accessing the class
+# variables from outside the class, because accesses to will go
+# through __getattr__ as if it were an Enum entry.
+#
+# FIXME(python 3.13+): Use Enum._add_value_alias_ instead:
+#
+#     UNKNOWN = auto(), _("Unknown"), None, []
+#     CONTINUOUS = auto(), _("Real time"), None, ["realtime"]
+#     SEVERAL_TIMES_A_DAY = "severalTimesADay", ..., ["fourTimesADay"]
+#
+#     def __new__(cls, id: str, ..., aliases: list[str]):
+#         ...
+#         for alias in aliases:
+#             obj._add_value_alias_(alias)
+#
+UpdateFrequency._LEGACY_FREQUENCIES = {  # type: ignore[misc]
+    "realtime": UpdateFrequency.CONTINUOUS,
+    "fourTimesADay": UpdateFrequency.SEVERAL_TIMES_A_DAY,
+    "fourTimesAWeek": UpdateFrequency.OTHER,
+    "fortnighly": UpdateFrequency.BIWEEKLY,
+    "biannual": UpdateFrequency.SEMIANNUAL,
 }
 
-DEFAULT_FREQUENCY = "unknown"
 
 DEFAULT_LICENSE = {
     "id": "notspecified",

udata/core/dataset/factories.py

@@ -8,6 +8,7 @@ from udata.core.organization.factories import OrganizationFactory
 from udata.core.spatial.factories import SpatialCoverageFactory
 from udata.factories import ModelFactory
 
+from .constants import UpdateFrequency
 from .models import Checksum, CommunityResource, Dataset, License, Resource
 
 
@@ -17,7 +18,7 @@ class DatasetFactory(ModelFactory):
 
     title = factory.Faker("sentence")
     description = factory.Faker("text")
-    frequency = "unknown"
+    frequency = UpdateFrequency.UNKNOWN
     resources = factory.LazyAttribute(lambda o: ResourceFactory.build_batch(o.nb_resources))
 
     class Params:

udata/core/dataset/forms.py

@@ -6,14 +6,12 @@ from udata.mongo.errors import FieldValidationError
 
 from .constants import (
     CHECKSUM_TYPES,
-    DEFAULT_FREQUENCY,
     DESCRIPTION_SHORT_SIZE_LIMIT,
     DESCRIPTION_SIZE_LIMIT,
-    LEGACY_FREQUENCIES,
     RESOURCE_FILETYPES,
     RESOURCE_TYPES,
     TITLE_SIZE_LIMIT,
-    UPDATE_FREQUENCIES,
+    UpdateFrequency,
 )
 from .models import (
     Checksum,
@@ -117,10 +115,11 @@ class CommunityResourceForm(BaseResourceForm):
     organization = fields.PublishAsField(_("Publish as"))
 
 
-def map_legacy_frequencies(form, field):
-    """Map legacy frequencies to new ones"""
-    if field.data in LEGACY_FREQUENCIES:
-        field.data = LEGACY_FREQUENCIES[field.data]
+def unmarshal_frequency(form, field):
+    # We don't need to worry about invalid field.data being fed to UpdateFrequency here,
+    # since the API will already have ensured incoming data matches the field definition,
+    # which in our case is an enum of valid UpdateFrequency values.
+    field.data = UpdateFrequency(field.data)
 
 
 def validate_contact_point(form, field):
@@ -160,10 +159,15 @@ class DatasetForm(ModelForm):
     license = fields.ModelSelectField(_("License"), model=License, allow_blank=True)
     frequency = fields.SelectField(
         _("Update frequency"),
-        choices=list(UPDATE_FREQUENCIES.items()),
-        default=DEFAULT_FREQUENCY,
+        choices=list(UpdateFrequency),
+        default=UpdateFrequency.UNKNOWN,
         validators=[validators.optional()],
-        preprocessors=[map_legacy_frequencies],
+        # Unmarshaling should not happen during validation, but flask-restx makes it cumbersome
+        # to do it earlier, requiring a request parser (unmarshaler) separate from the marshaler,
+        # meaning we can't use the same object for @api.expect and @api.marshal_with.
+        # This should get better once flask-restx moves to something like marshmallow, which
+        # handles marshaling/unmarshaling more symmetrically and in the same object.
+        preprocessors=[unmarshal_frequency],
         description=_("The frequency at which data are updated."),
     )
     frequency_date = fields.DateTimeField(_("Expected frequency date"))

udata/core/dataset/models.py

@@ -38,7 +38,6 @@ from .constants import (
     DESCRIPTION_SHORT_SIZE_LIMIT,
     HVD,
     INSPIRE,
-    LEGACY_FREQUENCIES,
     MAX_DISTANCE,
     PIVOTAL_DATA,
     RESOURCE_FILETYPES,
@@ -47,7 +46,7 @@ from .constants import (
     SL,
     SPD,
     SR,
-    UPDATE_FREQUENCIES,
+    UpdateFrequency,
 )
 from .exceptions import (
     SchemasCacheUnavailableException,
@@ -580,7 +579,8 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
     resources = field(db.ListField(db.EmbeddedDocumentField(Resource)), auditable=False)
 
     private = field(db.BooleanField(default=False))
-    frequency = field(db.StringField(choices=list(UPDATE_FREQUENCIES.keys())))
+
+    frequency = field(db.EnumField(UpdateFrequency))
     frequency_date = field(db.DateTimeField(verbose_name=_("Future date of update")))
     temporal_coverage = field(db.EmbeddedDocumentField(db.DateRange))
     spatial = field(db.EmbeddedDocumentField(SpatialCoverage))
@@ -703,8 +703,6 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
 
     def clean(self):
         super(Dataset, self).clean()
-        if self.frequency in LEGACY_FREQUENCIES:
-            self.frequency = LEGACY_FREQUENCIES[self.frequency]
 
         if len(set(res.id for res in self.resources)) != len(self.resources):
             raise MongoEngineValidationError(f"Duplicate resource ID in dataset #{self.id}.")
@@ -782,8 +780,8 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
             return self.owner.avatar.url
 
     @property
-    def frequency_label(self):
-        return UPDATE_FREQUENCIES.get(self.frequency or "unknown", UPDATE_FREQUENCIES["unknown"])
+    def has_frequency(self):
+        return self.frequency not in [None, UpdateFrequency.UNKNOWN]
 
     def check_availability(self):
         """Check if resources from that dataset are available.
@@ -835,33 +833,7 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
         Ex: the next update for a threeTimesAday freq is not
         every 8 hours, but is maximum 24 hours later.
         """
-        delta = None
-        if self.frequency == "hourly":
-            delta = timedelta(hours=1)
-        elif self.frequency in ["fourTimesADay", "threeTimesADay", "semidaily", "daily"]:
-            delta = timedelta(days=1)
-        elif self.frequency in ["fourTimesAWeek", "threeTimesAWeek", "semiweekly", "weekly"]:
-            delta = timedelta(weeks=1)
-        elif self.frequency == "biweekly":
-            delta = timedelta(weeks=2)
-        elif self.frequency in ["threeTimesAMonth", "semimonthly", "monthly"]:
-            delta = timedelta(days=31)
-        elif self.frequency == "bimonthly":
-            delta = timedelta(days=31 * 2)
-        elif self.frequency == "quarterly":
-            delta = timedelta(days=365 / 4)
-        elif self.frequency in ["threeTimesAYear", "semiannual", "annual"]:
-            delta = timedelta(days=365)
-        elif self.frequency == "biennial":
-            delta = timedelta(days=365 * 2)
-        elif self.frequency == "triennial":
-            delta = timedelta(days=365 * 3)
-        elif self.frequency == "quinquennial":
-            delta = timedelta(days=365 * 5)
-        if delta is None:
-            return
-        else:
-            return self.last_update + delta
+        return self.frequency.next_update(self.last_update) if self.has_frequency else None
 
     @property
     def quality(self):
@@ -880,7 +852,7 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
             # Allow for being one day late on update.
             # We may have up to one day delay due to harvesting for example
             quality["update_fulfilled_in_time"] = (next_update - datetime.utcnow()).days >= -1
-        elif self.frequency in ["continuous", "irregular", "punctual"]:
+        elif self.has_frequency and self.frequency.delta is None:
             # For these frequencies, we don't expect regular updates or can't quantify them.
             # Thus we consider the update_fulfilled_in_time quality criterion to be true.
             quality["update_fulfilled_in_time"] = True
@@ -905,7 +877,7 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
         result["temporal_coverage"] = True if self.temporal_coverage else False
         result["spatial"] = True if self.spatial else False
 
-        result["update_frequency"] = self.frequency and self.frequency != "unknown"
+        result["update_frequency"] = self.has_frequency
 
         # We only save the next_update here because it is based on resources
         # We cannot save the `update_fulfilled_in_time` because it is time

udata/core/dataset/preview.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from flask import current_app
 
@@ -12,12 +12,12 @@ if TYPE_CHECKING:
 # Define an abstract class
 class Preview(ABC):
     @abstractmethod
-    def preview_url(self, resource: Resource) -> Optional[str]:
+    def preview_url(self, resource: Resource) -> str | None:
         return None
 
 
 class TabularAPIPreview(Preview):
-    def preview_url(self, resource: Resource) -> Optional[str]:
+    def preview_url(self, resource: Resource) -> str | None:
         preview_base_url = current_app.config["TABULAR_EXPLORE_URL"]
         if not preview_base_url:
             return None

udata/core/dataset/rdf.py

@@ -6,7 +6,6 @@ import calendar
 import json
 import logging
 from datetime import date, datetime
-from typing import Optional
 
 from dateutil.parser import parse as parse_dt
 from flask import current_app
@@ -53,58 +52,85 @@ from udata.rdf import (
 )
 from udata.utils import get_by, safe_unicode, to_naive_datetime
 
-from .constants import OGC_SERVICE_FORMATS, UPDATE_FREQUENCIES
+from .constants import OGC_SERVICE_FORMATS, UpdateFrequency
 from .models import Checksum, Dataset, License, Resource
 
 log = logging.getLogger(__name__)
 
-# Map extra frequencies (ie. not defined in Dublin Core) to closest equivalent
-RDF_FREQUENCIES = {
-    "punctual": None,
-    "hourly": FREQ.continuous,
-    "fourTimesADay": FREQ.daily,
-    "threeTimesADay": FREQ.daily,
-    "semidaily": FREQ.daily,
-    "fourTimesAWeek": FREQ.threeTimesAWeek,
-    "quinquennial": None,
-    "unknown": None,
+FREQ_TERM_TO_UDATA = {
+    FREQ.continuous: UpdateFrequency.CONTINUOUS,
+    FREQ.daily: UpdateFrequency.DAILY,
+    FREQ.threeTimesAWeek: UpdateFrequency.THREE_TIMES_A_WEEK,
+    FREQ.semiweekly: UpdateFrequency.SEMIWEEKLY,
+    FREQ.weekly: UpdateFrequency.WEEKLY,
+    FREQ.biweekly: UpdateFrequency.BIWEEKLY,
+    FREQ.threeTimesAMonth: UpdateFrequency.THREE_TIMES_A_MONTH,
+    FREQ.semimonthly: UpdateFrequency.SEMIMONTHLY,
+    FREQ.monthly: UpdateFrequency.MONTHLY,
+    FREQ.bimonthly: UpdateFrequency.BIMONTHLY,
+    FREQ.quarterly: UpdateFrequency.QUARTERLY,
+    FREQ.threeTimesAYear: UpdateFrequency.THREE_TIMES_A_YEAR,
+    FREQ.semiannual: UpdateFrequency.SEMIANNUAL,
+    FREQ.annual: UpdateFrequency.ANNUAL,
+    FREQ.biennial: UpdateFrequency.BIENNIAL,
+    FREQ.triennial: UpdateFrequency.TRIENNIAL,
+    FREQ.irregular: UpdateFrequency.IRREGULAR,
+}
+FREQ_ID_TO_UDATA = {
+    namespace_manager.compute_qname(k)[2].lower(): v for k, v in FREQ_TERM_TO_UDATA.items()
 }
 
-# Map european frequencies to their closest equivalent
-# See:
-#  - http://publications.europa.eu/mdr/resource/authority/frequency/html/frequencies-eng.html # noqa: E501
-#  - https://publications.europa.eu/en/web/eu-vocabularies/at-dataset/-/resource/dataset/frequency # noqa: E501
-EU_RDF_REQUENCIES = {
-    # Match Dublin Core name
-    EUFREQ.ANNUAL: "annual",
-    EUFREQ.BIENNIAL: "biennial",
-    EUFREQ.TRIENNIAL: "triennial",
-    EUFREQ.QUARTERLY: "quarterly",
-    EUFREQ.MONTHLY: "monthly",
-    EUFREQ.BIMONTHLY: "bimonthly",
-    EUFREQ.WEEKLY: "weekly",
-    EUFREQ.BIWEEKLY: "biweekly",
-    EUFREQ.DAILY: "daily",
-    # Name differs from Dublin Core
-    EUFREQ.ANNUAL_2: "semiannual",
-    EUFREQ.ANNUAL_3: "threeTimesAYear",
-    EUFREQ.MONTHLY_2: "semimonthly",
-    EUFREQ.MONTHLY_3: "threeTimesAMonth",
-    EUFREQ.WEEKLY_2: "semiweekly",
-    EUFREQ.WEEKLY_3: "threeTimesAWeek",
-    EUFREQ.DAILY_2: "semidaily",
-    EUFREQ.CONT: "continuous",
-    EUFREQ.UPDATE_CONT: "continuous",
-    EUFREQ.IRREG: "irregular",
-    EUFREQ.UNKNOWN: "unknown",
-    EUFREQ.OTHER: "unknown",
-    EUFREQ.NEVER: "punctual",
+EUFREQ_TERM_TO_UDATA = {
+    EUFREQ.UNKNOWN: UpdateFrequency.UNKNOWN,
+    EUFREQ.UPDATE_CONT: UpdateFrequency.CONTINUOUS,
+    getattr(EUFREQ, "1MIN"): UpdateFrequency.ONE_MINUTE,
+    getattr(EUFREQ, "5MIN"): UpdateFrequency.FIVE_MINUTES,
+    getattr(EUFREQ, "10MIN"): UpdateFrequency.TEN_MINUTES,
+    getattr(EUFREQ, "15MIN"): UpdateFrequency.FIFTEEN_MINUTES,
+    getattr(EUFREQ, "30MIN"): UpdateFrequency.THIRTY_MINUTES,
+    EUFREQ.HOURLY: UpdateFrequency.HOURLY,
+    EUFREQ.BIHOURLY: UpdateFrequency.BIHOURLY,
+    EUFREQ.TRIHOURLY: UpdateFrequency.TRIHOURLY,
+    getattr(EUFREQ, "12HRS"): UpdateFrequency.TWELVE_HOURS,
+    EUFREQ.CONT: UpdateFrequency.SEVERAL_TIMES_A_DAY,
+    EUFREQ.DAILY_3: UpdateFrequency.THREE_TIMES_A_DAY,
+    EUFREQ.DAILY_2: UpdateFrequency.SEMIDAILY,
+    EUFREQ.DAILY: UpdateFrequency.DAILY,
+    EUFREQ.WEEKLY_5: UpdateFrequency.FIVE_TIMES_A_WEEK,
+    EUFREQ.WEEKLY_3: UpdateFrequency.THREE_TIMES_A_WEEK,
+    EUFREQ.WEEKLY_2: UpdateFrequency.SEMIWEEKLY,
+    EUFREQ.WEEKLY: UpdateFrequency.WEEKLY,
+    EUFREQ.BIWEEKLY: UpdateFrequency.BIWEEKLY,
+    EUFREQ.MONTHLY_3: UpdateFrequency.THREE_TIMES_A_MONTH,
+    EUFREQ.MONTHLY_2: UpdateFrequency.SEMIMONTHLY,
+    EUFREQ.MONTHLY: UpdateFrequency.MONTHLY,
+    EUFREQ.BIMONTHLY: UpdateFrequency.BIMONTHLY,
+    EUFREQ.QUARTERLY: UpdateFrequency.QUARTERLY,
+    EUFREQ.ANNUAL_3: UpdateFrequency.THREE_TIMES_A_YEAR,
+    EUFREQ.ANNUAL_2: UpdateFrequency.SEMIANNUAL,
+    EUFREQ.ANNUAL: UpdateFrequency.ANNUAL,
+    EUFREQ.BIENNIAL: UpdateFrequency.BIENNIAL,
+    EUFREQ.TRIENNIAL: UpdateFrequency.TRIENNIAL,
+    EUFREQ.QUADRENNIAL: UpdateFrequency.QUADRENNIAL,
+    EUFREQ.QUINQUENNIAL: UpdateFrequency.QUINQUENNIAL,
+    EUFREQ.DECENNIAL: UpdateFrequency.DECENNIAL,
+    EUFREQ.BIDECENNIAL: UpdateFrequency.BIDECENNIAL,
+    EUFREQ.TRIDECENNIAL: UpdateFrequency.TRIDECENNIAL,
+    EUFREQ.AS_NEEDED: UpdateFrequency.PUNCTUAL,
+    EUFREQ.IRREG: UpdateFrequency.IRREGULAR,
+    EUFREQ.NEVER: UpdateFrequency.NEVER,
+    EUFREQ.NOT_PLANNED: UpdateFrequency.NOT_PLANNED,
+    EUFREQ.OTHER: UpdateFrequency.OTHER,
+}
+EUFREQ_ID_TO_UDATA = {
+    namespace_manager.compute_qname(k)[2].lower(): v for k, v in EUFREQ_TERM_TO_UDATA.items()
 }
 
+# Merge order matters: we want FREQ to win over EUFREQ
+UDATA_FREQ_ID_TO_TERM = {v: k for k, v in {**EUFREQ_TERM_TO_UDATA, **FREQ_TERM_TO_UDATA}.items()}
 
-def temporal_to_rdf(
-    daterange: db.DateRange, graph: Optional[Graph] = None
-) -> Optional[RdfResource]:
+
+def temporal_to_rdf(daterange: db.DateRange, graph: Graph | None = None) -> RdfResource | None:
     if not daterange:
         return
     graph = graph or Graph(namespace_manager=namespace_manager)
@@ -117,13 +143,11 @@ def temporal_to_rdf(
     return pot
 
 
-def frequency_to_rdf(frequency: str, graph: Optional[Graph] = None) -> Optional[str]:
-    if not frequency:
-        return
-    return RDF_FREQUENCIES.get(frequency, getattr(FREQ, frequency))
+def frequency_to_rdf(frequency: UpdateFrequency | None, graph: Graph | None = None) -> str | None:
+    return UDATA_FREQ_ID_TO_TERM.get(frequency)
 
 
-def owner_to_rdf(dataset: Dataset, graph: Optional[Graph] = None) -> Optional[RdfResource]:
+def owner_to_rdf(dataset: Dataset, graph: Graph | None = None) -> RdfResource | None:
     from udata.core.organization.rdf import organization_to_rdf
     from udata.core.user.rdf import user_to_rdf
 
@@ -134,7 +158,7 @@ def owner_to_rdf(dataset: Dataset, graph: Optional[Graph] = None) -> Optional[Rd
     return
 
 
-def detect_ogc_service(resource: Resource) -> Optional[str]:
+def detect_ogc_service(resource: Resource) -> str | None:
     """
     Detect if the resource points towards an OGC Service based on either
     * a known OGC Service format
@@ -153,8 +177,8 @@ def detect_ogc_service(resource: Resource) -> Optional[str]:
 def ogc_service_to_rdf(
     dataset: Dataset,
     resource: Resource,
-    ogc_service_type: Optional[str] = None,
-    graph: Optional[Graph] = None,
+    ogc_service_type: str | None = None,
+    graph: Graph | None = None,
     is_hvd: bool = False,
 ) -> RdfResource:
     """
@@ -196,8 +220,8 @@ def ogc_service_to_rdf(
 
 def resource_to_rdf(
     resource: Resource,
-    dataset: Optional[Dataset] = None,
-    graph: Optional[Graph] = None,
+    dataset: Dataset | None = None,
+    graph: Graph | None = None,
     is_hvd: bool = False,
 ) -> RdfResource:
     """
@@ -261,7 +285,7 @@ def dataset_to_graph_id(dataset: Dataset) -> URIRef | BNode:
         return BNode()
 
 
-def dataset_to_rdf(dataset: Dataset, graph: Optional[Graph] = None) -> RdfResource:
+def dataset_to_rdf(dataset: Dataset, graph: Graph | None = None) -> RdfResource:
     """
     Map a dataset domain model to a DCAT/RDF graph
     """
@@ -336,8 +360,7 @@ def dataset_to_rdf(dataset: Dataset, graph: Optional[Graph] = None) -> RdfResour
     if dataset.temporal_coverage:
         d.set(DCT.temporal, temporal_to_rdf(dataset.temporal_coverage, graph))
 
-    frequency = frequency_to_rdf(dataset.frequency)
-    if frequency:
+    if frequency := frequency_to_rdf(dataset.frequency):
         d.set(DCT.accrualPeriodicity, frequency)
 
     owner_role = DCT.publisher
@@ -513,23 +536,19 @@ def spatial_from_rdf(graph):
         return None
 
 
-def frequency_from_rdf(term):
+def frequency_from_rdf(term) -> UpdateFrequency | None:
     if isinstance(term, str):
         try:
             term = URIRef(uris.validate(term))
         except uris.ValidationError:
             pass
     if isinstance(term, Literal):
-        if term.toPython().lower() in UPDATE_FREQUENCIES:
-            return term.toPython().lower()
+        term = term.toPython().lower()
+        return FREQ_ID_TO_UDATA.get(term) or EUFREQ_ID_TO_UDATA.get(term)
     if isinstance(term, RdfResource):
         term = term.identifier
     if isinstance(term, URIRef):
-        if EUFREQ in term:
-            return EU_RDF_REQUENCIES.get(term)
-        _, _, freq = namespace_manager.compute_qname(term)
-        if freq.lower() in UPDATE_FREQUENCIES:
-            return freq.lower()
+        return FREQ_TERM_TO_UDATA.get(term) or EUFREQ_TERM_TO_UDATA.get(term)
 
 
 def mime_from_rdf(resource):