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

udata/commands/static.py

@@ -1,13 +1,11 @@
 import logging
 import os
 import shutil
-
-import click
-
 from glob import iglob
 from os import makedirs
-from os.path import exists, join, isdir
+from os.path import exists, isdir, join
 
+import click
 from flask import current_app
 
 from udata.commands import cli
@@ -16,21 +14,21 @@ log = logging.getLogger(__name__)
 
 
 @cli.command()
-@click.argument('path', default='public')
-@click.option('-ni', '--no-input', is_flag=True, help="Disable input prompts")
+@click.argument("path", default="public")
+@click.option("-ni", "--no-input", is_flag=True, help="Disable input prompts")
 def collect(path, no_input):
-    '''Collect static files'''
+    """Collect static files"""
     if exists(path):
         msg = '"%s" directory already exists and will be erased'
         log.warning(msg, path)
         if not no_input:
-            click.confirm('Are you sure?', abort=True)
+            click.confirm("Are you sure?", abort=True)
 
         log.info('Deleting static directory "%s"', path)
         shutil.rmtree(path)
 
     prefix = current_app.static_url_path or current_app.static_folder
-    if prefix.startswith('/'):
+    if prefix.startswith("/"):
         prefix = prefix[1:]
     destination = join(path, prefix)
     log.info('Copying application assets into "%s"', destination)
@@ -39,29 +37,29 @@ def collect(path, no_input):
     for blueprint in current_app.blueprints.values():
         if blueprint.has_static_folder:
             prefix = current_app.static_prefixes.get(blueprint.name)
-            prefix = prefix or blueprint.url_prefix or ''
-            prefix += blueprint.static_url_path or ''
-            if prefix.startswith('/'):
+            prefix = prefix or blueprint.url_prefix or ""
+            prefix += blueprint.static_url_path or ""
+            if prefix.startswith("/"):
                 prefix = prefix[1:]
 
-            log.info('Copying %s assets to %s', blueprint.name, prefix)
+            log.info("Copying %s assets to %s", blueprint.name, prefix)
             destination = join(path, prefix)
             copy_recursive(blueprint.static_folder, destination)
 
-    for prefix, source in current_app.config['STATIC_DIRS']:
-        log.info('Copying %s to %s', source, prefix)
+    for prefix, source in current_app.config["STATIC_DIRS"]:
+        log.info("Copying %s to %s", source, prefix)
         destination = join(path, prefix)
         copy_recursive(source, destination)
 
-    log.info('Done')
+    log.info("Done")
 
 
 def copy_recursive(source, destination):
     if not exists(destination):
         makedirs(destination)
-    for filename in iglob(join(source, '*')):
+    for filename in iglob(join(source, "*")):
         if isdir(filename):
-            suffix = filename.replace(source, '')
+            suffix = filename.replace(source, "")
             if suffix.startswith(os.sep):
                 suffix = suffix[1:]
             copy_recursive(filename, join(destination, suffix))

udata/commands/test.py

@@ -1,33 +1,33 @@
 import logging
 
-from . import cli, success, error, header
+from . import cli, error, header, success
 
 logger = logging.getLogger(__name__)
 
 
-@cli.group('test')
+@cli.group("test")
 def test():
-    '''Some commands for testing purpose'''
+    """Some commands for testing purpose"""
 
 
 @test.command()
 def log():
-    '''Test logging'''
-    header('header é')
-    success('success é')
-    error('error é')
-    error('error with string details é', 'ééé')
-    error('error with object details é', Exception('ééé'))
-    logger.debug('debug é')
-    logger.info('info é')
-    logger.info('info é with unicode interpolation %s', 'ééé')
-    logger.info('info é with interpolations %s %d %f', 'ééé', 10, .1)
-    logger.info('success é')
-    logger.info('info\nmulti\nlines é')
-    logger.warning('warning é')
-    logger.error('error é')
-    logger.critical('critical é')
+    """Test logging"""
+    header("header é")
+    success("success é")
+    error("error é")
+    error("error with string details é", "ééé")
+    error("error with object details é", Exception("ééé"))
+    logger.debug("debug é")
+    logger.info("info é")
+    logger.info("info é with unicode interpolation %s", "ééé")
+    logger.info("info é with interpolations %s %d %f", "ééé", 10, 0.1)
+    logger.info("success é")
+    logger.info("info\nmulti\nlines é")
+    logger.warning("warning é")
+    logger.error("error é")
+    logger.critical("critical é")
     try:
-        raise Exception('An exception é')
+        raise Exception("An exception é")
     except Exception:
-        logger.exception('exception é')
+        logger.exception("exception é")

udata/commands/tests/fixtures.py

@@ -3,37 +3,39 @@ from tempfile import NamedTemporaryFile
 
 from udata import models
 from udata.commands.fixtures import generate_fixtures
-from udata.tests import TestCase, DBTestMixin
+from udata.tests import DBTestMixin, TestCase
 
 
 class FixturesTest(DBTestMixin, TestCase):
-
     def test_generate_fixtures(self):
         with NamedTemporaryFile(delete=True) as fixtures_fd:
-            json_fixtures = [{
-                "resources": [{
-                        "description": "test description",
-                        "filetype": "remote",
+            json_fixtures = [
+                {
+                    "resources": [
+                        {
+                            "description": "test description",
+                            "filetype": "remote",
+                            "title": "test",
+                            "url": "https://dev.local",
+                        }
+                    ],
+                    "dataset": {
+                        "description": "### Le Test",
+                        "frequency": "punctual",
+                        "tags": ["action-publique"],
                         "title": "test",
-                        "url": "https://dev.local"
-                    }],
-                "dataset": {
-                    "description": "### Le Test",
-                    "frequency": "punctual",
-                    "tags": ["action-publique"],
-                    "title": "test"
                     },
-                "organization": {
-                    "description": "test description",
-                    "name": "Test"
-                },
-                "reuses": [{
-                    "description": "test description",
-                    "title": "test",
-                    "url": "https://dev.local"
-                    }]
-                }]
-            with open(fixtures_fd, 'w') as f:
+                    "organization": {"description": "test description", "name": "Test"},
+                    "reuses": [
+                        {
+                            "description": "test description",
+                            "title": "test",
+                            "url": "https://dev.local",
+                        }
+                    ],
+                }
+            ]
+            with open(fixtures_fd, "w") as f:
                 json.dump(json_fixtures, f)
             generate_fixtures(fixtures_fd)
             self.assertEqual(models.Organization.objects.count(), 1)

udata/commands/worker.py

@@ -5,7 +5,6 @@ from urllib.parse import urlparse
 
 import click
 import redis
-
 from flask import current_app
 
 from udata.commands import cli, exit_with_error
@@ -14,15 +13,15 @@ from udata.tasks import celery, router
 log = logging.getLogger(__name__)
 
 
-@cli.group('worker')
+@cli.group("worker")
 def grp():
-    '''Worker related operations'''
+    """Worker related operations"""
     pass
 
 
 @grp.command()
 def start():
-    '''Start a worker'''
+    """Start a worker"""
     worker = celery.Worker()
     worker.start()
     return worker.exitcode
@@ -31,27 +30,27 @@ def start():
 def status_print_task(count, biggest_task_name, munin=False):
     if munin:
         # Munin expect all values, including zeros
-        print('%s.value %s' % (format_field_for_munin(count[0]), count[1]))
+        print("%s.value %s" % (format_field_for_munin(count[0]), count[1]))
     elif count[1] > 0:
         # We only display tasks with items in queue for readability
-        print('* %s : %s' % (count[0].ljust(biggest_task_name), count[1]))
+        print("* %s : %s" % (count[0].ljust(biggest_task_name), count[1]))
 
 
 def status_print_config(queue):
     if not queue:
-        exit_with_error('--munin-config called without a --queue parameter')
+        exit_with_error("--munin-config called without a --queue parameter")
     tasks = [n for n, q in get_tasks().items() if q == queue]
-    print('graph_title Waiting tasks for queue %s' % queue)
-    print('graph_vlabel Nb of tasks')
-    print('graph_category celery')
+    print("graph_title Waiting tasks for queue %s" % queue)
+    print("graph_vlabel Nb of tasks")
+    print("graph_category celery")
     for task in tasks:
-        print('%s.label %s' % (format_field_for_munin(task), short_name(task)))
+        print("%s.label %s" % (format_field_for_munin(task), short_name(task)))
 
 
 def status_print_queue(queue, munin=False):
     r = get_redis_connection()
     if not munin:
-        print('-' * 40)
+        print("-" * 40)
     queue_length = r.llen(queue)
     if not munin:
         print('Queue "%s": %s task(s)' % (queue, queue_length))
@@ -59,7 +58,7 @@ def status_print_queue(queue, munin=False):
     biggest_task_name = 0
     for task in r.lrange(queue, 0, -1):
         task = json.loads(task)
-        task_name = task['headers']['task']
+        task_name = task["headers"]["task"]
         if len(task_name) > biggest_task_name:
             biggest_task_name = len(task_name)
         counter[task_name] += 1
@@ -68,63 +67,62 @@ def status_print_queue(queue, munin=False):
 
 
 def format_field_for_munin(field):
-    return field.replace('.', '__').replace('-', '_')
+    return field.replace(".", "__").replace("-", "_")
 
 
 def get_queues(queue):
-    queues = [q.name for q in current_app.config['CELERY_TASK_QUEUES']]
+    queues = [q.name for q in current_app.config["CELERY_TASK_QUEUES"]]
     if queue:
         queues = [q for q in queues if q == queue]
     if not len(queues):
-        exit_with_error('Error: no queue found')
+        exit_with_error("Error: no queue found")
     return queues
 
 
 def get_redis_connection():
-    parsed_url = urlparse(current_app.config['CELERY_BROKER_URL'])
+    parsed_url = urlparse(current_app.config["CELERY_BROKER_URL"])
     db = parsed_url.path[1:] if parsed_url.path else 0
-    return redis.StrictRedis(host=parsed_url.hostname, port=parsed_url.port,
-                             db=db)
+    return redis.StrictRedis(host=parsed_url.hostname, port=parsed_url.port, db=db)
 
 
 def get_task_queue(name, cls):
-    return (router(name, [], {}, None, task=cls) or {}).get('queue', 'default')
+    return (router(name, [], {}, None, task=cls) or {}).get("queue", "default")
 
 
 def short_name(name):
-    if '.' not in name:
+    if "." not in name:
         return name
-    return name.rsplit('.', 1)[1]
+    return name.rsplit(".", 1)[1]
 
 
 def get_tasks():
-    '''Get a list of known tasks with their routing queue'''
+    """Get a list of known tasks with their routing queue"""
     return {
         name: get_task_queue(name, cls)
         for name, cls in celery.tasks.items()
         # Exclude celery internal tasks
-        if not name.startswith('celery.')
+        if not name.startswith("celery.")
         # Exclude udata test tasks
-        and not name.startswith('test-')
+        and not name.startswith("test-")
     }
 
 
 @grp.command()
 def tasks():
-    '''Display registered tasks with their queue'''
+    """Display registered tasks with their queue"""
     tasks = get_tasks()
     longest = max(tasks.keys(), key=len)
     size = len(longest)
     for name, queue in sorted(tasks.items()):
-        print('* {0}: {1}'.format(name.ljust(size), queue))
+        print("* {0}: {1}".format(name.ljust(size), queue))
 
 
 @grp.command()
-@click.option('-q', '--queue', help='Queue to be analyzed', default=None)
-@click.option('-m', '--munin', is_flag=True,
-              help='Output in a munin plugin compatible format')
-@click.option('-c', '--munin-config', is_flag=True,
-              help='Output in a munin plugin config compatible format')
+@click.option("-q", "--queue", help="Queue to be analyzed", default=None)
+@click.option("-m", "--munin", is_flag=True, help="Output in a munin plugin compatible format")
+@click.option(
+    "-c", "--munin-config", is_flag=True, help="Output in a munin plugin config compatible format"
+)
 def status(queue, munin, munin_config):
     """List queued tasks aggregated by name"""
     if munin_config:
@@ -133,4 +131,4 @@ def status(queue, munin, munin_config):
     for queue in queues:
         status_print_queue(queue, munin=munin)
     if not munin:
-        print('-' * 40)
+        print("-" * 40)

udata/core/__init__.py

@@ -1,21 +1,21 @@
 from importlib import import_module
 
 MODULES = (
-    'metrics',
-    'storages',
-    'user',
-    'dataset',
-    'reuse',
-    'organization',
-    'activity',
-    'followers',
-    'topic',
-    'post',
+    "metrics",
+    "storages",
+    "user",
+    "dataset",
+    "reuse",
+    "organization",
+    "activity",
+    "followers",
+    "topic",
+    "post",
 )
 
 
 def init_app(app):
     for module in MODULES:
-        module = import_module('udata.core.{0}'.format(module))
-        if hasattr(module, 'init_app'):
+        module = import_module("udata.core.{0}".format(module))
+        if hasattr(module, "init_app"):
             module.init_app(app)

udata/core/activity/__init__.py

@@ -1,6 +1,5 @@
 import logging
 
-
 log = logging.getLogger(__name__)
 
 

udata/core/activity/api.py

@@ -2,75 +2,85 @@ import logging
 
 from mongoengine.errors import DoesNotExist
 
-from udata.api import api, API, fields
-from udata.models import db, Activity
-
-from udata.core.user.api_fields import user_ref_fields
+from udata.api import API, api, fields
 from udata.core.organization.api_fields import org_ref_fields
+from udata.core.user.api_fields import user_ref_fields
+from udata.models import Activity, db
 
 log = logging.getLogger(__name__)
 
-activity_fields = api.model('Activity', {
-    'actor': fields.Nested(
-        user_ref_fields,
-        description='The user who performed the action', readonly=True),
-    'organization': fields.Nested(
-        org_ref_fields, allow_null=True, readonly=True,
-        description='The organization who performed the action'),
-    'related_to': fields.String(
-        attribute='related_to',
-        description='The activity target name', required=True),
-    'related_to_id': fields.String(
-        attribute='related_to.id',
-        description='The activity target object identifier', required=True),
-    'related_to_kind': fields.String(
-        attribute='related_to.__class__.__name__',
-        description='The activity target object class name', required=True),
-    'related_to_url': fields.String(
-        attribute='related_to.display_url',
-        description='The activity target model', required=True),
-    'created_at': fields.ISODateTime(
-        description='When the action has been performed', readonly=True),
-    'label': fields.String(
-        description='The label of the activity', required=True),
-    'key': fields.String(
-        description='The key of the activity', required=True),
-    'icon': fields.String(
-        description='The icon of the activity', required=True),
-    'extras': fields.Raw(description='Extras attributes as key-value pairs'),
-})
+activity_fields = api.model(
+    "Activity",
+    {
+        "actor": fields.Nested(
+            user_ref_fields, description="The user who performed the action", readonly=True
+        ),
+        "organization": fields.Nested(
+            org_ref_fields,
+            allow_null=True,
+            readonly=True,
+            description="The organization who performed the action",
+        ),
+        "related_to": fields.String(
+            attribute="related_to", description="The activity target name", required=True
+        ),
+        "related_to_id": fields.String(
+            attribute="related_to.id",
+            description="The activity target object identifier",
+            required=True,
+        ),
+        "related_to_kind": fields.String(
+            attribute="related_to.__class__.__name__",
+            description="The activity target object class name",
+            required=True,
+        ),
+        "related_to_url": fields.String(
+            attribute="related_to.display_url",
+            description="The activity target model",
+            required=True,
+        ),
+        "created_at": fields.ISODateTime(
+            description="When the action has been performed", readonly=True
+        ),
+        "label": fields.String(description="The label of the activity", required=True),
+        "key": fields.String(description="The key of the activity", required=True),
+        "icon": fields.String(description="The icon of the activity", required=True),
+        "extras": fields.Raw(description="Extras attributes as key-value pairs"),
+    },
+)
 
-activity_page_fields = api.model('ActivityPage', fields.pager(activity_fields))
+activity_page_fields = api.model("ActivityPage", fields.pager(activity_fields))
 
 activity_parser = api.page_parser()
 activity_parser.add_argument(
-    'user', type=str, help='Filter activities for that particular user',
-    location='args')
+    "user", type=str, help="Filter activities for that particular user", location="args"
+)
 activity_parser.add_argument(
-    'organization', type=str,
-    help='Filter activities for that particular organization',
-    location='args')
+    "organization",
+    type=str,
+    help="Filter activities for that particular organization",
+    location="args",
+)
 
 
-@api.route('/activity', endpoint='activity')
+@api.route("/activity", endpoint="activity")
 class SiteActivityAPI(API):
-    @api.doc('activity')
+    @api.doc("activity")
     @api.expect(activity_parser)
     @api.marshal_list_with(activity_page_fields)
     def get(self):
-        '''Fetch site activity, optionally filtered by user of org.'''
+        """Fetch site activity, optionally filtered by user of org."""
         args = activity_parser.parse_args()
         qs = Activity.objects
 
-        if args['organization']:
-            qs = qs(db.Q(organization=args['organization']) |
-                    db.Q(related_to=args['organization']))
+        if args["organization"]:
+            qs = qs(db.Q(organization=args["organization"]) | db.Q(related_to=args["organization"]))
 
-        if args['user']:
-            qs = qs(actor=args['user'])
+        if args["user"]:
+            qs = qs(actor=args["user"])
 
-        qs = qs.order_by('-created_at')
-        qs = qs.paginate(args['page'], args['page_size'])
+        qs = qs.order_by("-created_at")
+        qs = qs.paginate(args["page"], args["page_size"])
 
         # Filter out DBRefs
         # Always return a result even not complete

udata/core/activity/models.py

@@ -3,23 +3,22 @@ from datetime import datetime
 from blinker import Signal
 from mongoengine.signals import post_save
 
-from udata.mongo import db
 from udata.auth import current_user
+from udata.mongo import db
 
 from .signals import new_activity
 
-
-__all__ = ('Activity', )
+__all__ = ("Activity",)
 
 
 _registered_activities = {}
 
 
 class EmitNewActivityMetaClass(db.BaseDocumentMetaclass):
-    '''Ensure any child class dispatches the on_new signal'''
+    """Ensure any child class dispatches the on_new signal"""
+
     def __new__(cls, name, bases, attrs):
-        new_class = super(EmitNewActivityMetaClass, cls).__new__(
-            cls, name, bases, attrs)
+        new_class = super(EmitNewActivityMetaClass, cls).__new__(cls, name, bases, attrs)
         if new_class.key:
             post_save.connect(cls.post_save, sender=new_class)
             _registered_activities[new_class.key] = new_class
@@ -31,9 +30,10 @@ class EmitNewActivityMetaClass(db.BaseDocumentMetaclass):
 
 
 class Activity(db.Document, metaclass=EmitNewActivityMetaClass):
-    '''Store the activity entries for a single related object'''
-    actor = db.ReferenceField('User', required=True)
-    organization = db.ReferenceField('Organization')
+    """Store the activity entries for a single related object"""
+
+    actor = db.ReferenceField("User", required=True)
+    organization = db.ReferenceField("Organization")
     related_to = db.ReferenceField(db.DomainModel, required=True)
     created_at = db.DateTimeField(default=datetime.utcnow, required=True)
 
@@ -42,23 +42,23 @@ class Activity(db.Document, metaclass=EmitNewActivityMetaClass):
     on_new = Signal()
 
     meta = {
-        'indexes': [
-            'actor',
-            'organization',
-            'related_to',
-            '-created_at',
-            ('actor', '-created_at'),
-            ('organization', '-created_at'),
-            ('related_to', '-created_at'),
+        "indexes": [
+            "actor",
+            "organization",
+            "related_to",
+            "-created_at",
+            ("actor", "-created_at"),
+            ("organization", "-created_at"),
+            ("related_to", "-created_at"),
         ],
-        'allow_inheritance': True,
+        "allow_inheritance": True,
     }
 
     key = None
     label = None
-    badge_type = 'primary'
-    icon = 'fa fa-info-circle'
-    template = 'activity/base.html'
+    badge_type = "primary"
+    icon = "fa fa-info-circle"
+    template = "activity/base.html"
 
     @classmethod
     def connect(cls, func):
@@ -66,8 +66,10 @@ class Activity(db.Document, metaclass=EmitNewActivityMetaClass):
 
     @classmethod
     def emit(cls, related_to, organization=None, extras=None):
-        new_activity.send(cls,
-                          related_to=related_to,
-                          actor=current_user._get_current_object(),
-                          organization=organization,
-                          extras=extras)
+        new_activity.send(
+            cls,
+            related_to=related_to,
+            actor=current_user._get_current_object(),
+            organization=organization,
+            extras=extras,
+        )

udata/core/activity/signals.py

@@ -6,4 +6,4 @@ from blinker import Namespace
 ns = Namespace()
 
 #: Trigerred on new activity/action
-new_activity = ns.signal('new-activity')
+new_activity = ns.signal("new-activity")