MongoKit vs MongoEngine vs Flask-MongoAlchemy pour Flask

Question

Quelqu'un a des expériences avec MongoKit, MongoEngine ou Flask-MongoAlchemy for Flask?

lequel préfères-tu? Expériences positives ou négatives? Trop d'options pour un flask-newbie.

Answer 1

J'ai investi beaucoup de temps à évaluer le populaire Python Orm pour MongoDB. C'était un exercice exhaustif, que je voulais vraiment en choisir un.

Ma conclusion est qu'un ORM enlève le plaisir de MongoDB. Aucune ne se sent naturel, elles imposent des restrictions similaires à celles qui m'a fait me déplacer loin de bases de données relationnelles en premier lieu.

Encore une fois, je voulais vraiment utiliser un ORM, mais maintenant je suis convaincu que l'utilisation de pymongo directement est le chemin à parcourir. Maintenant, j'ai suivi un modèle qui embrasse MongoDB, pymongo, et Python.

Une Ressource Architecture Orientée conduit à de très naturel représentations. Par exemple, les ressources de l'Utilisateur:

from werkzeug.wrappers import Response
from werkzeug.exceptions import NotFound

Users = pymongo.Connection("localhost", 27017)["mydb"]["users"]


class User(Resource):

    def GET(self, request, username):
        spec = {
            "_id": username,
            "_meta.active": True
        }
        # this is a simple call to pymongo - really, do
        # we need anything else?
        doc = Users.find_one(spec)
        if not doc:
            return NotFound(username)
        payload, mimetype = representation(doc, request.accept)
        return Response(payload, mimetype=mimetype, status=200)

    def PUT(self, request, username):
        spec = {
            "_id": username,
            "_meta.active": True
        }
        operation = {
            "$set": request.json,
        }
        # this call to pymongo will return the updated document (implies safe=True)
        doc = Users.update(spec, operation, new=True)
        if not doc:
            return NotFound(username)
        payload, mimetype = representation(doc, request.accept)
        return Response(payload, mimetype=mimetype, status=200)

L' Resource classe de base ressemble

class Resource(object):

    def GET(self, request, **kwargs):
        return NotImplemented()

    def HEAD(self, request, **kwargs):
        return NotImplemented()

    def POST(self, request, **kwargs):
        return NotImplemented()

    def DELETE(self, request, **kwargs):
        return NotImplemented()

    def PUT(self, request, **kwargs):
        return NotImplemented()

    def __call__(self, request, **kwargs):
        handler = getattr(self, request.method)
        return handler(request, **kwargs)

Notez que j'utilise le WSGI spec directement, et l'effet de levier Werkzeug lorsque cela est possible (par la voie, je pense qu' Flask ajoute une complication inutile d' Werkzeug).

La fonction representation prend la demande de l' Accept - têtes, et produit une représentation appropriée (par exemple, application/jsonou text/html). Il n'est pas difficile à mettre en œuvre. Il ajoute également l' Last-Modified - tête.

Bien sûr, votre entrée doit être désinfectés, et le code, tel que présenté, ne fonctionnera pas (je veux dire, comme un exemple, mais il n'est pas difficile de comprendre mon point de vue).

Encore une fois, j'ai tout essayé, mais cette architecture fait mon code flexible, simple et extensible.