udata 9.1.4__py2.py3-none-any.whl → 9.1.4.dev30965__py2.py3-none-any.whl

udata/core/reuse/api.py

@@ -1,19 +1,15 @@
 from datetime import datetime
 
-import mongoengine
 from bson.objectid import ObjectId
 from flask import request
-from flask_login import current_user
 
 from udata.api import API, api, errors
 from udata.api.parsers import ModelApiParser
-from udata.api_fields import patch, patch_and_save
 from udata.auth import admin_permission
 from udata.core.badges import api as badges_api
 from udata.core.badges.fields import badge_fields
 from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.core.followers.api import FollowAPI
-from udata.core.reuse.constants import REUSE_TOPICS, REUSE_TYPES
 from udata.core.storages.api import (
     image_parser,
     parse_uploaded_image,
@@ -23,10 +19,14 @@ from udata.models import Dataset
 from udata.utils import id_or_404
 
 from .api_fields import (
+    reuse_fields,
+    reuse_page_fields,
     reuse_suggestion_fields,
     reuse_topic_fields,
     reuse_type_fields,
 )
+from .constants import REUSE_TOPICS, REUSE_TYPES
+from .forms import ReuseForm
 from .models import Reuse
 from .permissions import ReuseEditPermission
 
@@ -96,30 +96,24 @@ reuse_parser = ReuseApiParser()
 @ns.route("/", endpoint="reuses")
 class ReuseListAPI(API):
     @api.doc("list_reuses")
-    @api.expect(Reuse.__index_parser__)
-    @api.marshal_with(Reuse.__page_fields__)
+    @api.expect(reuse_parser.parser)
+    @api.marshal_with(reuse_page_fields)
     def get(self):
-        query = Reuse.objects(deleted=None, private__ne=True)
-
-        return Reuse.apply_sort_filters_and_pagination(query)
+        args = reuse_parser.parse()
+        reuses = Reuse.objects(deleted=None, private__ne=True)
+        reuses = reuse_parser.parse_filters(reuses, args)
+        sort = args["sort"] or ("$text_score" if args["q"] else None) or DEFAULT_SORTING
+        return reuses.order_by(sort).paginate(args["page"], args["page_size"])
 
     @api.secure
     @api.doc("create_reuse")
-    @api.expect(Reuse.__write_fields__)
+    @api.expect(reuse_fields)
     @api.response(400, "Validation error")
-    @api.marshal_with(Reuse.__read_fields__, code=201)
+    @api.marshal_with(reuse_fields)
     def post(self):
-        reuse = patch(Reuse(), request)
-
-        if not reuse.owner and not reuse.organization:
-            reuse.owner = current_user._get_current_object()
-
-        try:
-            reuse.save()
-        except mongoengine.errors.ValidationError as e:
-            api.abort(400, e.message)
-
-        return patch_and_save(reuse, request), 201
+        """Create a new object"""
+        form = api.validate(ReuseForm)
+        return form.save(), 201
 
 
 @ns.route("/<reuse:reuse>/", endpoint="reuse", doc=common_doc)
@@ -127,7 +121,7 @@ class ReuseListAPI(API):
 @api.response(410, "Reuse has been deleted")
 class ReuseAPI(API):
     @api.doc("get_reuse")
-    @api.marshal_with(Reuse.__read_fields__)
+    @api.marshal_with(reuse_fields)
     def get(self, reuse):
         """Fetch a given reuse"""
         if reuse.deleted and not ReuseEditPermission(reuse).can():
@@ -136,8 +130,8 @@ class ReuseAPI(API):
 
     @api.secure
     @api.doc("update_reuse")
-    @api.expect(Reuse.__write_fields__)
-    @api.marshal_with(Reuse.__read_fields__)
+    @api.expect(reuse_fields)
+    @api.marshal_with(reuse_fields)
     @api.response(400, errors.VALIDATION_ERROR)
     def put(self, reuse):
         """Update a given reuse"""
@@ -145,9 +139,8 @@ class ReuseAPI(API):
         if reuse.deleted and request_deleted is not None:
             api.abort(410, "This reuse has been deleted")
         ReuseEditPermission(reuse).test()
-
-        # This is a patch but old API acted like PATCH on PUT requests.
-        return patch_and_save(reuse, request)
+        form = api.validate(ReuseForm, reuse)
+        return form.save()
 
     @api.secure
     @api.doc("delete_reuse")
@@ -167,8 +160,8 @@ class ReuseDatasetsAPI(API):
     @api.secure
     @api.doc("reuse_add_dataset", **common_doc)
     @api.expect(dataset_ref_fields)
-    @api.response(200, "The dataset is already present", Reuse.__read_fields__)
-    @api.marshal_with(Reuse.__read_fields__, code=201)
+    @api.response(200, "The dataset is already present", reuse_fields)
+    @api.marshal_with(reuse_fields, code=201)
     def post(self, reuse):
         """Add a dataset to a given reuse"""
         if "id" not in request.json:
@@ -218,7 +211,7 @@ class ReuseBadgeAPI(API):
 class ReuseFeaturedAPI(API):
     @api.doc("feature_reuse")
     @api.secure(admin_permission)
-    @api.marshal_with(Reuse.__read_fields__)
+    @api.marshal_with(reuse_fields)
     def post(self, reuse):
         """Mark a reuse as featured"""
         reuse.featured = True
@@ -227,7 +220,7 @@ class ReuseFeaturedAPI(API):
 
     @api.doc("unfeature_reuse")
     @api.secure(admin_permission)
-    @api.marshal_with(Reuse.__read_fields__)
+    @api.marshal_with(reuse_fields)
     def delete(self, reuse):
         """Unmark a reuse as featured"""
         reuse.featured = False

udata/core/reuse/api_fields.py

@@ -1,9 +1,108 @@
-from udata.api import api, fields
+from udata.api import api, base_reference, fields
+from udata.core.badges.fields import badge_fields
+from udata.core.dataset.api_fields import dataset_fields
+from udata.core.organization.api_fields import org_ref_fields
+from udata.core.user.api_fields import user_ref_fields
 
-from .constants import IMAGE_SIZES
+from .constants import IMAGE_SIZES, REUSE_TOPICS, REUSE_TYPES
 
 BIGGEST_IMAGE_SIZE = IMAGE_SIZES[0]
 
+
+reuse_fields = api.model(
+    "Reuse",
+    {
+        "id": fields.String(description="The reuse identifier", readonly=True),
+        "title": fields.String(description="The reuse title", required=True),
+        "slug": fields.String(description="The reuse permalink string", readonly=True),
+        "type": fields.String(description="The reuse type", required=True, enum=list(REUSE_TYPES)),
+        "url": fields.String(description="The reuse remote URL (website)", required=True),
+        "description": fields.Markdown(
+            description="The reuse description in Markdown", required=True
+        ),
+        "tags": fields.List(fields.String, description="Some keywords to help in search"),
+        "badges": fields.List(
+            fields.Nested(badge_fields), description="The reuse badges", readonly=True
+        ),
+        "topic": fields.String(
+            description="The reuse topic", required=True, enum=list(REUSE_TOPICS)
+        ),
+        "featured": fields.Boolean(description="Is the reuse featured", readonly=True),
+        "private": fields.Boolean(
+            description="Is the reuse private to the owner or the organization"
+        ),
+        "image": fields.ImageField(description="The reuse thumbnail thumbnail (cropped) URL"),
+        "image_thumbnail": fields.ImageField(
+            attribute="image",
+            size=BIGGEST_IMAGE_SIZE,
+            description="The reuse thumbnail thumbnail URL. This is the square "
+            "({0}x{0}) and cropped version.".format(BIGGEST_IMAGE_SIZE),
+        ),
+        "created_at": fields.ISODateTime(description="The reuse creation date", readonly=True),
+        "last_modified": fields.ISODateTime(
+            description="The reuse last modification date", readonly=True
+        ),
+        "deleted": fields.ISODateTime(description="The deletion date if deleted", readonly=True),
+        "archived": fields.ISODateTime(
+            description="The archivation date if archived", allow_null=True
+        ),
+        "datasets": fields.List(fields.Nested(dataset_fields), description="The reused datasets"),
+        "organization": fields.Nested(
+            org_ref_fields,
+            allow_null=True,
+            description="The publishing organization",
+            readonly=True,
+        ),
+        "owner": fields.Nested(
+            user_ref_fields, description="The owner user", readonly=True, allow_null=True
+        ),
+        "metrics": fields.Raw(
+            attribute=lambda o: o.get_metrics(), description="The reuse metrics", readonly=True
+        ),
+        "uri": fields.UrlFor(
+            "api.reuse", lambda o: {"reuse": o}, description="The reuse API URI", readonly=True
+        ),
+        "page": fields.UrlFor(
+            "reuses.show",
+            lambda o: {"reuse": o},
+            description="The reuse page URL",
+            readonly=True,
+            fallback_endpoint="api.reuse",
+        ),
+        "extras": fields.Raw(description="Extras attributes as key-value pairs"),
+    },
+    mask="*,datasets{title,uri,page}",
+)
+
+reuse_page_fields = api.model("ReusePage", fields.pager(reuse_fields))
+
+
+reuse_ref_fields = api.inherit(
+    "ReuseReference",
+    base_reference,
+    {
+        "title": fields.String(description="The reuse title", readonly=True),
+        "image": fields.ImageField(description="The reuse thumbnail thumbnail (cropped) URL"),
+        "image_thumbnail": fields.ImageField(
+            attribute="image",
+            size=BIGGEST_IMAGE_SIZE,
+            description="The reuse thumbnail thumbnail URL. This is the square "
+            "({0}x{0}) and cropped version.".format(BIGGEST_IMAGE_SIZE),
+        ),
+        "uri": fields.UrlFor(
+            "api.reuse", lambda o: {"reuse": o}, description="The reuse API URI", readonly=True
+        ),
+        "page": fields.UrlFor(
+            "reuses.show",
+            lambda o: {"reuse": o},
+            description="The reuse page URL",
+            readonly=True,
+            fallback_endpoint="api.reuse",
+        ),
+    },
+)
+
+
 reuse_type_fields = api.model(
     "ReuseType",
     {

udata/core/reuse/apiv2.py

@@ -2,13 +2,13 @@ from flask import request
 
 from udata import search
 from udata.api import API, apiv2
-from udata.core.reuse.models import Reuse
 from udata.utils import multi_to_dict
 
+from .api_fields import reuse_fields, reuse_page_fields
 from .search import ReuseSearch
 
-apiv2.inherit("ReusePage", Reuse.__page_fields__)
-apiv2.inherit("Reuse (read)", Reuse.__read_fields__)
+apiv2.inherit("ReusePage", reuse_page_fields)
+apiv2.inherit("Reuse", reuse_fields)
 
 ns = apiv2.namespace("reuses", "Reuse related operations")
 
@@ -23,7 +23,7 @@ class ReuseSearchAPI(API):
 
     @apiv2.doc("search_reuses")
     @apiv2.expect(search_parser)
-    @apiv2.marshal_with(Reuse.__page_fields__)
+    @apiv2.marshal_with(reuse_page_fields)
     def get(self):
         """Search all reuses"""
         search_parser.parse_args()

udata/core/reuse/forms.py

@@ -0,0 +1,45 @@
+from udata.core.reuse.constants import REUSE_TOPICS, REUSE_TYPES
+from udata.forms import ModelForm, fields, validators
+from udata.i18n import lazy_gettext as _
+from udata.models import Reuse
+
+from .constants import DESCRIPTION_SIZE_LIMIT, IMAGE_SIZES, TITLE_SIZE_LIMIT
+
+__all__ = ("ReuseForm",)
+
+
+def check_url_does_not_exists(form, field):
+    """Ensure a reuse URL is not yet registered"""
+    if field.data != field.object_data and Reuse.url_exists(field.data):
+        raise validators.ValidationError(_("This URL is already registered"))
+
+
+class ReuseForm(ModelForm):
+    model_class = Reuse
+
+    title = fields.StringField(
+        _("Title"), [validators.DataRequired(), validators.Length(max=TITLE_SIZE_LIMIT)]
+    )
+    description = fields.MarkdownField(
+        _("Description"),
+        [validators.DataRequired(), validators.Length(max=DESCRIPTION_SIZE_LIMIT)],
+        description=_(
+            "The details about the reuse (build process, specifics, " "self-critics...)."
+        ),
+    )
+    type = fields.SelectField(_("Type"), choices=list(REUSE_TYPES.items()))
+    url = fields.URLField(_("URL"), [validators.DataRequired(), check_url_does_not_exists])
+    image = fields.ImageField(_("Image"), sizes=IMAGE_SIZES, placeholder="reuse")
+    tags = fields.TagField(_("Tags"), description=_("Some taxonomy keywords"))
+    datasets = fields.DatasetListField(_("Used datasets"))
+    private = fields.BooleanField(
+        _("Private"),
+        description=_("Restrict the dataset visibility to you or " "your organization only."),
+    )
+    topic = fields.SelectField(_("Topic"), choices=list(REUSE_TOPICS.items()))
+
+    owner = fields.CurrentUserField()
+    organization = fields.PublishAsField(_("Publish as"))
+    deleted = fields.DateTimeField()
+    archived = fields.DateTimeField()
+    extras = fields.ExtrasField()

udata/core/reuse/models.py

@@ -2,15 +2,11 @@ from blinker import Signal
 from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
-from udata.api_fields import field, function_field, generate_fields
-from udata.core.dataset.api_fields import dataset_fields
 from udata.core.owned import Owned, OwnedQuerySet
-from udata.core.reuse.api_fields import BIGGEST_IMAGE_SIZE
 from udata.core.storages import default_image_basename, images
 from udata.frontend.markdown import mdstrip
 from udata.i18n import lazy_gettext as _
 from udata.models import BadgeMixin, WithMetrics, db
-from udata.mongo.errors import FieldValidationError
 from udata.uris import endpoint_for
 from udata.utils import hash_url
 
@@ -27,100 +23,32 @@ class ReuseQuerySet(OwnedQuerySet):
         return self(db.Q(private=True) | db.Q(datasets__0__exists=False) | db.Q(deleted__ne=None))
 
 
-def check_url_does_not_exists(url):
-    """Ensure a reuse URL is not yet registered"""
-    if url and Reuse.url_exists(url):
-        raise FieldValidationError(_("This URL is already registered"), field="url")
-
-
-@generate_fields(
-    searchable=True,
-    additionalSorts=[
-        {"key": "datasets", "value": "metrics.datasets"},
-        {"key": "followers", "value": "metrics.followers"},
-        {"key": "views", "value": "metrics.views"},
-    ],
-)
 class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
-    title = field(
-        db.StringField(required=True),
-        sortable=True,
-        show_as_ref=True,
-    )
-    slug = field(
-        db.SlugField(
-            max_length=255, required=True, populate_from="title", update=True, follow=True
-        ),
-        readonly=True,
-    )
-    description = field(
-        db.StringField(required=True),
-        markdown=True,
-    )
-    type = field(
-        db.StringField(required=True, choices=list(REUSE_TYPES)),
-        filterable={},
-    )
-    url = field(
-        db.StringField(required=True),
-        description="The remote URL (website)",
-        check=check_url_does_not_exists,
+    title = db.StringField(required=True)
+    slug = db.SlugField(
+        max_length=255, required=True, populate_from="title", update=True, follow=True
     )
+    description = db.StringField(required=True)
+    type = db.StringField(required=True, choices=list(REUSE_TYPES))
+    url = db.StringField(required=True)
     urlhash = db.StringField(required=True, unique=True)
     image_url = db.StringField()
-    image = field(
-        db.ImageField(
-            fs=images,
-            basename=default_image_basename,
-            max_size=IMAGE_MAX_SIZE,
-            thumbnails=IMAGE_SIZES,
-        ),
-        readonly=True,
-        show_as_ref=True,
-        thumbnail_info={
-            "size": BIGGEST_IMAGE_SIZE,
-        },
-    )
-    datasets = field(
-        db.ListField(
-            field(
-                db.ReferenceField("Dataset", reverse_delete_rule=db.PULL),
-                nested_fields=dataset_fields,
-            ),
-        ),
-        filterable={
-            "key": "dataset",
-        },
-    )
-    tags = field(
-        db.TagListField(),
-        filterable={
-            "key": "tag",
-        },
-    )
-    topic = field(
-        db.StringField(required=True, choices=list(REUSE_TOPICS)),
-        filterable={},
+    image = db.ImageField(
+        fs=images, basename=default_image_basename, max_size=IMAGE_MAX_SIZE, thumbnails=IMAGE_SIZES
     )
+    datasets = db.ListField(db.ReferenceField("Dataset", reverse_delete_rule=db.PULL))
+    tags = db.TagListField()
+    topic = db.StringField(required=True, choices=list(REUSE_TOPICS))
     # badges = db.ListField(db.EmbeddedDocumentField(ReuseBadge))
 
-    private = field(db.BooleanField(default=False))
+    private = db.BooleanField(default=False)
 
     ext = db.MapField(db.GenericEmbeddedDocumentField())
-    extras = field(db.ExtrasField())
+    extras = db.ExtrasField()
 
-    featured = field(
-        db.BooleanField(),
-        filterable={},
-        readonly=True,
-    )
-    deleted = field(
-        db.DateTimeField(),
-        readonly=True,
-    )
-    archived = field(
-        db.DateTimeField(),
-    )
+    featured = db.BooleanField()
+    deleted = db.DateTimeField()
+    archived = db.DateTimeField()
 
     def __str__(self):
         return self.title or ""
@@ -182,16 +110,6 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
 
     display_url = property(url_for)
 
-    @function_field(description="Link to the API endpoint for this reuse", show_as_ref=True)
-    def uri(self):
-        return endpoint_for("api.reuse", reuse=self, _external=True)
-
-    @function_field(description="Link to the udata web page for this reuse", show_as_ref=True)
-    def page(self):
-        return endpoint_for(
-            "reuses.show", reuse=self, _external=True, fallback_endpoint="api.reuse"
-        )
-
     @property
     def is_visible(self):
         return not self.is_hidden

udata/core/site/api.py

@@ -1,10 +1,12 @@
 from bson import ObjectId
 from flask import json, make_response, redirect, request, url_for
+from mongoengine import Q
 
 from udata.api import API, api, fields
 from udata.auth import admin_permission
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.api_fields import dataset_fields
+from udata.core.reuse.api_fields import reuse_fields
 from udata.models import Dataset, Reuse
 from udata.rdf import CONTEXT, RDF_EXTENSIONS, graph_response, negociate_content
 from udata.utils import multi_to_dict
@@ -60,7 +62,7 @@ class SiteHomeDatasetsAPI(API):
 class SiteHomeReusesAPI(API):
     @api.doc("get_home_reuses")
     @api.secure(admin_permission)
-    @api.marshal_list_with(Reuse.__read_fields__)
+    @api.marshal_list_with(reuse_fields)
     def get(self):
         """List homepage featured reuses"""
         return current_site.settings.home_reuses
@@ -68,7 +70,7 @@ class SiteHomeReusesAPI(API):
     @api.secure(admin_permission)
     @api.doc("set_home_reuses")
     @api.expect(([str], "Reuse IDs to put in homepage"))
-    @api.marshal_list_with(Reuse.__read_fields__)
+    @api.marshal_list_with(reuse_fields)
     def put(self):
         """Set the homepage reuses editorial selection"""
         if not isinstance(request.json, list):
@@ -106,7 +108,31 @@ class SiteRdfCatalogFormat(API):
         if "tag" in params:
             datasets = datasets.filter(tags=params.get("tag", ""))
         datasets = datasets.paginate(page, page_size)
-        dataservices = Dataservice.objects.visible().filter_by_dataset_pagination(datasets, page)
+
+        # We need to add Dataservice to the catalog.
+        # In the best world, we want:
+        # - Keep the correct number of datasets on the page (if the requested page size is 100, we should have 100 datasets)
+        # - Have simple MongoDB queries
+        # - Do not duplicate the datasets (each dataset is present once in the catalog)
+        # - Do not duplicate the dataservices (each dataservice is present once in the catalog)
+        # - Every referenced dataset for one dataservices present on the page (hard to do)
+        #
+        # Multiple solutions are possible but none check all the constraints.
+        # The selected one is to put all the dataservices referencing at least one of the dataset on
+        # the page at the end of it. It means dataservices could be duplicated (present on multiple pages)
+        # and these dataservices may referenced some datasets not present in the current page. It's working
+        # if somebody is doing the same thing as us (keeping the list of all the datasets IDs for the entire catalog then
+        # listing all dataservices in a second pass)
+        # Another option is to do some tricky Mongo requests to order/group datasets by their presence in some dataservices but
+        # it could be really hard to do with a n..n relation.
+        # Let's keep this solution simple right now and iterate on it in the future.
+        dataservices_filter = Q(datasets__in=[d.id for d in datasets])
+
+        # On the first page, add all dataservices without datasets
+        if page == 1:
+            dataservices_filter = dataservices_filter | Q(datasets__size=0)
+
+        dataservices = Dataservice.objects.visible().filter(dataservices_filter)
 
         catalog = build_catalog(current_site, datasets, dataservices=dataservices, format=format)
         # bypass flask-restplus make_response, since graph_response

udata/core/spatial/commands.py

@@ -177,8 +177,8 @@ def migrate():
 
     level_summary = "\n".join(
         [
-            " - {0}: {1}".format(geolevel.id, counter[geolevel.id])
-            for geolevel in GeoLevel.objects.order_by("admin_level")
+            " - {0}: {1}".format(l.id, counter[l.id])
+            for l in GeoLevel.objects.order_by("admin_level")
         ]
     )
     summary = "\n".join(
@@ -188,7 +188,7 @@ def migrate():
     Summary
     =======
     Processed {zones} zones in {datasets} datasets:\
-    """.format(**counter)
+    """.format(level_summary, **counter)
             ),
             level_summary,
         ]

udata/core/spatial/factories.py

@@ -2,7 +2,7 @@ import factory
 from faker.providers import BaseProvider
 from geojson.utils import generate_random
 
-from udata.factories import ModelFactory
+from udata.factories import DateRangeFactory, ModelFactory
 from udata.utils import faker_provider
 
 from . import geoids

udata/core/spatial/forms.py

@@ -62,7 +62,7 @@ class GeomField(Field):
                     self.data = geojson.loads(value)
                 else:
                     self.data = geojson.GeoJSON.to_instance(value)
-            except Exception:
+            except:
                 self.data = None
                 log.exception("Unable to parse GeoJSON")
                 raise ValueError(self.gettext("Not a valid GeoJSON"))

udata/core/spatial/models.py

@@ -120,7 +120,7 @@ class GeoZone(WithMetrics, db.Document):
 @cache.memoize()
 def get_spatial_granularities(lang):
     with language(lang):
-        return [(geolevel.id, _(geolevel.name)) for geolevel in GeoLevel.objects] + [
+        return [(l.id, _(l.name)) for l in GeoLevel.objects] + [
             (id, str(label)) for id, label in BASE_GRANULARITIES
         ]
 
@@ -130,7 +130,7 @@ spatial_granularities = LocalProxy(lambda: get_spatial_granularities(get_locale(
 
 @cache.cached(timeout=50, key_prefix="admin_levels")
 def get_spatial_admin_levels():
-    return dict((geolevel.id, geolevel.admin_level) for geolevel in GeoLevel.objects)
+    return dict((l.id, l.admin_level) for l in GeoLevel.objects)
 
 
 admin_levels = LocalProxy(get_spatial_admin_levels)

udata/core/spatial/tests/test_models.py

@@ -2,7 +2,7 @@ from datetime import timedelta
 
 from udata.tests import DBTestMixin, TestCase
 
-from ..factories import GeoZoneFactory
+from ..factories import GeoLevelFactory, GeoZoneFactory
 from ..models import GeoZone, SpatialCoverage
 
 A_YEAR = timedelta(days=365)

udata/core/spatial/translations.py

@@ -1,7 +1,5 @@
 # Here to force translations by gettext
-def _(s):
-    return s  # noqa: force translations
-
+_ = lambda s: s  # noqa: force translations
 
 TRANSLATIONS = (
     _("French region"),

udata/core/topic/api.py

@@ -2,7 +2,7 @@ from udata.api import API, api, fields
 from udata.core.dataset.api_fields import dataset_fields
 from udata.core.discussions.models import Discussion
 from udata.core.organization.api_fields import org_ref_fields
-from udata.core.reuse.models import Reuse
+from udata.core.reuse.api_fields import reuse_fields
 from udata.core.spatial.api_fields import spatial_coverage_fields
 from udata.core.topic.parsers import TopicApiParser
 from udata.core.topic.permissions import TopicEditPermission
@@ -33,7 +33,7 @@ topic_fields = api.model(
             attribute=lambda o: [d.fetch() for d in o.datasets],
         ),
         "reuses": fields.List(
-            fields.Nested(Reuse.__read_fields__),
+            fields.Nested(reuse_fields),
             description="The topic reuses",
             attribute=lambda o: [r.fetch() for r in o.reuses],
         ),

udata/core/topic/apiv2.py

@@ -10,6 +10,7 @@ from udata.core.dataset.apiv2 import dataset_page_fields
 from udata.core.dataset.models import Dataset
 from udata.core.organization.api_fields import org_ref_fields
 from udata.core.reuse.api import ReuseApiParser
+from udata.core.reuse.apiv2 import reuse_page_fields
 from udata.core.reuse.models import Reuse
 from udata.core.spatial.api_fields import spatial_coverage_fields
 from udata.core.topic.models import Topic
@@ -215,7 +216,7 @@ class TopicDatasetAPI(API):
 class TopicReusesAPI(API):
     @apiv2.doc("topic_reuses")
     @apiv2.expect(reuse_parser.parser)
-    @apiv2.marshal_with(Reuse.__page_fields__)
+    @apiv2.marshal_with(reuse_page_fields)
     def get(self, topic):
         """Get a given topic reuses, with filters"""
         args = reuse_parser.parse()