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

udata/core/activity/tasks.py

@@ -1,7 +1,7 @@
 import logging
 
-from udata.models import db, User, Organization
-from udata.tasks import task, celery
+from udata.models import Organization, User, db
+from udata.tasks import celery, task
 
 from .signals import new_activity
 
@@ -16,16 +16,23 @@ def delay_activity(cls, related_to, actor, organization=None, extras=None):
         related_to_cls=related_to.__class__.__name__,
         related_to_id=str(related_to.id),
         organization_id=str(organization.id) if organization else None,
-        extras=extras
+        extras=extras,
     )
 
 
 @task
-def emit_activity(classname, actor_id, related_to_cls, related_to_id,
-                  organization_id=None, extras=None):
-    log.debug('Emit new activity: %s %s %s %s %s %s',
-              classname, actor_id, related_to_cls,
-              related_to_id, organization_id, extras)
+def emit_activity(
+    classname, actor_id, related_to_cls, related_to_id, organization_id=None, extras=None
+):
+    log.debug(
+        "Emit new activity: %s %s %s %s %s %s",
+        classname,
+        actor_id,
+        related_to_cls,
+        related_to_id,
+        organization_id,
+        extras,
+    )
     cls = db.resolve_model(classname)
     actor = User.objects.get(pk=actor_id)
     related_to = db.resolve_model(related_to_cls).objects.get(pk=related_to_id)
@@ -33,5 +40,4 @@ def emit_activity(classname, actor_id, related_to_cls, related_to_id,
         organization = Organization.objects.get(pk=organization_id)
     else:
         organization = None
-    cls.objects.create(actor=actor, related_to=related_to,
-                       organization=organization, extras=extras)
+    cls.objects.create(actor=actor, related_to=related_to, organization=organization, extras=extras)

udata/core/badges/api.py

@@ -4,14 +4,14 @@ from .forms import badge_form
 
 
 def add(obj):
-    '''
+    """
     Handle a badge add API.
 
     - Expecting badge_fieds as payload
     - Return the badge as payload
     - Return 200 if the badge is already
     - Return 201 if the badge is added
-    '''
+    """
     Form = badge_form(obj.__class__)
     form = api.validate(Form)
     kind = form.kind.data
@@ -23,13 +23,13 @@ def add(obj):
 
 
 def remove(obj, kind):
-    '''
+    """
     Handle badge removal API
 
     - Returns 404 if the badge for this kind is absent
     - Returns 204 on success
-    '''
+    """
     if not obj.get_badge(kind):
-        api.abort(404, 'Badge does not exists')
+        api.abort(404, "Badge does not exists")
     obj.remove_badge(kind)
-    return '', 204
+    return "", 204

udata/core/badges/commands.py

@@ -1,40 +1,41 @@
-import click
 import logging
-
 from os.path import exists
 
+import click
+
 from udata.commands import cli
 from udata.models import Organization
 
 log = logging.getLogger(__name__)
 
 
-@cli.group('badges')
+@cli.group("badges")
 def grp():
-    '''Badges related operations'''
+    """Badges related operations"""
 
 
 def toggle_badge(id_or_slug, badge_kind):
     organization = Organization.objects.get_by_id_or_slug(id_or_slug)
     if not organization:
-        log.error('No organization found for %s', id_or_slug)
+        log.error("No organization found for %s", id_or_slug)
         return
-    log.info('Toggling badge {kind} for organization {org}'.format(
-        kind=badge_kind,
-        org=organization.name
-    ))
+    log.info(
+        "Toggling badge {kind} for organization {org}".format(
+            kind=badge_kind, org=organization.name
+        )
+    )
     organization.toggle_badge(badge_kind)
 
 
 @grp.command()
-@click.argument('path_or_id')
-@click.argument('badge_kind')
+@click.argument("path_or_id")
+@click.argument("badge_kind")
 def toggle(path_or_id, badge_kind):
-    '''Toggle a `badge_kind` for a given `path_or_id`
+    """Toggle a `badge_kind` for a given `path_or_id`
 
     The `path_or_id` is either an id, a slug or a file containing a list
     of ids or slugs.
-    '''
+    """
     if exists(path_or_id):
         with open(path_or_id) as open_file:
             for id_or_slug in open_file.readlines():

udata/core/badges/fields.py

@@ -1,7 +1,10 @@
 from udata.api import api, fields
 
-badge_fields = api.model('Badge', {
-    'kind': fields.String(description=('Kind of badge (certified, etc), '
-                                       'specific to each model'),
-                          required=True),
-})
+badge_fields = api.model(
+    "Badge",
+    {
+        "kind": fields.String(
+            description=("Kind of badge (certified, etc), " "specific to each model"), required=True
+        ),
+    },
+)

udata/core/badges/forms.py

@@ -2,17 +2,20 @@ from udata.forms import ModelForm, fields, validators
 from udata.i18n import lazy_gettext as _
 from udata.models import Badge
 
-__all__ = ('badge_form', )
+__all__ = ("badge_form",)
 
 
 def badge_form(model):
-    '''A form factory for a given model badges'''
+    """A form factory for a given model badges"""
+
     class BadgeForm(ModelForm):
         model_class = Badge
 
         kind = fields.RadioField(
-            _('Kind'), [validators.DataRequired()],
+            _("Kind"),
+            [validators.DataRequired()],
             choices=list(model.__badges__.items()),
-            description=_('Kind of badge (certified, etc)'))
+            description=_("Kind of badge (certified, etc)"),
+        )
 
     return BadgeForm

udata/core/badges/models.py

@@ -1,5 +1,4 @@
 import logging
-
 from datetime import datetime
 
 from mongoengine.signals import post_save
@@ -8,26 +7,26 @@ from udata.api_fields import field
 from udata.auth import current_user
 from udata.mongo import db
 
-from .signals import on_badge_added, on_badge_removed
 from .fields import badge_fields
+from .signals import on_badge_added, on_badge_removed
 
 log = logging.getLogger(__name__)
 
-__all__ = ('Badge', 'BadgeMixin')
+__all__ = ("Badge", "BadgeMixin")
 
 
 class Badge(db.EmbeddedDocument):
     kind = db.StringField(required=True)
     created = db.DateTimeField(default=datetime.utcnow, required=True)
-    created_by = db.ReferenceField('User')
+    created_by = db.ReferenceField("User")
 
     def __str__(self):
         return self.kind
 
     def validate(self, clean=True):
-        badges = getattr(self._instance, '__badges__', {})
+        badges = getattr(self._instance, "__badges__", {})
         if self.kind not in badges.keys():
-            raise db.ValidationError('Unknown badge type %s' % self.kind)
+            raise db.ValidationError("Unknown badge type %s" % self.kind)
         return super(Badge, self).validate(clean=clean)
 
 
@@ -38,9 +37,7 @@ class BadgesList(db.EmbeddedDocumentListField):
     def validate(self, value):
         kinds = [b.kind for b in value]
         if len(kinds) > len(set(kinds)):
-            raise db.ValidationError(
-                'Duplicate badges for a given kind is not allowed'
-            )
+            raise db.ValidationError("Duplicate badges for a given kind is not allowed")
         return super(BadgesList, self).validate(value)
 
 
@@ -48,49 +45,37 @@ class BadgeMixin(object):
     badges = BadgesList()
 
     def get_badge(self, kind):
-        ''' Get a badge given its kind if present'''
+        """Get a badge given its kind if present"""
         candidates = [b for b in self.badges if b.kind == kind]
         return candidates[0] if candidates else None
 
     def add_badge(self, kind):
-        '''Perform an atomic prepend for a new badge'''
+        """Perform an atomic prepend for a new badge"""
         badge = self.get_badge(kind)
         if badge:
             return badge
-        if kind not in getattr(self, '__badges__', {}):
-            msg = 'Unknown badge type for {model}: {kind}'
-            raise db.ValidationError(msg.format(model=self.__class__.__name__,
-                                                kind=kind))
+        if kind not in getattr(self, "__badges__", {}):
+            msg = "Unknown badge type for {model}: {kind}"
+            raise db.ValidationError(msg.format(model=self.__class__.__name__, kind=kind))
         badge = Badge(kind=kind)
         if current_user.is_authenticated:
             badge.created_by = current_user.id
 
-        self.update(__raw__={
-            '$push': {
-                'badges': {
-                    '$each': [badge.to_mongo()],
-                    '$position': 0
-                }
-            }
-        })
+        self.update(__raw__={"$push": {"badges": {"$each": [badge.to_mongo()], "$position": 0}}})
         self.reload()
         post_save.send(self.__class__, document=self)
         on_badge_added.send(self, kind=kind)
         return self.get_badge(kind)
 
     def remove_badge(self, kind):
-        '''Perform an atomic removal for a given badge'''
-        self.update(__raw__={
-            '$pull': {
-                'badges': {'kind': kind}
-            }
-        })
+        """Perform an atomic removal for a given badge"""
+        self.update(__raw__={"$pull": {"badges": {"kind": kind}}})
         self.reload()
         on_badge_removed.send(self, kind=kind)
         post_save.send(self.__class__, document=self)
 
     def toggle_badge(self, kind):
-        '''Toggle a bdage given its kind'''
+        """Toggle a bdage given its kind"""
         badge = self.get_badge(kind)
         if badge:
             return self.remove_badge(kind)
@@ -98,6 +83,6 @@ class BadgeMixin(object):
             return self.add_badge(kind)
 
     def badge_label(self, badge):
-        '''Display the badge label for a given kind'''
+        """Display the badge label for a given kind"""
         kind = badge.kind if isinstance(badge, Badge) else badge
         return self.__badges__[kind]

udata/core/badges/permissions.py

@@ -1,14 +1,12 @@
 from udata.auth import Permission
-
 from udata.core.organization.permissions import OrganizationAdminNeed
 
 
 class BadgePermission(Permission):
-
     def __init__(self, badge):
         needs = []
         subject = badge.subject
-        if getattr(subject, 'organization', False):  # This is a Dataset.
+        if getattr(subject, "organization", False):  # This is a Dataset.
             organization_id = subject.organization.id
         else:  # This is an Organization.
             organization_id = subject.id

udata/core/badges/signals.py

@@ -3,7 +3,7 @@ from blinker import Namespace
 namespace = Namespace()
 
 #: Trigerred when a badge is added
-on_badge_added = namespace.signal('on-badge-added')
+on_badge_added = namespace.signal("on-badge-added")
 
 #: Trigerred when a badge is removed
-on_badge_removed = namespace.signal('on-badge-removed')
+on_badge_removed = namespace.signal("on-badge-removed")

udata/core/badges/tasks.py

@@ -1,4 +1,4 @@
-from udata.tasks import task, get_logger
+from udata.tasks import get_logger, task
 
 from .signals import on_badge_added
 
@@ -10,9 +10,10 @@ def notify_new_badge(cls, kind):
         t = task(func)
 
         def call_task(sender, **kwargs):
-            if isinstance(sender, cls) and kwargs.get('kind') == kind:
+            if isinstance(sender, cls) and kwargs.get("kind") == kind:
                 t.delay(str(sender.pk))
 
         on_badge_added.connect(call_task, weak=False)
         return t
+
     return wrapper

udata/core/badges/tests/test_commands.py

@@ -1,21 +1,21 @@
-import pytest
-
 from tempfile import NamedTemporaryFile
 
-from udata.models import Badge
+import pytest
+
 from udata.core.organization.constants import CERTIFIED, PUBLIC_SERVICE
 from udata.core.organization.factories import OrganizationFactory
+from udata.models import Badge
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class BadgeCommandTest:
     def toggle(self, path_or_id, kind):
-        return self.cli('badges', 'toggle', path_or_id, kind)
+        return self.cli("badges", "toggle", path_or_id, kind)
 
     def test_toggle_badge_on(self, cli):
         org = OrganizationFactory()
 
-        cli('badges', 'toggle', str(org.id), PUBLIC_SERVICE)
+        cli("badges", "toggle", str(org.id), PUBLIC_SERVICE)
 
         org.reload()
         assert org.badges[0].kind == PUBLIC_SERVICE
@@ -25,7 +25,7 @@ class BadgeCommandTest:
         certified_badge = Badge(kind=CERTIFIED)
         org = OrganizationFactory(badges=[ps_badge, certified_badge])
 
-        cli('badges', 'toggle', str(org.id), PUBLIC_SERVICE)
+        cli("badges", "toggle", str(org.id), PUBLIC_SERVICE)
 
         org.reload()
         assert org.badges[0].kind == CERTIFIED
@@ -33,11 +33,11 @@ class BadgeCommandTest:
     def test_toggle_badge_on_from_file(self, cli):
         orgs = [OrganizationFactory() for _ in range(2)]
 
-        with NamedTemporaryFile(mode='w') as temp:
-            temp.write('\n'.join((str(org.id) for org in orgs)))
+        with NamedTemporaryFile(mode="w") as temp:
+            temp.write("\n".join((str(org.id) for org in orgs)))
             temp.flush()
 
-            cli('badges', 'toggle', temp.name, PUBLIC_SERVICE)
+            cli("badges", "toggle", temp.name, PUBLIC_SERVICE)
 
         for org in orgs:
             org.reload()

udata/core/badges/tests/test_model.py

@@ -1,45 +1,41 @@
 from udata.auth import login_user
-from udata.mongo import db
-from udata.tests import TestCase, DBTestMixin
 from udata.core.user.factories import UserFactory
+from udata.mongo import db
+from udata.tests import DBTestMixin, TestCase
 
 from ..models import Badge, BadgeMixin
 
-
-TEST = 'test'
-OTHER = 'other'
+TEST = "test"
+OTHER = "other"
 
 
 class Fake(db.Document, BadgeMixin):
     __badges__ = {
-        TEST: 'Test',
-        OTHER: 'Other',
+        TEST: "Test",
+        OTHER: "Other",
     }
 
 
 class BadgeMixinTest(DBTestMixin, TestCase):
     def test_attributes(self):
-        '''It should have a badge list'''
+        """It should have a badge list"""
         fake = Fake.objects.create()
         self.assertIsInstance(fake.badges, (list, tuple))
 
     def test_get_badge_found(self):
-        '''It allow to get a badge by kind if present'''
-        fake = Fake.objects.create(badges=[
-            Badge(kind=TEST),
-            Badge(kind=OTHER)
-        ])
+        """It allow to get a badge by kind if present"""
+        fake = Fake.objects.create(badges=[Badge(kind=TEST), Badge(kind=OTHER)])
         badge = fake.get_badge(TEST)
         self.assertEqual(badge.kind, TEST)
 
     def test_get_badge_not_found(self):
-        '''It should return None if badge is absent'''
+        """It should return None if badge is absent"""
         fake = Fake.objects.create(badges=[Badge(kind=OTHER)])
         badge = fake.get_badge(TEST)
         self.assertIsNone(badge)
 
     def test_add_badge(self):
-        '''It should add a badge of a given kind'''
+        """It should add a badge of a given kind"""
         fake = Fake.objects.create()
 
         result = fake.add_badge(TEST)
@@ -52,7 +48,7 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertIsNone(badge.created_by)
 
     def test_add_2nd_badge(self):
-        '''It should add badges to the top of the list'''
+        """It should add badges to the top of the list"""
         fake = Fake.objects.create(badges=[Badge(kind=OTHER)])
 
         result = fake.add_badge(TEST)
@@ -65,7 +61,7 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertEqual(fake.badges[-1].kind, OTHER)
 
     def test_add_badge_with_logged_user(self):
-        '''It should track the user that add a badge'''
+        """It should track the user that add a badge"""
         user = UserFactory()
         fake = Fake.objects.create()
 
@@ -80,16 +76,16 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertEqual(badge.created_by, user)
 
     def test_add_unknown_badge(self):
-        '''It should not allow to add an unknown badge kind'''
+        """It should not allow to add an unknown badge kind"""
         fake = Fake.objects.create()
 
         with self.assertRaises(db.ValidationError):
-            fake.add_badge('unknown')
+            fake.add_badge("unknown")
 
         self.assertEqual(len(fake.badges), 0)
 
     def test_remove_badge(self):
-        '''It should remove a badge given its kind'''
+        """It should remove a badge given its kind"""
         badge = Badge(kind=TEST)
         fake = Fake.objects.create(badges=[badge])
 
@@ -98,7 +94,7 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertEqual(len(fake.badges), 0)
 
     def test_add_badge_twice(self):
-        '''It should not duplicate badges'''
+        """It should not duplicate badges"""
         fake = Fake.objects.create()
 
         result1 = fake.add_badge(TEST)
@@ -112,7 +108,7 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertIsNone(badge.created_by)
 
     def test_toggle_add_badge(self):
-        '''Toggle should add a badge of a given kind if absent'''
+        """Toggle should add a badge of a given kind if absent"""
         fake = Fake.objects.create()
 
         result = fake.toggle_badge(TEST)
@@ -124,7 +120,7 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertIsNotNone(badge.created)
 
     def test_toggle_remove_badge(self):
-        '''Toggle should remove a badge given its kind if present'''
+        """Toggle should remove a badge given its kind if present"""
         badge = Badge(kind=TEST)
         fake = Fake.objects.create(badges=[badge])
 
@@ -133,11 +129,8 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         self.assertEqual(len(fake.badges), 0)
 
     def test_create_with_badges(self):
-        '''It should allow object creation with badges'''
-        fake = Fake.objects.create(badges=[
-            Badge(kind=TEST),
-            Badge(kind=OTHER)
-        ])
+        """It should allow object creation with badges"""
+        fake = Fake.objects.create(badges=[Badge(kind=TEST), Badge(kind=OTHER)])
 
         self.assertEqual(len(fake.badges), 2)
         for badge, kind in zip(fake.badges, (TEST, OTHER)):
@@ -145,11 +138,11 @@ class BadgeMixinTest(DBTestMixin, TestCase):
             self.assertIsNotNone(badge.created)
 
     def test_create_disallow_duplicate_badges(self):
-        '''It should not allow object creation with duplicate badges'''
+        """It should not allow object creation with duplicate badges"""
         with self.assertRaises(db.ValidationError):
             Fake.objects.create(badges=[Badge(kind=TEST), Badge(kind=TEST)])
 
     def test_create_disallow_unknown_badges(self):
-        '''It should not allow object creation with unknown badges'''
+        """It should not allow object creation with unknown badges"""
         with self.assertRaises(db.ValidationError):
-            Fake.objects.create(badges=[Badge(kind='unknown')])
+            Fake.objects.create(badges=[Badge(kind="unknown")])

udata/core/contact_point/api.py

@@ -1,4 +1,4 @@
-from udata.api import api, API
+from udata.api import API, api
 from udata.api.parsers import ModelApiParser
 from udata.auth import admin_permission
 
@@ -14,49 +14,50 @@ class ContactPointApiParser(ModelApiParser):
         super().__init__()
 
 
-ns = api.namespace('contacts', 'Contact points related operations')
+ns = api.namespace("contacts", "Contact points related operations")
 
 contact_point_parser = ContactPointApiParser()
 
 
-@ns.route('/', endpoint='contact_points')
+@ns.route("/", endpoint="contact_points")
 class ContactPointsListAPI(API):
-    '''Contact points collection endpoint'''
+    """Contact points collection endpoint"""
+
     @api.secure
-    @api.doc('create_contact_point')
+    @api.doc("create_contact_point")
     @api.expect(contact_point_fields)
     @api.marshal_with(contact_point_fields)
-    @api.response(400, 'Validation error')
+    @api.response(400, "Validation error")
     def post(self):
-        '''Creates a contact point'''
+        """Creates a contact point"""
         form = api.validate(ContactPointForm)
         contact_point = form.save()
         return contact_point, 201
 
 
-@ns.route('/<contact_point:contact_point>/', endpoint='contact_point')
-@api.response(404, 'Contact point not found')
+@ns.route("/<contact_point:contact_point>/", endpoint="contact_point")
+@api.response(404, "Contact point not found")
 class ContactPointAPI(API):
-    @api.doc('get_contact_point')
+    @api.doc("get_contact_point")
     @api.marshal_with(contact_point_fields)
     def get(self, contact_point):
-        '''Get a contact point given its identifier'''
+        """Get a contact point given its identifier"""
         return contact_point
 
     @api.secure
-    @api.doc('update_contact_point')
+    @api.doc("update_contact_point")
     @api.expect(contact_point_fields)
     @api.marshal_with(contact_point_fields)
-    @api.response(400, 'Validation error')
+    @api.response(400, "Validation error")
     def put(self, contact_point):
-        '''Updates a contact point given its identifier'''
+        """Updates a contact point given its identifier"""
         form = api.validate(ContactPointForm, contact_point)
         return form.save()
 
     @api.secure
-    @api.doc('delete_contact_point')
-    @api.response(204, 'Contact point deleted')
+    @api.doc("delete_contact_point")
+    @api.response(204, "Contact point deleted")
     def delete(self, contact_point):
-        '''Deletes a contact point given its identifier'''
+        """Deletes a contact point given its identifier"""
         contact_point.delete()
-        return '', 204
+        return "", 204

udata/core/contact_point/api_fields.py

@@ -2,19 +2,26 @@ from udata.api import api, fields
 from udata.core.organization.api_fields import org_ref_fields
 from udata.core.user.api_fields import user_ref_fields
 
+DEFAULT_MASK = ",".join(("id", "name", "email"))
 
-DEFAULT_MASK = ','.join(('id', 'name', 'email'))
+contact_point_fields = api.model(
+    "ContactPoint",
+    {
+        "id": fields.String(description="The contact point's identifier", readonly=True),
+        "name": fields.String(description="The contact point's name", required=True),
+        "email": fields.String(description="The contact point's email", required=True),
+        "organization": fields.Nested(
+            org_ref_fields, allow_null=True, description="The producer organization"
+        ),
+        "owner": fields.Nested(
+            user_ref_fields, allow_null=True, description="The user information"
+        ),
+    },
+    mask=DEFAULT_MASK,
+)
 
-contact_point_fields = api.model('ContactPoint', {
-    'id': fields.String(description='The contact point\'s identifier', readonly=True),
-    'name': fields.String(description='The contact point\'s name', required=True),
-    'email': fields.String(description='The contact point\'s email', required=True),
-    'organization': fields.Nested(
-        org_ref_fields, allow_null=True,
-        description='The producer organization'),
-    'owner': fields.Nested(
-        user_ref_fields, allow_null=True, description='The user information')
-}, mask=DEFAULT_MASK)
-
-contact_point_page_fields = api.model('ContactPointPage', fields.pager(contact_point_fields),
-                                      mask='data{{{0}}},*'.format(DEFAULT_MASK))
+contact_point_page_fields = api.model(
+    "ContactPointPage",
+    fields.pager(contact_point_fields),
+    mask="data{{{0}}},*".format(DEFAULT_MASK),
+)