I'm always looking for more simple ways to build applications. Let's face it, it's 2008 and after roughly 50 years, writing something that collects a few bits of data and presents them in a nice way is still several days of work. And that's without Undo/Redo, a way to persist the data, a way to evolve the storage format, etc.
Python was always promising and with the tkinter module, they set a rather high watermark on how you easily could build UIs ... alas Tk is not the most powerful UI framework out there and ... well ... let's just leave it at that.
With Traits, we have a new contender and I have to admit that I like it ... a lot. The traits framework solves a lot of the standard issues out of the box while leaving all the hooks and bolts available between a very thin polish so you can still get at them when you have to.
For example, you have a list of persons and you want to assign each person a gender. Here is the model:
class Gender(HasTraits):
name = Str
def __repr__(self):
return 'Gender %s' % self.name
class Person(HasTraits):
name = Str
gender = Instance(Gender)
def __repr__(self):
return 'Person %s' % self.name
class Model(HasTraits):
genderList = List(Gender)
persons = List(Person)
Here is how you use this model:
female = Gender(name='Female')
male = Gender(name='Male')
undefined = Gender(name='Undefined')
aMale = Person(name='a male', gender=male)
aFemale = Person(name='a female', gender=female)
model = Model()
model.genderList.append(female)
model.genderList.append(male)
model.genderList.append(undefined)
model.persons.append(aFemale)
model.persons.append(aMale)
Nothing fancy so far. Unlike the rest of Python, with Traits, you can make sure that an attribute of an instance has the correct type. For example, "aMale.gender = aFemale" would throw an exception in the assignment.
The nice stuff is that the UI components honor the information you use to build your model. So if you want to show a tree with all persons and genders, you use code like this:
class Model(HasTraits):
genderList = List(Gender)
persons = List(Person)
tree = Property
def _get_tree(self):
return self
class ModelView(View):
def __init__(self):
super(ModelView, self).__init__(
Item('tree',
editor=TreeEditor(
nodes = [
TreeNode(node_for = [ Model ],
children = 'persons',
label = '=Persons',
view = View(),
),
TreeNode(node_for = [ Person ],
children = '',
label = 'name',
view = View(
Item('name'),
Item('gender',
editor=EnumEditor(values=genderList,)
),
),
),
TreeNode(node_for = [ Model ],
children = 'genderList',
label = '=Persons by Gender',
view = View(),
),
TreeNode(node_for = [ Gender ],
children = '',
label = 'name',
view = View(),
),
],
),
),
Item('genderList', style='custom'),
title = 'Tree Test',
resizable = True,
width = .5,
height = .5,
)
model.configure_traits(view=ModelView())
First of all, I needed to add a property "tree" to my "Model" class. This is a calculated field which just returns "self" and I need this to be able to reference it in my tree editor. The tree editor defines nodes by defining their properties. So a "Model" node has "persons" and "genderList" as children. The tree view is smart enough to figure out that these are in fact lists of elements and it will try to turn each element into a node if it can find a definition for it.
That's it. Everything else has already been defined in your model and what would be the point in doing that again?
But there is more. With just a few more lines of code, we can get a list of all persons from a Gender instance and with just a single change in the tree view, we can see them in the view. If you select a person and change its name, all nodes in the tree will update. Without any additional wiring. Sounds too good to be true?
First, we must be able to find all persons with a certain sex in Gender. To do that, we add a property which gives us access to the model and then query the model for all persons, filter this list by gender and that's it. Sounds complex? Have a look:
class Gender(HasTraits):
name = Str
persons = Property
def _get_persons(self):
return [p for p in self.model.persons
if p.gender == self]
But how do I define the attribute "model" in Gender? This is a hen-and-egg problem. Gender references Model and vice versa. Python to the rescue. Add this line after the definition of Model:
Gender.model = Instance(Model)
That's it. Now we need to assign this new field in Gender. We could do this manually but Traits offers a much better way: You can listen for changes on genderList!
def _genderList_items_changed(self, new):
for child in new.added:
child.model = self
This code will be executed for every change to the list. I walk over the list of new children and assign "model".
Does that work? Let's check: Append this line at the end of the file:
assert male.persons == [aMale], male.persons
And the icing of the cake: The tree. Just change the argument "children=''" to "children = 'persons'" in the TreeNode for Gender. Run and enjoy!
One last polish: The editor for genders looks a bit ugly. To suppress the persons list, add this to the Gender class:
traits_view = View(
Item('name')
)
There is one minor issue: You can't assign a type to the property "persons" in Gender. If you do, you'll get strange exceptions and bugs. Other than that, this is probably the most simple way to build a tree of objects in your model that I've seen so far.
To make things easier for you to try, here is the complete source again in one big block. You can download the Enthought Python Distribution which contains all and everything on the Enthought website.
from enthought.traits.api import \
HasTraits, Str, Instance, List, Property, This
from enthought.traits.ui.api import \
TreeEditor, TreeNode, View, Item, EnumEditor
class Gender(HasTraits):
name = Str
# Bug1: This works
persons = Property
# This corrupts the UI:
# wx._core.PyDeadObjectError: The C++ part of the ScrolledPanel object has been
# deleted, attribute access no longer allowed.
#persons = Property(List)
traits_view = View(
Item('name')
)
def _get_persons(self):
return [p for p in self.model.persons if p.gender == self]
def __repr__(self):
return 'Gender %s' % self.name
class Person(HasTraits):
name = Str
gender = Instance(Gender)
def __repr__(self):
return 'Person %s' % self.name
# Bug1: This doesn't work; you'll get ForwardProperty instead of a list when
# you access the property "persons"!
#Gender.persons = Property(fget=Gender._get_persons, trait=List(Person),)
# Same
#Gender.persons = Property(trait=List(Person),)
# Same
#Gender.persons = Property()
# Same, except it's now a TraitFactory
#Gender.persons = Property
class Model(HasTraits):
genderList = List(Gender)
persons = List(Person)
tree = Property
def _get_tree(self):
return self
def _genderList_items_changed(self, new):
for child in new.added:
child.model = self
Person.model = Instance(Model)
Gender.model = Instance(Model)
female = Gender(name='Female')
male = Gender(name='Male')
undefined = Gender(name='Undefined')
aMale = Person(name='a male', gender=male)
aFemale = Person(name='a female', gender=female)
model = Model()
model.genderList.append(female)
model.genderList.append(male)
model.genderList.append(undefined)
model.persons.append(aFemale)
model.persons.append(aMale)
assert male.persons == [aMale], male.persons
# This must be extenal because it references "Model"
# Usually, you would define this in the class to edit
# as a class field called "traits_view".
class ModelView(View):
def __init__(self):
super(ModelView, self).__init__(
Item('tree',
editor=TreeEditor(
nodes = [
TreeNode(node_for = [ Model ],
children = 'persons',
label = '=Persons',
view = View(),
),
TreeNode(node_for = [ Person ],
children = '',
label = 'name',
view = View(
Item('name'),
Item('gender',
editor=EnumEditor(
values=model.genderList,
)
),
),
),
TreeNode(node_for = [ Model ],
children = 'genderList',
label = '=Persons by Gender',
view = View(),
),
TreeNode(node_for = [ Gender ],
children = 'persons',
label = 'name',
view = View(),
),
],
),
),
Item('genderList', style='custom'),
title = 'Tree Test',
resizable = True,
width = .5,
height = .5,
)
model.configure_traits(view=ModelView())
