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

udata/core/discussions/tasks.py

@@ -1,22 +1,20 @@
 from udata import mail
-from udata.i18n import lazy_gettext as _
 from udata.core.dataset.models import Dataset
-from udata.core.reuse.models import Reuse
 from udata.core.post.models import Post
+from udata.core.reuse.models import Reuse
+from udata.i18n import lazy_gettext as _
 from udata.tasks import connect, get_logger
 
 from .models import Discussion, Message
-from .signals import (
-    on_new_discussion, on_new_discussion_comment, on_discussion_closed
-)
+from .signals import on_discussion_closed, on_new_discussion, on_new_discussion_comment
 
 log = get_logger(__name__)
 
 
 def owner_recipients(discussion):
-    if getattr(discussion.subject, 'organization', None):
+    if getattr(discussion.subject, "organization", None):
         return [m.user for m in discussion.subject.organization.members]
-    elif getattr(discussion.subject, 'owner', None):
+    elif getattr(discussion.subject, "owner", None):
         return [discussion.subject.owner]
     else:
         return []
@@ -27,13 +25,16 @@ def notify_new_discussion(discussion_id):
     discussion = Discussion.objects.get(pk=discussion_id)
     if isinstance(discussion.subject, (Dataset, Reuse, Post)):
         recipients = owner_recipients(discussion)
-        subject = _('Your %(type)s have a new discussion',
-                    type=discussion.subject.verbose_name)
-        mail.send(subject, recipients, 'new_discussion',
-                  discussion=discussion, message=discussion.discussion[0])
+        subject = _("Your %(type)s have a new discussion", type=discussion.subject.verbose_name)
+        mail.send(
+            subject,
+            recipients,
+            "new_discussion",
+            discussion=discussion,
+            message=discussion.discussion[0],
+        )
     else:
-        log.warning('Unrecognized discussion subject type %s',
-                    type(discussion.subject))
+        log.warning("Unrecognized discussion subject type %s", type(discussion.subject))
 
 
 @connect(on_new_discussion_comment, by_id=True)
@@ -41,17 +42,15 @@ def notify_new_discussion_comment(discussion_id, message=None):
     discussion = Discussion.objects.get(pk=discussion_id)
     message = discussion.discussion[message]
     if isinstance(discussion.subject, (Dataset, Reuse, Post)):
-        recipients = owner_recipients(discussion) + [
-            m.posted_by for m in discussion.discussion]
+        recipients = owner_recipients(discussion) + [m.posted_by for m in discussion.discussion]
         recipients = list({u.id: u for u in recipients if u != message.posted_by}.values())
-        subject = _('%(user)s commented your discussion',
-                    user=message.posted_by.fullname)
+        subject = _("%(user)s commented your discussion", user=message.posted_by.fullname)
 
-        mail.send(subject, recipients, 'new_discussion_comment',
-                  discussion=discussion, message=message)
+        mail.send(
+            subject, recipients, "new_discussion_comment", discussion=discussion, message=message
+        )
     else:
-        log.warning('Unrecognized discussion subject type %s',
-                    type(discussion.subject))
+        log.warning("Unrecognized discussion subject type %s", type(discussion.subject))
 
 
 @connect(on_discussion_closed, by_id=True)
@@ -59,12 +58,9 @@ def notify_discussion_closed(discussion_id, message=None):
     discussion = Discussion.objects.get(pk=discussion_id)
     message = discussion.discussion[message]
     if isinstance(discussion.subject, (Dataset, Reuse, Post)):
-        recipients = owner_recipients(discussion) + [
-            m.posted_by for m in discussion.discussion]
+        recipients = owner_recipients(discussion) + [m.posted_by for m in discussion.discussion]
         recipients = list({u.id: u for u in recipients if u != message.posted_by}.values())
-        subject = _('A discussion has been closed')
-        mail.send(subject, recipients, 'discussion_closed',
-                  discussion=discussion, message=message)
+        subject = _("A discussion has been closed")
+        mail.send(subject, recipients, "discussion_closed", discussion=discussion, message=message)
     else:
-        log.warning('Unrecognized discussion subject type %s',
-                    type(discussion.subject))
+        log.warning("Unrecognized discussion subject type %s", type(discussion.subject))

udata/core/followers/api.py

@@ -4,72 +4,71 @@ from flask import current_app, request
 from flask_security import current_user
 
 from udata import tracking
-from udata.api import api, API, fields
-from udata.models import Follow
+from udata.api import API, api, fields
 from udata.core.user.api_fields import user_ref_fields
+from udata.models import Follow
 from udata.utils import id_or_404
 
 from .signals import on_new_follow
 
+follow_fields = api.model(
+    "Follow",
+    {
+        "id": fields.String(description="The follow object technical ID", readonly=True),
+        "follower": fields.Nested(user_ref_fields, description="The follower", readonly=True),
+        "since": fields.ISODateTime(
+            description="The date from which the user started following", readonly=True
+        ),
+    },
+)
 
-follow_fields = api.model('Follow', {
-    'id': fields.String(
-        description='The follow object technical ID', readonly=True),
-    'follower': fields.Nested(
-        user_ref_fields, description='The follower', readonly=True),
-    'since': fields.ISODateTime(
-        description='The date from which the user started following',
-        readonly=True)
-})
-
-follow_page_fields = api.model('FollowPage', fields.pager(follow_fields))
+follow_page_fields = api.model("FollowPage", fields.pager(follow_fields))
 
 parser = api.parser()
+parser.add_argument("page", type=int, default=1, location="args", help="The page to fetch")
 parser.add_argument(
-    'page', type=int, default=1, location='args', help='The page to fetch')
-parser.add_argument(
-    'page_size', type=int, default=20, location='args',
-    help='The page size to fetch')
+    "page_size", type=int, default=20, location="args", help="The page size to fetch"
+)
 
-NOTE = 'Returns the number of followers left after the operation'
+NOTE = "Returns the number of followers left after the operation"
 
 
 class FollowAPI(API):
-    '''
+    """
     Base Follow Model API.
-    '''
+    """
+
     model = None
 
     @api.expect(parser)
     @api.marshal_with(follow_page_fields)
     def get(self, id):
-        '''List all followers for a given object'''
+        """List all followers for a given object"""
         args = parser.parse_args()
-        model = self.model.objects.only('id').get_or_404(id=id_or_404(id))
+        model = self.model.objects.only("id").get_or_404(id=id_or_404(id))
         qs = Follow.objects(following=model, until=None)
-        return qs.paginate(args['page'], args['page_size'])
+        return qs.paginate(args["page"], args["page_size"])
 
     @api.secure
     @api.doc(description=NOTE)
     def post(self, id):
-        '''Follow an object given its ID'''
+        """Follow an object given its ID"""
         model = self.model.objects.get_or_404(id=id_or_404(id))
         follow, created = Follow.objects.get_or_create(
-            follower=current_user.id, following=model, until=None)
+            follower=current_user.id, following=model, until=None
+        )
         count = Follow.objects.followers(model).count()
-        if not current_app.config['TESTING']:
+        if not current_app.config["TESTING"]:
             tracking.send_signal(on_new_follow, request, current_user)
-        return {'followers': count}, 201 if created else 200
+        return {"followers": count}, 201 if created else 200
 
     @api.secure
     @api.doc(description=NOTE)
     def delete(self, id):
-        '''Unfollow an object given its ID'''
-        model = self.model.objects.only('id').get_or_404(id=id_or_404(id))
-        follow = Follow.objects.get_or_404(follower=current_user.id,
-                                           following=model,
-                                           until=None)
+        """Unfollow an object given its ID"""
+        model = self.model.objects.only("id").get_or_404(id=id_or_404(id))
+        follow = Follow.objects.get_or_404(follower=current_user.id, following=model, until=None)
         follow.until = datetime.utcnow()
         follow.save()
         count = Follow.objects.followers(model).count()
-        return {'followers': count}, 200
+        return {"followers": count}, 200

udata/core/followers/models.py

@@ -1,10 +1,10 @@
 from datetime import datetime
 
 from udata.mongo import db
-from .signals import on_follow, on_unfollow
 
+from .signals import on_follow, on_unfollow
 
-__all__ = ('Follow', )
+__all__ = ("Follow",)
 
 
 class FollowQuerySet(db.BaseQuerySet):
@@ -19,19 +19,19 @@ class FollowQuerySet(db.BaseQuerySet):
 
 
 class Follow(db.Document):
-    follower = db.ReferenceField('User', required=True)
+    follower = db.ReferenceField("User", required=True)
     following = db.GenericReferenceField()
     since = db.DateTimeField(required=True, default=datetime.utcnow)
     until = db.DateTimeField()
 
     meta = {
-        'indexes': [
-            'follower',
-            'following',
-            ('follower', 'until'),
-            ('following', 'until'),
+        "indexes": [
+            "follower",
+            "following",
+            ("follower", "until"),
+            ("following", "until"),
         ],
-        'queryset_class': FollowQuerySet,
+        "queryset_class": FollowQuerySet,
     }
 
 

udata/core/followers/signals.py

@@ -3,13 +3,13 @@ from blinker import Namespace
 namespace = Namespace()
 
 #: Trigerred when an user follow someone or something
-on_follow = namespace.signal('on-follow')
+on_follow = namespace.signal("on-follow")
 
 #: Trigerred when an user follow someone or something (again)
 # We cannot reuse the `on_follow` one because we need to trigger it
 # from the view to pass user information for tracking
 # (vs `db.post_save.connect` signal).
-on_new_follow = namespace.signal('on-new-follow')
+on_new_follow = namespace.signal("on-new-follow")
 
 #: Trigerred when an user unfollow someone or something
-on_unfollow = namespace.signal('on-unfollow')
+on_unfollow = namespace.signal("on-unfollow")

udata/core/jobs/actions.py

@@ -9,20 +9,20 @@ def run(name, args, kwargs):
     args = args or []
     kwargs = dict(k.split() for k in kwargs) if kwargs else {}
     if name not in celery.tasks:
-        log.error('Job %s not found', name)
+        log.error("Job %s not found", name)
     job = celery.tasks[name]
-    log.info('Running job %s', name)
+    log.info("Running job %s", name)
     job.run(*args, **kwargs)
-    log.info('Job %s done', name)
+    log.info("Job %s done", name)
 
 
 def delay(name, args, kwargs):
-    '''Run a job asynchronously'''
+    """Run a job asynchronously"""
     args = args or []
     kwargs = dict(k.split() for k in kwargs) if kwargs else {}
     if name not in celery.tasks:
-        log.error('Job %s not found', name)
+        log.error("Job %s not found", name)
     job = celery.tasks[name]
-    log.info('Sending job %s', name)
+    log.info("Sending job %s", name)
     async_result = job.delay(*args, **kwargs)
-    log.info('Job %s sended to workers', async_result.id)
+    log.info("Job %s sended to workers", async_result.id)

udata/core/jobs/api.py

@@ -1,103 +1,108 @@
 from celery import states
 from celery.result import AsyncResult
 from celery.utils import get_full_cls_name
-from kombu.utils.encoding import safe_repr
 from flask import request
+from kombu.utils.encoding import safe_repr
 
-from udata.api import api, API, fields
+from udata.api import API, api, fields
 from udata.auth import admin_permission
-from udata.tasks import schedulables, celery
+from udata.tasks import celery, schedulables
 from udata.utils import id_or_404
 
 from .forms import CrontabTaskForm, IntervalTaskForm
-from .models import PeriodicTask, PERIODS
-
-ns = api.namespace(
-    'workers', 'Asynchronous workers related operations', path='')
-
-crontab_fields = api.model('Crontab', {
-    'minute': fields.String(
-        description='Cron expression for minute', required=True, default='*'),
-    'hour': fields.String(
-        description='Cron expression for hour', required=True, default='*'),
-    'day_of_week': fields.String(
-        description='Cron expression for day of week', required=True,
-        default='*'),
-    'day_of_month': fields.String(
-        description='Cron expression for day of month', required=True,
-        default='*'),
-    'month_of_year': fields.String(
-        description='Cron expression for month of year', required=True,
-        default='*'),
-})
-
-interval_fields = api.model('Interval', {
-    'every': fields.Integer(
-        description='The interval without unit', required=True),
-    'period': fields.String(
-        description='The period/interval type', required=True, enum=PERIODS),
-})
-
-job_fields = api.model('Job', {
-    'id': fields.String(
-        description='The job unique identifier', readonly=True),
-    'name': fields.String(description='The job unique name', required=True),
-    'description': fields.String(description='The job description'),
-    'task': fields.String(
-        description='The task name', required=True,
-        enum=[job.name for job in schedulables()]),
-    'crontab': fields.Nested(crontab_fields, allow_null=True),
-    'interval': fields.Nested(interval_fields, allow_null=True),
-    'args': fields.List(
-        fields.Raw, description='The job execution arguments', default=[]),
-    'kwargs': fields.Raw(
-        description='The job execution keyword arguments', default={}),
-    'schedule': fields.String(
-        attribute='schedule_display',
-        description='The schedule display', readonly=True),
-    'last_run_at': fields.ISODateTime(
-        description='The last job execution date', readonly=True),
-    'last_run_id': fields.String(
-        description='The last execution task id', readonly=True),
-    'enabled': fields.Boolean(
-        description='Is this job enabled', default=False),
-})
-
-task_fields = api.model('Task', {
-    'id': fields.String(description='Tha task execution ID', readonly=True),
-    'status': fields.String(
-        description='Cron expression for hour', readonly=True,
-        enum=list(states.ALL_STATES)),
-    'result': fields.String(description='The task results if exists'),
-    'exc': fields.String(description='The exception thrown during execution'),
-    'traceback': fields.String(description='The execution traceback'),
-})
-
-
-@ns.route('/jobs/', endpoint='jobs')
+from .models import PERIODS, PeriodicTask
+
+ns = api.namespace("workers", "Asynchronous workers related operations", path="")
+
+crontab_fields = api.model(
+    "Crontab",
+    {
+        "minute": fields.String(
+            description="Cron expression for minute", required=True, default="*"
+        ),
+        "hour": fields.String(description="Cron expression for hour", required=True, default="*"),
+        "day_of_week": fields.String(
+            description="Cron expression for day of week", required=True, default="*"
+        ),
+        "day_of_month": fields.String(
+            description="Cron expression for day of month", required=True, default="*"
+        ),
+        "month_of_year": fields.String(
+            description="Cron expression for month of year", required=True, default="*"
+        ),
+    },
+)
+
+interval_fields = api.model(
+    "Interval",
+    {
+        "every": fields.Integer(description="The interval without unit", required=True),
+        "period": fields.String(
+            description="The period/interval type", required=True, enum=PERIODS
+        ),
+    },
+)
+
+job_fields = api.model(
+    "Job",
+    {
+        "id": fields.String(description="The job unique identifier", readonly=True),
+        "name": fields.String(description="The job unique name", required=True),
+        "description": fields.String(description="The job description"),
+        "task": fields.String(
+            description="The task name", required=True, enum=[job.name for job in schedulables()]
+        ),
+        "crontab": fields.Nested(crontab_fields, allow_null=True),
+        "interval": fields.Nested(interval_fields, allow_null=True),
+        "args": fields.List(fields.Raw, description="The job execution arguments", default=[]),
+        "kwargs": fields.Raw(description="The job execution keyword arguments", default={}),
+        "schedule": fields.String(
+            attribute="schedule_display", description="The schedule display", readonly=True
+        ),
+        "last_run_at": fields.ISODateTime(description="The last job execution date", readonly=True),
+        "last_run_id": fields.String(description="The last execution task id", readonly=True),
+        "enabled": fields.Boolean(description="Is this job enabled", default=False),
+    },
+)
+
+task_fields = api.model(
+    "Task",
+    {
+        "id": fields.String(description="Tha task execution ID", readonly=True),
+        "status": fields.String(
+            description="Cron expression for hour", readonly=True, enum=list(states.ALL_STATES)
+        ),
+        "result": fields.String(description="The task results if exists"),
+        "exc": fields.String(description="The exception thrown during execution"),
+        "traceback": fields.String(description="The execution traceback"),
+    },
+)
+
+
+@ns.route("/jobs/", endpoint="jobs")
 class JobsAPI(API):
-    @api.doc(id='list_jobs')
+    @api.doc(id="list_jobs")
     @api.marshal_list_with(job_fields)
     def get(self):
-        '''List all scheduled jobs'''
+        """List all scheduled jobs"""
         return list(PeriodicTask.objects)
 
     @api.secure(admin_permission)
     @api.expect(job_fields)
     @api.marshal_with(job_fields)
     def post(self):
-        '''Create a new scheduled job'''
-        if 'crontab' in request.json and 'interval' in request.json:
-            api.abort(400, 'Cannot define both interval and crontab schedule')
-        if 'crontab' in request.json:
+        """Create a new scheduled job"""
+        if "crontab" in request.json and "interval" in request.json:
+            api.abort(400, "Cannot define both interval and crontab schedule")
+        if "crontab" in request.json:
             form = api.validate(CrontabTaskForm)
         else:
             form = api.validate(IntervalTaskForm)
         return form.save(), 201
 
 
-@ns.route('/jobs/<string:id>', endpoint='job')
-@api.param('id', 'A job ID')
+@ns.route("/jobs/<string:id>", endpoint="job")
+@api.param("id", "A job ID")
 class JobAPI(API):
     def get_or_404(self, id):
         task = PeriodicTask.objects(id=id).first()
@@ -107,15 +112,15 @@ class JobAPI(API):
 
     @api.marshal_with(job_fields)
     def get(self, id):
-        '''Fetch a single scheduled job'''
+        """Fetch a single scheduled job"""
         return self.get_or_404(id_or_404(id))
 
     @api.secure(admin_permission)
     @api.marshal_with(job_fields)
     def put(self, id):
-        '''Update a single scheduled job'''
+        """Update a single scheduled job"""
         task = self.get_or_404(id_or_404(id))
-        if 'crontab' in request.json:
+        if "crontab" in request.json:
             task.interval = None
             task.crontab = PeriodicTask.Crontab()
             form = api.validate(CrontabTaskForm, task)
@@ -126,35 +131,37 @@ class JobAPI(API):
         return form.save()
 
     @api.secure(admin_permission)
-    @api.response(204, 'Successfuly deleted')
+    @api.response(204, "Successfuly deleted")
     def delete(self, id):
-        '''Delete a single scheduled job'''
+        """Delete a single scheduled job"""
         task = self.get_or_404(id_or_404(id))
         task.delete()
-        return '', 204
+        return "", 204
 
 
-@ns.route('/tasks/<string:id>', endpoint='task')
+@ns.route("/tasks/<string:id>", endpoint="task")
 class TaskAPI(API):
     @api.marshal_with(task_fields)
     def get(self, id):
-        '''Get a tasks status given its ID'''
+        """Get a tasks status given its ID"""
         result = AsyncResult(id, app=celery)
         status, retval = result.status, result.result
-        data = {'id': id, 'status': status, 'result': retval}
+        data = {"id": id, "status": status, "result": retval}
         if status in states.EXCEPTION_STATES:
             traceback = result.traceback
-            data.update({
-                'result': safe_repr(retval),
-                'exc': get_full_cls_name(retval.__class__),
-                'traceback': traceback,
-            })
+            data.update(
+                {
+                    "result": safe_repr(retval),
+                    "exc": get_full_cls_name(retval.__class__),
+                    "traceback": traceback,
+                }
+            )
         return data
 
 
-@ns.route('/jobs/schedulables', endpoint='schedulable_jobs')
+@ns.route("/jobs/schedulables", endpoint="schedulable_jobs")
 class JobsReferenceAPI(API):
     @api.doc(model=[str])
     def get(self):
-        '''List all schedulable jobs'''
+        """List all schedulable jobs"""
         return [job.name for job in schedulables()]