udata 12.0.2.dev3__py3-none-any.whl → 12.0.2.dev5__py3-none-any.whl

udata/flask_mongoengine/__init__.py

@@ -0,0 +1,12 @@
+"""
+This module is a copy-paste of the components we use from flask-mongoengine.
+
+The original flask-mongoengine project (https://github.com/MongoEngine/flask-mongoengine/)
+is no longer maintained. While there are some forks like
+https://github.com/idoshr/flask-mongoengine, they don't seem to work well and also
+appear to be poorly maintained.
+
+Since we want to be able to update Flask and flask-mongoengine is a blocking dependency
+for the upgrade, we decided to internalize it. There isn't much code, and we should also
+be able to simplify this implementation as we simplify udata over time.
+"""

udata/flask_mongoengine/connection.py

@@ -0,0 +1,147 @@
+import mongoengine
+from pymongo import ReadPreference, uri_parser
+
+__all__ = (
+    "create_connections",
+    "get_connection_settings",
+    "InvalidSettingsError",
+)
+
+
+MONGODB_CONF_VARS = (
+    "MONGODB_ALIAS",
+    "MONGODB_DB",
+    "MONGODB_HOST",
+    "MONGODB_IS_MOCK",
+    "MONGODB_PASSWORD",
+    "MONGODB_PORT",
+    "MONGODB_USERNAME",
+    "MONGODB_CONNECT",
+    "MONGODB_TZ_AWARE",
+)
+
+
+class InvalidSettingsError(Exception):
+    pass
+
+
+def _sanitize_settings(settings):
+    """Given a dict of connection settings, sanitize the keys and fall
+    back to some sane defaults.
+    """
+    # Remove the "MONGODB_" prefix and make all settings keys lower case.
+    resolved_settings = {}
+    for k, v in settings.items():
+        if k.startswith("MONGODB_"):
+            k = k[len("MONGODB_") :]
+        k = k.lower()
+        resolved_settings[k] = v
+
+    # Handle uri style connections
+    if "://" in resolved_settings.get("host", ""):
+        # this section pulls the database name from the URI
+        # PyMongo requires URI to start with mongodb:// to parse
+        # this workaround allows mongomock to work
+        uri_to_check = resolved_settings["host"]
+
+        if uri_to_check.startswith("mongomock://"):
+            uri_to_check = uri_to_check.replace("mongomock://", "mongodb://")
+
+        uri_dict = uri_parser.parse_uri(uri_to_check)
+        resolved_settings["db"] = uri_dict["database"]
+
+    # Add a default name param or use the "db" key if exists
+    if resolved_settings.get("db"):
+        resolved_settings["name"] = resolved_settings.pop("db")
+    else:
+        resolved_settings["name"] = "test"
+
+    # Add various default values.
+    resolved_settings["alias"] = resolved_settings.get(
+        "alias", mongoengine.DEFAULT_CONNECTION_NAME
+    )  # TODO do we have to specify it here? MongoEngine should take care of that
+    resolved_settings["host"] = resolved_settings.get(
+        "host", "localhost"
+    )  # TODO this is the default host in pymongo.mongo_client.MongoClient, we may not need to explicitly set a default here
+    resolved_settings["port"] = resolved_settings.get(
+        "port", 27017
+    )  # TODO this is the default port in pymongo.mongo_client.MongoClient, we may not need to explicitly set a default here
+
+    # Default to ReadPreference.PRIMARY if no read_preference is supplied
+    resolved_settings["read_preference"] = resolved_settings.get(
+        "read_preference", ReadPreference.PRIMARY
+    )
+
+    # Clean up empty values
+    for k, v in list(resolved_settings.items()):
+        if v is None:
+            del resolved_settings[k]
+
+    return resolved_settings
+
+
+def get_connection_settings(config):
+    """
+    Given a config dict, return a sanitized dict of MongoDB connection
+    settings that we can then use to establish connections. For new
+    applications, settings should exist in a "MONGODB_SETTINGS" key, but
+    for backward compactibility we also support several config keys
+    prefixed by "MONGODB_", e.g. "MONGODB_HOST", "MONGODB_PORT", etc.
+    """
+    # Sanitize all the settings living under a "MONGODB_SETTINGS" config var
+    if "MONGODB_SETTINGS" in config:
+        settings = config["MONGODB_SETTINGS"]
+
+        # If MONGODB_SETTINGS is a list of settings dicts, sanitize each
+        # dict separately.
+        if isinstance(settings, list):
+            # List of connection settings.
+            settings_list = []
+            for setting in settings:
+                settings_list.append(_sanitize_settings(setting))
+            return settings_list
+
+        # Otherwise, it should be a single dict describing a single connection.
+        else:
+            return _sanitize_settings(settings)
+
+    # If "MONGODB_SETTINGS" doesn't exist, sanitize the "MONGODB_" keys
+    # as if they all describe a single connection.
+    else:
+        config = dict(
+            (k, v) for k, v in config.items() if k in MONGODB_CONF_VARS
+        )  # ugly dict comprehention in order to support python 2.6
+        return _sanitize_settings(config)
+
+
+def create_connections(config):
+    """
+    Given Flask application's config dict, extract relevant config vars
+    out of it and establish MongoEngine connection(s) based on them.
+    """
+    # Validate that the config is a dict
+    if config is None or not isinstance(config, dict):
+        raise InvalidSettingsError("Invalid application configuration")
+
+    # Get sanitized connection settings based on the config
+    conn_settings = get_connection_settings(config)
+
+    # If conn_settings is a list, set up each item as a separate connection
+    # and return a dict of connection aliases and their connections.
+    if isinstance(conn_settings, list):
+        connections = {}
+        for each in conn_settings:
+            alias = each["alias"]
+            connections[alias] = _connect(each)
+        return connections
+
+    # Otherwise, return a single connection
+    return _connect(conn_settings)
+
+
+def _connect(conn_settings):
+    """Given a dict of connection settings, create a connection to
+    MongoDB by calling mongoengine.connect and return its result.
+    """
+    db_name = conn_settings.pop("name")
+    return mongoengine.connect(db_name, **conn_settings)

udata/flask_mongoengine/document.py

@@ -0,0 +1,59 @@
+import mongoengine
+from flask import abort
+from mongoengine.errors import DoesNotExist
+from mongoengine.queryset import QuerySet
+
+from .pagination import ListFieldPagination, Pagination
+
+
+class BaseQuerySet(QuerySet):
+    """Mongoengine's queryset extended with handy extras."""
+
+    def get_or_404(self, *args, **kwargs):
+        """
+        Get a document and raise a 404 Not Found error if it doesn't
+        exist.
+        """
+        try:
+            return self.get(*args, **kwargs)
+        except DoesNotExist:
+            message = kwargs.get("message", None)
+            abort(404, message) if message else abort(404)
+
+    def first_or_404(self, message=None):
+        """Same as get_or_404, but uses .first, not .get."""
+        obj = self.first()
+        return obj if obj else abort(404, message) if message else abort(404)
+
+    def paginate(self, page, per_page, **kwargs):
+        """
+        Paginate the QuerySet with a certain number of docs per page
+        and return docs for a given page.
+        """
+        return Pagination(self, page, per_page)
+
+    def paginate_field(self, field_name, doc_id, page, per_page, total=None):
+        """
+        Paginate items within a list field from one document in the
+        QuerySet.
+        """
+        # TODO this doesn't sound useful at all - remove in next release?
+        item = self.get(id=doc_id)
+        count = getattr(item, field_name + "_count", "")
+        total = total or count or len(getattr(item, field_name))
+        return ListFieldPagination(self, doc_id, field_name, page, per_page, total=total)
+
+
+class Document(mongoengine.Document):
+    """Abstract document with extra helpers in the queryset class"""
+
+    meta = {"abstract": True, "queryset_class": BaseQuerySet}
+
+    def paginate_field(self, field_name, page, per_page, total=None):
+        """Paginate items within a list field."""
+        # TODO this doesn't sound useful at all - remove in next release?
+        count = getattr(self, field_name + "_count", "")
+        total = total or count or len(getattr(self, field_name))
+        return ListFieldPagination(
+            self.__class__.objects, self.pk, field_name, page, per_page, total=total
+        )

udata/flask_mongoengine/engine.py

@@ -0,0 +1,203 @@
+import inspect
+
+import mongoengine
+from flask import Flask, abort, current_app
+from mongoengine.base.fields import BaseField
+from mongoengine.errors import DoesNotExist
+from mongoengine.queryset import QuerySet
+
+from .connection import create_connections
+from .json import override_json_encoder
+from .pagination import ListFieldPagination, Pagination
+from .wtf import WtfBaseField
+
+VERSION = (1, 0, 0)
+
+
+def get_version():
+    """Return the VERSION as a string."""
+    return ".".join(map(str, VERSION))
+
+
+__version__ = get_version()
+
+
+def _patch_base_field(obj, name):
+    """
+    If the object submitted has a class whose base class is
+    mongoengine.base.fields.BaseField, then monkey patch to
+    replace it with flask_mongoengine.wtf.WtfBaseField.
+
+    @note:  WtfBaseField is an instance of BaseField - but
+            gives us the flexibility to extend field parameters
+            and settings required of WTForm via model form generator.
+
+    @see: flask_mongoengine.wtf.base.WtfBaseField.
+    @see: model_form in flask_mongoengine.wtf.orm
+
+    @param obj: MongoEngine instance in which we should locate the class.
+    @param name: Name of an attribute which may or may not be a BaseField.
+    """
+    # TODO is there a less hacky way to accomplish the same level of
+    # extensibility/control?
+
+    # get an attribute of the MongoEngine class and return if it's not
+    # a class
+    cls = getattr(obj, name)
+    if not inspect.isclass(cls):
+        return
+
+    # if it is a class, inspect all of its parent classes
+    cls_bases = list(cls.__bases__)
+
+    # if any of them is a BaseField, replace it with WtfBaseField
+    for index, base in enumerate(cls_bases):
+        if base == BaseField:
+            cls_bases[index] = WtfBaseField
+            cls.__bases__ = tuple(cls_bases)
+            break
+
+    # re-assign the class back to the MongoEngine instance
+    delattr(obj, name)
+    setattr(obj, name, cls)
+
+
+def _include_mongoengine(obj):
+    """
+    Copy all of the attributes from mongoengine and mongoengine.fields
+    onto obj (which should be an instance of the MongoEngine class).
+    """
+    # TODO why do we need this? What's wrong with importing from the
+    # original modules?
+    for module in (mongoengine, mongoengine.fields):
+        for attr_name in module.__all__:
+            if not hasattr(obj, attr_name):
+                setattr(obj, attr_name, getattr(module, attr_name))
+
+                # patch BaseField if available
+                _patch_base_field(obj, attr_name)
+
+
+def current_mongoengine_instance():
+    """Return a MongoEngine instance associated with current Flask app."""
+    me = current_app.extensions.get("mongoengine", {})
+    for k, v in me.items():
+        if isinstance(k, MongoEngine):
+            return k
+
+
+class MongoEngine(object):
+    """Main class used for initialization of Flask-MongoEngine."""
+
+    def __init__(self, app=None, config=None):
+        _include_mongoengine(self)
+
+        self.app = None
+        self.config = config
+        self.Document = Document
+        self.DynamicDocument = DynamicDocument
+
+        if app is not None:
+            self.init_app(app, config)
+
+    def init_app(self, app, config=None):
+        if not app or not isinstance(app, Flask):
+            raise TypeError("Invalid Flask application instance")
+
+        self.app = app
+
+        app.extensions = getattr(app, "extensions", {})
+
+        # Make documents JSON serializable
+        override_json_encoder(app)
+
+        if "mongoengine" not in app.extensions:
+            app.extensions["mongoengine"] = {}
+
+        if self in app.extensions["mongoengine"]:
+            # Raise an exception if extension already initialized as
+            # potentially new configuration would not be loaded.
+            raise ValueError("Extension already initialized")
+
+        if config:
+            # Passed config have max priority, over init config.
+            self.config = config
+
+        if not self.config:
+            # If no configs passed, use app.config.
+            config = app.config
+
+        # Obtain db connection(s)
+        connections = create_connections(config)
+
+        # Store objects in application instance so that multiple apps do not
+        # end up accessing the same objects.
+        s = {"app": app, "conn": connections}
+        app.extensions["mongoengine"][self] = s
+
+    @property
+    def connection(self):
+        """
+        Return MongoDB connection(s) associated with this MongoEngine
+        instance.
+        """
+        return current_app.extensions["mongoengine"][self]["conn"]
+
+
+class BaseQuerySet(QuerySet):
+    """Mongoengine's queryset extended with handy extras."""
+
+    def get_or_404(self, *args, **kwargs):
+        """
+        Get a document and raise a 404 Not Found error if it doesn't
+        exist.
+        """
+        try:
+            return self.get(*args, **kwargs)
+        except DoesNotExist:
+            message = kwargs.get("message", None)
+            abort(404, message) if message else abort(404)
+
+    def first_or_404(self, message=None):
+        """Same as get_or_404, but uses .first, not .get."""
+        obj = self.first()
+        return obj if obj else abort(404, message) if message else abort(404)
+
+    def paginate(self, page, per_page, **kwargs):
+        """
+        Paginate the QuerySet with a certain number of docs per page
+        and return docs for a given page.
+        """
+        return Pagination(self, page, per_page)
+
+    def paginate_field(self, field_name, doc_id, page, per_page, total=None):
+        """
+        Paginate items within a list field from one document in the
+        QuerySet.
+        """
+        # TODO this doesn't sound useful at all - remove in next release?
+        item = self.get(id=doc_id)
+        count = getattr(item, field_name + "_count", "")
+        total = total or count or len(getattr(item, field_name))
+        return ListFieldPagination(self, doc_id, field_name, page, per_page, total=total)
+
+
+class Document(mongoengine.Document):
+    """Abstract document with extra helpers in the queryset class"""
+
+    meta = {"abstract": True, "queryset_class": BaseQuerySet}
+
+    def paginate_field(self, field_name, page, per_page, total=None):
+        """Paginate items within a list field."""
+        # TODO this doesn't sound useful at all - remove in next release?
+        count = getattr(self, field_name + "_count", "")
+        total = total or count or len(getattr(self, field_name))
+        return ListFieldPagination(
+            self.__class__.objects, self.pk, field_name, page, per_page, total=total
+        )
+
+
+class DynamicDocument(mongoengine.DynamicDocument):
+    """Abstract Dynamic document with extra helpers in the queryset class"""
+
+    meta = {"abstract": True, "queryset_class": BaseQuerySet}

udata/flask_mongoengine/fields.py

@@ -0,0 +1,99 @@
+from gettext import gettext as _
+
+from mongoengine.queryset import DoesNotExist
+from wtforms import widgets
+from wtforms.fields import SelectFieldBase
+from wtforms.validators import ValidationError
+
+
+class QuerySetSelectField(SelectFieldBase):
+    """
+    Given a QuerySet either at initialization or inside a view, will display a
+    select drop-down field of choices. The `data` property actually will
+    store/keep an ORM model instance, not the ID. Submitting a choice which is
+    not in the queryset will result in a validation error.
+
+    Specifying `label_attr` in the constructor will use that property of the
+    model instance for display in the list, else the model object's `__str__`
+    or `__unicode__` will be used.
+
+    If `allow_blank` is set to `True`, then a blank choice will be added to the
+    top of the list. Selecting this choice will result in the `data` property
+    being `None`.  The label for the blank choice can be set by specifying the
+    `blank_text` parameter.
+    """
+
+    widget = widgets.Select()
+
+    def __init__(
+        self,
+        label="",
+        validators=None,
+        queryset=None,
+        label_attr="",
+        allow_blank=False,
+        blank_text="---",
+        label_modifier=None,
+        **kwargs,
+    ):
+        super(QuerySetSelectField, self).__init__(label, validators, **kwargs)
+        self.label_attr = label_attr
+        self.allow_blank = allow_blank
+        self.blank_text = blank_text
+        self.label_modifier = label_modifier
+        self.queryset = queryset
+
+    def iter_choices(self):
+        if self.allow_blank:
+            yield ("__None", self.blank_text, self.data is None)
+
+        if self.queryset is None:
+            return
+
+        self.queryset.rewind()
+        for obj in self.queryset:
+            label = (
+                self.label_modifier(obj)
+                if self.label_modifier
+                else (self.label_attr and getattr(obj, self.label_attr) or obj)
+            )
+
+            if isinstance(self.data, list):
+                selected = obj in self.data
+            else:
+                selected = self._is_selected(obj)
+            yield (obj.id, label, selected)
+
+    def process_formdata(self, valuelist):
+        if valuelist:
+            if valuelist[0] == "__None":
+                self.data = None
+            else:
+                if self.queryset is None:
+                    self.data = None
+                    return
+
+                try:
+                    obj = self.queryset.get(pk=valuelist[0])
+                    self.data = obj
+                except DoesNotExist:
+                    self.data = None
+
+    def pre_validate(self, form):
+        if not self.allow_blank or self.data is not None:
+            if not self.data:
+                raise ValidationError(_("Not a valid choice"))
+
+    def _is_selected(self, item):
+        return item == self.data
+
+
+class ModelSelectField(QuerySetSelectField):
+    """
+    Like a QuerySetSelectField, except takes a model class instead of a
+    queryset and lists everything in it.
+    """
+
+    def __init__(self, label="", validators=None, model=None, **kwargs):
+        queryset = kwargs.pop("queryset", model.objects)
+        super(ModelSelectField, self).__init__(label, validators, queryset=queryset, **kwargs)

udata/flask_mongoengine/json.py

@@ -0,0 +1,38 @@
+from bson import json_util
+from flask.json import JSONEncoder
+from mongoengine.base import BaseDocument
+from mongoengine.queryset import QuerySet
+
+
+def _make_encoder(superclass):
+    class MongoEngineJSONEncoder(superclass):
+        """
+        A JSONEncoder which provides serialization of MongoEngine
+        documents and queryset objects.
+        """
+
+        def default(self, obj):
+            if isinstance(obj, BaseDocument):
+                return json_util._json_convert(obj.to_mongo())
+            elif isinstance(obj, QuerySet):
+                return json_util._json_convert(obj.as_pymongo())
+            return superclass.default(self, obj)
+
+    return MongoEngineJSONEncoder
+
+
+MongoEngineJSONEncoder = _make_encoder(JSONEncoder)
+
+
+def override_json_encoder(app):
+    """
+    A function to dynamically create a new MongoEngineJSONEncoder class
+    based upon a custom base class.
+    This function allows us to combine MongoEngine serialization with
+    any changes to Flask's JSONEncoder which a user may have made
+    prior to calling init_app.
+
+    NOTE: This does not cover situations where users override
+    an instance's json_encoder after calling init_app.
+    """
+    app.json_encoder = _make_encoder(app.json_encoder)

udata/flask_mongoengine/model_form.py

@@ -0,0 +1,23 @@
+from flask_wtf import FlaskForm
+from flask_wtf.form import _Auto
+
+
+class ModelForm(FlaskForm):
+    """A WTForms mongoengine model form"""
+
+    def __init__(self, formdata=_Auto, **kwargs):
+        self.instance = kwargs.pop("instance", None) or kwargs.get("obj")
+        if self.instance and not formdata:
+            kwargs["obj"] = self.instance
+        self.formdata = formdata
+        super(ModelForm, self).__init__(formdata, **kwargs)
+
+    def save(self, commit=True, **kwargs):
+        if self.instance:
+            self.populate_obj(self.instance)
+        else:
+            self.instance = self.model_class(**self.data)
+
+        if commit:
+            self.instance.save(**kwargs)
+        return self.instance

udata/flask_mongoengine/pagination.py

@@ -0,0 +1,166 @@
+import math
+
+from flask import abort
+from mongoengine.queryset import QuerySet
+
+
+class Pagination(object):
+    def __init__(self, iterable, page, per_page):
+        if page < 1:
+            abort(404)
+
+        self.iterable = iterable
+        self.page = page
+        self.per_page = per_page
+
+        if isinstance(iterable, QuerySet):
+            self.total = iterable.count()
+        else:
+            self.total = len(iterable)
+
+        start_index = (page - 1) * per_page
+        end_index = page * per_page
+
+        self.items = iterable[start_index:end_index]
+        if isinstance(self.items, QuerySet):
+            self.items = self.items.select_related()
+        if not self.items and page != 1:
+            abort(404)
+
+    @property
+    def pages(self):
+        """The total number of pages"""
+        return int(math.ceil(self.total / float(self.per_page)))
+
+    def prev(self, error_out=False):
+        """Returns a :class:`Pagination` object for the previous page."""
+        assert self.iterable is not None, "an object is required for this method to work"
+        iterable = self.iterable
+        if isinstance(iterable, QuerySet):
+            iterable._skip = None
+            iterable._limit = None
+        return self.__class__(iterable, self.page - 1, self.per_page)
+
+    @property
+    def prev_num(self):
+        """Number of the previous page."""
+        return self.page - 1
+
+    @property
+    def has_prev(self):
+        """True if a previous page exists"""
+        return self.page > 1
+
+    def next(self, error_out=False):
+        """Returns a :class:`Pagination` object for the next page."""
+        assert self.iterable is not None, "an object is required for this method to work"
+        iterable = self.iterable
+        if isinstance(iterable, QuerySet):
+            iterable._skip = None
+            iterable._limit = None
+        return self.__class__(iterable, self.page + 1, self.per_page)
+
+    @property
+    def has_next(self):
+        """True if a next page exists."""
+        return self.page < self.pages
+
+    @property
+    def next_num(self):
+        """Number of the next page"""
+        return self.page + 1
+
+    def iter_pages(self, left_edge=2, left_current=2, right_current=5, right_edge=2):
+        """Iterates over the page numbers in the pagination.  The four
+        parameters control the thresholds how many numbers should be produced
+        from the sides.  Skipped page numbers are represented as `None`.
+        This is how you could render such a pagination in the templates:
+
+        .. sourcecode:: html+jinja
+
+            {% macro render_pagination(pagination, endpoint) %}
+              <div class=pagination>
+              {%- for page in pagination.iter_pages() %}
+                {% if page %}
+                  {% if page != pagination.page %}
+                    <a href="{{ url_for(endpoint, page=page) }}">{{ page }}</a>
+                  {% else %}
+                    <strong>{{ page }}</strong>
+                  {% endif %}
+                {% else %}
+                  <span class=ellipsis>…</span>
+                {% endif %}
+              {%- endfor %}
+              </div>
+            {% endmacro %}
+        """
+        last = 0
+        for num in range(1, self.pages + 1):
+            if (
+                num <= left_edge
+                or num > self.pages - right_edge
+                or (num >= self.page - left_current and num <= self.page + right_current)
+            ):
+                if last + 1 != num:
+                    yield None
+                yield num
+                last = num
+        if last != self.pages:
+            yield None
+
+
+class ListFieldPagination(Pagination):
+    def __init__(self, queryset, doc_id, field_name, page, per_page, total=None):
+        """Allows an array within a document to be paginated.
+
+        Queryset must contain the document which has the array we're
+        paginating, and doc_id should be it's _id.
+        Field name is the name of the array we're paginating.
+        Page and per_page work just like in Pagination.
+        Total is an argument because it can be computed more efficiently
+        elsewhere, but we still use array.length as a fallback.
+        """
+        if page < 1:
+            abort(404)
+
+        self.page = page
+        self.per_page = per_page
+
+        self.queryset = queryset
+        self.doc_id = doc_id
+        self.field_name = field_name
+
+        start_index = (page - 1) * per_page
+
+        field_attrs = {field_name: {"$slice": [start_index, per_page]}}
+
+        qs = queryset(pk=doc_id)
+        self.items = getattr(qs.fields(**field_attrs).first(), field_name)
+        self.total = total or len(getattr(qs.fields(**{field_name: 1}).first(), field_name))
+
+        if not self.items and page != 1:
+            abort(404)
+
+    def prev(self, error_out=False):
+        """Returns a :class:`Pagination` object for the previous page."""
+        assert self.items is not None, "a query object is required for this method to work"
+        return self.__class__(
+            self.queryset,
+            self.doc_id,
+            self.field_name,
+            self.page - 1,
+            self.per_page,
+            self.total,
+        )
+
+    def next(self, error_out=False):
+        """Returns a :class:`Pagination` object for the next page."""
+        assert self.items is not None, "a query object is required for this method to work"
+        return self.__class__(
+            self.queryset,
+            self.doc_id,
+            self.field_name,
+            self.page + 1,
+            self.per_page,
+            self.total,
+        )

udata/flask_mongoengine/wtf.py

@@ -0,0 +1,39 @@
+from mongoengine.base import BaseField
+
+__all__ = "WtfBaseField"
+
+
+class WtfBaseField(BaseField):
+    """
+    Extension wrapper class for mongoengine BaseField.
+
+    This enables flask-mongoengine  wtf to extend the
+    number of field parameters, and settings on behalf
+    of document model form generator for WTForm.
+
+    @param validators:  wtf model form field validators.
+    @param filters:     wtf model form field filters.
+    """
+
+    def __init__(self, validators=None, filters=None, **kwargs):
+        self.validators = self._ensure_callable_or_list(validators, "validators")
+        self.filters = self._ensure_callable_or_list(filters, "filters")
+
+        BaseField.__init__(self, **kwargs)
+
+    def _ensure_callable_or_list(self, field, msg_flag):
+        """
+        Ensure the value submitted via field is either
+        a callable object to convert to list or it is
+        in fact a valid list value.
+
+        """
+        if field is not None:
+            if callable(field):
+                field = [field]
+            else:
+                msg = "Argument '%s' must be a list value" % msg_flag
+                if not isinstance(field, list):
+                    raise TypeError(msg)
+
+        return field

udata/forms/__init__.py

@@ -2,10 +2,10 @@ import logging
 
 import wtforms_json
 
+from udata.flask_mongoengine.model_form import ModelForm as MEModelForm
+
 wtforms_json.init()
-from flask_mongoengine.wtf import model_form  # noqa
 
-from flask_mongoengine.wtf.models import ModelForm as MEModelForm  # noqa
 from flask_wtf import FlaskForm  # noqa
 
 from udata import i18n  # noqa

udata/forms/fields.py

@@ -2,7 +2,6 @@ import uuid
 
 from dateutil.parser import parse
 from flask import url_for
-from flask_mongoengine.wtf import fields as mefields
 from flask_storage.mongo import ImageReference
 from speaklater import is_lazy_string
 from wtforms import Field as WTField
@@ -16,6 +15,7 @@ from udata import tags, uris
 from udata.auth import admin_permission, current_user
 from udata.core.organization.permissions import OrganizationPrivatePermission
 from udata.core.storages import tmp
+from udata.flask_mongoengine.fields import ModelSelectField as BaseModelSelectField
 from udata.forms import ModelForm
 from udata.i18n import lazy_gettext as _
 from udata.models import ContactPoint, Dataset, Organization, Reuse, User, datastore, db
@@ -381,7 +381,7 @@ class SelectField(FieldHelper, fields.SelectField):
         self._choices = value
 
 
-class ModelSelectField(FieldHelper, mefields.ModelSelectField):
+class ModelSelectField(FieldHelper, BaseModelSelectField):
     pass
 
 

udata/mongo/document.py

@@ -1,7 +1,7 @@
 import logging
 from collections.abc import Iterable
 
-from flask_mongoengine import Document
+from udata.flask_mongoengine.document import Document
 
 from .queryset import UDataQuerySet
 

udata/mongo/engine.py

@@ -1,10 +1,11 @@
 from bson import DBRef, ObjectId
-from flask_mongoengine import MongoEngine, MongoEngineSessionInterface
 from flask_storage.mongo import FileField, ImageField
 from mongoengine.base import TopLevelDocumentMetaclass, get_document
 from mongoengine.errors import ValidationError
 from mongoengine.signals import post_save, pre_save
 
+from udata.flask_mongoengine.engine import MongoEngine
+
 from .datetime_fields import DateField, DateRange, Datetimed
 from .document import DomainModel, UDataDocument
 from .extras_fields import ExtrasField, OrganizationExtrasField
@@ -64,4 +65,3 @@ class UDataMongoEngine(MongoEngine):
 
 
 db = UDataMongoEngine()
-session_interface = MongoEngineSessionInterface(db)

udata/mongo/queryset.py

@@ -1,9 +1,9 @@
 import logging
 
 from bson import DBRef, ObjectId
-from flask_mongoengine import BaseQuerySet
 from mongoengine.signals import post_save
 
+from udata.flask_mongoengine.document import BaseQuerySet
 from udata.utils import Paginable
 
 log = logging.getLogger(__name__)

udata/mongo/slug_fields.py

@@ -1,10 +1,10 @@
 import logging
 
 import slugify
-from flask_mongoengine import Document
 from mongoengine.fields import StringField
 from mongoengine.signals import post_delete, pre_save
 
+from udata.flask_mongoengine.document import Document
 from udata.utils import is_uuid
 
 from .queryset import UDataQuerySet

udata/settings.py

@@ -676,7 +676,6 @@ class Debug(Defaults):
         "flask_debugtoolbar.panels.template.TemplateDebugPanel",
         "flask_debugtoolbar.panels.logger.LoggingPanel",
         "flask_debugtoolbar.panels.profiler.ProfilerDebugPanel",
-        "flask_mongoengine.panels.MongoDebugPanel",
     )
     CACHE_TYPE = "flask_caching.backends.null"
     CACHE_NO_NULL_WARNING = True

{udata-12.0.2.dev3.dist-info → udata-12.0.2.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: udata
-Version: 12.0.2.dev3
+Version: 12.0.2.dev5
 Summary: Open data portal
 Author-email: Opendata Team <opendatateam@data.gouv.fr>
 Maintainer-email: Opendata Team <opendatateam@data.gouv.fr>
@@ -47,13 +47,12 @@ Requires-Dist: flask-cdn==1.5.3
 Requires-Dist: flask-gravatar==0.5.0
 Requires-Dist: flask-login==0.6.3
 Requires-Dist: flask-mail==0.10.0
-Requires-Dist: flask-mongoengine==1.0.0
 Requires-Dist: flask-navigation-temp-python-311==0.2.1
 Requires-Dist: flask-principal==0.4.0
 Requires-Dist: flask-restx==1.3.0
 Requires-Dist: flask-security-too==5.1.2
 Requires-Dist: flask-sitemap==0.4.0
-Requires-Dist: flask-storage==1.3.2
+Requires-Dist: flask-storage~=1.4.0
 Requires-Dist: flask-wtf==1.2.2
 Requires-Dist: geojson==3.2.0
 Requires-Dist: geomet==1.1.0

{udata-12.0.2.dev3.dist-info → udata-12.0.2.dev5.dist-info}/RECORD

@@ -10,7 +10,7 @@ udata/mail.py,sha256=Huhx_1QthJkLvuRUuP6jqb5Qq5R4iSmqeEpLVO9ZkQ4,2671
 udata/rdf.py,sha256=aJKmnE1r6YyMKXLo-VRlUvOXoZSJuvNeNbMCqEl0kdY,19370
 udata/routing.py,sha256=Hnc1ktmKVS-RUHNKw2zYTft2HJ903FhjtlcenQ9igwI,8044
 udata/sentry.py,sha256=ekcxqUSqxfM98TtvCsPaOoX5i2l6PEcYt7kb4l3od-Q,3223
-udata/settings.py,sha256=HUoKXMBJBowxDIr6G0aKfRWk9AyQhKNkGV3UTGWKa-w,22162
+udata/settings.py,sha256=o6sV0gAXgZY4if2pU017yR0pKwDTEFBFbnEWYDyBxZg,22110
 udata/sitemap.py,sha256=oRRWoPI7ZsFFnUAOqGT1YuXFFKHBe8EcRnUCNHD7xjM,979
 udata/tags.py,sha256=ydq4uokd6bzdeGVSpEXASVtGvDfO2LfQs9mptvvKJCM,631
 udata/tasks.py,sha256=Sv01dhvATtq_oHOBp3J1j1VT1HQe0Pab7zxwIeIdKoo,5122
@@ -281,8 +281,17 @@ udata/features/transfer/factories.py,sha256=2dAvRaemGieLn5aVEXQ6cmIGD2dTX5I0Ql2R
 udata/features/transfer/models.py,sha256=sFmdbEHL7eUxYe2XdtjZ2zhrUWOW_ryP_5T_8N1qUEA,958
 udata/features/transfer/notifications.py,sha256=jeH5buqTuWcokgXfEj-EZ7C3YCrtw-NikfrH2bqFyHM,1121
 udata/features/transfer/permissions.py,sha256=0Iwt_I3S3QACpq4Ba6Ovb8RUBuozj2pbXDtFFp9jdLI,953
-udata/forms/__init__.py,sha256=OXNShgt05tADLYQ-cXPdB16qQtj2i48GxSsCVdR6cfI,843
-udata/forms/fields.py,sha256=UezHtGuuYsk0FWFpmztWXlPUB4Wf1Rf9IX9ANM796l0,30016
+udata/flask_mongoengine/__init__.py,sha256=Ijqs6lu009OSWgUFdw1AdihjbbLL7-BekwZojXg92bU,599
+udata/flask_mongoengine/connection.py,sha256=b4dPVa8X_xbCFJ8ngt-RWLZtjNCHyZQSw-0fhRL6ySA,5191
+udata/flask_mongoengine/document.py,sha256=KY_PtwbLuqtnlV105YX6ot5GVHq9k61EGv-V6Nf8r78,2200
+udata/flask_mongoengine/engine.py,sha256=vZnACne6XWTpHKvA95KWx8Bh-0hXY58xaGnXjgEc5ow,6769
+udata/flask_mongoengine/fields.py,sha256=moNEAt6_QYu3-Tv9uwI7Okak61iLQSn5_J-0IiP1pB0,3290
+udata/flask_mongoengine/json.py,sha256=ChAgqhfCoSljjcAzDm0-B_vAMlLsPT-1bynZa7A3YnU,1242
+udata/flask_mongoengine/model_form.py,sha256=LI6eqd2zykhron29U280mjt0uZlBpM8GP9NDKrB46Tw,718
+udata/flask_mongoengine/pagination.py,sha256=AmKZqC6Pe4K8Y2TF1kj5O4gM5_m1NVthtJQVvoayX2M,5592
+udata/flask_mongoengine/wtf.py,sha256=BU2ahk6xkUmM18oaUf539RXFTP04O8S2CvEniYGJ1co,1226
+udata/forms/__init__.py,sha256=WdBOu40HijJi0A6kjUkuT-WEP2YNW3k_ftSzQS_Zl9Y,789
+udata/forms/fields.py,sha256=UgC7NQvVAvs5dULUJA9T_MWUADhhwzXTJ509owKZNnc,30042
 udata/forms/validators.py,sha256=CRgmB6oow5O8LDR45LajlJJ9HX3RBCI08fapoWMH1vo,2727
 udata/forms/widgets.py,sha256=XMVxBlQMGfb0nQvqwLMsAVcEdsBdaZGQZ82F81FdmlM,1332
 udata/frontend/__init__.py,sha256=DkqncR72V9TRlA3QEcpVtCIkUMUlnTytBlJFQ4HfEiA,6454
@@ -398,12 +407,12 @@ udata/migrations/__init__.py,sha256=RBCBDaTlLjuMs_Qzwji6Z6T4r7FCGXhESKoxQbT5qAA,
 udata/models/__init__.py,sha256=77OriDFm4dJzQDIb-7ADKSkf9GAxkXbMHeWXoYYnTsk,1459
 udata/mongo/__init__.py,sha256=y4Rv-kq3o_kcEulcNpePLzocXPBNpx3Jd82G-VZPaMc,1421
 udata/mongo/datetime_fields.py,sha256=xACagQZu1OKPvpcznI-bMC1tJfAvo-VBUe7OOadnBdg,2089
-udata/mongo/document.py,sha256=pJJ5B-1EVbQUPMjRqgK51BHPY5eVnyaXgnBnzqwojtA,1777
-udata/mongo/engine.py,sha256=A5RBDM0zSBowkDvlPbDEY8oVYjsu5aPPoC3vhtWSIvQ,2475
+udata/mongo/document.py,sha256=yJl4rzE0L69SvNbtmnmyCALTGhXwBPrj7nvM-J6sDpE,1792
+udata/mongo/engine.py,sha256=JF9N55j7joDIn9NrItMtlIrA5CwVLhS_jlB2ptX94oA,2408
 udata/mongo/errors.py,sha256=SpTMAc_aNIfGkqyXGCbTlIAmYxU86rGM_NtIYaB642c,472
 udata/mongo/extras_fields.py,sha256=FfyVvRkpLn4pUeCqwI33NBJblHOywGlnA05RCEZ-ugs,4139
-udata/mongo/queryset.py,sha256=yIECtsmdDAk_KqbLm0pFzWdon_1ybODfjRdThBdbjac,3939
-udata/mongo/slug_fields.py,sha256=oJo8yZKgpWD4xLaG1VHKjA40chbqdXFwLeGW2xSZFYg,7507
+udata/mongo/queryset.py,sha256=fXfYkUHsCWAUoub3OR7v825USPv-PQQIHkv4U5FnjYg,3954
+udata/mongo/slug_fields.py,sha256=tEUlwozrdQfF42KR5dxk5PUNSX7zISTIXsSgHxR4YMg,7522
 udata/mongo/taglist_field.py,sha256=RPi8DlgMEMK1wk8hbQDLAyH2GnzZCfNpWXQsllxPB6g,1371
 udata/mongo/url_field.py,sha256=UmUr9c5SxDFDpS5QsRTq2pKcCTOr1SoB4UITwNjtuaI,1345
 udata/mongo/uuid_fields.py,sha256=tuQ3zs_BnQHjaiKSIYv43jxvYtOvRLw9nP5CQ3fcMks,482
@@ -623,9 +632,9 @@ udata/translations/pt/LC_MESSAGES/udata.mo,sha256=U0abG-nBwCIoYxRZNsc4KOLeIRSqTV
 udata/translations/pt/LC_MESSAGES/udata.po,sha256=eCG35rMzYLHXyLbsnLSexS1g0N_K-WpNHqrt_8y6I4E,48590
 udata/translations/sr/LC_MESSAGES/udata.mo,sha256=IBcCAdmcvkeK7ZeRBNRI-wJ0jzWNM0eXM5VXAc1frWI,28692
 udata/translations/sr/LC_MESSAGES/udata.po,sha256=yFxHEEB4behNwQ7JnyoYheiCKLNnMS_NV4guzgyzWcE,55332
-udata-12.0.2.dev3.dist-info/licenses/LICENSE,sha256=V8j_M8nAz8PvAOZQocyRDX7keai8UJ9skgmnwqETmdY,34520
-udata-12.0.2.dev3.dist-info/METADATA,sha256=0joZgGkFGtJkwaL6Ri9Mu36vdPcw8UMdltYz1oQMeYE,5593
-udata-12.0.2.dev3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-udata-12.0.2.dev3.dist-info/entry_points.txt,sha256=v2u12qO11i2lyLNIp136WmLJ-NHT-Kew3Duu8J-AXPM,614
-udata-12.0.2.dev3.dist-info/top_level.txt,sha256=EF6CE6YSHd_og-8LCEA4q25ALUpWVe8D0okOLdMAE3A,6
-udata-12.0.2.dev3.dist-info/RECORD,,
+udata-12.0.2.dev5.dist-info/licenses/LICENSE,sha256=V8j_M8nAz8PvAOZQocyRDX7keai8UJ9skgmnwqETmdY,34520
+udata-12.0.2.dev5.dist-info/METADATA,sha256=BPrPKteXNiyrE6-zNGpGBb35lWFFO2c7LT5ewq8wAw8,5553
+udata-12.0.2.dev5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+udata-12.0.2.dev5.dist-info/entry_points.txt,sha256=v2u12qO11i2lyLNIp136WmLJ-NHT-Kew3Duu8J-AXPM,614
+udata-12.0.2.dev5.dist-info/top_level.txt,sha256=EF6CE6YSHd_og-8LCEA4q25ALUpWVe8D0okOLdMAE3A,6
+udata-12.0.2.dev5.dist-info/RECORD,,