A collection of super mutables
Project description
supermutes
==========
This library works with python 2.6, 2.7 and 3.2.
It defines two kinds of mutables.
dot
---
The ``dot`` module contains classes that allow dot-notation to be used for
when accessing a ``list`` or ``dict`` object.
eg::
>> from supermutes.dot import dotify
>> d = dotify({'a':[1, 2, 3, 4, 5], 'b': {'c': 5}})
>> d.a._0
1
>> d.b.c
5
>> d.c = {'f': 9}
>> d.c.f
9
readonly
--------
The ``readonly`` module contains classes that transform ``dict`` and ``list``
objects into ones that cannot have any values changed on them.
eg::
>> from supermutes.readonly import readonly
>> r = readonly({'a':[1, 2, 3, 4, 5], 'b': {'c': 5}})
>> r
{'a': [1, 2, 3, 4, 5], 'b': {'c': 5}}
>> r['a'].append(5)
supermutes.readonly.ReadOnlyClassException: Cannot write to object.
>> r['b']['d'] = 6
supermutes.readonly.ReadOnlyClassException: Cannot write to object.
A decorator function is also available for readonly objects. It will
readonly-fy the output of the decorated function/method
eg:
from supermutes.decorators import return_readonly
@return_readonly
def get_list():
return ['12']
Creating Sub Classes
--------------------
Upon declaration of a sub class of any of the supermutes, that class will be
set as the defacto class for recursively changing data sets.
To reset the classes back to the original set, use the ``reset_mapping`` method
inside the module
eg::
>>> from supermutes.dot import DotDict, DotList, reset_mapping
>>> class MySubClass(DotDict): pass
>>> d = MySubClass({'a': {'b': {'c': 3}}})
>>> d.a.b
{'c': 3}
>>> d.a.b.__class__
<class '__main__.MySubClass'>
>>> f = DotList([1, {}])
>>> f[1].__class__
<class '__main__.MySubClass'>
>>> reset_mapping()
>>> f = DotList([1, {}])
>>> f[1].__class__
<class 'supermutes.dot.DotDict'>
Writing your own ``Supermutable``
---------------------------------
If you would like to contribute, and write a supermutable that behaves in a
particular fashion, just try to follow these guidelines:
* It should inherit from the mutable type that it is adapting (eg ``dict``
``list`` etc.)
* It should also inherit from ``base.SuperMutable``. This takes care of
all of the registering of any subclasses so that for example, all sub
dicts added to the SuperMutable are changed accordingly. See example.py
for a working sample.
Building
--------
After cloning the repo::
$ pip install -r test-requirements.txt
$ nosetests
``supermutes`` has a build job at http://travis-ci.org/alexcouper/supermutes
==========
This library works with python 2.6, 2.7 and 3.2.
It defines two kinds of mutables.
dot
---
The ``dot`` module contains classes that allow dot-notation to be used for
when accessing a ``list`` or ``dict`` object.
eg::
>> from supermutes.dot import dotify
>> d = dotify({'a':[1, 2, 3, 4, 5], 'b': {'c': 5}})
>> d.a._0
1
>> d.b.c
5
>> d.c = {'f': 9}
>> d.c.f
9
readonly
--------
The ``readonly`` module contains classes that transform ``dict`` and ``list``
objects into ones that cannot have any values changed on them.
eg::
>> from supermutes.readonly import readonly
>> r = readonly({'a':[1, 2, 3, 4, 5], 'b': {'c': 5}})
>> r
{'a': [1, 2, 3, 4, 5], 'b': {'c': 5}}
>> r['a'].append(5)
supermutes.readonly.ReadOnlyClassException: Cannot write to object.
>> r['b']['d'] = 6
supermutes.readonly.ReadOnlyClassException: Cannot write to object.
A decorator function is also available for readonly objects. It will
readonly-fy the output of the decorated function/method
eg:
from supermutes.decorators import return_readonly
@return_readonly
def get_list():
return ['12']
Creating Sub Classes
--------------------
Upon declaration of a sub class of any of the supermutes, that class will be
set as the defacto class for recursively changing data sets.
To reset the classes back to the original set, use the ``reset_mapping`` method
inside the module
eg::
>>> from supermutes.dot import DotDict, DotList, reset_mapping
>>> class MySubClass(DotDict): pass
>>> d = MySubClass({'a': {'b': {'c': 3}}})
>>> d.a.b
{'c': 3}
>>> d.a.b.__class__
<class '__main__.MySubClass'>
>>> f = DotList([1, {}])
>>> f[1].__class__
<class '__main__.MySubClass'>
>>> reset_mapping()
>>> f = DotList([1, {}])
>>> f[1].__class__
<class 'supermutes.dot.DotDict'>
Writing your own ``Supermutable``
---------------------------------
If you would like to contribute, and write a supermutable that behaves in a
particular fashion, just try to follow these guidelines:
* It should inherit from the mutable type that it is adapting (eg ``dict``
``list`` etc.)
* It should also inherit from ``base.SuperMutable``. This takes care of
all of the registering of any subclasses so that for example, all sub
dicts added to the SuperMutable are changed accordingly. See example.py
for a working sample.
Building
--------
After cloning the repo::
$ pip install -r test-requirements.txt
$ nosetests
``supermutes`` has a build job at http://travis-ci.org/alexcouper/supermutes
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
supermutes-0.2.4.tar.gz
(5.0 kB
view hashes)