MongoDB ORM pour Python ?

Question

J'essaie de migrer de sqlalchemy(SQlite) vers mongodb. Je voudrais une verticalisation des schémas. Je suis en train de regarder mongokit, mais je veux quelque chose qui est similaire à mappers, de sorte qu'il serait enregistrer à partir de la propriété de l'objet, et non un dict.

je voudrais un mappeur pour pouvoir utiliser des objets existants sans les modifier.

Answer 1

Une autre option est MongoEngine . L'ORM de MongoEngine est très similaire à l'ORM utilisé par Django.

Exemple (tiré du tutoriel) :

class Post(Document):
    title = StringField(max_length=120, required=True)
    author = ReferenceField(User)

class TextPost(Post):
    content = StringField()

class ImagePost(Post):
    image_path = StringField()

class LinkPost(Post):
    link_url = StringField()

Answer 2

N'étant satisfait ni de MongoKit ni de MongoEngine, j'ai décidé d'écrire ma propre interface orientée objet pour Python.

J'ai délégué toutes les requêtes directement à pymongo, donc la syntaxe des requêtes y est la même. La plupart du temps, il s'agit juste d'un objet enveloppant les résultats, avec quelques autres aides comme la mise en commun des connexions à la base de données, le support de DBRef, et d'autres méthodes pratiques pour vous faciliter la vie.

Ça s'appelle Minimongo et il est disponible sur github. Bon bricolage !

Exemple :

from minimongo import Model, MongoCollection 

class MyObject(Model): 
    model = MongoCollection(database='test', collection='my_collection')

m = MyObject()
m.x = 1
m.field = 'value'
m.other = {'list': True}
m.save()

x = MyObject({'x': 1, 'y': 2}).save()

objs = MyObject.find({'x': 1})
for o in objs: 
    print o

Answer 3

Vous voulez MongoKit . Il s'agit d'une couche d'abstraction supérieure à PyMongo . Je ne sais pas si vous utilisez Django, mais il y a également django-mongokit l'intégration.

Exemple de ce qui suit article de blog . Notez que les instances de Computer peuvent alors faire référence à la marque ou au modèle directement une fois que la structure est définie (par exemple atari.make, c64.model, ...). Pas besoin de dictionnaires :

import datetime 
from mongokit import Document

class Computer(Document):

    structure = { 
      'make': unicode, 
      'model': unicode, 
      'purchase_date': datetime.datetime, 
      'cpu_ghz': float, 
    }

    validators = { 
      'cpu_ghz': lambda x: x > 0, 
      'make': lambda x: x.strip(), 
    }

    default_values = { 
      'purchase_date': datetime.datetime.utcnow, 
    }

    use_dot_notation = True

    indexes = [ 
      {'fields': ['make']}, 
    ]

Answer 4

Je sais que je suis vraiment en retard pour cette question, mais je suis l'auteur de "Ming". http://merciless.sourceforge.net un moteur de validation et ORM MongoDB inspiré de SQLAlchemy. C'est ce que nous utilisons à SourceForge, et une présentation raisonnable est disponible à l'adresse suivante http://www.slideshare.net/rick446/rapid-and-scalable-development-with-mongodb-pymongo-and-ming ainsi qu'une étude de cas sur la migration de SQLAlchemy vers Ming. http://www.slideshare.net/__amol__/from-sqlalchemy-to-ming-with-turbogears2 . Voici un exemple de la couche ORM dans Ming (tiré du tutoriel) :

class WikiPage(MappedClass):

    class __mongometa__:
        session = session
        name = 'wiki_page'

    _id = FieldProperty(schema.ObjectId)
    title = FieldProperty(str)
    text = FieldProperty(str)
    comments=RelationProperty('WikiComment')

Les requêtes utilisent la syntaxe standard des requêtes MongoDB (et non les arguments magiques des mots-clés de l'ORM de Django) :

WikiComment.query.find(dict(page_id=wp._id))