udata 14.0.3.dev1__py3-none-any.whl → 14.7.3.dev4__py3-none-any.whl

udata/api/__init__.py

@@ -121,6 +121,8 @@ class UDataApi(Api):
         if "application/json" not in request.headers.get("Content-Type", ""):
             errors = {"Content-Type": "expecting application/json"}
             self.abort(400, errors=errors)
+        if not isinstance(request.json, dict):
+            self.abort(400, errors={"request": "expecting a JSON object"})
         form = form_cls.from_json(request.json, obj=obj, instance=obj, meta={"csrf": False})
         if not form.validate():
             self.abort(400, errors=form.errors)

udata/api_fields.py

@@ -29,7 +29,7 @@ import flask_restx.fields as restx_fields
 import mongoengine
 import mongoengine.fields as mongo_fields
 from bson import DBRef, ObjectId
-from flask import Request
+from flask import Request, request
 from flask_restx import marshal
 from flask_restx.inputs import boolean
 from flask_restx.reqparse import RequestParser
@@ -40,6 +40,32 @@ from udata.api import api, base_reference
 from udata.mongo.errors import FieldValidationError
 from udata.mongo.queryset import DBPaginator, UDataQuerySet
 
+
+def required_if(**conditions):
+    """Check helper that makes a field required when other fields have specific values.
+
+    Usage:
+        page_id = field(
+            db.ReferenceField("Page"),
+            checks=[required_if(body_type="blocs")],
+        )
+    """
+
+    def check(value, data, field, obj, **_kwargs):
+        if value is not None:
+            return
+        for condition_field, condition_value in conditions.items():
+            actual_condition = data.get(condition_field, getattr(obj, condition_field, None))
+            if actual_condition == condition_value:
+                raise FieldValidationError(
+                    f"'{field}' is required when '{condition_field}' is '{condition_value}'",
+                    field=field,
+                )
+
+    check.run_even_if_missing = True
+    return check
+
+
 lazy_reference = api.model(
     "LazyReference",
     {
@@ -55,8 +81,8 @@ classes_by_parents = {}
 
 
 class GenericField(restx_fields.Raw):
-    def __init__(self, fields_by_type):
-        super().__init__(self)
+    def __init__(self, fields_by_type, **kwargs):
+        super(GenericField, self).__init__(**kwargs)
         self.default = None
         self.fields_by_type = fields_by_type
 
@@ -79,13 +105,15 @@ def convert_db_to_field(key, field, info) -> tuple[Callable | None, Callable | N
     user-supplied overrides, setting the readonly flag…), it's easier to have to do this only once at the end of the function.
 
     """
+    from udata.mongo.engine import db
+
     params: dict = {}
     params["required"] = field.required
 
     read_params: dict = {}
     write_params: dict = {}
 
-    constructor: Callable
+    constructor: Callable | None = None
     constructor_read: Callable | None = None
     constructor_write: Callable | None = None
 
@@ -204,13 +232,34 @@ def convert_db_to_field(key, field, info) -> tuple[Callable | None, Callable | N
         def constructor_write(**kwargs):
             return restx_fields.List(field_write, **kwargs)
 
-    elif isinstance(
-        field, (mongo_fields.GenericReferenceField, mongoengine.fields.GenericLazyReferenceField)
-    ):
+    elif isinstance(field, mongoengine.fields.GenericLazyReferenceField):
 
         def constructor(**kwargs):
             return restx_fields.Nested(lazy_reference, **kwargs)
 
+    elif isinstance(field, mongo_fields.GenericReferenceField):
+        if field.choices:
+            generic_fields = {}
+            for cls in field.choices:
+                cls = db.resolve_model(cls) if isinstance(cls, str) else cls
+                generic_fields[cls.__name__] = convert_db_to_field(
+                    f"{key}.{cls.__name__}",
+                    # Instead of having GenericReferenceField() we'll create fields for each
+                    # of the subclasses with ReferenceField(Organization)…
+                    mongoengine.fields.ReferenceField(cls),
+                    info,
+                )
+
+            def constructor_read(**kwargs):
+                return GenericField({k: v[0].model for k, v in generic_fields.items()}, **kwargs)
+
+            def constructor_write(**kwargs):
+                return GenericField({k: v[1].model for k, v in generic_fields.items()}, **kwargs)
+        else:
+
+            def constructor(**kwargs):
+                return restx_fields.Nested(lazy_reference, **kwargs)
+
     elif isinstance(field, mongo_fields.ReferenceField | mongo_fields.LazyReferenceField):
         # For reference we accept while writing a String representing the ID of the referenced model.
         # For reading, if the user supplied a `nested_fields` (RestX model), we use it to convert
@@ -230,6 +279,23 @@ def convert_db_to_field(key, field, info) -> tuple[Callable | None, Callable | N
 
         write_params["description"] = "ID of the reference"
         constructor_write = restx_fields.String
+    elif isinstance(field, mongo_fields.GenericEmbeddedDocumentField):
+        generic_fields = {
+            cls.__name__: convert_db_to_field(
+                f"{key}.{cls.__name__}",
+                # Instead of having GenericEmbeddedDocumentField() we'll create fields for each
+                # of the subclasses with EmbededdDocumentField(MembershipRequestNotificationDetails)…
+                mongoengine.fields.EmbeddedDocumentField(cls),
+                info,
+            )
+            for cls in field.choices
+        }
+
+        def constructor_read(**kwargs):
+            return GenericField({k: v[0].model for k, v in generic_fields.items()}, **kwargs)
+
+        def constructor_write(**kwargs):
+            return GenericField({k: v[1].model for k, v in generic_fields.items()}, **kwargs)
     elif isinstance(field, mongo_fields.EmbeddedDocumentField):
         nested_fields = info.get("nested_fields")
         if nested_fields is not None:
@@ -322,12 +388,12 @@ def generate_fields(**kwargs) -> Callable:
         write_fields: dict = {}
         ref_fields: dict = {}
         sortables: list = kwargs.get("additional_sorts", [])
+        default_sort: list = kwargs.get("default_sort", None)
 
         filterables: list[dict] = kwargs.get("standalone_filters", [])
         nested_filters: dict[str, dict] = get_fields_with_nested_filters(
             kwargs.get("nested_filters", {})
         )
-
         if issubclass(cls, db.Document) or issubclass(cls, db.DynamicDocument):
             read_fields["id"] = restx_fields.String(required=True, readonly=True)
 
@@ -472,6 +538,7 @@ def generate_fields(**kwargs) -> Callable:
                 type=str,
                 location="args",
                 choices=choices,
+                default=default_sort,
                 help="The field (and direction) on which sorting apply",
             )
 
@@ -511,6 +578,9 @@ def generate_fields(**kwargs) -> Callable:
                 phrase_query: str = " ".join([f'"{elem}"' for elem in args["q"].split(" ")])
                 base_query = base_query.search_text(phrase_query)
 
+                if "sort" not in request.args:
+                    base_query = base_query.order_by("$text_score")
+
             for filterable in filterables:
                 # If it's from an `nested_filter`, use the custom label instead of the key,
                 # eg use `organization_badge` instead of `organization.badges` which is
@@ -637,6 +707,19 @@ def field(
         return inner
 
 
+def run_check(check, value, key, obj, data):
+    check(
+        value,
+        **{
+            "is_creation": obj._created,
+            "is_update": not obj._created,
+            "field": key,
+            "obj": obj,
+            "data": data,
+        },
+    )
+
+
 def patch(obj, request) -> type:
     """Patch the object with the data from the request.
 
@@ -646,12 +729,16 @@ def patch(obj, request) -> type:
     from udata.mongo.engine import db
 
     data = request.json if isinstance(request, Request) else request
+
     for key, value in data.items():
         field = obj.__write_fields__.get(key)
         if field is not None and not field.readonly:
             model_attribute = getattr(obj.__class__, key)
             info = getattr(model_attribute, "__additional_field_info__", {})
 
+            if value == "" and isinstance(model_attribute, mongo_fields.StringField):
+                value = None
+
             if hasattr(model_attribute, "from_input"):
                 value = model_attribute.from_input(value)
             elif isinstance(model_attribute, mongoengine.fields.ListField) and isinstance(
@@ -677,6 +764,13 @@ def patch(obj, request) -> type:
                     value["id"],
                     document_type=db.resolve_model(value["class"]),
                 )
+            elif value and isinstance(
+                model_attribute,
+                mongoengine.fields.GenericEmbeddedDocumentField,
+            ):
+                generic_key = info.get("generic_key", DEFAULT_GENERIC_KEY)
+                embedded_field = classes_by_names[value[generic_key]]
+                value = patch(embedded_field(), value)
             elif value and isinstance(
                 model_attribute,
                 mongoengine.fields.EmbeddedDocumentField,
@@ -703,23 +797,30 @@ def patch(obj, request) -> type:
 
                 value = objects
 
-            # `checks` field attribute allows to do validation from the request before setting
-            # the attribute
+            # Run checks if value is modified.
+            # We run checks here (before setattr) to compare old vs new value.
             checks = info.get("checks", [])
-
             if is_value_modified(getattr(obj, key), value):
                 for check in checks:
-                    check(
-                        value,
-                        **{
-                            "is_creation": obj._created,
-                            "is_update": not obj._created,
-                            "field": key,
-                        },
-                    )  # TODO add other model attributes in function parameters
+                    run_check(check, value, key, obj, data)
 
             setattr(obj, key, value)
 
+    # Run checks marked with `run_even_if_missing` on fields not in request.
+    # Some checks (like `required_if`) need to run even when their field is absent
+    # from the request, because they validate cross-field constraints based on
+    # other fields in the request (e.g. "page_id is required if body_type is blocs").
+    for key, _, info in get_fields(obj.__class__):
+        if key in data:
+            continue
+        checks = info.get("checks", [])
+        value = getattr(obj, key, None)
+
+        for check in checks:
+            if not getattr(check, "run_even_if_missing", False):
+                continue
+            run_check(check, value, key, obj, data)
+
     return obj
 
 

udata/app.py

@@ -1,26 +1,28 @@
-import datetime
 import logging
 import os
 import types
+from datetime import datetime
 from importlib.metadata import entry_points
 from os.path import abspath, dirname, exists, isfile, join
 
 import bson
+from bson import json_util
 from flask import Blueprint as BaseBlueprint
 from flask import (
     Flask,
     abort,
     g,
-    json,
     jsonify,
     make_response,
     render_template,
     request,
     send_from_directory,
 )
+from flask.json.provider import DefaultJSONProvider
 from flask_caching import Cache
 from flask_wtf.csrf import CSRFProtect
-from speaklater import is_lazy_string
+from mongoengine import EmbeddedDocument
+from mongoengine.base import BaseDocument
 from werkzeug.exceptions import NotFound
 from werkzeug.middleware.proxy_fix import ProxyFix
 
@@ -108,9 +110,9 @@ class Blueprint(BaseBlueprint):
         return wrapper
 
 
-class UDataJsonEncoder(json.JSONEncoder):
+class UdataJsonProvider(DefaultJSONProvider):
     """
-    A JSONEncoder subclass to encode unsupported types:
+    A JSONProvider subclass to encode unsupported types:
 
         - ObjectId
         - datetime
@@ -120,21 +122,16 @@ class UDataJsonEncoder(json.JSONEncoder):
     Ensure an app context is always present.
     """
 
-    def default(self, obj):
-        if is_lazy_string(obj):
+    @staticmethod
+    def default(obj):
+        if isinstance(obj, BaseDocument) or isinstance(obj, EmbeddedDocument):
+            return json_util._json_convert(obj.to_mongo())
+        elif isinstance(obj, bson.ObjectId):
             return str(obj)
-        elif isinstance(obj, bson.objectid.ObjectId):
-            return str(obj)
-        elif isinstance(obj, datetime.datetime):
+        elif isinstance(obj, datetime):
             return obj.isoformat()
-        elif hasattr(obj, "to_dict"):
-            return obj.to_dict()
-        elif hasattr(obj, "serialize"):
-            return obj.serialize()
-        # Serialize Raw data for Document and EmbeddedDocument.
-        elif hasattr(obj, "_data"):
-            return obj._data
-        return super(UDataJsonEncoder, self).default(obj)
+
+        return super(UdataJsonProvider, UdataJsonProvider).default(obj)
 
 
 # These loggers are very verbose
@@ -166,10 +163,11 @@ def create_app(config="udata.settings.Defaults", override=None, init_logging=ini
     if override:
         app.config.from_object(override)
 
-    app.json_encoder = UDataJsonEncoder
+    app.json_provider_class = UdataJsonProvider
+    app.json = app.json_provider_class(app)
 
     # `ujson` doesn't support `cls` parameter https://github.com/ultrajson/ultrajson/issues/124
-    app.config["RESTX_JSON"] = {"cls": UDataJsonEncoder}
+    app.config["RESTX_JSON"] = {"default": UdataJsonProvider.default}
 
     app.debug = app.config["DEBUG"] and not app.config["TESTING"]
 

udata/auth/__init__.py

@@ -26,9 +26,6 @@ def render_security_template(template_name_or_list, **kwargs):
     return render_template(template_name_or_list, **kwargs)
 
 
-security = Security()
-
-
 class Permission(BasePermission):
     def __init__(self, *needs):
         """Let administrator bypass all permissions"""
@@ -84,15 +81,13 @@ def init_app(app):
     # Same logic as in our own mail system :DisableMail
     debug = app.config.get("DEBUG", False)
     send_mail = app.config.get("SEND_MAIL", not debug)
-    mail_util_cls = None if send_mail else NoopMailUtil
+    mail_util_cls = mail_util.MailUtil if send_mail else NoopMailUtil
 
-    security.init_app(
-        app,
+    security = Security(
         datastore,
         register_blueprint=False,
         render_template=render_security_template,
         login_form=ExtendedLoginForm,
-        confirm_register_form=ExtendedRegisterForm,
         register_form=ExtendedRegisterForm,
         reset_password_form=ExtendedResetPasswordForm,
         forgot_password_form=ExtendedForgotPasswordForm,
@@ -100,6 +95,8 @@ def init_app(app):
         mail_util_cls=mail_util_cls,
     )
 
+    security.init_app(app, datastore, register_blueprint=False)
+
     security_bp = create_security_blueprint(app, app.extensions["security"], "security_blueprint")
 
     app.register_blueprint(security_bp)

udata/auth/forms.py

@@ -8,7 +8,7 @@ from flask_security.forms import (
     ForgotPasswordForm,
     Form,
     LoginForm,
-    RegisterForm,
+    RegisterFormV2,
     ResetPasswordForm,
 )
 
@@ -31,7 +31,7 @@ class WithCaptcha:
         return False
 
 
-class ExtendedRegisterForm(WithCaptcha, RegisterForm):
+class ExtendedRegisterForm(WithCaptcha, RegisterFormV2):
     first_name = fields.StringField(
         _("First name"),
         [
@@ -49,7 +49,7 @@ class ExtendedRegisterForm(WithCaptcha, RegisterForm):
     accept_conditions = fields.BooleanField(
         _("J'accepte les conditions générales d'utilisation"),
         validators=[
-            validators.DataRequired(message=_("Vous devez accepter les CGU pour continuer."))
+            validators.DataRequired(message=_("You must accept the terms of use to continue."))
         ],
     )
 

udata/auth/views.py

@@ -57,11 +57,15 @@ def confirm_change_email_token_status(token):
         token, "confirm", get_within_delta("CONFIRM_EMAIL_WITHIN")
     )
     new_email = None
+    user = None
 
     if not invalid and token_data:
-        user, token_email_hash, new_email = token_data
-        user = _datastore.find_user(fs_uniquifier=user)
-        invalid = not verify_hash(token_email_hash, user.email)
+        user_uniquifier, token_email_hash, new_email = token_data
+        user = _datastore.find_user(fs_uniquifier=user_uniquifier)
+        if user is None:
+            invalid = True
+        else:
+            invalid = not verify_hash(token_email_hash, user.email)
 
     return expired, invalid, user, new_email
 
@@ -84,6 +88,11 @@ def confirm_change_email(token):
     if flash:
         return redirect(homepage_url(flash=flash, flash_data=flash_data))
 
+    # Check if the new email is already taken by another user
+    existing_user = _datastore.find_user(email=new_email)
+    if existing_user and existing_user.id != user.id:
+        return redirect(homepage_url(flash="change_email_already_taken"))
+
     if user != current_user:
         logout_user()
         login_user(user)
@@ -140,10 +149,8 @@ def create_security_blueprint(app, state, import_name):
     This creates an I18nBlueprint to use as a base.
     """
     bp = I18nBlueprint(
-        state.blueprint_name,
+        "security",
         import_name,
-        url_prefix=state.url_prefix,
-        subdomain=state.subdomain,
         template_folder="templates",
     )
 

udata/commands/dcat.py

@@ -85,7 +85,7 @@ def parse_url(url, csw, iso, quiet=False, rid=""):
             echo("Item kwargs: {}".format(yellow(item.kwargs)))
             node = backend.get_node_from_item(graph, item)
             dataset = MockDatasetFactory()
-            dataset = dataset_from_rdf(graph, dataset, node=node)
+            dataset = dataset_from_rdf(graph, dataset, node=node, dryrun=True)
             echo("")
             echo(green("Dataset found!"))
             echo("Title: {}".format(yellow(dataset)))

udata/commands/serve.py

@@ -3,7 +3,7 @@ import os
 
 import click
 from flask import current_app
-from flask.cli import DispatchingApp, pass_script_info
+from flask.cli import pass_script_info
 from werkzeug.serving import run_simple
 
 from udata.commands import cli
@@ -26,17 +26,11 @@ log = logging.getLogger(__name__)
     default=None,
     help="Enable or disable the debugger.  By default the debugger is active if debug is enabled.",
 )
-@click.option(
-    "--eager-loading/--lazy-loader",
-    default=None,
-    help="Enable or disable eager loading.  By default eager "
-    "loading is enabled if the reloader is disabled.",
-)
 @click.option(
     "--with-threads/--without-threads", default=True, help="Enable or disable multithreading."
 )
 @pass_script_info
-def serve(info, host, port, reload, debugger, eager_loading, with_threads):
+def serve(info, host, port, reload, debugger, with_threads):
     """
     Runs a local udata development server.
 
@@ -62,10 +56,8 @@ def serve(info, host, port, reload, debugger, eager_loading, with_threads):
         reload = bool(debug)
     if debugger is None:
         debugger = bool(debug)
-    if eager_loading is None:
-        eager_loading = not reload
 
-    app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)
+    app = info.load_app()
 
     settings = os.environ.get("UDATA_SETTINGS", os.path.join(os.getcwd(), "udata.cfg"))
     extra_files = [settings]

udata/core/activity/api.py

@@ -4,8 +4,9 @@ from bson import ObjectId
 from mongoengine.errors import DoesNotExist
 
 from udata.api import API, api, fields
-from udata.auth import current_user
+from udata.core.dataset.permissions import OwnableReadPermission
 from udata.core.organization.api_fields import org_ref_fields
+from udata.core.owned import Owned
 from udata.core.user.api_fields import user_ref_fields
 from udata.models import Activity, db
 
@@ -101,7 +102,7 @@ class SiteActivityAPI(API):
         # Always return a result even not complete
         # But log the error (ie. visible in sentry, silent for user)
         # Can happen when someone manually delete an object in DB (ie. without proper purge)
-        # - Filter out private items (except for sysadmin users)
+        # - Filter out items not visible to the current user
         safe_items = []
         for item in qs.queryset.items:
             try:
@@ -109,10 +110,8 @@ class SiteActivityAPI(API):
             except DoesNotExist as e:
                 log.error(e, exc_info=True)
             else:
-                if hasattr(item.related_to, "private") and (
-                    current_user.is_anonymous or not current_user.sysadmin
-                ):
-                    if item.related_to.private:
+                if isinstance(item.related_to, Owned):
+                    if not OwnableReadPermission(item.related_to).can():
                         continue
                 safe_items.append(item)
         qs.queryset.items = safe_items

udata/core/badges/tests/test_tasks.py

@@ -1,5 +1,3 @@
-import udata.core.dataservices.tasks  # noqa
-import udata.core.dataset.tasks  # noqa
 from udata.core.badges.tasks import update_badges
 from udata.core.constants import HVD
 from udata.core.dataservices.factories import DataserviceFactory

udata/core/csv.py

@@ -5,6 +5,7 @@ from datetime import date, datetime
 from io import StringIO
 
 from flask import Response, stream_with_context
+from mongoengine.queryset import QuerySet
 
 from udata.mongo import db
 from udata.utils import recursive_get
@@ -35,6 +36,10 @@ class Adapter(object):
     fields = None
 
     def __init__(self, queryset):
+        # no_cache() to avoid eating up too much RAM when iterating over large querysets.
+        # Applied here rather than upstream to preserve custom QuerySet methods (like with_badge).
+        if isinstance(queryset, QuerySet):
+            queryset = queryset.no_cache()
         self.queryset = queryset
         self._fields = None
 

udata/core/dataservices/api.py

@@ -12,6 +12,7 @@ from udata.auth import admin_permission
 from udata.core.access_type.constants import AccessType
 from udata.core.dataset.models import Dataset
 from udata.core.followers.api import FollowAPI
+from udata.core.legal.mails import add_send_legal_notice_argument, send_legal_notice_on_deletion
 from udata.frontend.markdown import md
 from udata.i18n import gettext as _
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
@@ -88,6 +89,9 @@ class DataservicesAtomFeedAPI(API):
         return response
 
 
+dataservice_delete_parser = add_send_legal_notice_argument(api.parser())
+
+
 @ns.route("/<dataservice:dataservice>/", endpoint="dataservice")
 class DataserviceAPI(API):
     @api.doc("get_dataservice")
@@ -123,16 +127,19 @@ class DataserviceAPI(API):
 
     @api.secure
     @api.doc("delete_dataservice")
+    @api.expect(dataservice_delete_parser)
     @api.response(204, "dataservice deleted")
     def delete(self, dataservice):
+        args = dataservice_delete_parser.parse_args()
         if dataservice.deleted_at:
             api.abort(410, "dataservice has been deleted")
 
         dataservice.permissions["delete"].test()
+        send_legal_notice_on_deletion(dataservice, args)
+
         dataservice.deleted_at = datetime.utcnow()
         dataservice.metadata_modified_at = datetime.utcnow()
         dataservice.save()
-
         return "", 204
 
 

udata/core/dataservices/apiv2.py

@@ -1,10 +1,7 @@
-from flask import request
-
 from udata import search
 from udata.api import API, apiv2
 from udata.core.access_type.models import AccessAudience
 from udata.core.dataservices.models import Dataservice, HarvestMetadata
-from udata.utils import multi_to_dict
 
 from .models import dataservice_permissions_fields
 from .search import DataserviceSearch
@@ -18,7 +15,7 @@ apiv2.inherit("AccessAudience (read)", AccessAudience.__read_fields__)
 
 ns = apiv2.namespace("dataservices", "Dataservice related operations")
 
-search_parser = DataserviceSearch.as_request_parser()
+search_parser = DataserviceSearch.as_request_parser(store_missing=False)
 
 
 @ns.route("/search/", endpoint="dataservice_search")
@@ -30,5 +27,5 @@ class DataserviceSearchAPI(API):
     @apiv2.marshal_with(Dataservice.__page_fields__)
     def get(self):
         """Search all dataservices"""
-        search_parser.parse_args()
-        return search.query(DataserviceSearch, **multi_to_dict(request.args))
+        args = search_parser.parse_args()
+        return search.query(DataserviceSearch, **args)

udata/core/dataservices/models.py

@@ -201,7 +201,10 @@ class Dataservice(
         ),
         readonly=True,
     )
-    description = field(db.StringField(default=""), description="In markdown")
+    description = field(
+        db.StringField(default=""),
+        markdown=True,
+    )
     base_api_url = field(db.URLField(), sortable=True)
 
     machine_documentation_url = field(
@@ -309,7 +312,7 @@ class Dataservice(
 
     @field(description="Link to the udata web page for this dataservice", show_as_ref=True)
     def self_web_url(self, **kwargs):
-        return cdata_url(f"/dataservices/{self._link_id(**kwargs)}/", **kwargs)
+        return cdata_url(f"/dataservices/{self._link_id(**kwargs)}", **kwargs)
 
     __metrics_keys__ = [
         "discussions",

udata/core/dataservices/rdf.py

@@ -31,6 +31,7 @@ def dataservice_from_rdf(
     node,
     all_datasets: list[Dataset],
     remote_url_prefix: str | None = None,
+    dryrun: bool = False,
 ) -> Dataservice:
     """
     Create or update a dataservice from a RDF/DCAT graph
@@ -51,7 +52,7 @@ def dataservice_from_rdf(
     dataservice.machine_documentation_url = url_from_rdf(d, DCAT.endpointDescription)
 
     roles = [  # Imbricated list of contact points for each role
-        contact_points_from_rdf(d, rdf_entity, role, dataservice)
+        contact_points_from_rdf(d, rdf_entity, role, dataservice, dryrun=dryrun)
         for rdf_entity, role in CONTACT_POINT_ENTITY_TO_ROLE.items()
     ]
     dataservice.contact_points = [  # Flattened list of contact points