Why should a blog have a title ?

import datetime # we will use this to put default values in DateTime columns

# Elixir will create a table for each class inherting form Entity
class User(Entity):
    # By default, your table names will look like "ModuleName_ClassName".
    # To change this, you can either pass in a shortnames=True argument to
    # the using_options function, which will tell elixir to create your tables
    # based on ClassName only, or a tablename=’My_Table_Name’ argument.
    # I’m used to have plural names for tables, and single names for classes,
    # so I’ll pass in a tablename arguemnt
   
    # Next thing is the inhertince argument. This will tell Elixir
    # that User can be subclassed.
    using_options (tablename=“Users”,inheritance=“multi”)
   
    # I like powers of 2
    username      = Field(Unicode(32))
    email         = Field(Unicode(64))
    password      = Field(Unicode(32))
    phone         = Field(Unicode(16))
    address       = Field(Unicode(64))
    # Many users may live in One City, so in this case it’s Many(users)ToOne(City)
    city          = ManyToOne(“City”)
    creation_date = Field(DateTime,default=datetime.datetime.now)

# Let’s make a distinction between Persons and Companies. Both are users, wich means they share a certain amount of
# properties, but they can also have different additional attribtues of their own.

class Person(User):
    using_options (tablename=“Persons”,inheritance=“multi”)
    first_name = Field(Unicode(32))
    last_name  = Field(Unicode(32))   

    def __str__(self):
        “”” This method is called when you try to print a user.”“”
        return “%s %s (%s)” % (self.first.encode(“utf-8″), self.last.encode(“utf-8″), self.username.encode(“utf-8″))
   
    def __repr__(self):
        “”” This method is called when you try to print a representation of a user.”“”
        return “” % str(self)   

class Company(User):
    using_options (tablename=“Users”,inheritance=“multi”)   
    logo    = Field(String(32)) # we store only the filename here.
    name    = Field(Unicode(64))
    website = Field(Unicode(64))

from pylons import request, response, session, tmpl_context as c
from pylons.controllers.util import abort, redirect_to
from myapp.lib.base import BaseController, render
# These imports up there are generated for you by paster
# Now you’ll need two other imports to generate the form : FieldSet and your model’s Person

# This is a customized FieldSet that will render itself following the template that you’ll find
# in templates/forms/fieldset.mako.
# I have edited that template to use semantic html elements like dl, dt and dd instead of bare div elements.
from myapp.forms import FieldSet

# This represents a form field, we will use this to create a password check form field.
from formalchemy import Field

from myapp.model import Person

log = logging.getLogger(__name__)

class RegistrationController(BaseController):

    def personRegistrationForm(self):
        “”“
        Call this action in your mako templates to render the registration form
        ““”
        fs = self.getPersonFieldSet()       
        c.form = fs.render()
        return render(“/pages/registration.mako”)

    def processRegistrationForm(self):
        “”“
        Put this method in your registration’s form’s action attribute.
        <form action=”/registration/processRegistrationForm“>
        or use
        <form action=”${h.url_for(controller=‘registration’,action=‘processRegistrationForm’)}“>
        ““”
        fs      = self.getPersonFieldSet()
        # This will populate the FieldSet with values found in request.params
        fs.data = request.params
        # This will populate the Person instance that FieldSet stores as an attribute named "model"
        fs.sync()
        # Here’s your object :) !
        user = fs.model
        # now do whatever you want with it. For this example, we’ll just return a simple message
        # saying that everything was ok.
        return “User (%s) successfully created” % str(user) # This will call user.__str__

    def getPersonFieldSet(self):
        “”“
        Return the fieldset corresponding to a Person
        ““”
        # Just pass in the class, not a specific instance
        fs = FieldSet(Person)
        # Now let’s add a password check field.
        # name is the attribute name that will be generated
        #
        # By default, formalchemy will append the class name as a prefix to every field name.
        # This is to prevent confusion when two classes may have the same name for one of their attribute.
        pwdcheck= Field(name=“pwdcheck”,type=Unicode)
        # We’ll add it to the FieldSet
        fs.append(pwdcheck)
        # Now we’ll customize the generated HTML with the conigure method.
        # the include argument tells FieldSet objects what fields you actually want to render.
        # A FieldSet consists of a group of Fields. Each field is accessed as an attribute of the FieldSet
        # it’s contained within. The attribute name of that field is the same as the Field name you used
        # in your class declaration.
        fs.configure(include=[fs.first,fs.last,fs.username,fs.city,fs.adresse,fs.email,
                              # Now here we’ll tell fs.password to render itself as a password field
                              # instead of a usual text field. This will return the modified field.
                              fs.password.password(),
                              # Now we’ll configure the pwdcheck field to have a meaningful and helpful label
                              fs.pwdcheck.password().label(“Confirm your password”)])
        return fs

class User(Entity):
    using_options (tablename=“Users”,inheritance=“multi”)
    # I like powers of 2
    username      = Field(Unicode(32))
    email         = Field(Unicode(64))
    password      = Field(Unicode(32))
    phone         = Field(Unicode(16))
    address       = Field(Unicode(64))
    city          = ManyToOne(“City”)
    creation_date = Field(DateTime,default=datetime.datetime.now)

class Person(User):
    using_options (tablename=“Persons”,inheritance=“multi”)
    first_name = Field(Unicode(32))
    last_name  = Field(Unicode(32))   

    def __str__(self):
        “”” This method is called when you try to print a user.”“”
        return “%s %s (%s)” % (self.first.encode(“utf-8″), self.last.encode(“utf-8″), self.username.encode(“utf-8″))
   
    def __repr__(self):
        “”” This method is called when you try to print a representation of a user.”“”
        return “” % str(self)   

class Company(User):
    using_options (tablename=“Users”,inheritance=“multi”)   
    logo    = Field(String(32)) # we store only the filename here.
    name    = Field(Unicode(64))
    website = Field(Unicode(64))

class RegistrationController(BaseController):

    def personRegistrationForm(self):
        “”“
        Call this action in your mako templates to render the registration form
        ““”
        fs = self.getPersonFieldSet()       
        c.form = fs.render()
        return render(“/pages/registration.mako”)

    def processRegistrationForm(self):
        “”“
        Put this method in your registration’s form’s action attribute.
        ““”
        fs      = self.getPersonFieldSet()
        fs.data = request.params
        fs.sync()
        user = fs.model
        return “User (%s) successfully created” % str(user) # This will call user.__str__

    def getPersonFieldSet(self):
        “”“
        Return the fieldset corresponding to a Person
        ““”
        fs = FieldSet(Person)
        pwdcheck= Field(name=“pwdcheck”,type=Unicode)
        fs.append(pwdcheck)
        fs.configure(include=[fs.first,fs.last,fs.username,fs.city,fs.adresse,fs.email,
                              fs.password.password(),
                              fs.pwdcheck.password().label(“Confirm your password”)])
        return fs

class SubClassOne(BaseClass):
    # Your actual class
    # …

class SubClassTwo(BaseClass):
    # Your class here
    # …
#… more subclasses
 

class SubClassOne(BaseClass,Entity):
    # Your class here
    # …

class SubClassTwo(BaseClass,Entity):
    # Your class here
    # …
#… more subclasses
 

    def __call__(cls,key):
        “”“
        If it’s in the cache, return the cached version
        If not in the cache :
            If it’s in the database, retrieve it, cache it and return it
            If it’s not there, create it, cache it and return it
        ““”
        thecache = cache.get_cache(cls.__name__,type=“memory”)
        def makeTag():
            theTag = cls.query.filter_by(**{cls.filterby:key}).first()
            if not theTag:
                #not in the database either
                theTag = type.__call__(cls,key)
                session.add(theTag)
            return theTag
        return thecache.get_value(key=key,createfunc=makeTag)
   
class Ville(Entity):
    using_options (tablename=“Villes”)
    __metaclass__ = UniqueMeta
    nom           = Field(Unicode(64))
    filterby      = “nom”
    def __init__(self,nom,*args,**kw):
        Entity.__init__(self,*args,**kw)
        self.nom = nom

    def __repr__(self):
        return “” %  self.nom
   
class TypeBien(Entity):
    using_options (tablename=“TypesBiens”)
    __metaclass__ = UniqueMeta
    type          = Field(Unicode(64))
    filterby      = “type”

    def __init__(self,type,*args,**kw):
        Entity.__init__(self,*args,**kw)
        self.type = type

    def __repr__(self):
        return “” % self.type

class MetaCity(EntityMeta):
    cache = cache.get_cache(“cities”,type=“memory”)
    def __call__(cls,name):
        “”“
        If it’s in the cache, return the cached version
        If not in the cache :
            If it’s in the database, retrieve it, cache it and return it
            If it’s not there, create it, cache it and return it
        ““”
        theCity = MetaCity.cache.get_value(key=name,createfunc=lambda:None)
        if not theCity :
            #not in the cache
            theCity = cls.query.filter_by(name=name).first()
            if not theCity:
                #not in the database either
                print “not in the database”
                theCity = type.__call__(cls,name)
                session.add(theCity)
            #Adding it to the cache, after creating it in the database if it wasn’t there
            MetaCity.cache.set_value(key=name,value=theCity)           
        return theCity
   
class City(Entity):
    __metaclass__ = MetaCity
    using_options (tablename=“Cities”)
    name   = Field(Unicode(64))

    def __init__(self,name,*args,**kw):
        Entity.__init__(self,*args,**kw)
        self.name = name

    def __repr__(self):
        return “” %  self.name

metadata.bind = “mysql://username:password@localhost:3306/db”
metadata.bind.echo = True