MongoDB ORM pour Python? [fermé]

J'essaie de migrer de sqlalchemy (SQlite) vers l'utilisation de mongodb. Je voudrais une vertification de schéma. Je suis en train de regarder mongokit, mais je veux quelque chose qui est similaire aux mappeurs, afin qu'il sauve de la propriété de l'objet, et non un dict.

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

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()

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 de requête est la même. La plupart du temps, il ne s'agit que d'un wrapper d'objets autour des résultats, avec d'autres aides comme le pool de connexions de base de données, la prise en charge de DBRef et d'autres méthodes pratiques pour vous simplifier la vie.

Il s'appelle Minimongo et est disponible sur github. Bon piratage!

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

Vous voulez MongoKit . C'est une couche d'abstraction plus élevée que PyMongo . Je ne sais pas si vous utilisez Django, mais il existe également une intégration django-mongokit .

Exemple tiré de ce billet de blog . Notez que les instances de Computer peuvent alors référencer directement make / model une fois la structure 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']}, 
    ]

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 MongoDB et ORM inspiré de SQLAlchemy. C'est ce que nous utilisons chez SourceForge, et il y a une présentation raisonnable disponible à http://www.slideshare.net/rick446/rapid-and-scalable-development-with-mongodb-pymongo-and-ming ainsi qu'une étude de cas sur 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 (à partir 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 de requête MongoDB standard (et non les arguments de mots clés magiques de Django ORM):

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