MongoDB ORM para Python? [cerrado]

Estoy intentando migrar de sqlalchemy (SQlite) a usar mongodb. Me gustaría la verticalización del 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 dict.

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

Otra opción es MongoEngine . El ORM para 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()

No estando satisfecho con MongoKit o MongoEngine, decidí escribir mi propia interfaz orientada a objetos para Python.

Delegué todas las consultas directamente a pymongo, por lo que la sintaxis de la consulta es la misma. En su mayoría, es solo un envoltorio de objetos alrededor de los resultados, con algunos otros ayudantes como la agrupación de conexiones de base 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 piratería!

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

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

Ejemplo de esta publicación de blog . Tenga en cuenta que las instancias de Computer pueden hacer referencia a la marca / modelo directamente una vez definida 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é tarde a esta pregunta, pero soy el autor de Ming http://merciless.sourceforge.net , un motor de validación y ORM MongoDB inspirado en SQLAlchemy. Es lo que usamos en SourceForge, y hay una presentación razonable disponible en http://www.slideshare.net/rick446/rapid-and-scalable-development-with-mongodb-pymongo-and-ming , así como un estudio de caso sobre migrando 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))