MongoDB ORM per Python? [chiuso]

Sto cercando di migrare da sqlalchemy (SQlite) all'utilizzo di mongodb. Vorrei la verifica dello schema. Sto guardando mongokit, ma voglio qualcosa che sia simile ai mappatori, in modo che salvi dalla proprietà dell'oggetto, e non un dict.

vorrei un mappatore in modo da poter utilizzare oggetti esistenti senza modificarli.

Un'altra opzione è MongoEngine . L'ORM per MongoEngine è molto simile all'ORM utilizzato da Django.

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

Non essendo soddisfatto né di MongoKit né di MongoEngine, ho deciso di scrivere la mia interfaccia orientata agli oggetti per Python.

Ho delegato tutte le query direttamente a pymongo, quindi la sintassi della query è la stessa. Per lo più, è solo un oggetto wrapper attorno ai risultati, con alcuni altri helper come il pool di connessioni al database, il supporto DBRef e altri metodi convenienti per semplificarti la vita.

Si chiama Minimongo ed è disponibile su GitHub. Buon hacking!

Esempio:

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

Vuoi MongoKit . È uno strato di astrazione superiore a PyMongo . Non sono sicuro se stai usando Django, ma c'è anche django-mongokit integrazione .

Esempio da questo post del blog . Si noti che le istanze di Computer possono quindi fare riferimento a make / model direttamente una volta definita la struttura (ad esempio atari.make, c64.model, ...). Non servono dizionari:

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

So di essere davvero in ritardo su questa domanda, ma sono l'autore di Ming http://merciless.sourceforge.net , una convalida MongoDB ispirata a SQLAlchemy e un motore ORM. È quello che usiamo a SourceForge, e c'è una presentazione ragionevole disponibile su http://www.slideshare.net/rick446/rapid-and-scalable-development-with-mongodb-pymongo-and-ming , nonché un caso di studio su migrazione da SQLAlchemy a Ming http://www.slideshare.net/__amol__/from-sqlalchemy-to-ming-with-turbogears2 . Ecco un esempio del livello ORM in Ming (dal tutorial):

class WikiPage(MappedClass):

    class __mongometa__:
        session = session
        name = 'wiki_page'

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

Le query utilizzano la sintassi delle query MongoDB standard (non gli argomenti delle parole chiave magiche di Django ORM):

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