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

udata/core/reuse/models.py

@@ -1,17 +1,18 @@
 from blinker import Signal
-from mongoengine.signals import pre_save, post_save
+from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
-from udata.core.storages import images, default_image_basename
+from udata.core.owned import Owned, OwnedQuerySet
+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 db, BadgeMixin, WithMetrics
-from udata.utils import hash_url
+from udata.models import BadgeMixin, WithMetrics, db
 from udata.uris import endpoint_for
-from udata.core.owned import Owned, OwnedQuerySet
+from udata.utils import hash_url
+
 from .constants import IMAGE_MAX_SIZE, IMAGE_SIZES, REUSE_TOPICS, REUSE_TYPES
 
-__all__ = ('Reuse',)
+__all__ = ("Reuse",)
 
 
 class ReuseQuerySet(OwnedQuerySet):
@@ -19,25 +20,23 @@ class ReuseQuerySet(OwnedQuerySet):
         return self(private__ne=True, datasets__0__exists=True, deleted=None)
 
     def hidden(self):
-        return self(db.Q(private=True) |
-                    db.Q(datasets__0__exists=False) |
-                    db.Q(deleted__ne=None))
+        return self(db.Q(private=True) | db.Q(datasets__0__exists=False) | db.Q(deleted__ne=None))
 
 
 class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
     title = db.StringField(required=True)
-    slug = db.SlugField(max_length=255, required=True, populate_from='title',
-                        update=True, follow=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 = 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))
+        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))
@@ -51,28 +50,31 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
     deleted = db.DateTimeField()
 
     def __str__(self):
-        return self.title or ''
+        return self.title or ""
 
     __badges__ = {}
 
     __metrics_keys__ = [
-        'discussions',
-        'datasets',
-        'followers',
-        'views',
+        "discussions",
+        "datasets",
+        "followers",
+        "views",
     ]
 
     meta = {
-        'indexes': ['$title',
-                    'created_at',
-                    'last_modified',
-                    'metrics.datasets',
-                    'metrics.followers',
-                    'metrics.views',
-                    'urlhash'] + Owned.meta['indexes'],
-        'ordering': ['-created_at'],
-        'queryset_class': ReuseQuerySet,
-        'auto_create_index_on_save': True
+        "indexes": [
+            "$title",
+            "created_at",
+            "last_modified",
+            "metrics.datasets",
+            "metrics.followers",
+            "metrics.views",
+            "urlhash",
+        ]
+        + Owned.meta["indexes"],
+        "ordering": ["-created_at"],
+        "queryset_class": ReuseQuerySet,
+        "auto_create_index_on_save": True,
     }
 
     before_save = Signal()
@@ -83,7 +85,7 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
     after_delete = Signal()
     on_delete = Signal()
 
-    verbose_name = _('reuse')
+    verbose_name = _("reuse")
 
     @classmethod
     def pre_save(cls, sender, document, **kwargs):
@@ -92,10 +94,10 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
 
     @classmethod
     def post_save(cls, sender, document, **kwargs):
-        if 'post_save' in kwargs.get('ignores', []):
+        if "post_save" in kwargs.get("ignores", []):
             return
         cls.after_save.send(document)
-        if kwargs.get('created'):
+        if kwargs.get("created"):
             cls.on_create.send(document)
         else:
             cls.on_update.send(document)
@@ -103,7 +105,7 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
             cls.on_delete.send(document)
 
     def url_for(self, *args, **kwargs):
-        return endpoint_for('reuses.show', 'api.reuse', reuse=self, *args, **kwargs)
+        return endpoint_for("reuses.show", "api.reuse", reuse=self, *args, **kwargs)
 
     display_url = property(url_for)
 
@@ -129,8 +131,8 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
 
     def clean(self):
         super(Reuse, self).clean()
-        '''Auto populate urlhash from url'''
-        if not self.urlhash or 'url' in self._get_changed_fields():
+        """Auto populate urlhash from url"""
+        if not self.urlhash or "url" in self._get_changed_fields():
             self.urlhash = hash_url(self.url)
 
     @classmethod
@@ -146,18 +148,18 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
     @cached_property
     def json_ld(self):
         result = {
-            '@context': 'http://schema.org',
-            '@type': 'CreativeWork',
-            'alternateName': self.slug,
-            'dateCreated': self.created_at.isoformat(),
-            'dateModified': self.last_modified.isoformat(),
-            'url': endpoint_for('reuses.show', 'api.reuse', reuse=self, _external=True),
-            'name': self.title,
-            'isBasedOnUrl': self.url,
+            "@context": "http://schema.org",
+            "@type": "CreativeWork",
+            "alternateName": self.slug,
+            "dateCreated": self.created_at.isoformat(),
+            "dateModified": self.last_modified.isoformat(),
+            "url": endpoint_for("reuses.show", "api.reuse", reuse=self, _external=True),
+            "name": self.title,
+            "isBasedOnUrl": self.url,
         }
 
         if self.description:
-            result['description'] = mdstrip(self.description)
+            result["description"] = mdstrip(self.description)
 
         if self.organization:
             author = self.organization.json_ld
@@ -167,26 +169,28 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
             author = None
 
         if author:
-            result['author'] = author
+            result["author"] = author
 
         return result
 
     @property
     def views_count(self):
-        return self.metrics.get('views', 0)
+        return self.metrics.get("views", 0)
 
     def count_datasets(self):
-        self.metrics['datasets'] = len(self.datasets)
-        self.save(signal_kwargs={'ignores': ['post_save']})
+        self.metrics["datasets"] = len(self.datasets)
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_discussions(self):
         from udata.models import Discussion
-        self.metrics['discussions'] = Discussion.objects(subject=self, closed=None).count()
+
+        self.metrics["discussions"] = Discussion.objects(subject=self, closed=None).count()
         self.save()
 
     def count_followers(self):
         from udata.models import Follow
-        self.metrics['followers'] = Follow.objects(until=None).followers(self).count()
+
+        self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
         self.save()
 
 

udata/core/reuse/permissions.py

@@ -1,7 +1,7 @@
 from udata.auth import Permission, UserNeed
-
 from udata.core.organization.permissions import (
-    OrganizationAdminNeed, OrganizationEditorNeed
+    OrganizationAdminNeed,
+    OrganizationEditorNeed,
 )
 
 

udata/core/reuse/search.py

@@ -1,54 +1,57 @@
 import datetime
-from udata.models import (
-    Reuse, Organization, User
-)
+
+from udata.core.reuse.api import DEFAULT_SORTING, ReuseApiParser
+from udata.models import Organization, Reuse, User
 from udata.search import (
-    ModelSearchAdapter, register,
-    ModelTermsFilter, BoolFilter, Filter
+    BoolFilter,
+    Filter,
+    ModelSearchAdapter,
+    ModelTermsFilter,
+    register,
 )
-from udata.core.reuse.api import ReuseApiParser, DEFAULT_SORTING
 from udata.utils import to_iso_datetime
 
-
-__all__ = ('ReuseSearch', )
+__all__ = ("ReuseSearch",)
 
 
 @register
 class ReuseSearch(ModelSearchAdapter):
     model = Reuse
-    search_url = 'reuses/'
+    search_url = "reuses/"
 
     sorts = {
-        'created': 'created_at',
-        'datasets': 'metrics.datasets',
-        'followers': 'metrics.followers',
-        'views': 'metrics.views'
+        "created": "created_at",
+        "datasets": "metrics.datasets",
+        "followers": "metrics.followers",
+        "views": "metrics.views",
     }
 
     filters = {
-        'tag': Filter(),
-        'organization': ModelTermsFilter(model=Organization),
-        'owner': ModelTermsFilter(model=User),
-        'type': Filter(),
-        'badge': Filter(),
-        'featured': BoolFilter(),
-        'topic': Filter(),
+        "tag": Filter(),
+        "organization": ModelTermsFilter(model=Organization),
+        "owner": ModelTermsFilter(model=User),
+        "type": Filter(),
+        "badge": Filter(),
+        "featured": BoolFilter(),
+        "topic": Filter(),
     }
 
     @classmethod
     def is_indexable(cls, reuse):
-        return (reuse.deleted is None and
-                len(reuse.datasets) > 0 and
-                not reuse.private)
+        return reuse.deleted is None and len(reuse.datasets) > 0 and not reuse.private
 
     @classmethod
     def mongo_search(cls, args):
         reuses = Reuse.objects(deleted=None, private__ne=True)
         reuses = ReuseApiParser.parse_filters(reuses, args)
 
-        sort = cls.parse_sort(args['sort']) or ('$text_score' if args['q'] else None) or DEFAULT_SORTING
-        offset = (args['page'] - 1) * args['page_size']
-        return reuses.order_by(sort).skip(offset).limit(args['page_size']), reuses.count()
+        sort = (
+            cls.parse_sort(args["sort"])
+            or ("$text_score" if args["q"] else None)
+            or DEFAULT_SORTING
+        )
+        offset = (args["page"] - 1) * args["page_size"]
+        return reuses.order_by(sort).skip(offset).limit(args["page_size"]), reuses.count()
 
     @classmethod
     def serialize(cls, reuse):
@@ -57,10 +60,10 @@ class ReuseSearch(ModelSearchAdapter):
         if reuse.organization:
             org = Organization.objects(id=reuse.organization.id).first()
             organization = {
-                'id': str(org.id),
-                'name': org.name,
-                'public_service': 1 if org.public_service else 0,
-                'followers': org.metrics.get('followers', 0)
+                "id": str(org.id),
+                "name": org.name,
+                "public_service": 1 if org.public_service else 0,
+                "followers": org.metrics.get("followers", 0),
             }
         elif reuse.owner:
             owner = User.objects(id=reuse.owner.id).first()
@@ -70,20 +73,20 @@ class ReuseSearch(ModelSearchAdapter):
             extras[key] = to_iso_datetime(value) if isinstance(value, datetime.datetime) else value
 
         return {
-            'id': str(reuse.id),
-            'title': reuse.title,
-            'description': reuse.description,
-            'url': reuse.url,
-            'created_at': to_iso_datetime(reuse.created_at),
-            'views': reuse.metrics.get('views', 0),
-            'followers': reuse.metrics.get('followers', 0),
-            'datasets': reuse.metrics.get('datasets', 0),
-            'featured': 1 if reuse.featured else 0,
-            'organization': organization,
-            'owner': str(owner.id) if owner else None,
-            'type': reuse.type,
-            'topic': reuse.topic,
-            'tags': reuse.tags,
-            'badges': [badge.kind for badge in reuse.badges],
-            'extras': extras
+            "id": str(reuse.id),
+            "title": reuse.title,
+            "description": reuse.description,
+            "url": reuse.url,
+            "created_at": to_iso_datetime(reuse.created_at),
+            "views": reuse.metrics.get("views", 0),
+            "followers": reuse.metrics.get("followers", 0),
+            "datasets": reuse.metrics.get("datasets", 0),
+            "featured": 1 if reuse.featured else 0,
+            "organization": organization,
+            "owner": str(owner.id) if owner else None,
+            "type": reuse.type,
+            "topic": reuse.topic,
+            "tags": reuse.tags,
+            "badges": [badge.kind for badge in reuse.badges],
+            "extras": extras,
         }

udata/core/reuse/signals.py

@@ -3,4 +3,4 @@ from blinker import Namespace
 namespace = Namespace()
 
 #: Trigerred when a reuse is published
-on_reuse_published = namespace.signal('on-reuse-published')
+on_reuse_published = namespace.signal("on-reuse-published")

udata/core/reuse/tasks.py

@@ -1,6 +1,6 @@
 from udata import mail
-from udata.i18n import lazy_gettext as _
 from udata.core import storages
+from udata.i18n import lazy_gettext as _
 from udata.models import Activity, Discussion, Follow, Transfer
 from udata.tasks import get_logger, job, task
 
@@ -9,10 +9,10 @@ from .models import Reuse
 log = get_logger(__name__)
 
 
-@job('purge-reuses')
+@job("purge-reuses")
 def purge_reuses(self):
     for reuse in Reuse.objects(deleted__ne=None):
-        log.info(f'Purging reuse {reuse}')
+        log.info(f"Purging reuse {reuse}")
         # Remove followers
         Follow.objects(following=reuse).delete()
         # Remove discussions
@@ -42,5 +42,4 @@ def notify_new_reuse(reuse_id):
         else:
             recipients = None
         if recipients:
-            mail.send(_('New reuse'), recipients, 'new_reuse', reuse=reuse,
-                      dataset=dataset)
+            mail.send(_("New reuse"), recipients, "new_reuse", reuse=reuse, dataset=dataset)

udata/core/site/api.py

@@ -1,115 +1,112 @@
 from bson import ObjectId
-
-from flask import request, redirect, url_for, json, make_response
+from flask import json, make_response, redirect, request, url_for
 from mongoengine import Q
 
-from udata.api import api, API, fields
+from udata.api import API, api, fields
 from udata.auth import admin_permission
 from udata.core.dataservices.models import Dataservice
-from udata.models import Dataset, Reuse
-from udata.utils import multi_to_dict
-from udata.rdf import (
-    CONTEXT, RDF_EXTENSIONS,
-    negociate_content, graph_response
-)
-
 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
 
 from .models import current_site
 from .rdf import build_catalog
 
-site_fields = api.model('Site', {
-    'id': fields.String(
-        description='The Site unique identifier', required=True),
-    'title': fields.String(
-        description='The site display title', required=True),
-    'metrics': fields.Raw(attribute=lambda o: o.get_metrics(), description='The associated metrics', default={}),
-})
+site_fields = api.model(
+    "Site",
+    {
+        "id": fields.String(description="The Site unique identifier", required=True),
+        "title": fields.String(description="The site display title", required=True),
+        "metrics": fields.Raw(
+            attribute=lambda o: o.get_metrics(), description="The associated metrics", default={}
+        ),
+    },
+)
 
 
-@api.route('/site/', endpoint='site')
+@api.route("/site/", endpoint="site")
 class SiteAPI(API):
-
-    @api.doc(id='get_site')
+    @api.doc(id="get_site")
     @api.marshal_with(site_fields)
     def get(self):
-        '''Site-wide variables'''
+        """Site-wide variables"""
         return current_site
 
 
-@api.route('/site/home/datasets/', endpoint='home_datasets')
+@api.route("/site/home/datasets/", endpoint="home_datasets")
 class SiteHomeDatasetsAPI(API):
-    @api.doc('get_home_datasets')
+    @api.doc("get_home_datasets")
     # @api.secure(admin_permission)
     @api.marshal_list_with(dataset_fields)
     def get(self):
-        '''List homepage datasets'''
+        """List homepage datasets"""
         return current_site.settings.home_datasets
 
     @api.secure(admin_permission)
-    @api.doc('set_home_datasets')
-    @api.expect(([str], 'Dataset IDs to put in homepage'))
+    @api.doc("set_home_datasets")
+    @api.expect(([str], "Dataset IDs to put in homepage"))
     @api.marshal_list_with(dataset_fields)
     def put(self):
-        '''Set the homepage datasets editorial selection'''
+        """Set the homepage datasets editorial selection"""
         if not isinstance(request.json, list):
-            api.abort(400, 'Expect a list of dataset IDs')
+            api.abort(400, "Expect a list of dataset IDs")
         ids = [ObjectId(id) for id in request.json]
         current_site.settings.home_datasets = Dataset.objects.bulk_list(ids)
         current_site.save()
         return current_site.settings.home_datasets
 
 
-@api.route('/site/home/reuses/', endpoint='home_reuses')
+@api.route("/site/home/reuses/", endpoint="home_reuses")
 class SiteHomeReusesAPI(API):
-    @api.doc('get_home_reuses')
+    @api.doc("get_home_reuses")
     @api.secure(admin_permission)
     @api.marshal_list_with(reuse_fields)
     def get(self):
-        '''List homepage featured reuses'''
+        """List homepage featured reuses"""
         return current_site.settings.home_reuses
 
     @api.secure(admin_permission)
-    @api.doc('set_home_reuses')
-    @api.expect(([str], 'Reuse IDs to put in homepage'))
+    @api.doc("set_home_reuses")
+    @api.expect(([str], "Reuse IDs to put in homepage"))
     @api.marshal_list_with(reuse_fields)
     def put(self):
-        '''Set the homepage reuses editorial selection'''
+        """Set the homepage reuses editorial selection"""
         if not isinstance(request.json, list):
-            api.abort(400, 'Expect a list of reuse IDs')
+            api.abort(400, "Expect a list of reuse IDs")
         ids = [ObjectId(id) for id in request.json]
         current_site.settings.home_reuses = Reuse.objects.bulk_list(ids)
         current_site.save()
         return current_site.settings.home_reuses
 
 
-@api.route('/site/data.<format>', endpoint='site_dataportal')
+@api.route("/site/data.<format>", endpoint="site_dataportal")
 class SiteDataPortal(API):
     def get(self, format):
-        '''Root RDF endpoint with content negociation handling'''
-        url = url_for('api.site_rdf_catalog_format', format=format)
+        """Root RDF endpoint with content negociation handling"""
+        url = url_for("api.site_rdf_catalog_format", format=format)
         return redirect(url)
 
 
-@api.route('/site/catalog', endpoint='site_rdf_catalog')
+@api.route("/site/catalog", endpoint="site_rdf_catalog")
 class SiteRdfCatalog(API):
     def get(self):
-        '''Root RDF endpoint with content negociation handling'''
+        """Root RDF endpoint with content negociation handling"""
         format = RDF_EXTENSIONS[negociate_content()]
-        url = url_for('api.site_rdf_catalog_format', format=format)
+        url = url_for("api.site_rdf_catalog_format", format=format)
         return redirect(url)
 
 
-@api.route('/site/catalog.<format>', endpoint='site_rdf_catalog_format')
+@api.route("/site/catalog.<format>", endpoint="site_rdf_catalog_format")
 class SiteRdfCatalogFormat(API):
     def get(self, format):
         params = multi_to_dict(request.args)
-        page = int(params.get('page', 1))
-        page_size = int(params.get('page_size', 100))
+        page = int(params.get("page", 1))
+        page_size = int(params.get("page_size", 100))
         datasets = Dataset.objects.visible()
-        if 'tag' in params:
-            datasets = datasets.filter(tags=params.get('tag', ''))
+        if "tag" in params:
+            datasets = datasets.filter(tags=params.get("tag", ""))
         datasets = datasets.paginate(page, page_size)
 
         # We need to add Dataservice to the catalog.
@@ -119,14 +116,14 @@ class SiteRdfCatalogFormat(API):
         # - 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 
+        # 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])
@@ -143,9 +140,9 @@ class SiteRdfCatalogFormat(API):
         return make_response(*graph_response(catalog, format))
 
 
-@api.route('/site/context.jsonld', endpoint='site_jsonld_context')
+@api.route("/site/context.jsonld", endpoint="site_jsonld_context")
 class SiteJsonLdContext(API):
     def get(self):
         response = make_response(json.dumps(CONTEXT))
-        response.headers['Content-Type'] = 'application/ld+json'
+        response.headers["Content-Type"] = "application/ld+json"
         return response

udata/core/site/factories.py

@@ -14,6 +14,6 @@ class SiteFactory(ModelFactory):
     class Meta:
         model = Site
 
-    id = factory.Faker('word')
-    title = factory.Faker('name')
+    id = factory.Faker("word")
+    title = factory.Faker("name")
     settings = factory.SubFactory(SiteSettingsFactory)

udata/core/site/forms.py

@@ -3,13 +3,12 @@ from udata.i18n import lazy_gettext as _
 
 from .models import Site
 
-__all__ = ('SiteConfigForm', )
+__all__ = ("SiteConfigForm",)
 
 
 class SiteConfigForm(ModelForm):
     model_class = Site
 
-    title = fields.StringField(_('Title'), [validators.DataRequired()])
-    keywords = fields.TagField(_('Tags'), description=_('Some SEO keywords'))
-    feed_size = fields.IntegerField(
-        _('Feed size'), description=_('Number of elements in feeds'))
+    title = fields.StringField(_("Title"), [validators.DataRequired()])
+    keywords = fields.TagField(_("Tags"), description=_("Some SEO keywords"))
+    feed_size = fields.IntegerField(_("Feed size"), description=_("Number of elements in feeds"))