mutabletuple 0.2

Additional class members

mutabletuple class contain these members:

• _asdict(): Returns a dict which maps field names to their corresponding values.

• _fields: Tuple of strings listing the field names. Useful for introspection.

• merge: Recursively merge with a dict or another mutabletuple.

• orderedDict: Recursively convert a mutabletuple into an ordered dict.

• iteritems: To iterate like a dict.

Mutable default values

For mutabletuple, be aware of specifying mutable default values. Due to the way Python handles default values, each instance of a mutabletuple will share the default. This is especially problematic with default values that are lists. For example:

>>> A = mutabletuple('A', [('x', [])])
>>> a = A()
>>> a.x.append(4)
>>> b = A()
>>> assert b.x == [4]

This is probably not the desired behavior, so see the next section.

Specifying a factory function for default values

For mutabletuple, you can supply a zero-argument callable for a default, by wrapping it in a MtFactory call. The only change in this example is to change the default from [] to MtFactory(list). But note that b.x is a new list object, not shared with a.x:

>>> from mutabletuple import MtFactory
>>> A = mutabletuple('A', [('x', MtFactory(list))])
>>> a = A()
>>> a.x.append(4)
>>> b = A()
>>> assert b.x == []

Every time a new instance is created, your callable (in this case, list), will be called to produce a new instance for the default value.

Specifying arguments to a factory function

When using nested mutabletuple, you might want to provide arguments for the creation of nested mutabletuple. Here is an example of how to do it:

>>> Point  = mutabletuple('Point', [('x', 0), ('y', 0)])
>>> Vector = mutabletuple('Vector', [('p1', MtFactory(Point, 2)),
...                                  ('p2', MtFactory(Point, 4, 8))])
>>> v1     = Vector()
>>> assert(v1 == Vector(Point(2, 0), Point(4, 8)))

Initialized points are created every time a vector is created.

Merging mutabletuple with mutabletuple or dict

When working with nested mutabletuple, it might be useful to be able to merge recursively with a dictionary that represents only a subset of the mutabletuple:

>>> Point  = mutabletuple('Point', [('x', 0), ('y', 0)])
>>> Vector = mutabletuple('Vector', [('p1', MtFactory(Point)),
...                                  ('p2', MtFactory(Point))])
>>> Shape  = mutabletuple('Shape', [('v1', MtFactory(Vector)),
...                                 ('v2', MtFactory(Vector))])
>>> s = Shape()
>>> d = {'v1': {'p1': {'x': 20}, 'p2': Point(30, 40)}}
>>> s.merge(d)
>>> assert(s._asdict() == {
...     'v1': {'p1': {'x': 20, 'y': 0}, 'p2': {'x': 30, 'y': 40}},
...     'v2': {'p1': {'x': 0, 'y': 0}, 'p2': {'x': 0, 'y': 0}}})

Iterating over instances

Because instances are iterable (like lists or tuples), iteration works the same way. Values are returned in definition order:

>>> Point = mutabletuple('Point', 'x y z t')
>>> p = Point(1.0, 42.0, 3.14, 2.71828)
>>> for value in p:
...    print(value)
1.0
42.0
3.14
2.71828