¿MongoDB ORM para Python? [closed]

Estoy tratando de migrar de sqlalchemy (SQlite) a usar mongodb. Me gustaría verificación de esquema. Estoy mirando mongokit, pero quiero algo que sea similar a los mapeadores, para que se salve de la propiedad del objeto, y no de un dictado.

Me gustaría un mapeador para poder usar objetos existentes sin modificarlos.

Otra opción es MongoMotor. El ORM de MongoEngine es muy similar al ORM utilizado por Django.

Ejemplo (del tutorial):

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

Como no estaba satisfecho ni con MongoKit ni con MongoEngine, decidí escribir mi propia interfaz orientada a objetos para Python.

Delegué todas las consultas directamente a pymongo, por lo que la sintaxis de consulta es la misma. En su mayoría, es solo un contenedor de objetos alrededor de los resultados, con algunos otros ayudantes como la agrupación de conexiones de bases de datos, soporte DBRef y otros métodos convenientes para hacer su vida más fácil.

Se llama minimongo y está disponible en github. ¡Feliz pirateo!

Ejemplo:

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

Usted quiere MongoKit. Es una capa de abstracción más alta que PyMongo. No estoy seguro si estás usando Django, pero también hay django-mongokit integración.

Ejemplo de esto entrada en el blog. Tenga en cuenta que las instancias de Computer pueden hacer referencia directamente a la marca/modelo una vez que se define la estructura (por ejemplo, atari.make, c64.model, …). Sin necesidad de diccionarios:

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']}, 
    ]

Sé que llegué muy tarde a esta pregunta, pero soy el autor de Ming http://despiadado.sourceforge.net, un motor ORM y validación de MongoDB inspirado en SQLAlchemy. Es lo que usamos en SourceForge, y hay una presentación razonable disponible en http://www.slideshare.net/rick446/desarrollo-rápido-y-escalable-con-mongodb-pymongo-and-ming así como un estudio de caso sobre la migración de SQLAlchemy a Ming http://www.slideshare.net/__amol__/from-sqlalchemy-to-ming-with-turbogears2. Aquí hay un ejemplo de la capa ORM en Ming (del tutorial):

class WikiPage(MappedClass):

    class __mongometa__:
        session = session
        name="wiki_page"

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

Las consultas utilizan la sintaxis de consulta estándar de MongoDB (no los argumentos de palabras clave mágicas de Django ORM):

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