udata 9.1.2.dev30754__py2.py3-none-any.whl → 9.1.4.dev30983__py2.py3-none-any.whl

tasks/helpers.py

@@ -1,10 +1,11 @@
 from os.path import abspath, dirname, join
+from typing import Callable
 
 #: Project absolute root path
 ROOT = abspath(join(dirname(__file__), ".."))
 
 
-def color(code):
+def color(code: str) -> Callable:
     """A simple ANSI color wrapper factory"""
     return lambda t: "\033[{0}{1}\033[0;m".format(code, t)
 
@@ -17,25 +18,25 @@ purple = color("1;35m")
 white = color("1;39m")
 
 
-def header(text, *args, **kwargs):
+def header(text: str, *args, **kwargs) -> None:
     """Display an header"""
     text = text.format(*args, **kwargs)
     print(" ".join((blue(">>"), cyan(text))))
 
 
-def info(text, *args, **kwargs):
+def info(text: str, *args, **kwargs) -> None:
     """Display informations"""
     text = text.format(*args, **kwargs)
     print(" ".join((purple(">>>"), text)))
 
 
-def success(text, *args, **kwargs):
+def success(text: str, *args, **kwargs) -> None:
     """Display a success message"""
     text = text.format(*args, **kwargs)
     print(" ".join((green("✔"), white(text))))
 
 
-def error(text, *args, **kwargs):
+def error(text: str, *args, **kwargs) -> None:
     """Display an error message"""
     text = text.format(*args, **kwargs)
     print(red("✘ {0}".format(text)))

udata/__init__.py

@@ -4,5 +4,5 @@
 udata
 """
 
-__version__ = "9.1.2.dev"
+__version__ = "9.1.4.dev"
 __description__ = "Open data portal"

udata/api/__init__.py

@@ -1,5 +1,4 @@
 import inspect
-import itertools
 import logging
 import urllib.parse
 from functools import wraps
@@ -18,7 +17,7 @@ from flask import (
 from flask_restx import Api, Resource
 from flask_storage import UnauthorizedFileType
 
-from udata import cors, entrypoints, tracking
+from udata import entrypoints, tracking
 from udata.app import csrf
 from udata.auth import Permission, PermissionDenied, RoleNeed, current_user, login_user
 from udata.i18n import get_locale
@@ -325,7 +324,7 @@ def init_app(app):
     import udata.harvest.api  # noqa
 
     for module in entrypoints.get_enabled("udata.apis", app).values():
-        api_module = module if inspect.ismodule(module) else import_module(module)
+        module if inspect.ismodule(module) else import_module(module)
 
     # api.init_app(app)
     app.register_blueprint(apiv1_blueprint)

udata/api/commands.py

@@ -4,7 +4,6 @@ import os
 import click
 from flask import current_app, json
 from flask_restx import schemas
-from werkzeug.security import gen_salt
 
 from udata.api import api
 from udata.api.oauth2 import OAuth2Client

udata/api/fields.py

@@ -4,7 +4,28 @@ import logging
 import pytz
 from dateutil.parser import parse
 from flask import request, url_for
-from flask_restx.fields import *  # noqa
+
+# Explicitly import all of flask_restx fields so they're available throughout the codebase as api.fields
+from flask_restx.fields import Arbitrary as Arbitrary
+from flask_restx.fields import Boolean as Boolean
+from flask_restx.fields import ClassName as ClassName
+from flask_restx.fields import Date as Date
+from flask_restx.fields import DateTime as DateTime
+from flask_restx.fields import Fixed as Fixed
+from flask_restx.fields import Float as Float
+from flask_restx.fields import FormattedString as FormattedString
+from flask_restx.fields import Integer as Integer
+from flask_restx.fields import List as List
+from flask_restx.fields import MarshallingError as MarshallingError
+from flask_restx.fields import MinMaxMixin as MinMaxMixin
+from flask_restx.fields import Nested as Nested
+from flask_restx.fields import NumberMixin as NumberMixin
+from flask_restx.fields import Polymorph as Polymorph
+from flask_restx.fields import Raw as Raw
+from flask_restx.fields import String as String
+from flask_restx.fields import StringMixin as StringMixin
+from flask_restx.fields import Url as Url
+from flask_restx.fields import Wildcard as Wildcard
 
 from udata.uris import endpoint_for
 from udata.utils import multi_to_dict

udata/api_fields.py

@@ -67,12 +67,18 @@ def convert_db_to_field(key, field, info={}):
         field_read, field_write = convert_db_to_field(
             f"{key}.inner", field.field, info.get("inner_field_info", {})
         )
-        constructor_read = lambda **kwargs: restx_fields.List(field_read, **kwargs)
-        constructor_write = lambda **kwargs: restx_fields.List(field_write, **kwargs)
+
+        def constructor_read(**kwargs):
+            return restx_fields.List(field_read, **kwargs)
+
+        def constructor_write(**kwargs):
+            return restx_fields.List(field_write, **kwargs)
     elif isinstance(
         field, (mongo_fields.GenericReferenceField, mongoengine.fields.GenericLazyReferenceField)
     ):
-        constructor = lambda **kwargs: restx_fields.Nested(lazy_reference, **kwargs)
+
+        def constructor(**kwargs):
+            return restx_fields.Nested(lazy_reference, **kwargs)
     elif isinstance(field, mongo_fields.ReferenceField):
         # For reference we accept while writing a String representing the ID of the referenced model.
         # For reading, if the user supplied a `nested_fields` (RestX model), we use it to convert
@@ -83,21 +89,25 @@ def convert_db_to_field(key, field, info={}):
             # If there is no `nested_fields` convert the object to the string representation.
             constructor_read = restx_fields.String
         else:
-            constructor_read = lambda **kwargs: restx_fields.Nested(nested_fields, **kwargs)
+
+            def constructor_read(**kwargs):
+                return restx_fields.Nested(nested_fields, **kwargs)
 
         write_params["description"] = "ID of the reference"
         constructor_write = restx_fields.String
     elif isinstance(field, mongo_fields.EmbeddedDocumentField):
         nested_fields = info.get("nested_fields")
         if nested_fields is not None:
-            constructor = lambda **kwargs: restx_fields.Nested(nested_fields, **kwargs)
+
+            def constructor(**kwargs):
+                return restx_fields.Nested(nested_fields, **kwargs)
         elif hasattr(field.document_type_obj, "__read_fields__"):
-            constructor_read = lambda **kwargs: restx_fields.Nested(
-                field.document_type_obj.__read_fields__, **kwargs
-            )
-            constructor_write = lambda **kwargs: restx_fields.Nested(
-                field.document_type_obj.__write_fields__, **kwargs
-            )
+
+            def constructor_read(**kwargs):
+                return restx_fields.Nested(field.document_type_obj.__read_fields__, **kwargs)
+
+            def constructor_write(**kwargs):
+                return restx_fields.Nested(field.document_type_obj.__write_fields__, **kwargs)
         else:
             raise ValueError(
                 f"EmbeddedDocumentField `{key}` requires a `nested_fields` param to serialize/deserialize or a `@generate_fields()` definition."
@@ -335,7 +345,7 @@ def wrap_primary_key(
     field_name: str,
     foreign_field: mongoengine.fields.ReferenceField | mongoengine.fields.GenericReferenceField,
     value: str,
-    document_type: type = None,
+    document_type=None,
 ):
     """
     We need to wrap the `String` inside an `ObjectId` most of the time. If the foreign ID is a `String` we need to get

udata/app.py

@@ -206,7 +206,7 @@ def register_extensions(app):
         mail,
         models,
         mongo,
-        notifications,
+        notifications,  # noqa
         routing,
         search,
         sentry,

udata/assets.py

@@ -2,7 +2,7 @@ from flask import current_app, url_for
 from flask_cdn import url_for as cdn_url_for
 
 
-def cdn_for(endpoint, **kwargs):
+def cdn_for(endpoint: str, **kwargs) -> str:
     """
     Get a CDN URL for a static assets.
 

udata/auth/__init__.py

@@ -2,18 +2,14 @@ import logging
 
 from flask import current_app, render_template
 from flask_principal import Permission as BasePermission
-from flask_principal import (
-    PermissionDenied,  # noqa: facade pattern
-    RoleNeed,
-    UserNeed,  # noqa: facade pattern
-    identity_loaded,  # noqa: facade pattern
-)
-from flask_security import (  # noqa
-    Security,  # noqa
-    current_user,
-    login_required,
-    login_user,
-)
+from flask_principal import PermissionDenied as PermissionDenied
+from flask_principal import RoleNeed as RoleNeed
+from flask_principal import UserNeed as UserNeed
+from flask_principal import identity_loaded as identity_loaded
+from flask_security import Security as Security
+from flask_security import current_user as current_user
+from flask_security import login_required as login_required
+from flask_security import login_user as login_user
 from werkzeug.utils import import_string
 
 log = logging.getLogger(__name__)

udata/commands/db.py

@@ -159,10 +159,10 @@ def check_references(models_to_check):
     references = []
     for model in set(_models):
         if model.__name__ == "Activity":
-            print(f"Skipping Activity model, scheduled for deprecation")
+            print("Skipping Activity model, scheduled for deprecation")
             continue
         if model.__name__ == "GeoLevel":
-            print(f"Skipping GeoLevel model, scheduled for deprecation")
+            print("Skipping GeoLevel model, scheduled for deprecation")
             continue
 
         if models_to_check and model.__name__ not in models_to_check:
@@ -367,7 +367,7 @@ def check_references(models_to_check):
                                     )
                         else:
                             print_and_save(f'Unknown ref type {reference["type"]}')
-                    except mongoengine.errors.FieldDoesNotExist as e:
+                    except mongoengine.errors.FieldDoesNotExist:
                         print_and_save(
                             f"[ERROR for {model.__name__} {obj.id}] {traceback.format_exc()}"
                         )

udata/commands/dcat.py

@@ -33,7 +33,7 @@ def parse_url(url, csw, iso, quiet=False, rid=""):
     """Parse the datasets in a DCAT format located at URL (debug)"""
     if quiet:
         verbose_loggers = ["rdflib", "udata.core.dataset"]
-        [logging.getLogger(l).setLevel(logging.ERROR) for l in verbose_loggers]
+        [logging.getLogger(logger).setLevel(logging.ERROR) for logger in verbose_loggers]
 
     class MockSource:
         url = ""

udata/commands/fixtures.py

@@ -1,11 +1,21 @@
+"""Commands to download fixtures from the udata-fixtures repository, import them locally.
+
+When "downloading" (generating) the fixtures, save the json as is.
+When "importing" the fixtures, massage them so then can be loaded properly.
+"""
+
 import json
 import logging
+import pathlib
 
 import click
 import requests
 from flask import current_app
 
 from udata.commands import cli
+from udata.core.contact_point.factories import ContactPointFactory
+from udata.core.contact_point.models import ContactPoint
+from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataset.factories import (
     CommunityResourceFactory,
     DatasetFactory,
@@ -21,21 +31,79 @@ log = logging.getLogger(__name__)
 
 
 DATASET_URL = "/api/1/datasets"
+DATASERVICES_URL = "/api/1/dataservices"
 ORG_URL = "/api/1/organizations"
 REUSE_URL = "/api/1/reuses"
 COMMUNITY_RES_URL = "/api/1/datasets/community_resources"
 DISCUSSION_URL = "/api/1/discussions"
 
 
-DEFAULT_FIXTURE_FILE = (
-    "https://raw.githubusercontent.com/opendatateam/udata-fixtures/main/results.json"  # noqa
-)
+DEFAULT_FIXTURE_FILE_TAG: str = "v2.0.0"
+DEFAULT_FIXTURE_FILE: str = f"https://raw.githubusercontent.com/opendatateam/udata-fixtures/{DEFAULT_FIXTURE_FILE_TAG}/results.json"  # noqa
+
+DEFAULT_FIXTURES_RESULTS_FILENAME: str = "results.json"
+
+UNWANTED_KEYS: dict[str, list[str]] = {
+    "dataset": [
+        "uri",
+        "page",
+        "last_update",
+        "last_modified",
+        "license",
+        "badges",
+        "spatial",
+        "quality",
+    ],
+    "resource": ["latest", "preview_url", "last_modified"],
+    "organization": ["members", "page", "uri", "logo_thumbnail"],
+    "reuse": ["datasets", "image_thumbnail", "page", "uri", "organization", "owner"],
+    "community": [
+        "dataset",
+        "organization",
+        "owner",
+        "latest",
+        "last_modified",
+        "preview_url",
+    ],
+    "discussion": ["subject", "user", "url", "class"],
+    "message": ["posted_by"],
+    "dataservice": [
+        "datasets",
+        "license",
+        "organization",
+        "owner",
+        "self_api_url",
+        "self_web_url",
+    ],
+}
+
+
+def remove_unwanted_keys(obj: dict, filter_type: str) -> dict:
+    """Remove UNWANTED_KEYS from a dict."""
+    for unwanted_key in UNWANTED_KEYS[filter_type]:
+        if unwanted_key in obj:
+            del obj[unwanted_key]
+    fix_dates(obj)
+    return obj
+
+
+def fix_dates(obj: dict) -> dict:
+    """Fix dates from the fixtures so they can be safely reloaded later on."""
+    if "internal" not in obj:
+        return obj
+    obj["created_at_internal"] = obj["internal"]["created_at_internal"]
+    obj["last_modified_internal"] = obj["internal"]["last_modified_internal"]
+    del obj["internal"]
+    del obj["created_at"]
+    return obj
 
 
 @cli.command()
 @click.argument("data-source")
-def generate_fixtures_file(data_source):
-    """Build sample fixture file based on datasets slugs list (users, datasets, reuses)."""
+@click.argument("results-filename", default=DEFAULT_FIXTURES_RESULTS_FILENAME)
+def generate_fixtures_file(data_source: str, results_filename: str) -> None:
+    """Build sample fixture file based on datasets slugs list (users, datasets, reuses, dataservices)."""
+    results_file = pathlib.Path(results_filename)
     datasets_slugs = current_app.config["FIXTURE_DATASET_SLUGS"]
     json_result = []
 
@@ -44,31 +112,13 @@ def generate_fixtures_file(data_source):
             json_fixture = {}
 
             json_dataset = requests.get(f"{data_source}{DATASET_URL}/{slug}/").json()
-            del json_dataset["uri"]
-            del json_dataset["page"]
-            del json_dataset["last_update"]
-            del json_dataset["last_modified"]
-            del json_dataset["license"]
-            del json_dataset["badges"]
-            del json_dataset["spatial"]
-            del json_dataset["quality"]
-            json_dataset["created_at_internal"] = json_dataset.pop("created_at")
             json_resources = json_dataset.pop("resources")
-            for res in json_resources:
-                del res["latest"]
-                del res["preview_url"]
-                del res["last_modified"]
-                res["created_at_internal"] = res.pop("created_at")
             if json_dataset["organization"] is None:
                 json_owner = json_dataset.pop("owner")
                 json_dataset["owner"] = json_owner["id"]
             else:
                 json_org = json_dataset.pop("organization")
                 json_org = requests.get(f"{data_source}{ORG_URL}/{json_org['id']}/").json()
-                del json_org["members"]
-                del json_org["page"]
-                del json_org["uri"]
-                del json_org["logo_thumbnail"]
                 json_fixture["organization"] = json_org
             json_fixture["resources"] = json_resources
             json_fixture["dataset"] = json_dataset
@@ -76,50 +126,34 @@ def generate_fixtures_file(data_source):
             json_reuses = requests.get(
                 f"{data_source}{REUSE_URL}/?dataset={json_dataset['id']}"
             ).json()["data"]
-            for reuse in json_reuses:
-                del reuse["datasets"]
-                del reuse["image_thumbnail"]
-                del reuse["page"]
-                del reuse["uri"]
-                del reuse["organization"]
-                del reuse["owner"]
             json_fixture["reuses"] = json_reuses
 
             json_community = requests.get(
                 f"{data_source}{COMMUNITY_RES_URL}/?dataset={json_dataset['id']}"
             ).json()["data"]
-            for com in json_community:
-                del com["dataset"]
-                del com["organization"]
-                del com["owner"]
-                del com["latest"]
-                del com["last_modified"]
-                del com["preview_url"]
-                com["created_at_internal"] = com.pop("created_at")
             json_fixture["community_resources"] = json_community
 
             json_discussion = requests.get(
                 f"{data_source}{DISCUSSION_URL}/?for={json_dataset['id']}"
             ).json()["data"]
-            for discussion in json_discussion:
-                del discussion["subject"]
-                del discussion["user"]
-                del discussion["url"]
-                del discussion["class"]
-                for message in discussion["discussion"]:
-                    del message["posted_by"]
             json_fixture["discussions"] = json_discussion
 
+            json_dataservices = requests.get(
+                f"{data_source}{DATASERVICES_URL}/?dataset={json_dataset['id']}"
+            ).json()["data"]
+            json_fixture["dataservices"] = json_dataservices
+
             json_result.append(json_fixture)
 
-    with open("results.json", "w") as f:
-        json.dump(json_result, f)
+    with results_file.open("w") as f:
+        json.dump(json_result, f, indent=2)
+        print(f"Fixtures saved to file {results_filename}")
 
 
 @cli.command()
 @click.argument("source", default=DEFAULT_FIXTURE_FILE)
-def generate_fixtures(source):
-    """Build sample fixture data (users, datasets, reuses) from local or remote file."""
+def import_fixtures(source):
+    """Build sample fixture data (users, datasets, reuses, dataservices) from local or remote file."""
     if source.startswith("http"):
         json_fixtures = requests.get(source).json()
     else:
@@ -129,24 +163,32 @@ def generate_fixtures(source):
     with click.progressbar(json_fixtures) as bar:
         for fixture in bar:
             user = UserFactory()
+            dataset = fixture["dataset"]
+            dataset = remove_unwanted_keys(dataset, "dataset")
             if not fixture["organization"]:
-                dataset = DatasetFactory(**fixture["dataset"], owner=user)
+                dataset = DatasetFactory(**dataset, owner=user)
             else:
                 org = Organization.objects(id=fixture["organization"]["id"]).first()
                 if not org:
-                    org = OrganizationFactory(
-                        **fixture["organization"], members=[Member(user=user)]
-                    )
-                dataset = DatasetFactory(**fixture["dataset"], organization=org)
+                    organization = fixture["organization"]
+                    organization = remove_unwanted_keys(organization, "organization")
+                    org = OrganizationFactory(**organization, members=[Member(user=user)])
+                dataset = DatasetFactory(**dataset, organization=org)
             for resource in fixture["resources"]:
+                resource = remove_unwanted_keys(resource, "resource")
                 res = ResourceFactory(**resource)
                 dataset.add_resource(res)
             for reuse in fixture["reuses"]:
+                reuse = remove_unwanted_keys(reuse, "reuse")
                 ReuseFactory(**reuse, datasets=[dataset], owner=user)
             for community in fixture["community_resources"]:
+                community = remove_unwanted_keys(community, "community")
                 CommunityResourceFactory(**community, dataset=dataset, owner=user)
             for discussion in fixture["discussions"]:
+                discussion = remove_unwanted_keys(discussion, "discussion")
                 messages = discussion.pop("discussion")
+                for message in messages:
+                    message = remove_unwanted_keys(message, "message")
                 DiscussionFactory(
                     **discussion,
                     subject=dataset,
@@ -155,3 +197,17 @@ def generate_fixtures(source):
                         MessageDiscussionFactory(**message, posted_by=user) for message in messages
                     ],
                 )
+            for dataservice in fixture["dataservices"]:
+                dataservice = remove_unwanted_keys(dataservice, "dataservice")
+                if not dataservice["contact_point"]:
+                    DataserviceFactory(**dataservice, datasets=[dataset])
+                else:
+                    contact_point = ContactPoint.objects(
+                        id=dataservice["contact_point"]["id"]
+                    ).first()
+                    if not contact_point:
+                        contact_point = ContactPointFactory(**dataservice["contact_point"])
+                    dataservice.pop("contact_point")
+                    DataserviceFactory(
+                        **dataservice, datasets=[dataset], contact_point=contact_point
+                    )

udata/commands/init.py

@@ -11,7 +11,7 @@ from udata.i18n import gettext as _
 from udata.search.commands import index
 
 from .db import migrate
-from .fixtures import generate_fixtures
+from .fixtures import import_fixtures
 
 log = logging.getLogger(__name__)
 
@@ -44,6 +44,6 @@ def init(ctx):
 
         text = _("Do you want to create some sample data?")
         if click.confirm(text, default=True):
-            ctx.invoke(generate_fixtures)
+            ctx.invoke(import_fixtures)
 
     success(_("Your udata instance is ready!"))

udata/commands/tests/test_fixtures.py

@@ -0,0 +1,71 @@
+from tempfile import NamedTemporaryFile
+
+import pytest
+import requests
+from werkzeug.wrappers.response import Response
+
+import udata.commands.fixtures
+from udata import models
+from udata.core.dataservices.factories import DataserviceFactory
+from udata.core.dataset.factories import (
+    CommunityResourceFactory,
+    DatasetFactory,
+    ResourceFactory,
+)
+from udata.core.discussions.factories import DiscussionFactory, MessageDiscussionFactory
+from udata.core.organization.factories import OrganizationFactory
+from udata.core.organization.models import Member
+from udata.core.reuse.factories import ReuseFactory
+from udata.core.user.factories import UserFactory
+
+
+@pytest.mark.usefixtures("clean_db")
+class FixturesTest:
+    @pytest.mark.frontend
+    @pytest.mark.options(FIXTURE_DATASET_SLUGS=["some-test-dataset-slug"])
+    def test_generate_fixtures_file_then_import(self, app, cli, api, monkeypatch):
+        """Test generating fixtures from the current env, then importing them back."""
+        assert models.Dataset.objects.count() == 0  # Start with a clean slate.
+        user = UserFactory()
+        org = OrganizationFactory(**{}, members=[Member(user=user)])
+        # Set the same slug we're 'exporting' from the FIXTURE_DATASET_SLUG config, see the
+        # @pytest.mark.options above.
+        dataset = DatasetFactory(**{}, slug="some-test-dataset-slug", organization=org)
+        res = ResourceFactory(**{})
+        dataset.add_resource(res)
+        ReuseFactory(**{}, datasets=[dataset], owner=user)
+        CommunityResourceFactory(**{}, dataset=dataset, owner=user)
+        DiscussionFactory(
+            **{},
+            subject=dataset,
+            user=user,
+            discussion=[MessageDiscussionFactory(**{}, posted_by=user)],
+        )
+        DataserviceFactory(**{}, datasets=[dataset])
+
+        with NamedTemporaryFile(mode="w+", delete=True) as fixtures_fd:
+            # Get the fixtures from the local instance.
+            monkeypatch.setattr(requests, "get", lambda url: api.get(url))
+            monkeypatch.setattr(Response, "json", Response.get_json)
+            result = cli("generate-fixtures-file", "", fixtures_fd.name)
+            fixtures_fd.flush()
+            assert "Fixtures saved to file " in result.output
+
+            # Then load them in the database to make sure they're correct.
+            result = cli("import-fixtures", fixtures_fd.name)
+        assert models.Organization.objects(slug=org.slug).count() > 0
+        assert models.Dataset.objects.count() > 0
+        assert models.Discussion.objects.count() > 0
+        assert models.CommunityResource.objects.count() > 0
+        assert models.User.objects.count() > 0
+        assert models.Dataservice.objects.count() > 0
+
+    def test_import_fixtures_from_default_file(self, cli):
+        """Test importing fixtures from udata.commands.fixture.DEFAULT_FIXTURE_FILE."""
+        cli("import-fixtures")
+        assert models.Organization.objects.count() > 0
+        assert models.Dataset.objects.count() > 0
+        assert models.Reuse.objects.count() > 0
+        assert models.User.objects.count() > 0
+        if udata.commands.fixtures.DEFAULT_FIXTURE_FILE_TAG > "v1.0.0":
+            assert models.Dataservice.objects.count() > 0

udata/core/activity/tasks.py

@@ -1,7 +1,7 @@
 import logging
 
 from udata.models import Organization, User, db
-from udata.tasks import celery, task
+from udata.tasks import task
 
 from .signals import new_activity
 

udata/core/badges/models.py

@@ -3,11 +3,9 @@ from datetime import datetime
 
 from mongoengine.signals import post_save
 
-from udata.api_fields import field
 from udata.auth import current_user
 from udata.mongo import db
 
-from .fields import badge_fields
 from .signals import on_badge_added, on_badge_removed
 
 log = logging.getLogger(__name__)

udata/core/contact_point/api.py

@@ -1,10 +1,8 @@
 from udata.api import API, api
 from udata.api.parsers import ModelApiParser
-from udata.auth import admin_permission
 
-from .api_fields import contact_point_fields, contact_point_page_fields
+from .api_fields import contact_point_fields
 from .forms import ContactPointForm
-from .models import ContactPoint
 
 
 class ContactPointApiParser(ModelApiParser):

udata/core/dataservices/tasks.py

@@ -3,7 +3,7 @@ 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 Activity, Discussion, Follow, Transfer
+from udata.models import Discussion, Follow, Transfer
 from udata.tasks import job
 
 log = get_task_logger(__name__)