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

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/rdf.py

@@ -52,54 +52,83 @@ 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: Graph | None = None) -> RdfResource | None:
     if not daterange:
@@ -114,10 +143,8 @@ def temporal_to_rdf(daterange: db.DateRange, graph: Graph | None = None) -> RdfR
     return pot
 
 
-def frequency_to_rdf(frequency: str, graph: Graph | None = None) -> str | None:
-    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: Graph | None = None) -> RdfResource | None:
@@ -333,8 +360,7 @@ def dataset_to_rdf(dataset: Dataset, graph: Graph | None = None) -> RdfResource:
     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
@@ -510,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):

udata/core/dataset/tasks.py

@@ -1,22 +1,19 @@
 import collections
 import os
-from datetime import datetime, timedelta
+from datetime import datetime
 from tempfile import NamedTemporaryFile
 
 from celery.utils.log import get_task_logger
 from flask import current_app
 from mongoengine import ValidationError
 
-from udata import mail
 from udata import models as udata_models
 from udata.core import csv, storages
 from udata.core.dataservices.models import Dataservice
 from udata.harvest.models import HarvestJob
-from udata.i18n import lazy_gettext as _
-from udata.models import Activity, Discussion, Follow, Organization, TopicElement, Transfer, db
+from udata.models import Activity, Discussion, Follow, TopicElement, Transfer, db
 from udata.tasks import job
 
-from .constants import UPDATE_FREQUENCIES
 from .models import Checksum, CommunityResource, Dataset, Resource
 
 log = get_task_logger(__name__)
@@ -75,51 +72,6 @@ def purge_datasets(self):
         dataset.delete()
 
 
-@job("send-frequency-reminder")
-def send_frequency_reminder(self):
-    # We exclude irrelevant frequencies.
-    frequencies = [
-        f
-        for f in UPDATE_FREQUENCIES.keys()
-        if f not in ("unknown", "realtime", "punctual", "irregular", "continuous")
-    ]
-    now = datetime.utcnow()
-    reminded_orgs = {}
-    reminded_people = []
-    allowed_delay = current_app.config["DELAY_BEFORE_REMINDER_NOTIFICATION"]
-    for org in Organization.objects.visible():
-        outdated_datasets = []
-        for dataset in Dataset.objects.filter(
-            frequency__in=frequencies, organization=org
-        ).visible():
-            if dataset.next_update + timedelta(days=allowed_delay) < now:
-                dataset.outdated = now - dataset.next_update
-                dataset.frequency_str = UPDATE_FREQUENCIES[dataset.frequency]
-                outdated_datasets.append(dataset)
-        if outdated_datasets:
-            reminded_orgs[org] = outdated_datasets
-    for reminded_org, datasets in reminded_orgs.items():
-        print(
-            "{org.name} will be emailed for {datasets_nb} datasets".format(
-                org=reminded_org, datasets_nb=len(datasets)
-            )
-        )
-        recipients = [m.user for m in reminded_org.members]
-        reminded_people.append(recipients)
-        subject = _("You need to update some frequency-based datasets")
-        mail.send(subject, recipients, "frequency_reminder", org=reminded_org, datasets=datasets)
-
-    print("{nb_orgs} orgs concerned".format(nb_orgs=len(reminded_orgs)))
-    reminded_people = list(flatten(reminded_people))
-    print(
-        "{nb_emails} people contacted ({nb_emails_twice} twice)".format(
-            nb_emails=len(reminded_people),
-            nb_emails_twice=len(reminded_people) - len(set(reminded_people)),
-        )
-    )
-    print("Done")
-
-
 def get_queryset(model_cls):
     # special case for resources
     if model_cls.__name__ == "Resource":

udata/cors.py

@@ -1,6 +1,6 @@
 import logging
 
-from flask import g, request
+from flask import current_app, g, request
 from werkzeug.datastructures import Headers
 
 log = logging.getLogger(__name__)
@@ -36,10 +36,27 @@ def is_allowed_cors_route():
         path: str = request.path.removeprefix(f"/{g.lang_code}")
     else:
         path: str = request.path
+
+    # Allow to keep clean CORS when `udata` and the frontend are on the same domain
+    # (as it's the case in data.gouv with cdata/udata).
+    if not current_app.config["SECURITY_SPA_ON_SAME_DOMAIN"] and (
+        path.startswith("/login")
+        or path.startswith("/logout")
+        or path.startswith("/reset")
+        or path.startswith("/register")
+        or path.startswith("/confirm")
+        or path.startswith("/change")
+        or path.startswith("/change-email")
+        or path.startswith("/oauth")
+        or path.startswith("/get-csrf")
+    ):
+        return True
+
     return (
         path.endswith((".js", ".css", ".woff", ".woff2", ".png", ".jpg", ".jpeg", ".svg"))
         or path.startswith("/api")
-        or path.startswith("/oauth")
+        or path.startswith("/oauth/token")
+        or path.startswith("/oauth/revoke")
         or path.startswith("/datasets/r/")
     )