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

udata/api_fields.py

@@ -1,14 +1,15 @@
-from udata.api import api
 import flask_restx.fields as restx_fields
-import udata.api.fields as custom_restx_fields
-from bson import ObjectId
 import mongoengine
 import mongoengine.fields as mongo_fields
+from bson import ObjectId
 
+import udata.api.fields as custom_restx_fields
+from udata.api import api
 from udata.mongo.errors import FieldValidationError
 
-def convert_db_to_field(key, field, info = {}):
-    '''
+
+def convert_db_to_field(key, field, info={}):
+    """
     This function maps a Mongo field to a Flask RestX field.
     Most of the types are a simple 1-to-1 mapping except lists and references that requires
     more work.
@@ -17,11 +18,11 @@ def convert_db_to_field(key, field, info = {}):
     In the first part of the function we save the RestX constructor as a lambda because we need to call it with the
     params. Since merging the params involve a litte bit of work (merging default params with read/write params and then with
     user-supplied overrides, setting the readonly flag…), it's easier to have do this one time at the end of the function.
-    '''
-    info = { **getattr(field, '__additional_field_info__', {}), **info }
+    """
+    info = {**getattr(field, "__additional_field_info__", {}), **info}
 
     params = {}
-    params['required'] = field.required
+    params["required"] = field.required
 
     read_params = {}
     write_params = {}
@@ -30,21 +31,21 @@ def convert_db_to_field(key, field, info = {}):
     constructor_read = None
     constructor_write = None
 
-    if info.get('convert_to'):
+    if info.get("convert_to"):
         # TODO: this is currently never used. We may remove it if the auto-conversion
         # is always good enough.
-        return info.get('convert_to'), info.get('convert_to')
+        return info.get("convert_to"), info.get("convert_to")
     elif isinstance(field, mongo_fields.StringField):
         constructor = restx_fields.String
-        params['min_length'] = field.min_length
-        params['max_length'] = field.max_length
-        params['enum'] = field.choices
+        params["min_length"] = field.min_length
+        params["max_length"] = field.max_length
+        params["enum"] = field.choices
     elif isinstance(field, mongo_fields.ObjectIdField):
         constructor = restx_fields.String
     elif isinstance(field, mongo_fields.FloatField):
         constructor = restx_fields.Float
-        params['min'] = field.min # TODO min_value?
-        params['max'] = field.max
+        params["min"] = field.min  # TODO min_value?
+        params["max"] = field.max
     elif isinstance(field, mongo_fields.BooleanField):
         constructor = restx_fields.Boolean
     elif isinstance(field, mongo_fields.DateTimeField):
@@ -54,7 +55,9 @@ def convert_db_to_field(key, field, info = {}):
     elif isinstance(field, mongo_fields.ListField):
         # For lists, we convert the inner value from Mongo to RestX then we create
         # the `List` RestX type with this converted inner value.
-        field_read, field_write = convert_db_to_field(f"{key}.inner", field.field, info.get('inner_field_info', {}))
+        field_read, field_write = convert_db_to_field(
+            f"{key}.inner", field.field, info.get("inner_field_info", {})
+        )
         constructor_read = lambda **kwargs: restx_fields.List(field_read, **kwargs)
         constructor_write = lambda **kwargs: restx_fields.List(field_write, **kwargs)
     elif isinstance(field, mongo_fields.ReferenceField):
@@ -62,69 +65,83 @@ def convert_db_to_field(key, field, info = {}):
         # For reading, if the user supplied a `nested_fields` (RestX model), we use it to convert
         # the referenced model, if not we return a String (and RestX will call the `str()` of the model
         # when returning from an endpoint)
-        nested_fields = info.get('nested_fields')
+        nested_fields = info.get("nested_fields")
         if nested_fields is None:
             # If there is no `nested_fields` convert the object to the string representation.
             constructor_read = restx_fields.String
         else:
             constructor_read = lambda **kwargs: restx_fields.Nested(nested_fields, **kwargs)
 
-        write_params['description'] = "ID of the reference"
+        write_params["description"] = "ID of the reference"
         constructor_write = restx_fields.String
     elif isinstance(field, mongo_fields.EmbeddedDocumentField):
-        nested_fields = info.get('nested_fields')
+        nested_fields = info.get("nested_fields")
         if nested_fields is not None:
             constructor = lambda **kwargs: restx_fields.Nested(nested_fields, **kwargs)
-        elif hasattr(field.document_type_obj, '__read_fields__'):
-            constructor_read = lambda **kwargs: restx_fields.Nested(field.document_type_obj.__read_fields__, **kwargs)
-            constructor_write = lambda **kwargs: restx_fields.Nested(field.document_type_obj.__write_fields__, **kwargs)
+        elif hasattr(field.document_type_obj, "__read_fields__"):
+            constructor_read = lambda **kwargs: restx_fields.Nested(
+                field.document_type_obj.__read_fields__, **kwargs
+            )
+            constructor_write = lambda **kwargs: restx_fields.Nested(
+                field.document_type_obj.__write_fields__, **kwargs
+            )
         else:
-            raise ValueError(f"EmbeddedDocumentField `{key}` requires a `nested_fields` param to serialize/deserialize or a `@generate_fields()` definition.")
+            raise ValueError(
+                f"EmbeddedDocumentField `{key}` requires a `nested_fields` param to serialize/deserialize or a `@generate_fields()` definition."
+            )
 
     else:
         raise ValueError(f"Unsupported MongoEngine field type {field.__class__.__name__}")
-    
+
     read_params = {**params, **read_params, **info}
     write_params = {**params, **write_params, **info}
 
     read = constructor_read(**read_params) if constructor_read else constructor(**read_params)
-    if write_params.get('readonly', False):
+    if write_params.get("readonly", False):
         write = None
     else:
-        write = constructor_write(**write_params) if constructor_write else constructor(**write_params)
+        write = (
+            constructor_write(**write_params) if constructor_write else constructor(**write_params)
+        )
     return read, write
 
+
 def generate_fields(**kwargs):
-    '''
+    """
     This decorator will create two auto-generated attributes on the class `__read_fields__` and `__write_fields__`
     that can be used in API endpoint inside `expect()` and `marshall_with()`.
-    '''
+    """
+
     def wrapper(cls):
         read_fields = {}
         write_fields = {}
         sortables = []
         filterables = []
 
-        read_fields['id'] = restx_fields.String(required=True)
+        read_fields["id"] = restx_fields.String(required=True)
 
         for key, field in cls._fields.items():
-            info = getattr(field, '__additional_field_info__', None)
-            if info is None: continue 
+            info = getattr(field, "__additional_field_info__", None)
+            if info is None:
+                continue
 
-            if info.get('sortable', False):
+            if info.get("sortable", False):
                 sortables.append(key)
 
-            filterable = info.get('filterable', None)
+            filterable = info.get("filterable", None)
             if filterable is not None:
-                if 'key' not in filterable:
-                    filterable['key'] = key
-                if 'column' not in filterable:
-                    filterable['column'] = key
-
-                if 'constraints' not in filterable:
-                    filterable['constraints'] = []
-                    if isinstance(field, mongo_fields.ReferenceField) or (isinstance(field, mongo_fields.ListField) and isinstance(field.field, mongo_fields.ReferenceField)):
-                        filterable['constraints'].append('objectid')
+                if "key" not in filterable:
+                    filterable["key"] = key
+                if "column" not in filterable:
+                    filterable["column"] = key
+
+                if "constraints" not in filterable:
+                    filterable["constraints"] = []
+                    if isinstance(field, mongo_fields.ReferenceField) or (
+                        isinstance(field, mongo_fields.ListField)
+                        and isinstance(field.field, mongo_fields.ReferenceField)
+                    ):
+                        filterable["constraints"].append("objectid")
 
                 # We may add more information later here:
                 # - type of mongo query to execute (right now only simple =)
@@ -139,78 +156,105 @@ def generate_fields(**kwargs):
                 write_fields[key] = write
 
         # The goal of this loop is to fetch all functions (getters) of the class
-        # If a function has an `__additional_field_info__` attribute it means 
+        # If a function has an `__additional_field_info__` attribute it means
         # it has been decorated with `@function_field()` and should be included
         # in the API response.
         for method_name in dir(cls):
-            if method_name == 'objects': continue
-            if method_name.startswith('_'): continue
-            if method_name in read_fields: continue # Do not override if the attribute is also callable like for Extras
+            if method_name == "objects":
+                continue
+            if method_name.startswith("_"):
+                continue
+            if method_name in read_fields:
+                continue  # Do not override if the attribute is also callable like for Extras
 
             method = getattr(cls, method_name)
-            if not callable(method): continue
+            if not callable(method):
+                continue
 
-            info = getattr(method, '__additional_field_info__', None)
-            if info is None: continue
+            info = getattr(method, "__additional_field_info__", None)
+            if info is None:
+                continue
 
             def make_lambda(method):
-                '''
+                """
                 Factory function to create a lambda with the correct scope.
-                If we don't have this factory function, the `method` will be the 
+                If we don't have this factory function, the `method` will be the
                 last method assigned in this loop?
-                '''
+                """
                 return lambda o: method(o)
 
-            read_fields[method_name] = restx_fields.String(attribute=make_lambda(method), **{ 'readonly':True, **info })
-
+            read_fields[method_name] = restx_fields.String(
+                attribute=make_lambda(method), **{"readonly": True, **info}
+            )
 
         cls.__read_fields__ = api.model(f"{cls.__name__} (read)", read_fields, **kwargs)
         cls.__write_fields__ = api.model(f"{cls.__name__} (write)", write_fields, **kwargs)
 
-        mask = kwargs.pop('mask', None)
+        mask = kwargs.pop("mask", None)
         if mask is not None:
-            mask = 'data{{{0}}},*'.format(mask)
-        cls.__page_fields__ = api.model(f"{cls.__name__}Page", custom_restx_fields.pager(cls.__read_fields__), mask=mask, **kwargs)
+            mask = "data{{{0}}},*".format(mask)
+        cls.__page_fields__ = api.model(
+            f"{cls.__name__}Page",
+            custom_restx_fields.pager(cls.__read_fields__),
+            mask=mask,
+            **kwargs,
+        )
 
         # Parser for index sort/filters
-        paginable = kwargs.get('paginable', True)
+        paginable = kwargs.get("paginable", True)
         parser = api.parser()
 
         if paginable:
-            parser.add_argument('page', type=int, location='args', default=1, help='The page to display')
-            parser.add_argument('page_size', type=int, location='args', default=20, help='The page size')
-        
+            parser.add_argument(
+                "page", type=int, location="args", default=1, help="The page to display"
+            )
+            parser.add_argument(
+                "page_size", type=int, location="args", default=20, help="The page size"
+            )
+
         if sortables:
-            choices = sortables + ['-' + k for k in sortables]
-            parser.add_argument('sort', type=str, location='args', choices=choices, help='The field (and direction) on which sorting apply')
+            choices = sortables + ["-" + k for k in sortables]
+            parser.add_argument(
+                "sort",
+                type=str,
+                location="args",
+                choices=choices,
+                help="The field (and direction) on which sorting apply",
+            )
 
         for filterable in filterables:
-            parser.add_argument(filterable['key'], type=str, location='args')
+            parser.add_argument(filterable["key"], type=str, location="args")
 
         cls.__index_parser__ = parser
+
         def apply_sort_filters_and_pagination(base_query):
             args = cls.__index_parser__.parse_args()
 
-            if sortables and args['sort']:
-                base_query = base_query.order_by(args['sort'])
+            if sortables and args["sort"]:
+                base_query = base_query.order_by(args["sort"])
 
             for filterable in filterables:
-                if args.get(filterable['key']):
-                    for constraint in filterable['constraints']:
-                        if constraint == 'objectid' and not ObjectId.is_valid(args[filterable['key']]):
+                if args.get(filterable["key"]):
+                    for constraint in filterable["constraints"]:
+                        if constraint == "objectid" and not ObjectId.is_valid(
+                            args[filterable["key"]]
+                        ):
                             api.abort(400, f'`{filterable["key"]}` must be an identifier')
 
-                    base_query = base_query.filter(**{
-                        filterable['column']: args[filterable['key']],
-                    })
+                    base_query = base_query.filter(
+                        **{
+                            filterable["column"]: args[filterable["key"]],
+                        }
+                    )
 
             if paginable:
-                base_query = base_query.paginate(args['page'], args['page_size'])
+                base_query = base_query.paginate(args["page"], args["page_size"])
 
             return base_query
 
         cls.apply_sort_filters_and_pagination = apply_sort_filters_and_pagination
         return cls
+
     return wrapper
 
 
@@ -221,50 +265,53 @@ def function_field(**info):
 
     return inner
 
+
 def field(inner, **kwargs):
-    '''
+    """
     Simple decorator to mark a field as visible for the API fields.
     We can pass additional arguments that will be forward to the RestX field constructor.
-    '''
+    """
     inner.__additional_field_info__ = kwargs
     return inner
 
 
-def patch(obj, request): 
-    '''
+def patch(obj, request):
+    """
     Patch the object with the data from the request.
     Only fields decorated with the `field()` decorator will be read (and not readonly).
-    '''
+    """
     for key, value in request.json.items():
         field = obj.__write_fields__.get(key)
         if field is not None and not field.readonly:
             model_attribute = getattr(obj.__class__, key)
-            if isinstance(model_attribute, mongoengine.fields.ListField) and isinstance(model_attribute.field, mongoengine.fields.ReferenceField):
+            if isinstance(model_attribute, mongoengine.fields.ListField) and isinstance(
+                model_attribute.field, mongoengine.fields.ReferenceField
+            ):
                 # TODO `wrap_primary_key` do Mongo request, do a first pass to fetch all documents before calling it (to avoid multiple queries).
                 value = [wrap_primary_key(key, model_attribute.field, id) for id in value]
             if isinstance(model_attribute, mongoengine.fields.ReferenceField):
                 value = wrap_primary_key(key, model_attribute, value)
 
-
-            info = getattr(model_attribute, '__additional_field_info__', {})
+            info = getattr(model_attribute, "__additional_field_info__", {})
 
             # `check` field attribute allows to do validation from the request before setting
             # the attribute
-            check = info.get('check', None)
+            check = info.get("check", None)
             if check is not None:
-                check(**{key: value}) # TODO add other model attributes in function parameters
+                check(**{key: value})  # TODO add other model attributes in function parameters
 
             setattr(obj, key, value)
 
     return obj
 
+
 def wrap_primary_key(field_name: str, foreign_field: mongoengine.fields.ReferenceField, value: str):
-    '''
-    We need to wrap the `String` inside an `ObjectId` most of the time. If the foreign ID is a `String` we need to get 
+    """
+    We need to wrap the `String` inside an `ObjectId` most of the time. If the foreign ID is a `String` we need to get
     a `DBRef` from the database.
 
     TODO: we only check the document reference if the ID is a `String` field (not in the case of a classic `ObjectId`).
-    '''
+    """
     document_type = foreign_field.document_type()
     id_field_name = document_type.__class__._meta["id_field"]
 
@@ -275,7 +322,7 @@ def wrap_primary_key(field_name: str, foreign_field: mongoengine.fields.Referenc
     foreign_document = document_type.__class__.objects(**{id_field_name: value}).first()
     if foreign_document is None:
         raise FieldValidationError(field=field_name, message=f"Unknown reference '{value}'")
-    
+
     if isinstance(id_field, mongoengine.fields.ObjectIdField):
         return ObjectId(value)
     elif isinstance(id_field, mongoengine.fields.StringField):
@@ -288,5 +335,6 @@ def wrap_primary_key(field_name: str, foreign_field: mongoengine.fields.Referenc
         # … but it may be important to check before-hand that the reference point to a correct document.
         return foreign_document.to_dbref()
     else:
-        raise ValueError(f"Unknown ID field type {id_field.__class__} for {document_type.__class__} (ID field name is {id_field_name}, value was {value})")
-
+        raise ValueError(
+            f"Unknown ID field type {id_field.__class__} for {document_type.__class__} (ID field name is {id_field_name}, value was {value})"
+        )

udata/app.py

@@ -1,26 +1,21 @@
-import bson
 import datetime
+import importlib
 import logging
 import os
-import importlib
 import types
+from os.path import abspath, dirname, exists, isfile, join
 
-from os.path import abspath, join, dirname, isfile, exists
-
-from flask import (
-    Flask, abort, g, send_from_directory, json, Blueprint as BaseBlueprint,
-    make_response
-)
+import bson
+from flask import Blueprint as BaseBlueprint
+from flask import Flask, abort, g, json, make_response, send_from_directory
 from flask_caching import Cache
-
 from flask_wtf.csrf import CSRFProtect
 from speaklater import is_lazy_string
 from werkzeug.middleware.proxy_fix import ProxyFix
 
 from udata import entrypoints
 
-
-APP_NAME = __name__.split('.')[0]
+APP_NAME = __name__.split(".")[0]
 ROOT_DIR = abspath(join(dirname(__file__)))
 
 log = logging.getLogger(__name__)
@@ -32,81 +27,78 @@ csrf = CSRFProtect()
 def send_static(directory, filename, cache_timeout):
     out = send_from_directory(directory, filename, cache_timeout=cache_timeout)
     response = make_response(out)
-    response.headers['Access-Control-Allow-Methods'] = 'GET, OPTIONS'
-    response.headers['Access-Control-Allow-Origin'] = '*'
+    response.headers["Access-Control-Allow-Methods"] = "GET, OPTIONS"
+    response.headers["Access-Control-Allow-Origin"] = "*"
     return response
 
 
 class UDataApp(Flask):
-    debug_log_format = '[%(levelname)s][%(name)s:%(lineno)d] %(message)s'
+    debug_log_format = "[%(levelname)s][%(name)s:%(lineno)d] %(message)s"
 
     # Keep track of static dirs given as register_blueprint argument
     static_prefixes = {}
 
     def send_static_file(self, filename):
-        '''
+        """
         Override default static handling:
         - raises 404 if not debug
         - handle static aliases
-        '''
+        """
         if not self.debug:
-            self.logger.error('Static files are only served in debug')
+            self.logger.error("Static files are only served in debug")
             abort(404)
 
         cache_timeout = self.get_send_file_max_age(filename)
 
         # Default behavior
         if isfile(join(self.static_folder, filename)):
-            return send_static(self.static_folder, filename,
-                               cache_timeout=cache_timeout)
+            return send_static(self.static_folder, filename, cache_timeout=cache_timeout)
 
         # Handle aliases
-        for prefix, directory in self.config.get('STATIC_DIRS', tuple()):
+        for prefix, directory in self.config.get("STATIC_DIRS", tuple()):
             if filename.startswith(prefix):
-                real_filename = filename[len(prefix):]
-                if real_filename.startswith('/'):
+                real_filename = filename[len(prefix) :]
+                if real_filename.startswith("/"):
                     real_filename = real_filename[1:]
                 if isfile(join(directory, real_filename)):
-                    return send_static(directory, real_filename,
-                                       cache_timeout=cache_timeout)
+                    return send_static(directory, real_filename, cache_timeout=cache_timeout)
         abort(404)
 
     def handle_http_exception(self, e):
         # Make exception/HTTPError available for context processors
-        if 'error' not in g:
+        if "error" not in g:
             g.error = e
         return super(UDataApp, self).handle_http_exception(e)
 
     def register_blueprint(self, blueprint, **kwargs):
-
         if blueprint.name in self.blueprints:
             # TODO: remove this warning and let Flask return a ValueError once
             # we can set a custom blueprint name in Flask-storage
-            self.logger.warning('Blueprint already loaded')
+            self.logger.warning("Blueprint already loaded")
             return self.blueprints[blueprint.name]
 
-        if blueprint.has_static_folder and 'url_prefix' in kwargs:
-            self.static_prefixes[blueprint.name] = kwargs['url_prefix']
+        if blueprint.has_static_folder and "url_prefix" in kwargs:
+            self.static_prefixes[blueprint.name] = kwargs["url_prefix"]
         return super(UDataApp, self).register_blueprint(blueprint, **kwargs)
 
 
 class Blueprint(BaseBlueprint):
-    '''A blueprint allowing to decorate class too'''
+    """A blueprint allowing to decorate class too"""
+
     def route(self, rule, **options):
         def wrapper(func_or_cls):
-            endpoint = str(options.pop('endpoint', func_or_cls.__name__))
+            endpoint = str(options.pop("endpoint", func_or_cls.__name__))
             if isinstance(func_or_cls, types.FunctionType):
                 self.add_url_rule(rule, endpoint, func_or_cls, **options)
             else:
-                self.add_url_rule(rule,
-                                  view_func=func_or_cls.as_view(endpoint),
-                                  **options)
+                self.add_url_rule(rule, view_func=func_or_cls.as_view(endpoint), **options)
             return func_or_cls
+
         return wrapper
 
 
 class UDataJsonEncoder(json.JSONEncoder):
-    '''
+    """
     A JSONEncoder subclass to encode unsupported types:
 
         - ObjectId
@@ -115,7 +107,8 @@ class UDataJsonEncoder(json.JSONEncoder):
 
     Handle special serialize() method and _data attribute.
     Ensure an app context is always present.
-    '''
+    """
+
     def default(self, obj):
         if is_lazy_string(obj):
             return str(obj)
@@ -123,12 +116,12 @@ class UDataJsonEncoder(json.JSONEncoder):
             return str(obj)
         elif isinstance(obj, datetime.datetime):
             return obj.isoformat()
-        elif hasattr(obj, 'to_dict'):
+        elif hasattr(obj, "to_dict"):
             return obj.to_dict()
-        elif hasattr(obj, 'serialize'):
+        elif hasattr(obj, "serialize"):
             return obj.serialize()
         # Serialize Raw data for Document and EmbeddedDocument.
-        elif hasattr(obj, '_data'):
+        elif hasattr(obj, "_data"):
             return obj._data
         return super(UDataJsonEncoder, self).default(obj)
 
@@ -136,12 +129,12 @@ class UDataJsonEncoder(json.JSONEncoder):
 # These loggers are very verbose
 # We need to put them in WARNING level
 # even if the main level is INFO or DEBUG
-VERBOSE_LOGGERS = 'requests',
+VERBOSE_LOGGERS = ("requests",)
 
 
 def init_logging(app):
     logging.captureWarnings(True)  # Display warnings
-    debug = app.debug or app.config.get('TESTING')
+    debug = app.debug or app.config.get("TESTING")
     log_level = logging.DEBUG if debug else logging.WARNING
     app.logger.setLevel(log_level)
     for name in entrypoints.get_roots():  # Entrypoints loggers
@@ -151,13 +144,12 @@ def init_logging(app):
     return app
 
 
-def create_app(config='udata.settings.Defaults', override=None,
-               init_logging=init_logging):
-    '''Factory for a minimal application'''
+def create_app(config="udata.settings.Defaults", override=None, init_logging=init_logging):
+    """Factory for a minimal application"""
     app = UDataApp(APP_NAME)
     app.config.from_object(config)
 
-    settings = os.environ.get('UDATA_SETTINGS', join(os.getcwd(), 'udata.cfg'))
+    settings = os.environ.get("UDATA_SETTINGS", join(os.getcwd(), "udata.cfg"))
     if exists(settings):
         app.settings_file = settings  # Keep track of loaded settings for diagnostic
         app.config.from_pyfile(settings)
@@ -167,24 +159,24 @@ def create_app(config='udata.settings.Defaults', override=None,
 
     # Loads defaults from plugins
     for pkg in entrypoints.get_roots(app):
-        if pkg == 'udata':
+        if pkg == "udata":
             continue  # Defaults are already loaded
-        module = '{}.settings'.format(pkg)
+        module = "{}.settings".format(pkg)
         try:
             settings = importlib.import_module(module)
         except ImportError:
             continue
         for key, default in settings.__dict__.items():
-            if key.startswith('__'):
+            if key.startswith("__"):
                 continue
             app.config.setdefault(key, default)
 
     app.json_encoder = UDataJsonEncoder
 
     # `ujson` doesn't support `cls` parameter https://github.com/ultrajson/ultrajson/issues/124
-    app.config['RESTX_JSON'] = { 'cls': UDataJsonEncoder }
+    app.config["RESTX_JSON"] = {"cls": UDataJsonEncoder}
 
-    app.debug = app.config['DEBUG'] and not app.config['TESTING']
+    app.debug = app.config["DEBUG"] and not app.config["TESTING"]
 
     app.wsgi_app = ProxyFix(app.wsgi_app)
 
@@ -195,7 +187,7 @@ def create_app(config='udata.settings.Defaults', override=None,
 
 
 def standalone(app):
-    '''Factory for an all in one application'''
+    """Factory for an all in one application"""
     from udata import api, core, frontend
 
     core.init_app(app)
@@ -209,9 +201,19 @@ def standalone(app):
 
 def register_extensions(app):
     from udata import (
-        models, mongo, routing, tasks, mail, i18n, auth, search, sitemap,
-        sentry, notifications
+        auth,
+        i18n,
+        mail,
+        models,
+        mongo,
+        notifications,
+        routing,
+        search,
+        sentry,
+        sitemap,
+        tasks,
     )
+
     tasks.init_app(app)
     i18n.init_app(app)
     mongo.init_app(app)
@@ -232,5 +234,5 @@ def register_features(app):
 
     notifications.init_app(app)
 
-    for ep in entrypoints.get_enabled('udata.plugins', app).values():
+    for ep in entrypoints.get_enabled("udata.plugins", app).values():
         ep.init_app(app)