jon-example.py

from sqlalchemy import MetaData, create_engine
from sqlalchemy.orm import scoped_session, sessionmaker

def _make_node(node_table):
    return type.__new__(type, "Node", (Node,), dict(mp=sqlamp.MPManager(node_table, node_table.c.id, node_table.c.parent_id)))

class Node(object):
    
    def __init__(self, name, value=None, parent=None):
        self.name = name
        self.value = value
        self.parent = parent

    def __repr__(self):
        return "<Node %r>" % self.name
    
    def __getitem__(self, name):
        try:
            return self.children[name] # allow node[0] for the first node
        except TypeError:
            return [child for child in self.children if child.name == name][0]

    def __setitem__(self, name, value):
        assert isinstance(value, Node)
        if isinstance(name, basestring):
            value.name = name
            self.children.append(value)
        else:
            self.children[name] = value

class BrainStorage(object):
    
    def __init__(self, conn_str):
        self.conn_str = conn_str
        self.engine   = create_engine(conn_str)
        self.meta     = MetaData(bind=engine)
        self.session  = scoped_session(sessionmaker(bind=self.engine))
    
    def init_model(self):

        self.node_table = sqlalchemy.Table('node', meta.metadata,
          sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True),
          sqlalchemy.Column('type', sqlalchemy.String, nullable=False),
          sqlalchemy.Column('name', sqlalchemy.String),
          sqlalchemy.Column('parent_id', sqlalchemy.ForeignKey('node.id')),
        )

        NodeClass = _make_node(self.node_table)
        
        self.node_mapper = sqlalchemy.orm.mapper(
            NodeClass, self.node_table,
            extension=[NodeClass.mp.mapper_extension],
            polymorphic_on=node_table.c.type,
            polymorphic_identity='node',
            properties=dict(
                parent=sqlalchemy.orm.relation(NodeClass,
                                               remote_side=[node_table.c.id],
                                               backref=sqlalchemy.orm.backref('children', cascade='all, delete'),
                                               cascade='all, delete')
           )
        )
        
        self.NodeClass = NodeClass
        return NodeClass