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

udata/core/organization/signals.py

@@ -2,16 +2,16 @@ from blinker import Namespace
 
 namespace = Namespace()
 
-organization_created = namespace.signal('organization-created')
+organization_created = namespace.signal("organization-created")
 
-organization_updated = namespace.signal('organization-updated')
+organization_updated = namespace.signal("organization-updated")
 
-organization_deleted = namespace.signal('organization-deleted')
+organization_deleted = namespace.signal("organization-deleted")
 
-new_member = namespace.signal('new-member')
+new_member = namespace.signal("new-member")
 
-new_membership_request = namespace.signal('new-membership-request')
+new_membership_request = namespace.signal("new-membership-request")
 
-membership_accepted = namespace.signal('membership-accepted')
+membership_accepted = namespace.signal("membership-accepted")
 
-membership_refused = namespace.signal('membership-refused')
+membership_refused = namespace.signal("membership-refused")

udata/core/organization/tasks.py

@@ -1,22 +1,21 @@
 from udata import mail
-from udata.i18n import lazy_gettext as _
 from udata.core import storages
-from udata.models import Follow, Activity, Dataset, Transfer, ContactPoint
-from udata.search import reindex
-from udata.tasks import job, task, get_logger
-
 from udata.core.badges.tasks import notify_new_badge
+from udata.i18n import lazy_gettext as _
+from udata.models import Activity, ContactPoint, Dataset, Follow, Transfer
+from udata.search import reindex
+from udata.tasks import get_logger, job, task
 
+from .constants import ASSOCIATION, CERTIFIED, COMPANY, LOCAL_AUTHORITY, PUBLIC_SERVICE
 from .models import Organization
-from .constants import CERTIFIED, PUBLIC_SERVICE, COMPANY, ASSOCIATION, LOCAL_AUTHORITY
 
 log = get_logger(__name__)
 
 
-@job('purge-organizations')
+@job("purge-organizations")
 def purge_organizations(self):
     for organization in Organization.objects(deleted__ne=None):
-        log.info(f'Purging organization {organization}')
+        log.info(f"Purging organization {organization}")
         # Remove followers
         Follow.objects(following=organization).delete()
         # Remove activity
@@ -43,28 +42,27 @@ def purge_organizations(self):
             reindex(Dataset.__name__, str(id))
 
 
-@task(route='high.mail')
+@task(route="high.mail")
 def notify_membership_request(org_id, request_id):
     org = Organization.objects.get(pk=org_id)
     request = next((r for r in org.requests if str(r.id) == request_id), None)
 
-    recipients = [m.user for m in org.by_role('admin')]
+    recipients = [m.user for m in org.by_role("admin")]
     mail.send(
-        _('New membership request'), recipients, 'membership_request',
-        org=org, request=request)
+        _("New membership request"), recipients, "membership_request", org=org, request=request
+    )
 
 
-@task(route='high.mail')
+@task(route="high.mail")
 def notify_membership_response(org_id, request_id):
     org = Organization.objects.get(pk=org_id)
     request = next((r for r in org.requests if str(r.id) == request_id), None)
 
-    if request.status == 'accepted':
-        subject = _('You are now a member of the organization "%(org)s"',
-                    org=org)
-        template = 'new_member'
+    if request.status == "accepted":
+        subject = _('You are now a member of the organization "%(org)s"', org=org)
+        template = "new_member"
     else:
-        subject, template = _('Membership refused'), 'membership_refused'
+        subject, template = _("Membership refused"), "membership_refused"
     mail.send(subject, request.user, template, org=org, request=request)
 
 
@@ -74,104 +72,87 @@ def notify_new_member(org_id, email):
     member = next((m for m in org.members if m.user.email == email), None)
 
     subject = _('You are now a member of the organization "%(org)s"', org=org)
-    mail.send(subject, member.user, 'new_member', org=org)
+    mail.send(subject, member.user, "new_member", org=org)
 
 
 @notify_new_badge(Organization, CERTIFIED)
 def notify_badge_certified(org_id):
-    '''
+    """
     Send an email when a `CERTIFIED` badge is added to an `Organization`
-    '''
+    """
     org = Organization.objects.get(pk=org_id)
     recipients = [member.user for member in org.members]
-    subject = _(
-        'Your organization "%(name)s" has been certified',
-        name=org.name
-    )
+    subject = _('Your organization "%(name)s" has been certified', name=org.name)
     mail.send(
         subject,
         recipients,
-        'badge_added_certified',
+        "badge_added_certified",
         organization=org,
-        badge=org.get_badge(CERTIFIED)
+        badge=org.get_badge(CERTIFIED),
     )
 
 
 @notify_new_badge(Organization, PUBLIC_SERVICE)
 def notify_badge_public_service(org_id):
-    '''
+    """
     Send an email when a `PUBLIC_SERVICE` badge is added to an `Organization`
-    '''
+    """
     org = Organization.objects.get(pk=org_id)
     recipients = [member.user for member in org.members]
-    subject = _(
-        'Your organization "%(name)s" has been identified as public service',
-        name=org.name
-    )
+    subject = _('Your organization "%(name)s" has been identified as public service', name=org.name)
     mail.send(
         subject,
         recipients,
-        'badge_added_public_service',
+        "badge_added_public_service",
         organization=org,
-        badge=org.get_badge(PUBLIC_SERVICE)
+        badge=org.get_badge(PUBLIC_SERVICE),
     )
 
 
 @notify_new_badge(Organization, COMPANY)
 def notify_badge_company(org_id):
-    '''
+    """
     Send an email when a `COMPANY` badge is added to an `Organization`
-    '''
+    """
     org = Organization.objects.get(pk=org_id)
     recipients = [member.user for member in org.members]
-    subject = _(
-        'Your organization "%(name)s" has been identified as a company',
-        name=org.name
-    )
+    subject = _('Your organization "%(name)s" has been identified as a company', name=org.name)
     mail.send(
-        subject,
-        recipients,
-        'badge_added_company',
-        organization=org,
-        badge=org.get_badge(COMPANY)
+        subject, recipients, "badge_added_company", organization=org, badge=org.get_badge(COMPANY)
     )
 
 
 @notify_new_badge(Organization, ASSOCIATION)
 def notify_badge_association(org_id):
-    '''
+    """
     Send an email when a `ASSOCIATION` badge is added to an `Organization`
-    '''
+    """
     org = Organization.objects.get(pk=org_id)
     recipients = [member.user for member in org.members]
-    subject = _(
-        'Your organization "%(name)s" has been identified as an association',
-        name=org.name
-    )
+    subject = _('Your organization "%(name)s" has been identified as an association', name=org.name)
     mail.send(
         subject,
         recipients,
-        'badge_added_association',
+        "badge_added_association",
         organization=org,
-        badge=org.get_badge(ASSOCIATION)
+        badge=org.get_badge(ASSOCIATION),
     )
 
 
 @notify_new_badge(Organization, LOCAL_AUTHORITY)
 def notify_badge_local_authority(org_id):
-    '''
+    """
     Send an email when a `LOCAL_AUTHORITY` badge is added to an `Organization`
-    '''
+    """
     org = Organization.objects.get(pk=org_id)
     recipients = [member.user for member in org.members]
     subject = _(
-        'Your organization "%(name)s" has been identified as a local authority',
-        name=org.name
+        'Your organization "%(name)s" has been identified as a local authority', name=org.name
     )
     mail.send(
         subject,
         recipients,
-        'badge_added_local_authority',
+        "badge_added_local_authority",
         organization=org,
-        badge=org.get_badge(LOCAL_AUTHORITY)
-    )
+        badge=org.get_badge(LOCAL_AUTHORITY),
+    )

udata/core/owned.py

@@ -5,14 +5,14 @@ from mongoengine import NULLIFY, Q, post_save
 from mongoengine.fields import ReferenceField
 
 from udata.api_fields import field
-from udata.core.organization.models import Organization
-from udata.core.user.models import User
-from udata.mongo.queryset import UDataQuerySet
-from udata.core.user.api_fields import user_ref_fields
 from udata.core.organization.api_fields import org_ref_fields
+from udata.core.organization.models import Organization
 from udata.core.organization.permissions import OrganizationPrivatePermission
-from udata.mongo.errors import FieldValidationError
+from udata.core.user.api_fields import user_ref_fields
+from udata.core.user.models import User
 from udata.i18n import lazy_gettext as _
+from udata.mongo.errors import FieldValidationError
+from udata.mongo.queryset import UDataQuerySet
 
 log = logging.getLogger(__name__)
 
@@ -23,11 +23,19 @@ class OwnedQuerySet(UDataQuerySet):
         for owner in owners:
             qs |= Q(owner=owner) | Q(organization=owner)
         return self(qs)
-    
+
+
 def check_owner_is_current_user(owner):
-    from udata.auth import current_user, admin_permission
-    if current_user.is_authenticated and owner and not admin_permission and current_user.id != owner:
-        raise FieldValidationError(_('You can only set yourself as owner'), field="owner")
+    from udata.auth import admin_permission, current_user
+
+    if (
+        current_user.is_authenticated
+        and owner
+        and not admin_permission
+        and current_user.id != owner
+    ):
+        raise FieldValidationError(_("You can only set yourself as owner"), field="owner")
+
 
 def check_organization_is_valid_for_current_user(organization):
     from udata.auth import current_user
@@ -38,13 +46,16 @@ def check_organization_is_valid_for_current_user(organization):
         raise FieldValidationError(_("Unknown organization"), field="organization")
 
     if current_user.is_authenticated and org and not OrganizationPrivatePermission(org).can():
-        raise FieldValidationError(_("Permission denied for this organization"), field="organization")
+        raise FieldValidationError(
+            _("Permission denied for this organization"), field="organization"
+        )
 
 
 class Owned(object):
-    '''
+    """
     A mixin to factorize owning behvaior between users and organizations.
-    '''
+    """
+
     owner = field(
         ReferenceField(User, reverse_delete_rule=NULLIFY),
         nested_fields=user_ref_fields,
@@ -60,26 +71,26 @@ class Owned(object):
         allow_null=True,
     )
 
-    on_owner_change = signal('Owned.on_owner_change')
+    on_owner_change = signal("Owned.on_owner_change")
 
     meta = {
-        'indexes': [
-            'owner',
-            'organization',
+        "indexes": [
+            "owner",
+            "organization",
         ],
-        'queryset_class': OwnedQuerySet,
+        "queryset_class": OwnedQuerySet,
     }
 
     def clean(self):
-        '''
+        """
         Verify owner consistency and fetch original owner before the new one erase it.
-        '''
+        """
 
         changed_fields = self._get_changed_fields()
-        if 'organization' in changed_fields and 'owner' in changed_fields:
+        if "organization" in changed_fields and "owner" in changed_fields:
             # Ownership changes (org to owner or the other way around) have already been made
             return
-        if 'organization' in changed_fields:
+        if "organization" in changed_fields:
             if self.owner:
                 # Change from owner to organization
                 self._previous_owner = self.owner
@@ -87,9 +98,9 @@ class Owned(object):
             else:
                 # Change from org to another
                 # Need to fetch previous value in base
-                original = self.__class__.objects.only('organization').get(pk=self.pk)
+                original = self.__class__.objects.only("organization").get(pk=self.pk)
                 self._previous_owner = original.organization
-        elif 'owner' in changed_fields:
+        elif "owner" in changed_fields:
             if self.organization:
                 # Change from organization to owner
                 self._previous_owner = self.organization
@@ -97,20 +108,20 @@ class Owned(object):
             else:
                 # Change from owner to another
                 # Need to fetch previous value in base
-                original = self.__class__.objects.only('owner').get(pk=self.pk)
+                original = self.__class__.objects.only("owner").get(pk=self.pk)
                 self._previous_owner = original.owner
 
 
 def owned_post_save(sender, document, **kwargs):
-    '''
+    """
     Owned mongoengine.post_save signal handler
     Dispatch the `Owned.on_owner_change` signal
     once the document has been saved including the previous owner.
 
     The signal handler should have the following signature:
     ``def handler(document, previous)``
-    '''
-    if isinstance(document, Owned) and hasattr(document, '_previous_owner'):
+    """
+    if isinstance(document, Owned) and hasattr(document, "_previous_owner"):
         Owned.on_owner_change.send(document, previous=document._previous_owner)
 
 

udata/core/post/api.py

@@ -1,156 +1,157 @@
 from datetime import datetime
 
-from udata.api import api, fields, API
+from udata.api import API, api, fields
 from udata.auth import admin_permission
-
 from udata.core.dataset.api_fields import dataset_fields
 from udata.core.reuse.api_fields import reuse_fields
-from udata.core.user.api_fields import user_ref_fields
 from udata.core.storages.api import (
-    uploaded_image_fields, image_parser, parse_uploaded_image
+    image_parser,
+    parse_uploaded_image,
+    uploaded_image_fields,
 )
+from udata.core.user.api_fields import user_ref_fields
 
-from .models import Post
 from .forms import PostForm
+from .models import Post
 
-ns = api.namespace('posts', 'Posts related operations')
-
-post_fields = api.model('Post', {
-    'id': fields.String(description='The post identifier'),
-    'name': fields.String(description='The post name', required=True),
-    'slug': fields.String(
-        description='The post permalink string', readonly=True),
-    'headline': fields.String(description='The post headline', required=True),
-    'content': fields.Markdown(
-        description='The post content in Markdown', required=True),
-
-    'image': fields.ImageField(description='The post image', readonly=True),
-    'credit_to': fields.String(
-        description='An optional credit line (associated to the image)'),
-    'credit_url': fields.String(
-        description='An optional link associated to the credits'),
-
-    'tags': fields.List(
-        fields.String, description='Some keywords to help in search'),
-    'datasets': fields.List(
-        fields.Nested(dataset_fields), description='The post datasets'),
-    'reuses': fields.List(
-        fields.Nested(reuse_fields), description='The post reuses'),
-
-    'owner': fields.Nested(
-        user_ref_fields, description='The owner user',
-        readonly=True, allow_null=True),
-    'created_at': fields.ISODateTime(
-        description='The post creation date', readonly=True),
-    'last_modified': fields.ISODateTime(
-        description='The post last modification date', readonly=True),
-    'published': fields.ISODateTime(
-        description='The post publication date', readonly=True),
-    'body_type': fields.String(description='HTML or markdown body type', default='markdown'),
-    'uri': fields.UrlFor(
-        'api.post', lambda o: {'post': o},
-        description='The post API URI', readonly=True),
-    'page': fields.UrlFor(
-        'posts.show', lambda o: {'post': o},
-        description='The post page URL', readonly=True, fallback_endpoint='api.post'),
-}, mask='*,datasets{id,title,acronym,uri,page},reuses{id,title,image,image_thumbnail,uri,page}')
-
-post_page_fields = api.model('PostPage', fields.pager(post_fields))
+ns = api.namespace("posts", "Posts related operations")
+
+post_fields = api.model(
+    "Post",
+    {
+        "id": fields.String(description="The post identifier"),
+        "name": fields.String(description="The post name", required=True),
+        "slug": fields.String(description="The post permalink string", readonly=True),
+        "headline": fields.String(description="The post headline", required=True),
+        "content": fields.Markdown(description="The post content in Markdown", required=True),
+        "image": fields.ImageField(description="The post image", readonly=True),
+        "credit_to": fields.String(description="An optional credit line (associated to the image)"),
+        "credit_url": fields.String(description="An optional link associated to the credits"),
+        "tags": fields.List(fields.String, description="Some keywords to help in search"),
+        "datasets": fields.List(fields.Nested(dataset_fields), description="The post datasets"),
+        "reuses": fields.List(fields.Nested(reuse_fields), description="The post reuses"),
+        "owner": fields.Nested(
+            user_ref_fields, description="The owner user", readonly=True, allow_null=True
+        ),
+        "created_at": fields.ISODateTime(description="The post creation date", readonly=True),
+        "last_modified": fields.ISODateTime(
+            description="The post last modification date", readonly=True
+        ),
+        "published": fields.ISODateTime(description="The post publication date", readonly=True),
+        "body_type": fields.String(description="HTML or markdown body type", default="markdown"),
+        "uri": fields.UrlFor(
+            "api.post", lambda o: {"post": o}, description="The post API URI", readonly=True
+        ),
+        "page": fields.UrlFor(
+            "posts.show",
+            lambda o: {"post": o},
+            description="The post page URL",
+            readonly=True,
+            fallback_endpoint="api.post",
+        ),
+    },
+    mask="*,datasets{id,title,acronym,uri,page},reuses{id,title,image,image_thumbnail,uri,page}",
+)
+
+post_page_fields = api.model("PostPage", fields.pager(post_fields))
 
 parser = api.page_parser()
 
-parser.add_argument('sort', type=str, default='-created_at', location='args',
-                    help='The sorting attribute')
+parser.add_argument(
+    "sort", type=str, default="-created_at", location="args", help="The sorting attribute"
+)
 
 
-@ns.route('/', endpoint='posts')
+@ns.route("/", endpoint="posts")
 class PostsAPI(API):
-
-    @api.doc('list_posts')
+    @api.doc("list_posts")
     @api.expect(parser)
     @api.marshal_with(post_page_fields)
     def get(self):
-        '''List all posts'''
+        """List all posts"""
         args = parser.parse_args()
-        return (Post.objects.published().order_by(args['sort'])
-                            .paginate(args['page'], args['page_size']))
+        return (
+            Post.objects.published()
+            .order_by(args["sort"])
+            .paginate(args["page"], args["page_size"])
+        )
 
-    @api.doc('create_post')
+    @api.doc("create_post")
     @api.secure(admin_permission)
     @api.expect(post_fields)
     @api.marshal_with(post_fields)
-    @api.response(400, 'Validation error')
+    @api.response(400, "Validation error")
     def post(self):
-        '''Create a post'''
+        """Create a post"""
         form = api.validate(PostForm)
         return form.save(), 201
 
 
-@ns.route('/<post:post>/', endpoint='post')
-@api.response(404, 'Object not found')
-@api.param('post', 'The post ID or slug')
+@ns.route("/<post:post>/", endpoint="post")
+@api.response(404, "Object not found")
+@api.param("post", "The post ID or slug")
 class PostAPI(API):
-    @api.doc('get_post')
+    @api.doc("get_post")
     @api.marshal_with(post_fields)
     def get(self, post):
-        '''Get a given post'''
+        """Get a given post"""
         return post
 
-    @api.doc('update_post')
+    @api.doc("update_post")
     @api.secure(admin_permission)
     @api.expect(post_fields)
     @api.marshal_with(post_fields)
-    @api.response(400, 'Validation error')
+    @api.response(400, "Validation error")
     def put(self, post):
-        '''Update a given post'''
+        """Update a given post"""
         form = api.validate(PostForm, post)
         return form.save()
 
     @api.secure(admin_permission)
-    @api.doc('delete_post')
-    @api.response(204, 'Object deleted')
+    @api.doc("delete_post")
+    @api.response(204, "Object deleted")
     def delete(self, post):
-        '''Delete a given post'''
+        """Delete a given post"""
         post.delete()
-        return '', 204
+        return "", 204
 
 
-@ns.route('/<post:post>/publish', endpoint='publish_post')
+@ns.route("/<post:post>/publish", endpoint="publish_post")
 class PublishPostAPI(API):
     @api.secure(admin_permission)
-    @api.doc('publish_post')
+    @api.doc("publish_post")
     @api.marshal_with(post_fields)
     def post(self, post):
-        '''Publish an existing post'''
+        """Publish an existing post"""
         post.modify(published=datetime.utcnow())
         return post
 
     @api.secure(admin_permission)
-    @api.doc('unpublish_post')
+    @api.doc("unpublish_post")
     @api.marshal_with(post_fields)
     def delete(self, post):
-        '''Publish an existing post'''
+        """Publish an existing post"""
         post.modify(published=None)
         return post
 
 
-@ns.route('/<post:post>/image', endpoint='post_image')
+@ns.route("/<post:post>/image", endpoint="post_image")
 class PostImageAPI(API):
     @api.secure(admin_permission)
-    @api.doc('post_image')
+    @api.doc("post_image")
     @api.expect(image_parser)  # Swagger 2.0 does not support formData at path level
     @api.marshal_with(uploaded_image_fields)
     def post(self, post):
-        '''Upload a new image'''
+        """Upload a new image"""
         parse_uploaded_image(post.image)
         post.save()
         return post
 
     @api.secure(admin_permission)
-    @api.doc('resize_post_image')
+    @api.doc("resize_post_image")
     @api.expect(image_parser)  # Swagger 2.0 does not support formData at path level
     @api.marshal_with(uploaded_image_fields)
     def put(self, post):
-        '''Set the image BBox'''
+        """Set the image BBox"""
         parse_uploaded_image(post.image)
         return post

udata/core/post/constants.py

@@ -1,9 +1,12 @@
-from udata.i18n import lazy_gettext as _
 from collections import OrderedDict
 
+from udata.i18n import lazy_gettext as _
+
 IMAGE_SIZES = [400, 100, 50]
 
-BODY_TYPES = OrderedDict([
-    ('markdown', _('Markdown')),
-    ('html', _('HTML')),
-])
+BODY_TYPES = OrderedDict(
+    [
+        ("markdown", _("Markdown")),
+        ("html", _("HTML")),
+    ]
+)

udata/core/post/factories.py

@@ -11,10 +11,10 @@ class PostFactory(ModelFactory):
     class Meta:
         model = Post
 
-    name = factory.Faker('sentence')
-    headline = factory.Faker('sentence')
-    content = factory.Faker('text')
-    published = factory.Faker('past_datetime')
+    name = factory.Faker("sentence")
+    headline = factory.Faker("sentence")
+    content = factory.Faker("text")
+    published = factory.Faker("past_datetime")
 
     @factory.lazy_attribute
     def datasets(self):