¿Cuáles son algunas buenas soluciones de Python ORM? [cerrado]

Estoy evaluando y analizando el uso de CherryPy para un proyecto que es básicamente un front-end de JavaScript desde el lado del cliente (navegador) que se comunica con un servicio web de Python en el back-end. Entonces, realmente necesito algo rápido y liviano en el back-end que pueda implementar usando Python que luego le hable a PostgreSQL DB a través de un ORM (JSON al navegador).

También estoy viendo Django, que me gusta, ya que su ORM está integrado. Sin embargo, creo que Django podría ser un poco más de lo que realmente necesito (es decir, ¿más funciones de las que realmente necesito == más lento?).

¿Alguien tiene alguna experiencia con diferentes soluciones ORM de Python que puedan comparar y contrastar sus características y funcionalidad, velocidad, eficiencia, etc.?

SQLAlchemy es más completo y potente (utiliza el patrón DataMapper). Django ORM tiene una sintaxis más limpia y es más fácil de escribir (patrón ActiveRecord). No sé sobre las diferencias de rendimiento.

SQLAlchemy también tiene una capa declarativa que oculta cierta complejidad y le da una sintaxis de estilo ActiveRecord más similar al ORM de Django.

No me preocuparía que Django sea "demasiado pesado". Está lo suficientemente desacoplado para que pueda usar el ORM si lo desea sin tener que importar el resto .

Dicho esto, si ya estuviera usando CherryPy para la capa web y solo necesitara un ORM, probablemente optaría por SQLAlchemy.

Si está buscando peso ligero y ya está familiarizado con los modelos declarativos de estilo django, eche un vistazo a peewee: https://github.com/coleifer/peewee

Ejemplo:

import datetime
from peewee import *

class Blog(Model):
    name = CharField()

class Entry(Model):
    blog = ForeignKeyField(Blog)
    title = CharField()
    body = TextField()
    pub_date = DateTimeField(default=datetime.datetime.now)

# query it like django
Entry.filter(blog__name='Some great blog')

# or programmatically for finer-grained control
Entry.select().join(Blog).where(Blog.name == 'Some awesome blog')

Consulte los documentos para obtener más ejemplos.

Storm tiene posiblemente la API más simple:

from storm.locals import *

class Foo:
    __storm_table__ = 'foos'
    id = Int(primary=True)


class Thing:
    __storm_table__ = 'things'
    id = Int(primary=True)
    name = Unicode()
    description = Unicode()
    foo_id = Int()
    foo = Reference(foo_id, Foo.id)

db = create_database('sqlite:')
store = Store(db)

foo = Foo()
store.add(foo)
thing = Thing()
thing.foo = foo
store.add(thing)
store.commit()

Y hace que sea fácil desplegarse en SQL sin formato cuando necesita:

store.execute('UPDATE bars SET bar_name=? WHERE bar_id like ?', []) 
store.commit()

Usualmente uso SQLAlchemy . Es bastante poderoso y es probablemente el ORM python más maduro.

Si está planeando usar CherryPy, también puede considerar dejavu como lo hizo Robert Brewer (el tipo que es el actual líder del proyecto CherryPy). Personalmente no lo he usado, pero conozco a algunas personas que lo aman.

SQLObject es un poco más fácil de usar ORM que SQLAlchemy, pero no es tan poderoso.

Personalmente, no usaría el Django ORM a menos que estuviera planeando escribir todo el proyecto en Django, pero solo soy yo.

La extensión declarativa de SQLAlchemy , que se está convirtiendo en estándar en 0.5, proporciona una interfaz todo en uno muy parecida a la de Django o Storm. También se integra a la perfección con clases / tablas configuradas utilizando el estilo de mapa de datos:

Base = declarative_base()

class Foo(Base):
    __tablename__ = 'foos'
    id = Column(Integer, primary_key=True)

class Thing(Base):
    __tablename__ = 'things'

    id = Column(Integer, primary_key=True)
    name = Column(Unicode)
    description = Column(Unicode)
    foo_id = Column(Integer, ForeignKey('foos.id'))
    foo = relation(Foo)

engine = create_engine('sqlite://')

Base.metadata.create_all(engine)  # issues DDL to create tables

session = sessionmaker(bind=engine)()

foo = Foo()
session.add(foo)
thing = Thing(name='thing1', description='some thing')
thing.foo = foo  # also adds Thing to session
session.commit()

Usamos Elixir junto con SQLAlchemy y hasta ahora nos ha gustado. Elixir pone una capa encima de SQLAlchemy que hace que se parezca más a las partes opuestas del "patrón ActiveRecord".

Este parece ser el punto de referencia canónico para la interacción de bases de datos de alto nivel en Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

A partir de ahí, parece que Dejavu implementa el patrón DataMapper de Martin Fowler de manera bastante abstracta en Python.

Creo que podrías mirar:

Otoño

Tormenta

No hay forma concebible de que las funciones no utilizadas en Django denuncien el rendimiento. Podría ser útil si alguna vez decides mejorar el proyecto.

Usé Storm + SQLite para un proyecto pequeño, y estuve bastante contento con él hasta que agregué el multiprocesamiento. Intentar usar la base de datos de múltiples procesos resultó en una excepción de "La base de datos está bloqueada". Cambié a SQLAlchemy, y el mismo código funcionó sin problemas.

SQLAlchemy es muy, muy poderoso. Sin embargo, no es seguro para subprocesos, asegúrese de tenerlo en cuenta cuando trabaje con cherrypy en modo de grupo de subprocesos.

Verificaría SQLAlchemy

Es realmente fácil de usar y los modelos con los que trabaja no son malos en absoluto. Django usa SQLAlchemy por su ORM pero usarlo por sí solo le permite usar toda su potencia.

Aquí hay un pequeño ejemplo sobre cómo crear y seleccionar objetos orm

>>> ed_user = User('ed', 'Ed Jones', 'edspassword')
>>> session.add(ed_user)
>>> our_user = session.query(User).filter_by(name='ed').first() 
>>> our_user
    <User('ed','Ed Jones', 'edspassword')>