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

udata/core/contact_point/factories.py

@@ -9,5 +9,5 @@ class ContactPointFactory(ModelFactory):
     class Meta:
         model = ContactPoint
 
-    name = factory.Faker('name')
-    email = factory.Faker('email')
+    name = factory.Faker("name")
+    email = factory.Faker("email")

udata/core/contact_point/forms.py

@@ -2,15 +2,16 @@ from udata.forms import ModelForm, fields, validators
 from udata.i18n import lazy_gettext as _
 from udata.models import ContactPoint
 
-
-__all__ = ('ContactPointForm',)
+__all__ = ("ContactPointForm",)
 
 
 class ContactPointForm(ModelForm):
     model_class = ContactPoint
 
-    name = fields.StringField(_('Name'), [validators.DataRequired(),
-                                                validators.NoURLs(_('URLs not allowed in this field'))])
-    email = fields.StringField(_('Email'), [validators.DataRequired(), validators.Email()])
+    name = fields.StringField(
+        _("Name"),
+        [validators.DataRequired(), validators.NoURLs(_("URLs not allowed in this field"))],
+    )
+    email = fields.StringField(_("Email"), [validators.DataRequired(), validators.Email()])
     owner = fields.CurrentUserField()
-    organization = fields.PublishAsField(_('Publish as'))
+    organization = fields.PublishAsField(_("Publish as"))

udata/core/contact_point/models.py

@@ -1,13 +1,11 @@
-from udata.mongo import db
 from udata.core.owned import Owned, OwnedQuerySet
+from udata.mongo import db
 
-__all__ = ('ContactPoint', )
+__all__ = ("ContactPoint",)
 
 
 class ContactPoint(db.Document, Owned):
     email = db.StringField(max_length=255, required=True)
     name = db.StringField(max_length=255, required=True)
 
-    meta = {
-        'queryset_class': OwnedQuerySet
-    }
+    meta = {"queryset_class": OwnedQuerySet}

udata/core/dataservices/api.py

@@ -1,31 +1,34 @@
 from datetime import datetime
+
+import mongoengine
 from flask import request
 from flask_login import current_user
-import mongoengine
 
-from udata.api import api, API
+from udata.api import API, api
 from udata.api_fields import patch
 from udata.core.dataset.permissions import OwnablePermission
 from udata.core.followers.api import FollowAPI
+
 from .models import Dataservice
 
-ns = api.namespace('dataservices', 'Dataservices related operations (beta)')
+ns = api.namespace("dataservices", "Dataservices related operations (beta)")
 
 
-@ns.route('/', endpoint='dataservices')
+@ns.route("/", endpoint="dataservices")
 class DataservicesAPI(API):
-    '''Dataservices collection endpoint'''
-    @api.doc('list_dataservices')
+    """Dataservices collection endpoint"""
+
+    @api.doc("list_dataservices")
     @api.expect(Dataservice.__index_parser__)
     @api.marshal_with(Dataservice.__page_fields__)
     def get(self):
-        '''List or search all dataservices'''
+        """List or search all dataservices"""
         query = Dataservice.objects.visible()
 
         return Dataservice.apply_sort_filters_and_pagination(query)
 
     @api.secure
-    @api.doc('create_dataservice', responses={400: 'Validation error'})
+    @api.doc("create_dataservice", responses={400: "Validation error"})
     @api.expect(Dataservice.__write_fields__)
     @api.marshal_with(Dataservice.__read_fields__, code=201)
     def post(self):
@@ -41,22 +44,22 @@ class DataservicesAPI(API):
         return dataservice, 201
 
 
-@ns.route('/<dataservice:dataservice>/', endpoint='dataservice')
+@ns.route("/<dataservice:dataservice>/", endpoint="dataservice")
 class DataserviceAPI(API):
-    @api.doc('get_dataservice')
+    @api.doc("get_dataservice")
     @api.marshal_with(Dataservice.__read_fields__)
     def get(self, dataservice):
         if dataservice.deleted_at and not OwnablePermission(dataservice).can():
-            api.abort(410, 'Dataservice has been deleted')
+            api.abort(410, "Dataservice has been deleted")
         return dataservice
 
     @api.secure
-    @api.doc('update_dataservice', responses={400: 'Validation error'})
+    @api.doc("update_dataservice", responses={400: "Validation error"})
     @api.expect(Dataservice.__write_fields__)
     @api.marshal_with(Dataservice.__read_fields__)
     def patch(self, dataservice):
         if dataservice.deleted_at:
-            api.abort(410, 'dataservice has been deleted')
+            api.abort(410, "dataservice has been deleted")
 
         OwnablePermission(dataservice).test()
 
@@ -70,23 +73,25 @@ class DataserviceAPI(API):
             api.abort(400, e.message)
 
     @api.secure
-    @api.doc('delete_dataservice')
-    @api.response(204, 'dataservice deleted')
+    @api.doc("delete_dataservice")
+    @api.response(204, "dataservice deleted")
     def delete(self, dataservice):
         if dataservice.deleted_at:
-            api.abort(410, 'dataservice has been deleted')
+            api.abort(410, "dataservice has been deleted")
 
         OwnablePermission(dataservice).test()
         dataservice.deleted_at = datetime.utcnow()
         dataservice.modified_at = datetime.utcnow()
         dataservice.save()
 
-        return '', 204
+        return "", 204
 
 
-@ns.route('/<id>/followers/', endpoint='dataservice_followers')
-@ns.doc(get={'id': 'list_dataservice_followers'},
-        post={'id': 'follow_dataservice'},
-        delete={'id': 'unfollow_dataservice'})
+@ns.route("/<id>/followers/", endpoint="dataservice_followers")
+@ns.doc(
+    get={"id": "list_dataservice_followers"},
+    post={"id": "follow_dataservice"},
+    delete={"id": "unfollow_dataservice"},
+)
 class DataserviceFollowersAPI(FollowAPI):
     model = Dataservice

udata/core/dataservices/factories.py

@@ -4,30 +4,32 @@ from udata.core.dataservices.models import Dataservice, HarvestMetadata
 from udata.core.organization.factories import OrganizationFactory
 from udata.factories import ModelFactory
 
+
 class HarvestMetadataFactory(ModelFactory):
     class Meta:
         model = HarvestMetadata
 
-    backend = 'csw-dcat'
-    domain = 'data.gouv.fr'
+    backend = "csw-dcat"
+    domain = "data.gouv.fr"
+
+    source_id = factory.Faker("unique_string")
+    source_url = factory.Faker("url")
 
-    source_id = factory.Faker('unique_string')
-    source_url = factory.Faker('url')
+    remote_id = factory.Faker("unique_string")
+    remote_url = factory.Faker("url")
 
-    remote_id = factory.Faker('unique_string')
-    remote_url = factory.Faker('url')
+    uri = factory.Faker("url")
 
-    uri = factory.Faker('url')
 
 class DataserviceFactory(ModelFactory):
     class Meta:
         model = Dataservice
 
-    title = factory.Faker('sentence')
-    description = factory.Faker('text')
-    base_api_url = factory.Faker('url')
+    title = factory.Faker("sentence")
+    description = factory.Faker("text")
+    base_api_url = factory.Faker("url")
 
     class Params:
         org = factory.Trait(
             organization=factory.SubFactory(OrganizationFactory),
-        )
+        )

udata/core/dataservices/models.py

@@ -1,13 +1,13 @@
 from datetime import datetime
+
+import udata.core.contact_point.api_fields as contact_api_fields
+import udata.core.dataset.api_fields as datasets_api_fields
 from udata.api_fields import field, function_field, generate_fields
 from udata.core.dataset.models import Dataset
 from udata.core.metrics.models import WithMetrics
 from udata.core.owned import Owned, OwnedQuerySet
-import udata.core.contact_point.api_fields as contact_api_fields
-import udata.core.dataset.api_fields as datasets_api_fields
 from udata.i18n import lazy_gettext as _
-
-from udata.models import db, Discussion, Follow
+from udata.models import Discussion, Follow, db
 from udata.uris import endpoint_for
 
 # "frequency"
@@ -19,7 +19,7 @@ from udata.uris import endpoint_for
 # "spatial"
 # "temporal_coverage"
 
-DATASERVICE_FORMATS = ['REST', 'WMS', 'WSL']
+DATASERVICE_FORMATS = ["REST", "WMS", "WSL"]
 
 
 class DataserviceQuerySet(OwnedQuerySet):
@@ -27,9 +27,8 @@ class DataserviceQuerySet(OwnedQuerySet):
         return self(archived_at=None, deleted_at=None, private=False)
 
     def hidden(self):
-        return self(db.Q(private=True) |
-                    db.Q(deleted_at__ne=None) |
-                    db.Q(archived_at__ne=None))
+        return self(db.Q(private=True) | db.Q(deleted_at__ne=None) | db.Q(archived_at__ne=None))
+
 
 @generate_fields()
 class HarvestMetadata(db.EmbeddedDocument):
@@ -43,7 +42,7 @@ class HarvestMetadata(db.EmbeddedDocument):
     remote_url = field(db.URLField())
 
     # If the node ID is a `URIRef` it means it links to something external, if it's not an `URIRef` it's often a
-    # auto-generated ID just to link multiple RDF node togethers. When exporting as RDF to other catalogs, we 
+    # auto-generated ID just to link multiple RDF node togethers. When exporting as RDF to other catalogs, we
     # want to re-use this node ID (only if it's not auto-generated) to improve compatibility.
     uri = field(
         db.URLField(),
@@ -51,23 +50,21 @@ class HarvestMetadata(db.EmbeddedDocument):
     )
 
     created_at = field(
-        db.DateTimeField(),
-        description="Date of the creation as provided by the harvested catalog"
-    )
-    last_update = field(
-        db.DateTimeField(),
-        description="Date of the last harvesting"
+        db.DateTimeField(), description="Date of the creation as provided by the harvested catalog"
     )
+    last_update = field(db.DateTimeField(), description="Date of the last harvesting")
     archived_at = field(db.DateTimeField())
 
+
 @generate_fields()
 class Dataservice(WithMetrics, Owned, db.Document):
     meta = {
-        'indexes': [
-            '$title',
-        ] + Owned.meta['indexes'],
-        'queryset_class': DataserviceQuerySet,
-        'auto_create_index_on_save': True
+        "indexes": [
+            "$title",
+        ]
+        + Owned.meta["indexes"],
+        "queryset_class": DataserviceQuerySet,
+        "auto_create_index_on_save": True,
     }
 
     title = field(
@@ -81,30 +78,26 @@ class Dataservice(WithMetrics, Owned, db.Document):
     # /!\ do not set directly the slug when creating or updating a dataset
     # this will break the search indexation
     slug = field(
-        db.SlugField(max_length=255, required=True, populate_from='title', update=True, follow=True),
+        db.SlugField(
+            max_length=255, required=True, populate_from="title", update=True, follow=True
+        ),
         readonly=True,
     )
-    description = field(
-        db.StringField(default=''),
-        description="In markdown"
-    )
+    description = field(db.StringField(default=""), description="In markdown")
     base_api_url = field(
         db.URLField(required=True),
         sortable=True,
     )
     endpoint_description_url = field(db.URLField())
     authorization_request_url = field(db.URLField())
-    availability= field(
-        db.FloatField(min=0, max=100),
-        example='99.99'
-    )
+    availability = field(db.FloatField(min=0, max=100), example="99.99")
     rate_limiting = field(db.StringField())
     is_restricted = field(db.BooleanField())
     has_token = field(db.BooleanField())
     format = field(db.StringField(choices=DATASERVICE_FORMATS))
 
     license = field(
-        db.ReferenceField('License'),
+        db.ReferenceField("License"),
         allow_null=True,
     )
 
@@ -114,23 +107,25 @@ class Dataservice(WithMetrics, Owned, db.Document):
 
     private = field(
         db.BooleanField(default=False),
-        description='Is the dataservice private to the owner or the organization'
+        description="Is the dataservice private to the owner or the organization",
     )
-    
+
     extras = field(db.ExtrasField())
 
     contact_point = field(
-        db.ReferenceField('ContactPoint', reverse_delete_rule=db.NULLIFY),
+        db.ReferenceField("ContactPoint", reverse_delete_rule=db.NULLIFY),
         nested_fields=contact_api_fields.contact_point_fields,
         allow_null=True,
     )
 
     created_at = field(
-        db.DateTimeField(verbose_name=_('Creation date'), default=datetime.utcnow, required=True),
+        db.DateTimeField(verbose_name=_("Creation date"), default=datetime.utcnow, required=True),
         readonly=True,
     )
     metadata_modified_at = field(
-        db.DateTimeField(verbose_name=_('Last modification date'), default=datetime.utcnow, required=True),
+        db.DateTimeField(
+            verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+        ),
         readonly=True,
     )
     deleted_at = field(db.DateTimeField(), readonly=True)
@@ -144,7 +139,7 @@ class Dataservice(WithMetrics, Owned, db.Document):
             )
         ),
         filterable={
-            'key': 'dataset',
+            "key": "dataset",
         },
     )
 
@@ -155,11 +150,11 @@ class Dataservice(WithMetrics, Owned, db.Document):
 
     @function_field(description="Link to the API endpoint for this dataservice")
     def self_api_url(self):
-        return endpoint_for('api.dataservice', dataservice=self, _external=True)
+        return endpoint_for("api.dataservice", dataservice=self, _external=True)
 
     @function_field(description="Link to the udata web page for this dataservice")
     def self_web_url(self):
-        return endpoint_for('dataservices.show', dataservice=self, _external=True)
+        return endpoint_for("dataservices.show", dataservice=self, _external=True)
 
     # TODO
     # frequency = db.StringField(choices=list(UPDATE_FREQUENCIES.keys()))
@@ -172,9 +167,9 @@ class Dataservice(WithMetrics, Owned, db.Document):
         return self.private or self.deleted_at or self.archived_at
 
     def count_discussions(self):
-        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):
-        self.metrics['followers'] = Follow.objects(until=None).followers(self).count()
+        self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
         self.save()

udata/core/dataservices/permissions.py

@@ -1,7 +1,7 @@
-from udata.core.dataset.permissions import (
-    OwnablePermission
-)
+from udata.core.dataset.permissions import OwnablePermission
+
 
 class DataserviceEditPermission(OwnablePermission):
-    '''Permissions to edit a Dataservice'''
+    """Permissions to edit a Dataservice"""
+
     pass

udata/core/dataservices/rdf.py

@@ -1,16 +1,28 @@
-
 from rdflib import RDF, BNode, Graph, Literal, URIRef
 
-from udata.core.dataservices.models import Dataservice, HarvestMetadata as HarvestDataserviceMetadata
+from udata.core.dataservices.models import Dataservice
+from udata.core.dataservices.models import HarvestMetadata as HarvestDataserviceMetadata
 from udata.core.dataset.models import Dataset, License
 from udata.core.dataset.rdf import dataset_to_graph_id, sanitize_html
-from udata.rdf import namespace_manager, DCAT, DCT, contact_point_from_rdf, rdf_value, remote_url_from_rdf, themes_from_rdf, url_from_rdf
+from udata.rdf import (
+    DCAT,
+    DCT,
+    contact_point_from_rdf,
+    namespace_manager,
+    rdf_value,
+    remote_url_from_rdf,
+    themes_from_rdf,
+    url_from_rdf,
+)
 from udata.uris import endpoint_for
 
-def dataservice_from_rdf(graph: Graph, dataservice: Dataservice, node, all_datasets: list[Dataset]) -> Dataservice :
-    '''
+
+def dataservice_from_rdf(
+    graph: Graph, dataservice: Dataservice, node, all_datasets: list[Dataset]
+) -> Dataservice:
+    """
     Create or update a dataset from a RDF/DCAT graph
-    '''
+    """
     if node is None:  # Assume first match is the only match
         node = graph.value(predicate=RDF.type, object=DCAT.DataService)
 
@@ -27,11 +39,16 @@ def dataservice_from_rdf(graph: Graph, dataservice: Dataservice, node, all_datas
     datasets = []
     for dataset_node in d.objects(DCAT.servesDataset):
         id = dataset_node.value(DCT.identifier)
-        dataset = next((d for d in all_datasets if d is not None and d.harvest.remote_id == id), None)
+        dataset = next(
+            (d for d in all_datasets if d is not None and d.harvest.remote_id == id), None
+        )
 
         if dataset is None:
             # We try with `endswith` because Europe XSLT have problems with IDs. Sometimes they are prefixed with the domain of the catalog, sometimes not.
-            dataset = next((d for d in all_datasets if d is not None and d.harvest.remote_id.endswith(id)), None)
+            dataset = next(
+                (d for d in all_datasets if d is not None and d.harvest.remote_id.endswith(id)),
+                None,
+            )
 
         if dataset is not None:
             datasets.append(dataset.id)
@@ -57,16 +74,22 @@ def dataservice_from_rdf(graph: Graph, dataservice: Dataservice, node, all_datas
 
 
 def dataservice_to_rdf(dataservice: Dataservice, graph=None):
-    '''
+    """
     Map a dataservice domain model to a DCAT/RDF graph
-    '''
+    """
     # Use the unlocalized permalink to the dataset as URI when available
     # unless there is already an upstream URI
     if dataservice.harvest and dataservice.harvest.uri:
         id = URIRef(dataservice.harvest.uri)
     elif dataservice.id:
-        id = URIRef(endpoint_for('dataservices.show_redirect', 'api.dataservice',
-                    dataservice=dataservice.id, _external=True))
+        id = URIRef(
+            endpoint_for(
+                "dataservices.show_redirect",
+                "api.dataservice",
+                dataservice=dataservice.id,
+                _external=True,
+            )
+        )
     else:
         # Should not happen in production. Some test only
         # `build()` a dataset without saving it to the DB.
@@ -85,10 +108,10 @@ def dataservice_to_rdf(dataservice: Dataservice, graph=None):
     d.set(DCT.title, Literal(dataservice.title))
     d.set(DCT.description, Literal(dataservice.description))
     d.set(DCT.issued, Literal(dataservice.created_at))
-    
+
     if dataservice.base_api_url:
         d.set(DCAT.endpointURL, Literal(dataservice.base_api_url))
-    
+
     if dataservice.endpoint_description_url:
         d.set(DCAT.endpointDescription, Literal(dataservice.endpoint_description_url))
 
@@ -96,11 +119,11 @@ def dataservice_to_rdf(dataservice: Dataservice, graph=None):
         d.add(DCAT.keyword, Literal(tag))
 
     # `dataset_to_graph_id(dataset)` URIRef may not exist in the current page
-    # but should exists in the catalog somewhere. Maybe we should create a Node 
-    # with some basic information about this dataset (but this will return a page 
+    # but should exists in the catalog somewhere. Maybe we should create a Node
+    # with some basic information about this dataset (but this will return a page
     # with more datasets than the page size… and could be problematic when processing the
     # correct Node with all the information in a future page)
     for dataset in dataservice.datasets:
         d.add(DCAT.servesDataset, dataset_to_graph_id(dataset))
 
-    return d
+    return d

udata/core/dataservices/tasks.py

@@ -1,17 +1,18 @@
 from celery.utils.log import get_task_logger
 
 from udata.core.dataservices.models import Dataservice
+
 # from udata.harvest.models import HarvestJob
-from udata.models import (Follow, Discussion, Activity, Transfer)
+from udata.models import Activity, Discussion, Follow, Transfer
 from udata.tasks import job
 
 log = get_task_logger(__name__)
 
 
-@job('purge-dataservices')
+@job("purge-dataservices")
 def purge_dataservices(self):
     for dataservice in Dataservice.objects(deleted_at__ne=None):
-        log.info(f'Purging dataservice {dataservice}')
+        log.info(f"Purging dataservice {dataservice}")
         # Remove followers
         Follow.objects(following=dataservice).delete()
         # Remove discussions

udata/core/dataset/actions.py

@@ -12,24 +12,24 @@ log = logging.getLogger(__name__)
 def archive(dataset, comment=False):
     """Archive a dataset"""
     if dataset.archived:
-        log.warning('Dataset %s already archived, bumping date', dataset)
+        log.warning("Dataset %s already archived, bumping date", dataset)
     dataset.archived = datetime.utcnow()
     dataset.save()
 
     if comment:
-        log.info('Posting comment for dataset %s...', dataset)
-        lang = current_app.config['DEFAULT_LANGUAGE']
-        title = current_app.config['ARCHIVE_COMMENT_TITLE']
-        user_id = current_app.config['ARCHIVE_COMMENT_USER_ID']
+        log.info("Posting comment for dataset %s...", dataset)
+        lang = current_app.config["DEFAULT_LANGUAGE"]
+        title = current_app.config["ARCHIVE_COMMENT_TITLE"]
+        user_id = current_app.config["ARCHIVE_COMMENT_USER_ID"]
         if user_id:
             with i18n.language(lang):
-                msg = render_template('comments/dataset_archived.txt')
+                msg = render_template("comments/dataset_archived.txt")
                 message = Message(content=msg, posted_by=user_id)
                 discussion = Discussion(
-                    user=user_id, discussion=[message], subject=dataset,
-                    title=str(title))
+                    user=user_id, discussion=[message], subject=dataset, title=str(title)
+                )
                 discussion.save()
         else:
-            log.warning('ARCHIVE_COMMENT_USER_ID not set, skipping comment')
+            log.warning("ARCHIVE_COMMENT_USER_ID not set, skipping comment")
 
-    log.info('Archived dataset %s', dataset)
+    log.info("Archived dataset %s", dataset)

udata/core/dataset/activities.py

@@ -1,55 +1,53 @@
 from udata.auth import current_user
 from udata.i18n import lazy_gettext as _
-from udata.models import db, Dataset, Activity
-
+from udata.models import Activity, Dataset, db
 
 __all__ = (
-    'UserCreatedDataset', 'UserUpdatedDataset', 'UserDeletedDataset',
-    'DatasetRelatedActivity'
+    "UserCreatedDataset",
+    "UserUpdatedDataset",
+    "UserDeletedDataset",
+    "DatasetRelatedActivity",
 )
 
 
 class DatasetRelatedActivity(object):
-    template = 'activity/dataset.html'
-    related_to = db.ReferenceField('Dataset')
+    template = "activity/dataset.html"
+    related_to = db.ReferenceField("Dataset")
 
 
 class UserCreatedDataset(DatasetRelatedActivity, Activity):
-    key = 'dataset:created'
-    icon = 'fa fa-plus'
-    badge_type = 'success'
-    label = _('created a dataset')
+    key = "dataset:created"
+    icon = "fa fa-plus"
+    badge_type = "success"
+    label = _("created a dataset")
 
 
 class UserUpdatedDataset(DatasetRelatedActivity, Activity):
-    key = 'dataset:updated'
-    icon = 'fa fa-pencil'
-    label = _('updated a dataset')
+    key = "dataset:updated"
+    icon = "fa fa-pencil"
+    label = _("updated a dataset")
 
 
 class UserDeletedDataset(DatasetRelatedActivity, Activity):
-    key = 'dataset:deleted'
-    icon = 'fa fa-remove'
-    badge_type = 'error'
-    label = _('deleted a dataset')
+    key = "dataset:deleted"
+    icon = "fa fa-remove"
+    badge_type = "error"
+    label = _("deleted a dataset")
 
 
 @Dataset.on_create.connect
 def on_user_created_dataset(dataset):
-    if (not dataset.private and current_user and
-            current_user.is_authenticated):
+    if not dataset.private and current_user and current_user.is_authenticated:
         UserCreatedDataset.emit(dataset, dataset.organization)
 
 
 @Dataset.on_update.connect
 def on_user_updated_dataset(dataset):
-    if (not dataset.private and current_user and
-            current_user.is_authenticated):
+    if not dataset.private and current_user and current_user.is_authenticated:
         UserUpdatedDataset.emit(dataset, dataset.organization)
 
 
 @Dataset.on_delete.connect
 def on_user_deleted_dataset(dataset):
-    if (not dataset.private and current_user and
-            current_user.is_authenticated):
+    if not dataset.private and current_user and current_user.is_authenticated:
         UserDeletedDataset.emit(dataset, dataset.organization)