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

udata/migrations/__init__.py

@@ -1,19 +1,25 @@
-'''
+"""
 Data migrations logic
-'''
+"""
+
 import importlib.util
 import inspect
 import logging
 import os
 import queue
 import traceback
-
 from datetime import datetime
 from logging.handlers import QueueHandler
+
 from flask import current_app
 from mongoengine.connection import get_db
+from pkg_resources import (
+    resource_filename,
+    resource_isdir,
+    resource_listdir,
+    resource_string,
+)
 from pymongo import ReturnDocument
-from pkg_resources import resource_isdir, resource_listdir, resource_filename, resource_string
 
 from udata import entrypoints
 
@@ -21,13 +27,14 @@ log = logging.getLogger(__name__)
 
 
 class MigrationError(Exception):
-    '''
+    """
     Raised on migration execution error.
 
     :param msg str: A human readable message (a reason)
     :param output str: An optionnal array of logging output
     :param exc Exception: An optionnal underlying exception
-    '''
+    """
+
     def __init__(self, msg, output=None, exc=None, traceback=None):
         super().__init__(msg)
         self.msg = msg
@@ -37,10 +44,11 @@ class MigrationError(Exception):
 
 
 class RollbackError(MigrationError):
-    '''
+    """
     Raised on rollback.
     Hold the initial migration error and rollback exception (if any)
-    '''
+    """
+
     def __init__(self, msg, output=None, exc=None, migrate_exc=None):
         super().__init__(msg)
         self.msg = msg
@@ -54,13 +62,14 @@ class MigrationFormatter(logging.Formatter):
 
 
 class Record(dict):
-    '''
+    """
     A simple wrapper to migrations document
-    '''
+    """
+
     __getattr__ = dict.get
 
     def load(self):
-        specs = {'plugin': self['plugin'], 'filename': self['filename']}
+        specs = {"plugin": self["plugin"], "filename": self["filename"]}
         self.clear()
         data = get_db().migrations.find_one(specs)
         self.update(data or specs)
@@ -77,7 +86,7 @@ class Record(dict):
 
     @property
     def status(self):
-        '''
+        """
         Status is the status of the last operation.
 
         Will be `None` if the record doesn't exists.
@@ -87,69 +96,73 @@ class Record(dict):
           - rollback-error
           - error
           - recorded
-        '''
+        """
         if not self.exists():
             return
         op = self.ops[-1]
-        if op['success']:
-            if op['type'] == 'migrate':
-                return 'success'
-            elif op['type'] == 'rollback':
-                return 'rollback'
-            elif op['type'] == 'record':
-                return 'recorded'
+        if op["success"]:
+            if op["type"] == "migrate":
+                return "success"
+            elif op["type"] == "rollback":
+                return "rollback"
+            elif op["type"] == "record":
+                return "recorded"
             else:
-                return 'unknown'
+                return "unknown"
         else:
-            return 'rollback-error' if op['type'] == 'rollback' else 'error'
+            return "rollback-error" if op["type"] == "rollback" else "error"
 
     @property
     def last_date(self):
         if not self.exists():
             return
         op = self.ops[-1]
-        return op['date']
+        return op["date"]
 
     @property
     def ok(self):
-        '''
+        """
         Is true if the migration is considered as successfully applied
-        '''
+        """
         if not self.exists():
             return False
         op = self.ops[-1]
-        return op['success'] and op['type'] in ('migrate', 'record')
+        return op["success"] and op["type"] in ("migrate", "record")
 
     def add(self, _type, migration, output, state, success):
         script = inspect.getsource(migration)
-        return Record(self.collection.find_one_and_update(
-            {'plugin': self.plugin, 'filename': self.filename},
-            {
-                '$push': {'ops': {
-                    'date': datetime.utcnow(),
-                    'type': _type,
-                    'script': script,
-                    'output': output,
-                    'state': state,
-                    'success': success,
-                }}
-            },
-            upsert=True,
-            return_document=ReturnDocument.AFTER,
-        ))
+        return Record(
+            self.collection.find_one_and_update(
+                {"plugin": self.plugin, "filename": self.filename},
+                {
+                    "$push": {
+                        "ops": {
+                            "date": datetime.utcnow(),
+                            "type": _type,
+                            "script": script,
+                            "output": output,
+                            "state": state,
+                            "success": success,
+                        }
+                    }
+                },
+                upsert=True,
+                return_document=ReturnDocument.AFTER,
+            )
+        )
 
     def delete(self):
-        return self.collection.delete_one({'_id': self._id})
+        return self.collection.delete_one({"_id": self._id})
 
 
 class Migration:
     def __init__(self, plugin_or_specs, filename, module_name=None):
-        if filename is None and ':' in plugin_or_specs:
-            plugin, filename = plugin_or_specs.split(':')
+        if filename is None and ":" in plugin_or_specs:
+            plugin, filename = plugin_or_specs.split(":")
         else:
             plugin = plugin_or_specs
-        if not filename.endswith('.py'):
-            filename += '.py'
+        if not filename.endswith(".py"):
+            filename += ".py"
 
         self.plugin = plugin
         self.filename = filename
@@ -163,16 +176,16 @@ class Migration:
 
     @property
     def db_query(self):
-        return {'plugin': self.plugin, 'filename': self.filename}
+        return {"plugin": self.plugin, "filename": self.filename}
 
     @property
     def label(self):
-        return ':'.join((self.plugin, self.filename))
+        return ":".join((self.plugin, self.filename))
 
     @property
     def record(self):
         if self._record is None:
-            specs = {'plugin': self.plugin, 'filename': self.filename}
+            specs = {"plugin": self.plugin, "filename": self.filename}
             data = get_db().migrations.find_one(specs)
             self._record = Record(data or specs)
         return self._record
@@ -186,31 +199,31 @@ class Migration:
     def __eq__(self, value):
         return (
             isinstance(value, Migration)
-            and getattr(value, 'plugin') == self.plugin
-            and getattr(value, 'filename') == self.filename
+            and getattr(value, "plugin") == self.plugin
+            and getattr(value, "filename") == self.filename
         )
 
     def execute(self, recordonly=False, dryrun=False):
-        '''
+        """
         Execute a migration
 
         If recordonly is True, the migration is only recorded
         If dryrun is True, the migration is neither executed nor recorded
-        '''
+        """
         q = queue.Queue(-1)  # no limit on size
         handler = QueueHandler(q)
         handler.setFormatter(MigrationFormatter())
-        logger = getattr(self.module, 'log', logging.getLogger(self.module.__name__))
+        logger = getattr(self.module, "log", logging.getLogger(self.module.__name__))
         logger.propagate = False
         for h in logger.handlers:
             logger.removeHandler(h)
         logger.addHandler(handler)
 
-        if not hasattr(self.module, 'migrate'):
-            error = SyntaxError('A migration should at least have a migrate(db) function')
-            raise MigrationError('Error while executing migration', exc=error)
+        if not hasattr(self.module, "migrate"):
+            error = SyntaxError("A migration should at least have a migrate(db) function")
+            raise MigrationError("Error while executing migration", exc=error)
 
-        out = [['info', 'Recorded only']] if recordonly else []
+        out = [["info", "Recorded only"]] if recordonly else []
         state = {}
 
         if not recordonly and not dryrun:
@@ -222,115 +235,120 @@ class Migration:
             except Exception as e:
                 out = _extract_output(q)
                 tb = traceback.format_exc()
-                self.add_record('migrate', out, db._state, False, traceback=tb)
-                fe = MigrationError('Error while executing migration',
-                                    output=out, exc=e, traceback=tb)
-                if hasattr(self.module, 'rollback'):
+                self.add_record("migrate", out, db._state, False, traceback=tb)
+                fe = MigrationError(
+                    "Error while executing migration", output=out, exc=e, traceback=tb
+                )
+                if hasattr(self.module, "rollback"):
                     try:
                         self.module.rollback(db)
                         out = _extract_output(q)
-                        self.add_record('rollback', out, db._state, True)
-                        msg = 'Error while executing migration, rollback has been applied'
+                        self.add_record("rollback", out, db._state, True)
+                        msg = "Error while executing migration, rollback has been applied"
                         fe = RollbackError(msg, output=out, migrate_exc=fe)
                     except Exception as re:
                         out = _extract_output(q)
-                        self.add_record('rollback', out, db._state, False)
-                        msg = 'Error while executing migration rollback'
+                        self.add_record("rollback", out, db._state, False)
+                        msg = "Error while executing migration rollback"
                         fe = RollbackError(msg, output=out, exc=re, migrate_exc=fe)
                 raise fe
 
         if not dryrun:
-            self.add_record('migrate', out, state, True)
+            self.add_record("migrate", out, state, True)
 
         return out
 
     def unrecord(self):
-        '''Delete a migration record'''
+        """Delete a migration record"""
         if not self.record.exists():
             return False
         return bool(self.collection.delete_one(self.db_query).deleted_count)
 
     def add_record(self, type, output, state, success, traceback=None):
         script = inspect.getsource(self.module)
-        return Record(self.collection.find_one_and_update(
-            self.db_query,
-            {
-                '$push': {'ops': {
-                    'date': datetime.utcnow(),
-                    'type': type,
-                    'script': script,
-                    'output': output,
-                    'state': state,
-                    'success': success,
-                    'traceback': traceback,
-                }}
-            },
-            upsert=True,
-            return_document=ReturnDocument.AFTER,
-        ))
+        return Record(
+            self.collection.find_one_and_update(
+                self.db_query,
+                {
+                    "$push": {
+                        "ops": {
+                            "date": datetime.utcnow(),
+                            "type": type,
+                            "script": script,
+                            "output": output,
+                            "state": state,
+                            "success": success,
+                            "traceback": traceback,
+                        }
+                    }
+                },
+                upsert=True,
+                return_document=ReturnDocument.AFTER,
+            )
+        )
 
 
 def get(plugin, filename):
-    '''Get a migration'''
+    """Get a migration"""
     return Migration(plugin, filename)
 
 
 def list_available():
-    '''
+    """
     List available migrations for udata and enabled plugins
 
     Each row is a tuple with following signature:
 
         (plugin, package, filename)
-    '''
+    """
     migrations = []
 
-    migrations.extend(_iter('udata', 'udata'))
+    migrations.extend(_iter("udata", "udata"))
 
-    plugins = entrypoints.get_enabled('udata.models', current_app)
+    plugins = entrypoints.get_enabled("udata.models", current_app)
     for plugin, module in plugins.items():
         migrations.extend(_iter(plugin, module))
     return sorted(migrations, key=lambda m: m.filename)
 
 
 def _iter(plugin, module):
-    '''
+    """
     Iterate over migrations for a given plugin module
 
     Yield tuples in the form (plugin_name, module_name, filename)
-    '''
+    """
     module_name = module if isinstance(module, str) else module.__name__
-    if not resource_isdir(module_name, 'migrations'):
+    if not resource_isdir(module_name, "migrations"):
         return
-    for filename in resource_listdir(module_name, 'migrations'):
-        if filename.endswith('.py') and not filename.startswith('__'):
+    for filename in resource_listdir(module_name, "migrations"):
+        if filename.endswith(".py") and not filename.startswith("__"):
             yield Migration(plugin, filename, module_name)
 
 
 def _module_name(plugin):
-    '''Get the module name for a given plugin'''
-    if plugin == 'udata':
-        return 'udata'
-    module = entrypoints.get_plugin_module('udata.models', current_app, plugin)
+    """Get the module name for a given plugin"""
+    if plugin == "udata":
+        return "udata"
+    module = entrypoints.get_plugin_module("udata.models", current_app, plugin)
     if module is None:
-        raise MigrationError('Plugin {} not found'.format(plugin))
+        raise MigrationError("Plugin {} not found".format(plugin))
     return module.__name__
 
 
 def load_migration(plugin, filename, module_name=None):
-    '''
+    """
     Load a migration from its python file
 
     :returns: the loaded module
-    '''
+    """
     module_name = module_name or _module_name(plugin)
     basename = os.path.splitext(os.path.basename(filename))[0]
-    name = '.'.join((module_name, 'migrations', basename))
-    filename = os.path.join('migrations', filename)
+    name = ".".join((module_name, "migrations", basename))
+    filename = os.path.join("migrations", filename)
     try:
         script = resource_string(module_name, filename)
     except Exception:
-        msg = 'Unable to load file {} from module {}'.format(filename, module_name)
+        msg = "Unable to load file {} from module {}".format(filename, module_name)
         raise MigrationError(msg)
     spec = importlib.util.spec_from_loader(name, loader=None)
     module = importlib.util.module_from_spec(spec)
@@ -340,7 +358,7 @@ def load_migration(plugin, filename, module_name=None):
 
 
 def _extract_output(q):
-    '''Extract log output from a QueueHandler queue'''
+    """Extract log output from a QueueHandler queue"""
     out = []
     while not q.empty():
         record = q.get()

udata/models/__init__.py

@@ -1,7 +1,7 @@
-from mongoengine.errors import ValidationError
+from mongoengine.errors import ValidationError  # noqa
 
-from udata import entrypoints
-from udata.mongo import *
+from udata import entrypoints  # noqa
+from udata.mongo import *  # noqa
 
 # Load all core models and mixins
 from udata.core.spatial.models import *  # noqa
@@ -33,4 +33,4 @@ import udata.linkchecker.models  # noqa
 
 
 def init_app(app):
-    entrypoints.get_enabled('udata.models', app)
+    entrypoints.get_enabled("udata.models", app)

udata/mongo/__init__.py

@@ -8,8 +8,9 @@ from .engine import db
 
 log = logging.getLogger(__name__)
 
-MONGODB_DEPRECATED_SETTINGS = 'MONGODB_PORT', 'MONGODB_DB'
-MONGODB_DEPRECATED_MSG = '{0} is deprecated, use the MONGODB_HOST url syntax'
+MONGODB_DEPRECATED_SETTINGS = "MONGODB_PORT", "MONGODB_DB"
+MONGODB_DEPRECATED_MSG = "{0} is deprecated, use the MONGODB_HOST url syntax"
+
 
 def validate_config(config):
     for setting in MONGODB_DEPRECATED_SETTINGS:
@@ -17,26 +18,27 @@ def validate_config(config):
             msg = MONGODB_DEPRECATED_MSG.format(setting)
             log.warning(msg)
             warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-    url = config['MONGODB_HOST']
+    url = config["MONGODB_HOST"]
     parsed_url = urlparse(url)
     if not all((parsed_url.scheme, parsed_url.netloc)):
-        raise ConfigError('{0} is not a valid MongoDB URL'.format(url))
+        raise ConfigError("{0} is not a valid MongoDB URL".format(url))
     if len(parsed_url.path) <= 1:
-        raise ConfigError('{0} is missing the database path'.format(url))
+        raise ConfigError("{0} is missing the database path".format(url))
 
 
 def build_test_config(config):
-    if 'MONGODB_HOST_TEST' in config:
-        config['MONGODB_HOST'] = config['MONGODB_HOST_TEST']
+    if "MONGODB_HOST_TEST" in config:
+        config["MONGODB_HOST"] = config["MONGODB_HOST_TEST"]
     else:
         # use `{database_name}-test` database for testing
-        parsed_url = urlparse(config['MONGODB_HOST'])
-        parsed_url = parsed_url._replace(path='%s-test' % parsed_url.path)
-        config['MONGODB_HOST'] = parsed_url.geturl()
+        parsed_url = urlparse(config["MONGODB_HOST"])
+        parsed_url = parsed_url._replace(path="%s-test" % parsed_url.path)
+        config["MONGODB_HOST"] = parsed_url.geturl()
     validate_config(config)
 
+
 def init_app(app):
     validate_config(app.config)
-    if app.config['TESTING']:
+    if app.config["TESTING"]:
         build_test_config(app.config)
     db.init_app(app)

udata/mongo/badges_field.py

@@ -20,15 +20,16 @@ class BadgesField(ListField):
 
         for key in value:
             if key not in self.registered:
-                errors[key] = 'Badge {0} is not registered'.format(key)
+                errors[key] = "Badge {0} is not registered".format(key)
 
         if errors:
-            self.error('Unknown badges types', errors=errors)
+            self.error("Unknown badges types", errors=errors)
 
     def __call__(self, key):
         def inner(cls):
             self.register(key, cls)
             return cls
+
         return inner
 
 

udata/mongo/datetime_fields.py

@@ -1,22 +1,21 @@
 import logging
-
 from datetime import date, datetime
-from dateutil.parser import parse
 
+from dateutil.parser import parse
 from mongoengine import EmbeddedDocument
 from mongoengine.fields import BaseField, DateTimeField
 from mongoengine.signals import pre_save
 
 from udata.i18n import lazy_gettext as _
 
-
 log = logging.getLogger(__name__)
 
 
 class DateField(BaseField):
-    '''
+    """
     Store date in iso format
-    '''
+    """
+
     def to_python(self, value):
         if isinstance(value, date):
             return value
@@ -40,7 +39,7 @@ class DateField(BaseField):
 
     def validate(self, value):
         if not isinstance(value, date):
-            self.error('DateField only accepts date values')
+            self.error("DateField only accepts date values")
 
 
 class DateRange(EmbeddedDocument):
@@ -48,7 +47,7 @@ class DateRange(EmbeddedDocument):
     end = DateField()
 
     def to_dict(self):
-        return {'start': self.start, 'end': self.end}
+        return {"start": self.start, "end": self.end}
 
     def clean(self):
         if self.start and self.end and self.start > self.end:
@@ -56,14 +55,16 @@ class DateRange(EmbeddedDocument):
 
 
 class Datetimed(object):
-    created_at = DateTimeField(verbose_name=_('Creation date'),
-                               default=datetime.utcnow, required=True)
-    last_modified = DateTimeField(verbose_name=_('Last modification date'),
-                                  default=datetime.utcnow, required=True)
+    created_at = DateTimeField(
+        verbose_name=_("Creation date"), default=datetime.utcnow, required=True
+    )
+    last_modified = DateTimeField(
+        verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+    )
 
 
 @pre_save.connect
 def set_modified_datetime(sender, document, **kwargs):
     changed = document._get_changed_fields()
-    if isinstance(document, Datetimed) and 'last_modified' not in changed:
+    if isinstance(document, Datetimed) and "last_modified" not in changed:
         document.last_modified = datetime.utcnow()

udata/mongo/document.py

@@ -1,5 +1,4 @@
 import logging
-
 from collections.abc import Iterable
 
 from flask_mongoengine import Document
@@ -10,7 +9,7 @@ log = logging.getLogger(__name__)
 
 
 def serialize(value):
-    if hasattr(value, 'to_dict'):
+    if hasattr(value, "to_dict"):
         return value.to_dict()
     elif isinstance(value, Iterable) and not isinstance(value, str):
         return [serialize(val) for val in value]
@@ -20,30 +19,32 @@ def serialize(value):
 
 class UDataDocument(Document):
     meta = {
-        'abstract': True,
-        'queryset_class': UDataQuerySet,
+        "abstract": True,
+        "queryset_class": UDataQuerySet,
     }
 
     def to_dict(self, exclude=None):
-        id_field = self._meta['id_field']
+        id_field = self._meta["id_field"]
         excluded_keys = set(exclude or [])
-        excluded_keys.add('_id')
-        excluded_keys.add('_cls')
-        data = dict((
-            (key, serialize(value))
-            for key, value in self.to_mongo().items()
-            if key not in excluded_keys
-        ))
+        excluded_keys.add("_id")
+        excluded_keys.add("_cls")
+        data = dict(
+            (
+                (key, serialize(value))
+                for key, value in self.to_mongo().items()
+                if key not in excluded_keys
+            )
+        )
         data[id_field] = getattr(self, id_field)
         return data
 
     def __str__(self):
-        return '{classname}({id})'.format(
-            classname=self.__class__.__name__,
-            id=getattr(self, self._meta['id_field'])
+        return "{classname}({id})".format(
+            classname=self.__class__.__name__, id=getattr(self, self._meta["id_field"])
         )
 
 
 class DomainModel(UDataDocument):
-    '''Placeholder for inheritance'''
+    """Placeholder for inheritance"""
+
     pass