MongoDB ORM para Python? [fechadas]

Estou tentando migrar do sqlalchemy (SQlite) para o mongodb. Eu gostaria de verificação do esquema. Estou olhando para o mongokit, mas quero algo que seja semelhante aos mapeadores, de modo que seja salvo da propriedade do objeto, e não de um dict.

Eu gostaria de um mapeador para que eu possa usar objetos existentes sem modificá-los.

Outra opção é o MongoEngine . O ORM para MongoEngine é muito semelhante ao ORM usado pelo Django.

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

Não estando satisfeito com o MongoKit ou MongoEngine, decidi escrever minha própria interface orientada a objetos para Python.

Deleguei todas as consultas diretamente para pymongo, de modo que a sintaxe da consulta lá é a mesma. Principalmente, é apenas um envoltório de objeto em torno dos resultados, com alguns outros auxiliares como pool de conexão de banco de dados, suporte DBRef e outros métodos de conveniência para tornar sua vida mais fácil.

Chama-se Minimongo e está disponível no github. Feliz hackeamento!

Exemplo:

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

Você quer o MongoKit . É uma camada de abstração superior a PyMongo . Não tenho certeza se você está usando Django, mas também há integração django-mongokit .

Exemplo desta postagem do blog . Observe que as instâncias de Computer podem então fazer referência a marca / modelo diretamente, uma vez que a estrutura seja definida (por exemplo, atari.make, c64.model, ...). Não há necessidade de dicionários:

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

Eu sei que estou muito atrasado para esta pergunta, mas sou o autor de Ming http://merciless.sourceforge.net , um mecanismo de validação e ORM inspirado em SQLAlchemy MongoDB. É o que usamos no SourceForge, e há uma apresentação razoável disponível em http://www.slideshare.net/rick446/rapid-and-scalable-development-with-mongodb-pymongo-and-ming , bem como um estudo de caso sobre migrando de SQLAlchemy para Ming http://www.slideshare.net/__amol__/from-sqlalchemy-to-ming-with-turbogears2 . Aqui está um exemplo da camada ORM no Ming (do tutorial):

class WikiPage(MappedClass):

    class __mongometa__:
        session = session
        name = 'wiki_page'

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

As consultas usam a sintaxe de consulta padrão do MongoDB (não os argumentos de palavra-chave mágica do Django ORM):

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