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

udata/core/post/forms.py

@@ -1,11 +1,10 @@
 from udata.forms import ModelForm, fields, validators, widgets
 from udata.i18n import lazy_gettext as _
 
-from .models import Post
 from .constants import IMAGE_SIZES
+from .models import Post
 
-
-__all__ = ('PostForm', )
+__all__ = ("PostForm",)
 
 
 class PostForm(ModelForm):
@@ -13,19 +12,19 @@ class PostForm(ModelForm):
 
     owner = fields.CurrentUserField()
 
-    name = fields.StringField(_('Name'), [validators.DataRequired()])
-    headline = fields.StringField(_('Headline'), widget=widgets.TextArea())
-    content = fields.MarkdownField(_('Content'), [validators.DataRequired()])
+    name = fields.StringField(_("Name"), [validators.DataRequired()])
+    headline = fields.StringField(_("Headline"), widget=widgets.TextArea())
+    content = fields.MarkdownField(_("Content"), [validators.DataRequired()])
 
-    datasets = fields.DatasetListField(_('Associated datasets'))
-    reuses = fields.ReuseListField(_('Associated reuses'))
+    datasets = fields.DatasetListField(_("Associated datasets"))
+    reuses = fields.ReuseListField(_("Associated reuses"))
 
-    image = fields.ImageField(_('Image'), sizes=IMAGE_SIZES)
-    credit_to = fields.StringField(_('Image credits'))
-    credit_url = fields.URLField(_('Credit URL'))
+    image = fields.ImageField(_("Image"), sizes=IMAGE_SIZES)
+    credit_to = fields.StringField(_("Image credits"))
+    credit_url = fields.URLField(_("Credit URL"))
 
-    tags = fields.TagField(_('Tags'))
+    tags = fields.TagField(_("Tags"))
 
     body_type = fields.StringField(
-        _('body type'),
-        description=_('Specify your body type (HTML or markdown)'))
+        _("body type"), description=_("Specify your body type (HTML or markdown)")
+    )

udata/core/post/models.py

@@ -1,59 +1,57 @@
 from flask import url_for
 
-from udata.core.storages import images, default_image_basename
+from udata.core.storages import default_image_basename, images
 from udata.i18n import lazy_gettext as _
 from udata.mongo import db
+
 from .constants import BODY_TYPES, IMAGE_SIZES
 
-__all__ = ('Post', )
+__all__ = ("Post",)
 
 
 class PostQuerySet(db.BaseQuerySet):
     def published(self):
-        return self(published__ne=None).order_by('-published')
+        return self(published__ne=None).order_by("-published")
 
 
 class Post(db.Datetimed, db.Document):
     name = db.StringField(max_length=255, required=True)
-    slug = db.SlugField(max_length=255, required=True, populate_from='name',
-                        update=True, follow=True)
+    slug = db.SlugField(
+        max_length=255, required=True, populate_from="name", update=True, follow=True
+    )
     headline = db.StringField()
     content = db.StringField(required=True)
     image_url = db.StringField()
-    image = db.ImageField(
-        fs=images, basename=default_image_basename, thumbnails=IMAGE_SIZES)
+    image = db.ImageField(fs=images, basename=default_image_basename, thumbnails=IMAGE_SIZES)
 
     credit_to = db.StringField()
     credit_url = db.URLField()
 
     tags = db.ListField(db.StringField())
-    datasets = db.ListField(
-        db.ReferenceField('Dataset', reverse_delete_rule=db.PULL))
-    reuses = db.ListField(
-        db.ReferenceField('Reuse', reverse_delete_rule=db.PULL))
+    datasets = db.ListField(db.ReferenceField("Dataset", reverse_delete_rule=db.PULL))
+    reuses = db.ListField(db.ReferenceField("Reuse", reverse_delete_rule=db.PULL))
 
-    owner = db.ReferenceField('User')
+    owner = db.ReferenceField("User")
     published = db.DateTimeField()
 
-    body_type = db.StringField(
-        choices=list(BODY_TYPES), default='markdown', required=False)
+    body_type = db.StringField(choices=list(BODY_TYPES), default="markdown", required=False)
 
     meta = {
-        'ordering': ['-created_at'],
-        'indexes': [
-            '-created_at',
-            '-published',
+        "ordering": ["-created_at"],
+        "indexes": [
+            "-created_at",
+            "-published",
         ],
-        'queryset_class': PostQuerySet,
+        "queryset_class": PostQuerySet,
     }
 
-    verbose_name = _('post')
+    verbose_name = _("post")
 
     def __str__(self):
-        return self.name or ''
+        return self.name or ""
 
     def url_for(self, *args, **kwargs):
-        return url_for('posts.show', post=self, *args, **kwargs)
+        return url_for("posts.show", post=self, *args, **kwargs)
 
     @property
     def display_url(self):

udata/core/post/tests/test_api.py

@@ -1,5 +1,4 @@
 import pytest
-
 from flask import url_for
 
 from udata.core.dataset.factories import DatasetFactory
@@ -7,90 +6,89 @@ from udata.core.post.factories import PostFactory
 from udata.core.post.models import Post
 from udata.core.reuse.factories import ReuseFactory
 from udata.core.user.factories import AdminFactory
-
 from udata.tests.helpers import assert200, assert201, assert204
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class PostsAPITest:
     modules = []
 
     def test_post_api_list(self, api):
-        '''It should fetch a post list from the API'''
+        """It should fetch a post list from the API"""
         posts = PostFactory.create_batch(3)
         posts.append(PostFactory(published=None))
 
-        response = api.get(url_for('api.posts'))
+        response = api.get(url_for("api.posts"))
         assert200(response)
         # Response should not contain the unpublished post
-        assert len(response.json['data']) == 3
+        assert len(response.json["data"]) == 3
 
     def test_post_api_get(self, api):
-        '''It should fetch a post from the API'''
+        """It should fetch a post from the API"""
         post = PostFactory()
-        response = api.get(url_for('api.post', post=post))
+        response = api.get(url_for("api.post", post=post))
         assert200(response)
 
     def test_post_api_create(self, api):
-        '''It should create a post from the API'''
+        """It should create a post from the API"""
         data = PostFactory.as_dict()
-        data['datasets'] = [str(d.id) for d in data['datasets']]
-        data['reuses'] = [str(r.id) for r in data['reuses']]
+        data["datasets"] = [str(d.id) for d in data["datasets"]]
+        data["reuses"] = [str(r.id) for r in data["reuses"]]
         api.login(AdminFactory())
-        response = api.post(url_for('api.posts'), data)
+        response = api.post(url_for("api.posts"), data)
         assert201(response)
         assert Post.objects.count() == 1
         post = Post.objects.first()
-        for dataset, expected in zip(post.datasets, data['datasets']):
+        for dataset, expected in zip(post.datasets, data["datasets"]):
             assert str(dataset.id) == expected
-        for reuse, expected in zip(post.reuses, data['reuses']):
+        for reuse, expected in zip(post.reuses, data["reuses"]):
             assert str(reuse.id) == expected
 
     def test_post_api_update(self, api):
-        '''It should update a post from the API'''
+        """It should update a post from the API"""
         post = PostFactory()
         data = post.to_dict()
-        data['content'] = 'new content'
+        data["content"] = "new content"
         api.login(AdminFactory())
-        response = api.put(url_for('api.post', post=post), data)
+        response = api.put(url_for("api.post", post=post), data)
         assert200(response)
         assert Post.objects.count() == 1
-        assert Post.objects.first().content == 'new content'
+        assert Post.objects.first().content == "new content"
 
     def test_post_api_update_with_related_dataset_and_reuse(self, api):
-        '''It should update a post from the API with related dataset and reuse'''
+        """It should update a post from the API with related dataset and reuse"""
         api.login(AdminFactory())
         post = PostFactory()
         data = post.to_dict()
-        data['content'] = 'new content'
+        data["content"] = "new content"
 
         # Add datasets
-        data['datasets'] = [DatasetFactory().to_dict()]
-        response = api.put(url_for('api.post', post=post), data)
+        data["datasets"] = [DatasetFactory().to_dict()]
+        response = api.put(url_for("api.post", post=post), data)
         assert200(response)
 
         # Add reuses to the post value returned by the previous api call
         data = response.json
-        data['reuses'] = [ReuseFactory().to_dict()]
-        response = api.put(url_for('api.post', post=post), data)
+        data["reuses"] = [ReuseFactory().to_dict()]
+        response = api.put(url_for("api.post", post=post), data)
         assert200(response)
 
-        assert len(response.json['datasets']) == 1
-        assert len(response.json['reuses']) == 1
+        assert len(response.json["datasets"]) == 1
+        assert len(response.json["reuses"]) == 1
 
     def test_post_api_delete(self, api):
-        '''It should delete a post from the API'''
+        """It should delete a post from the API"""
         post = PostFactory()
         with api.user(AdminFactory()):
-            response = api.delete(url_for('api.post', post=post))
+            response = api.delete(url_for("api.post", post=post))
         assert204(response)
         assert Post.objects.count() == 0
 
     def test_post_api_publish(self, api):
-        '''It should update a post from the API'''
+        """It should update a post from the API"""
         post = PostFactory(published=None)
         api.login(AdminFactory())
-        response = api.post(url_for('api.publish_post', post=post))
+        response = api.post(url_for("api.publish_post", post=post))
         assert200(response)
         assert Post.objects.count() == 1
 
@@ -98,10 +96,10 @@ class PostsAPITest:
         assert post.published is not None
 
     def test_post_api_unpublish(self, api):
-        '''It should update a post from the API'''
+        """It should update a post from the API"""
         post = PostFactory()
         api.login(AdminFactory())
-        response = api.delete(url_for('api.publish_post', post=post))
+        response = api.delete(url_for("api.publish_post", post=post))
         assert200(response)
         assert Post.objects.count() == 1
 

udata/core/reports/api.py

@@ -8,11 +8,12 @@ from udata.api_fields import patch
 from .constants import reports_reasons_translations
 from .models import Report
 
-ns = api.namespace('reports', 'User reported objects related operations (beta)')
+ns = api.namespace("reports", "User reported objects related operations (beta)")
 
-@ns.route('/', endpoint='reports')
+
+@ns.route("/", endpoint="reports")
 class ReportsAPI(API):
-    @api.doc('list_reports')
+    @api.doc("list_reports")
     @api.expect(Report.__index_parser__)
     @api.marshal_with(Report.__page_fields__)
     def get(self):
@@ -21,7 +22,7 @@ class ReportsAPI(API):
         return Report.apply_sort_filters_and_pagination(query)
 
     @api.secure
-    @api.doc('create_report', responses={400: 'Validation error'})
+    @api.doc("create_report", responses={400: "Validation error"})
     @api.expect(Report.__write_fields__)
     @api.marshal_with(Report.__read_fields__, code=201)
     def post(self):
@@ -34,11 +35,11 @@ class ReportsAPI(API):
             api.abort(400, e.message)
 
         return report, 201
-    
 
-@ns.route('/reasons/', endpoint='reports_reasons')
+
+@ns.route("/reasons/", endpoint="reports_reasons")
 class ReportsReasonsAPI(API):
-    @api.doc('list_reports_reasons')
+    @api.doc("list_reports_reasons")
     @ns.response(200, "list of available reasons associated with their labels", fields.Raw)
     def get(self):
         return reports_reasons_translations()

udata/core/reports/constants.py

@@ -24,7 +24,5 @@ def reports_reasons_translations() -> list:
     ]
 
 
-REPORT_REASONS_CHOICES: list[str] = [
-    item["value"] for item in reports_reasons_translations()
-]
+REPORT_REASONS_CHOICES: list[str] = [item["value"] for item in reports_reasons_translations()]
 REPORTABLE_MODELS = [Dataset]

udata/core/reports/models.py

@@ -20,12 +20,8 @@ class Report(db.Document):
         allow_null=True,
     )
 
-    object_type = field(
-        db.StringField(choices=[m.__name__ for m in REPORTABLE_MODELS])
-    )
-    object_id = field(
-        db.ObjectIdField()
-    )
+    object_type = field(db.StringField(choices=[m.__name__ for m in REPORTABLE_MODELS]))
+    object_id = field(db.ObjectIdField())
     object_deleted_at = field(
         db.DateTimeField(),
         allow_null=True,
@@ -47,12 +43,16 @@ class Report(db.Document):
     @classmethod
     def mark_as_deleted_soft_delete(cls, sender, document, **kwargs):
         if document.deleted:
-            Report.objects(object_type=sender.__name__, object_id=document.id, object_deleted_at=None).update(object_deleted_at=datetime.utcnow)
-    
+            Report.objects(
+                object_type=sender.__name__, object_id=document.id, object_deleted_at=None
+            ).update(object_deleted_at=datetime.utcnow)
+
     def mark_as_deleted_hard_delete(cls, document, **kwargs):
-        Report.objects(object_type=document.__class__.__name__, object_id=document.id, object_deleted_at=None).update(object_deleted_at=datetime.utcnow)
+        Report.objects(
+            object_type=document.__class__.__name__, object_id=document.id, object_deleted_at=None
+        ).update(object_deleted_at=datetime.utcnow)
 
 
 for model in REPORTABLE_MODELS:
     signals.post_save.connect(Report.mark_as_deleted_soft_delete, sender=model)
-    signals.post_delete.connect(Report.mark_as_deleted_hard_delete, sender=model)
+    signals.post_delete.connect(Report.mark_as_deleted_hard_delete, sender=model)

udata/core/reuse/activities.py

@@ -1,38 +1,34 @@
 from flask_security import current_user
 
 from udata.i18n import lazy_gettext as _
-from udata.models import db, Reuse, Activity
+from udata.models import Activity, Reuse, db
 
-
-__all__ = (
-    'UserCreatedReuse', 'UserUpdatedReuse', 'UserDeletedReuse',
-    'ReuseRelatedActivity'
-)
+__all__ = ("UserCreatedReuse", "UserUpdatedReuse", "UserDeletedReuse", "ReuseRelatedActivity")
 
 
 class ReuseRelatedActivity(object):
-    template = 'activity/reuse.html'
-    related_to = db.ReferenceField('Reuse')
+    template = "activity/reuse.html"
+    related_to = db.ReferenceField("Reuse")
 
 
 class UserCreatedReuse(ReuseRelatedActivity, Activity):
-    key = 'reuse:created'
-    icon = 'fa fa-plus'
-    badge_type = 'success'
-    label = _('created a reuse')
+    key = "reuse:created"
+    icon = "fa fa-plus"
+    badge_type = "success"
+    label = _("created a reuse")
 
 
 class UserUpdatedReuse(ReuseRelatedActivity, Activity):
-    key = 'reuse:updated'
-    icon = 'fa fa-pencil'
-    label = _('updated a reuse')
+    key = "reuse:updated"
+    icon = "fa fa-pencil"
+    label = _("updated a reuse")
 
 
 class UserDeletedReuse(ReuseRelatedActivity, Activity):
-    key = 'reuse:deleted'
-    icon = 'fa fa-remove'
-    badge_type = 'error'
-    label = _('deleted a reuse')
+    key = "reuse:deleted"
+    icon = "fa fa-remove"
+    badge_type = "error"
+    label = _("deleted a reuse")
 
 
 @Reuse.on_create.connect