This Friday, at 9 am., we want to invite you to an unofficial montreal-python gathering, at Savoir-Faire Linux’s booth, in the St-Pierre room (across from the blue “Dinner/Lunch” room). (Hilton Bonaventure Hotel)
And more than that, you can come if you’re registered to Confoo after 13h30 !
I will be back with tons of ideas of posts and code after Confoo.
Formalchemy is offering us multiple ways to render our data and to display it. With a form we can create new instances of your objects and modify existing ones. But, more importantly, in our case, we can use it to create multiple new instances at a time
For a project at work, it was needed to generate multiple instances of an item. I decided to use formalchemy to render different form. At first, it was not that easy, when I launched the validation process, an exception was thrown because multiple values with the same key were found. The problem was caused by the fact that each new item was using the same fields name.
It was necessary to use a kind of unique id for each new item and to make sure that their fields would use this in their id
Yeah that's cool, but how to propagated a unique to id the field and how to make the validation process to use them?
All form's definition are built using zope.schema and it's type definition tools
from formalchemy.ext.zope import FieldSet, Grid, Pk
class IOrderEditForm(interface.Interface):
"""Interface of order's edition form"""
number = schema.Int(title=u"Id of the order", required=True)
supplyer = schema.List(title=u"Supplyer", required=True)
class IOrderAddItemForm(interface.Interface):
line = schema.Int(title=u"Line", required=True)
product = schema.List(title=u"Product", required=True)
quantity = schema.Int(title=u"Quantity", required=True)
OrderAddItemForm = Grid(IOrderAddItemForm)
OrderEditForm = FieldSet(IOrderEditForm)
class OrderEdit(object):
_pk = Pk("number")
interface.implements(IOrderEditForm)
class OrderAddItem(object):
_pk = Pk("line")
interface.implements(IOrderAddItemForm)
The controller is responsible of the rendering of the different fields and to launch the validations. In our case, it's important to configure item's form with pk (primary key) flag to True.
def edit(self):
c.instance = OrderEdit()
c.instance_items = []
for i in range(0,request.params['item_count'] or 1):
item = OrderAddItem()
item.line = i+1
c.istance_items.append(item)
c.form = OrderEditForm.bind(c.instance, data=request.params or None)
c.form_items = OrderAddItemForm.bind(c.instance_items, \
data=request.params or None)
supps = [('One',1),('Two',2),('Three',3)]
params = [c.form.supplyer.dropdown(options=supp)]
c.form.configure(options=params)
c.form_items.configure(pk=True)
if request.method == "POST" and c.form.validate() \
and c.form_items.validate():
#... ...
# save routine
#... ...
return render("/order/detail")
return render("/order/edit")
By using a primary key for your multi-items form, it will generate the correct name for each fields, including this primary key value. By example, the name of line field of the first item would be:
OrderAddItem-1-line
When you will validate your form, it will bind each post's data to the corresponding item, depending of the primary of each item ! You just need to create a cool ajaxified interface for your form and it would complete your multi-item form. Oh! And by the way, you should think about using jquery.form.js if you need to submit in an Ajaxified way your form !
Not so long ago, I started to work on a new pylons project at work. I was now in charge of the development of a new website dealing with accountancy datas.
The particularity of this project is that data is stocked in a proprietary software and we communicate with it using a socket and a special kind of textual request language.
Request are in a csv-like format. For example, to fetch all products id, name and available quantity in stock, we would send this:
RQ39,R01,,PRO,PNOM,,PNUM,PNOM,PQST
The response will be something like a csv list of the requested attributes and values. I decided to build a simple kind of ORM and to connect it to pylons with formalchemy and normal html tables.
Formalchemy is a form generator especially useful when using SQLAlchemy. But I did not want to create a kind of adaptor for our strange request system. So I decided to use zope.schema and zope.interface to define the structure of the different fields and to connect everything to my custom ORM.
1. First of all, I defined my form's model with the different field types and their attributes, that way:
class IBuyEditForm(interface.Interface):
buyid = schema.Int(title=u'Id', readonly=True)
prodid = schema.Int(title=u'Product', required=True)
quantity = schema.Int(title=Quantity', required=True)
2. Secondly I implemented my form model as a new type of FieldSet:
from formalchemy.ext.zope import FieldSet
BuyEditForm = FieldSet(IBuyEditForm)
3. Now I use my form's fieldset in a pylons controller:
from formalchemy.ext.zope import FlexibleDict
from your.project.forms import BuyEditForm
from your.project.lib.buy import BuyWriter
def edit(self):
instance = FlexibleDict()
c.form = BuyEditForm.bind(instance, data=request.params or None)
if request.method == "POST" and c.form.validate():
c.form.sync()
BuyWriter.update(**instance)
return redirect_to(controler='buy', action='detail', id=instance.id)
return render("/buy/edit.mako")
With the simplicity of formalchemy and zope.schema, I successfuly implemented all needed forms dealing with all my custom queries in my custom ORM. The zope.schema part is very useful to define generic validation parameters and structure of forms. The formalchemy part was very easy to integrate with this kind of strange logic of development, connected with a none common way to interact data.
Thank you zope, you can be easy and useful some times!
Thank you formalchemy, you're the best !
class Topic(Object):
db = "topics"
title = TextField()
name = TextField()
url = TextField()
order = IntegerField()
by_order = View('topics_by_order', '''\
function(doc) {
emit(doc.order, doc);
}''')
def by_order(self):The good thing with views is that they are stored in the database, it's a kind of index which is recalculated everytime you insert new data. The bad thing is that insertions are little slower but it's not a big trouble for me.
for e in Topic.query(Topic.fd, \
Topic.by_order.map_fun, ''):
yield e
Mathieu leduc-hamel - Montreal (Quebec) - you can contact me
at marrakis@gmail.com -
Proudly powered by Zine
