udata 9.1.2.dev30355__py2.py3-none-any.whl → 9.1.2.dev30382__py2.py3-none-any.whl

udata/core/topic/api.py

@@ -1,134 +1,145 @@
-from udata.api import api, fields, API
+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.api_fields import reuse_fields
 from udata.core.spatial.api_fields import spatial_coverage_fields
-from udata.core.topic.permissions import TopicEditPermission
 from udata.core.topic.parsers import TopicApiParser
+from udata.core.topic.permissions import TopicEditPermission
 from udata.core.user.api_fields import user_ref_fields
 
-from .models import Topic
 from .forms import TopicForm
+from .models import Topic
 
-DEFAULT_SORTING = '-created_at'
+DEFAULT_SORTING = "-created_at"
 
-ns = api.namespace('topics', 'Topics related operations')
+ns = api.namespace("topics", "Topics related operations")
 
-topic_fields = api.model('Topic', {
-    'id': fields.String(description='The topic identifier'),
-    'name': fields.String(description='The topic name', required=True),
-    'slug': fields.String(
-        description='The topic permalink string', readonly=True),
-    'description': fields.Markdown(
-        description='The topic description in Markdown', required=True),
-    'tags': fields.List(
-        fields.String, description='Some keywords to help in search', required=True),
-    'datasets': fields.List(
-        fields.Nested(dataset_fields),
-        description='The topic datasets',
-        attribute=lambda o: [d.fetch() for d in o.datasets],
-    ),
-    'reuses': fields.List(
-        fields.Nested(reuse_fields),
-        description='The topic reuses',
-        attribute=lambda o: [r.fetch() for r in o.reuses],
-    ),
-    'featured': fields.Boolean(description='Is the topic featured'),
-    'private': fields.Boolean(description='Is the topic private'),
-    'created_at': fields.ISODateTime(
-        description='The topic creation date', readonly=True),
-    'spatial': fields.Nested(
-        spatial_coverage_fields, allow_null=True,
-        description='The spatial coverage'),
-    'last_modified': fields.ISODateTime(
-        description='The topic last modification date', readonly=True),
-    '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),
-    'uri': fields.UrlFor(
-        'api.topic', lambda o: {'topic': o},
-        description='The topic API URI', readonly=True),
-    'page': fields.UrlFor(
-        'topics.display', lambda o: {'topic': o},
-        description='The topic page URL', readonly=True, fallback_endpoint='api.topic'),
-    'extras': fields.Raw(description='Extras attributes as key-value pairs'),
-}, mask='*,datasets{id,title,uri,page},reuses{id,title,image,image_thumbnail,uri,page}')
+topic_fields = api.model(
+    "Topic",
+    {
+        "id": fields.String(description="The topic identifier"),
+        "name": fields.String(description="The topic name", required=True),
+        "slug": fields.String(description="The topic permalink string", readonly=True),
+        "description": fields.Markdown(
+            description="The topic description in Markdown", required=True
+        ),
+        "tags": fields.List(
+            fields.String, description="Some keywords to help in search", required=True
+        ),
+        "datasets": fields.List(
+            fields.Nested(dataset_fields),
+            description="The topic datasets",
+            attribute=lambda o: [d.fetch() for d in o.datasets],
+        ),
+        "reuses": fields.List(
+            fields.Nested(reuse_fields),
+            description="The topic reuses",
+            attribute=lambda o: [r.fetch() for r in o.reuses],
+        ),
+        "featured": fields.Boolean(description="Is the topic featured"),
+        "private": fields.Boolean(description="Is the topic private"),
+        "created_at": fields.ISODateTime(description="The topic creation date", readonly=True),
+        "spatial": fields.Nested(
+            spatial_coverage_fields, allow_null=True, description="The spatial coverage"
+        ),
+        "last_modified": fields.ISODateTime(
+            description="The topic last modification date", readonly=True
+        ),
+        "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
+        ),
+        "uri": fields.UrlFor(
+            "api.topic", lambda o: {"topic": o}, description="The topic API URI", readonly=True
+        ),
+        "page": fields.UrlFor(
+            "topics.display",
+            lambda o: {"topic": o},
+            description="The topic page URL",
+            readonly=True,
+            fallback_endpoint="api.topic",
+        ),
+        "extras": fields.Raw(description="Extras attributes as key-value pairs"),
+    },
+    mask="*,datasets{id,title,uri,page},reuses{id,title,image,image_thumbnail,uri,page}",
+)
 
-topic_page_fields = api.model('TopicPage', fields.pager(topic_fields))
+topic_page_fields = api.model("TopicPage", fields.pager(topic_fields))
 
 topic_parser = TopicApiParser()
 
 
-@ns.route('/', endpoint='topics')
+@ns.route("/", endpoint="topics")
 class TopicsAPI(API):
     """
     Warning: querying a list with a topic containing a lot of related objects (datasets, reuses)
     will fail/take a lot of time because every object is dereferenced. Use api v2 if you can.
     """
 
-    @api.doc('list_topics')
+    @api.doc("list_topics")
     @api.expect(topic_parser.parser)
     @api.marshal_with(topic_page_fields)
     def get(self):
-        '''List all topics'''
+        """List all topics"""
         args = topic_parser.parse()
         topics = Topic.objects()
         topics = topic_parser.parse_filters(topics, args)
-        sort = args['sort'] or ('$text_score' if args['q'] else None) or DEFAULT_SORTING
-        return (topics.order_by(sort)
-                .paginate(args['page'], args['page_size']))
+        sort = args["sort"] or ("$text_score" if args["q"] else None) or DEFAULT_SORTING
+        return topics.order_by(sort).paginate(args["page"], args["page_size"])
 
-    @api.doc('create_topic')
+    @api.doc("create_topic")
     @api.expect(topic_fields)
     @api.marshal_with(topic_fields)
-    @api.response(400, 'Validation error')
+    @api.response(400, "Validation error")
     def post(self):
-        '''Create a topic'''
+        """Create a topic"""
         form = api.validate(TopicForm)
         return form.save(), 201
 
 
-@ns.route('/<topic:topic>/', endpoint='topic')
-@api.param('topic', 'The topic ID or slug')
-@api.response(404, 'Object not found')
+@ns.route("/<topic:topic>/", endpoint="topic")
+@api.param("topic", "The topic ID or slug")
+@api.response(404, "Object not found")
 class TopicAPI(API):
     """
     Warning: querying a topic containing a lot of related objects (datasets, reuses)
     will fail/take a lot of time because every object is dereferenced. Use api v2 if you can.
     """
 
-    @api.doc('get_topic')
+    @api.doc("get_topic")
     @api.marshal_with(topic_fields)
     def get(self, topic):
-        '''Get a given topic'''
+        """Get a given topic"""
         return topic
 
     @api.secure
-    @api.doc('update_topic')
+    @api.doc("update_topic")
     @api.expect(topic_fields)
     @api.marshal_with(topic_fields)
-    @api.response(400, 'Validation error')
-    @api.response(403, 'Forbidden')
+    @api.response(400, "Validation error")
+    @api.response(403, "Forbidden")
     def put(self, topic):
-        '''Update a given topic'''
+        """Update a given topic"""
         if not TopicEditPermission(topic).can():
-            api.abort(403, 'Forbidden')
+            api.abort(403, "Forbidden")
         form = api.validate(TopicForm, topic)
         return form.save()
 
     @api.secure
-    @api.doc('delete_topic')
-    @api.response(204, 'Object deleted')
-    @api.response(403, 'Forbidden')
+    @api.doc("delete_topic")
+    @api.response(204, "Object deleted")
+    @api.response(403, "Forbidden")
     def delete(self, topic):
-        '''Delete a given topic'''
+        """Delete a given topic"""
         if not TopicEditPermission(topic).can():
-            api.abort(403, 'Forbidden')
+            api.abort(403, "Forbidden")
         # Remove discussions linked to the topic
         Discussion.objects(subject=topic).delete()
         topic.delete()
-        return '', 204
+        return "", 204

udata/core/topic/apiv2.py

@@ -1,11 +1,10 @@
 import logging
 
 import mongoengine
-
 from bson import ObjectId
-from flask import url_for, request
+from flask import request, url_for
 
-from udata.api import apiv2, API, fields
+from udata.api import API, apiv2, fields
 from udata.core.dataset.api import DatasetApiParser
 from udata.core.dataset.apiv2 import dataset_page_fields
 from udata.core.dataset.models import Dataset
@@ -19,142 +18,169 @@ from udata.core.topic.parsers import TopicApiParser
 from udata.core.topic.permissions import TopicEditPermission
 from udata.core.user.api_fields import user_ref_fields
 
-DEFAULT_SORTING = '-created_at'
+DEFAULT_SORTING = "-created_at"
 DEFAULT_PAGE_SIZE = 20
 
 log = logging.getLogger(__name__)
 
-ns = apiv2.namespace('topics', 'Topics related operations')
+ns = apiv2.namespace("topics", "Topics related operations")
 
 topic_parser = TopicApiParser()
 generic_parser = apiv2.page_parser()
 dataset_parser = DatasetApiParser()
 reuse_parser = ReuseApiParser()
 
-common_doc = {
-    'params': {'topic': 'The topic ID'}
-}
-
-
-topic_fields = apiv2.model('Topic', {
-    'id': fields.String(description='The topic identifier'),
-    'name': fields.String(description='The topic name', required=True),
-    'slug': fields.String(
-        description='The topic permalink string', readonly=True),
-    'description': fields.Markdown(
-        description='The topic description in Markdown', required=True),
-    'tags': fields.List(
-        fields.String, description='Some keywords to help in search', required=True),
-
-    'datasets': fields.Raw(attribute=lambda o: {
-        'rel': 'subsection',
-        'href': url_for('apiv2.topic_datasets', topic=o.id, page=1,
-                        page_size=DEFAULT_PAGE_SIZE, _external=True),
-        'type': 'GET',
-        'total': len(o.datasets)
-        }, description='Link to the topic datasets'),
-    'reuses': fields.Raw(attribute=lambda o: {
-        'rel': 'subsection',
-        'href': url_for('apiv2.topic_reuses', topic=o.id, page=1,
-                        page_size=DEFAULT_PAGE_SIZE, _external=True),
-        'type': 'GET',
-        'total': len(o.reuses)
-        }, description='Link to the topic reuses'),
-    'featured': fields.Boolean(description='Is the topic featured'),
-    'private': fields.Boolean(description='Is the topic private'),
-    'created_at': fields.ISODateTime(
-        description='The topic creation date', readonly=True),
-    'spatial': fields.Nested(
-        spatial_coverage_fields, allow_null=True,
-        description='The spatial coverage'),
-    'last_modified': fields.ISODateTime(
-        description='The topic last modification date', readonly=True),
-    '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),
-    'uri': fields.UrlFor(
-        'api.topic', lambda o: {'topic': o},
-        description='The topic API URI', readonly=True),
-    'page': fields.UrlFor(
-        'topics.display', lambda o: {'topic': o},
-        description='The topic page URL', readonly=True, fallback_endpoint='api.topic'),
-    'extras': fields.Raw(description='Extras attributes as key-value pairs'),
-})
-
-topic_page_fields = apiv2.model('TopicPage', fields.pager(topic_fields))
-
-
-@ns.route('/', endpoint='topics_list')
+common_doc = {"params": {"topic": "The topic ID"}}
+
+
+topic_fields = apiv2.model(
+    "Topic",
+    {
+        "id": fields.String(description="The topic identifier"),
+        "name": fields.String(description="The topic name", required=True),
+        "slug": fields.String(description="The topic permalink string", readonly=True),
+        "description": fields.Markdown(
+            description="The topic description in Markdown", required=True
+        ),
+        "tags": fields.List(
+            fields.String, description="Some keywords to help in search", required=True
+        ),
+        "datasets": fields.Raw(
+            attribute=lambda o: {
+                "rel": "subsection",
+                "href": url_for(
+                    "apiv2.topic_datasets",
+                    topic=o.id,
+                    page=1,
+                    page_size=DEFAULT_PAGE_SIZE,
+                    _external=True,
+                ),
+                "type": "GET",
+                "total": len(o.datasets),
+            },
+            description="Link to the topic datasets",
+        ),
+        "reuses": fields.Raw(
+            attribute=lambda o: {
+                "rel": "subsection",
+                "href": url_for(
+                    "apiv2.topic_reuses",
+                    topic=o.id,
+                    page=1,
+                    page_size=DEFAULT_PAGE_SIZE,
+                    _external=True,
+                ),
+                "type": "GET",
+                "total": len(o.reuses),
+            },
+            description="Link to the topic reuses",
+        ),
+        "featured": fields.Boolean(description="Is the topic featured"),
+        "private": fields.Boolean(description="Is the topic private"),
+        "created_at": fields.ISODateTime(description="The topic creation date", readonly=True),
+        "spatial": fields.Nested(
+            spatial_coverage_fields, allow_null=True, description="The spatial coverage"
+        ),
+        "last_modified": fields.ISODateTime(
+            description="The topic last modification date", readonly=True
+        ),
+        "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
+        ),
+        "uri": fields.UrlFor(
+            "api.topic", lambda o: {"topic": o}, description="The topic API URI", readonly=True
+        ),
+        "page": fields.UrlFor(
+            "topics.display",
+            lambda o: {"topic": o},
+            description="The topic page URL",
+            readonly=True,
+            fallback_endpoint="api.topic",
+        ),
+        "extras": fields.Raw(description="Extras attributes as key-value pairs"),
+    },
+)
+
+topic_page_fields = apiv2.model("TopicPage", fields.pager(topic_fields))
+
+
+@ns.route("/", endpoint="topics_list")
 class TopicsAPI(API):
     @apiv2.expect(topic_parser.parser)
     @apiv2.marshal_with(topic_page_fields)
     def get(self):
-        '''List all topics'''
+        """List all topics"""
         args = topic_parser.parse()
         topics = Topic.objects()
         topics = topic_parser.parse_filters(topics, args)
-        sort = args['sort'] or ('$text_score' if args['q'] else None) or DEFAULT_SORTING
-        return (topics.order_by(sort)
-                .paginate(args['page'], args['page_size']))
+        sort = args["sort"] or ("$text_score" if args["q"] else None) or DEFAULT_SORTING
+        return topics.order_by(sort).paginate(args["page"], args["page_size"])
 
 
-@ns.route('/<topic:topic>/', endpoint='topic', doc=common_doc)
-@apiv2.response(404, 'Topic not found')
+@ns.route("/<topic:topic>/", endpoint="topic", doc=common_doc)
+@apiv2.response(404, "Topic not found")
 class TopicAPI(API):
-    @apiv2.doc('get_topic')
+    @apiv2.doc("get_topic")
     @apiv2.marshal_with(topic_fields)
     def get(self, topic):
-        '''Get a given topic'''
+        """Get a given topic"""
         return topic
 
 
-topic_add_items_fields = apiv2.model('TopicItemsAdd', {
-    'id': fields.String(description='Id of the item to add', required=True),
-}, location='json')
+topic_add_items_fields = apiv2.model(
+    "TopicItemsAdd",
+    {
+        "id": fields.String(description="Id of the item to add", required=True),
+    },
+    location="json",
+)
 
 
-@ns.route('/<topic:topic>/datasets/', endpoint='topic_datasets', doc=common_doc)
+@ns.route("/<topic:topic>/datasets/", endpoint="topic_datasets", doc=common_doc)
 class TopicDatasetsAPI(API):
-    @apiv2.doc('topic_datasets')
+    @apiv2.doc("topic_datasets")
     @apiv2.expect(dataset_parser.parser)
     @apiv2.marshal_with(dataset_page_fields)
     def get(self, topic):
-        '''Get a given topic datasets, with filters'''
+        """Get a given topic datasets, with filters"""
         args = dataset_parser.parse()
-        args['topic'] = topic.id
+        args["topic"] = topic.id
         datasets = Dataset.objects(archived=None, deleted=None, private=False)
         datasets = dataset_parser.parse_filters(datasets, args)
-        sort = args['sort'] or ('$text_score' if args['q'] else None) or '-created_at_internal'
-        return datasets.order_by(sort).paginate(args['page'], args['page_size'])
+        sort = args["sort"] or ("$text_score" if args["q"] else None) or "-created_at_internal"
+        return datasets.order_by(sort).paginate(args["page"], args["page_size"])
 
     @apiv2.secure
-    @apiv2.doc('topic_datasets_create')
+    @apiv2.doc("topic_datasets_create")
     @apiv2.expect([topic_add_items_fields])
     @apiv2.marshal_with(topic_fields)
-    @apiv2.response(400, 'Malformed object id(s) in request')
-    @apiv2.response(400, 'Expecting a list')
-    @apiv2.response(400, 'Expecting a list of dicts with id attribute')
-    @apiv2.response(404, 'Topic not found')
-    @apiv2.response(403, 'Forbidden')
+    @apiv2.response(400, "Malformed object id(s) in request")
+    @apiv2.response(400, "Expecting a list")
+    @apiv2.response(400, "Expecting a list of dicts with id attribute")
+    @apiv2.response(404, "Topic not found")
+    @apiv2.response(403, "Forbidden")
     def post(self, topic):
         if not TopicEditPermission(topic).can():
-            apiv2.abort(403, 'Forbidden')
+            apiv2.abort(403, "Forbidden")
 
         data = request.json
 
         if not isinstance(data, list):
-            apiv2.abort(400, 'Expecting a list')
-        if not all(isinstance(d, dict) and d.get('id') for d in data):
-            apiv2.abort(400, 'Expecting a list of dicts with id attribute')
+            apiv2.abort(400, "Expecting a list")
+        if not all(isinstance(d, dict) and d.get("id") for d in data):
+            apiv2.abort(400, "Expecting a list of dicts with id attribute")
 
         try:
-            datasets = Dataset.objects.filter(id__in=[d['id'] for d in data]).only('id')
+            datasets = Dataset.objects.filter(id__in=[d["id"] for d in data]).only("id")
             diff = set(d.id for d in datasets) - set(d.id for d in topic.datasets)
         except mongoengine.errors.ValidationError:
-            apiv2.abort(400, 'Malformed object id(s) in request')
+            apiv2.abort(400, "Malformed object id(s) in request")
 
         if diff:
             topic.datasets += [ObjectId(did) for did in diff]
@@ -163,69 +189,71 @@ class TopicDatasetsAPI(API):
         return topic, 201
 
 
-@ns.route('/<topic:topic>/datasets/<dataset:dataset>/', endpoint='topic_dataset', doc={
-    'params': {'topic': 'The topic ID', 'dataset': 'The dataset ID'}
-})
+@ns.route(
+    "/<topic:topic>/datasets/<dataset:dataset>/",
+    endpoint="topic_dataset",
+    doc={"params": {"topic": "The topic ID", "dataset": "The dataset ID"}},
+)
 class TopicDatasetAPI(API):
     @apiv2.secure
-    @apiv2.response(404, 'Topic not found')
-    @apiv2.response(404, 'Dataset not found in topic')
-    @apiv2.response(204, 'Success')
+    @apiv2.response(404, "Topic not found")
+    @apiv2.response(404, "Dataset not found in topic")
+    @apiv2.response(204, "Success")
     def delete(self, topic, dataset):
-        '''Delete a given dataset from the given topic'''
+        """Delete a given dataset from the given topic"""
         if not TopicEditPermission(topic).can():
-            apiv2.abort(403, 'Forbidden')
+            apiv2.abort(403, "Forbidden")
 
         if dataset.id not in (d.id for d in topic.datasets):
-            apiv2.abort(404, 'Dataset not found in topic')
+            apiv2.abort(404, "Dataset not found in topic")
         topic.datasets = [d for d in topic.datasets if d.id != dataset.id]
         topic.save()
 
         return None, 204
 
 
-@ns.route('/<topic:topic>/reuses/', endpoint='topic_reuses', doc=common_doc)
+@ns.route("/<topic:topic>/reuses/", endpoint="topic_reuses", doc=common_doc)
 class TopicReusesAPI(API):
-    @apiv2.doc('topic_reuses')
+    @apiv2.doc("topic_reuses")
     @apiv2.expect(reuse_parser.parser)
     @apiv2.marshal_with(reuse_page_fields)
     def get(self, topic):
-        '''Get a given topic reuses, with filters'''
+        """Get a given topic reuses, with filters"""
         args = reuse_parser.parse()
         reuses = Reuse.objects(deleted=None, private__ne=True).filter(
             id__in=[d.id for d in topic.reuses]
         )
         # warning: topic in reuse_parser is different from Topic
         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'])
+        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"])
 
     @apiv2.secure
-    @apiv2.doc('topic_reuses_create')
+    @apiv2.doc("topic_reuses_create")
     @apiv2.expect([topic_add_items_fields])
     @apiv2.marshal_with(topic_fields)
-    @apiv2.response(400, 'Malformed object id(s) in request')
-    @apiv2.response(400, 'Expecting a list')
-    @apiv2.response(400, 'Expecting a list of dicts with id attribute')
-    @apiv2.response(404, 'Topic not found')
-    @apiv2.response(403, 'Forbidden')
+    @apiv2.response(400, "Malformed object id(s) in request")
+    @apiv2.response(400, "Expecting a list")
+    @apiv2.response(400, "Expecting a list of dicts with id attribute")
+    @apiv2.response(404, "Topic not found")
+    @apiv2.response(403, "Forbidden")
     def post(self, topic):
-        '''Add reuses to a given topic from a list of reuses ids'''
+        """Add reuses to a given topic from a list of reuses ids"""
         if not TopicEditPermission(topic).can():
-            apiv2.abort(403, 'Forbidden')
+            apiv2.abort(403, "Forbidden")
 
         data = request.json
 
         if not isinstance(data, list):
-            apiv2.abort(400, 'Expecting a list')
-        if not all(isinstance(d, dict) and d.get('id') for d in data):
-            apiv2.abort(400, 'Expecting a list of dicts with id attribute')
+            apiv2.abort(400, "Expecting a list")
+        if not all(isinstance(d, dict) and d.get("id") for d in data):
+            apiv2.abort(400, "Expecting a list of dicts with id attribute")
 
         try:
-            reuses = Reuse.objects.filter(id__in=[r['id'] for r in data]).only('id')
+            reuses = Reuse.objects.filter(id__in=[r["id"] for r in data]).only("id")
             diff = set(d.id for d in reuses) - set(d.id for d in topic.reuses)
         except mongoengine.errors.ValidationError:
-            apiv2.abort(400, 'Malformed object id(s) in request')
+            apiv2.abort(400, "Malformed object id(s) in request")
 
         if diff:
             topic.reuses += [ObjectId(rid) for rid in diff]
@@ -234,21 +262,23 @@ class TopicReusesAPI(API):
         return topic, 201
 
 
-@ns.route('/<topic:topic>/reuses/<reuse:reuse>/', endpoint='topic_reuse', doc={
-    'params': {'topic': 'The topic ID', 'reuse': 'The reuse ID'}
-})
+@ns.route(
+    "/<topic:topic>/reuses/<reuse:reuse>/",
+    endpoint="topic_reuse",
+    doc={"params": {"topic": "The topic ID", "reuse": "The reuse ID"}},
+)
 class TopicReuseAPI(API):
     @apiv2.secure
-    @apiv2.response(404, 'Topic not found')
-    @apiv2.response(404, 'Reuse not found in topic')
-    @apiv2.response(204, 'Success')
+    @apiv2.response(404, "Topic not found")
+    @apiv2.response(404, "Reuse not found in topic")
+    @apiv2.response(204, "Success")
     def delete(self, topic, reuse):
-        '''Delete a given reuse from the given topic'''
+        """Delete a given reuse from the given topic"""
         if not TopicEditPermission(topic).can():
-            apiv2.abort(403, 'Forbidden')
+            apiv2.abort(403, "Forbidden")
 
         if reuse.id not in (d.id for d in topic.reuses):
-            apiv2.abort(404, 'Reuse not found in topic')
+            apiv2.abort(404, "Reuse not found in topic")
         topic.reuses = [d for d in topic.reuses if d.id != reuse.id]
         topic.save()
 

udata/core/topic/factories.py

@@ -12,10 +12,9 @@ class TopicFactory(ModelFactory):
     class Meta:
         model = Topic
 
-    name = factory.Faker('sentence')
-    description = factory.Faker('text')
-    tags = factory.LazyAttribute(lambda o: [utils.unique_string(16)
-                                 for _ in range(3)])
+    name = factory.Faker("sentence")
+    description = factory.Faker("text")
+    tags = factory.LazyAttribute(lambda o: [utils.unique_string(16) for _ in range(3)])
     private = False
 
     @factory.lazy_attribute