Record.py

# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without
# restriction, including without limitation the rights to use,
# copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the
# Software is furnished to do so.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import operator
from itertools import islice

def Record(*slots):
    class cls(RecordBase):
        pass

    cls.set_slots(slots)

    return cls

class RecordBase(tuple):
    SLOTS = ()

    ## overide this one instead of __init__
    def __new__(cls, *values):
        assert len(values) == len(cls.SLOTS)
        return tuple.__new__(cls, values)

    ## use this when overriding __new__
    @classmethod
    def new(cls, *values):
        assert len(values) == len(cls.SLOTS)
        return tuple.__new__(cls, values)

    def __iter__(self):
        return islice(tuple.__iter__(self), len(self.SLOTS))

    ## use this when overriding __iter__
    @property
    def values(self):
        return islice(tuple.__iter__(self), len(self.SLOTS))

    def __repr__(self):
        return self.__class__.__name__ + repr(tuple(self.values))

    def alter(self, **value_by_slot):
        return self.new(*(value_by_slot.get(self.SLOTS[index], value)
                          for index, value
                          in enumerate(self.values)))

    @property
    def named_values(self):
        return ((self.SLOTS[index], value) for (index, value) in enumerate(self.values))

    @classmethod
    def from_named_values(cls, named_values):
        return cls.from_dict(dict(named_values))

    @classmethod
    def from_dict(cls, dct, default = None):
        return cls.new(*(dct.get(slot, default) for slot in cls.SLOTS))
        

    def get_by_index(self, index):
        return tuple.__getitem__(self, index)

    def set_by_index(self, set_index, set_value):
        return self.new(*(set_value if set_index == index else value
                          for (index, value)
                          in enumerate(self.values)))


    ## setting up getters and setters
    @classmethod
    def set_slots(cls, slots):
        cls.SLOTS = slots
        for index, slot in enumerate(slots):
            setattr(cls, slot, property(cls.make_getter(index)))
            setattr(cls, "set_" + slot, cls.make_setter(index))

    @classmethod
    def make_getter(cls, index):
        return lambda self : self.get_by_index(index)

    @classmethod
    def make_setter(cls, index):
        return lambda self, value: self.set_by_index(index, value)

    ## for Pickling

    def __getnewargs__(self):
        return self

def upper_first(string):
    return string[0].upper() + string[1:]
    

class LinkedList(Record("first", "rest")):
    def __new__(cls, first, rest = None):
        return cls.new(first, rest)

    def __getitem__(self, index):
        return iget(self, index)

    def __iter__(rest):
        while True:
            first, rest = rest.values
            yield first
            if rest is None:
                raise StopIteration

    def cons(self, value):
        return self.new(value, self)

if __name__ == "__main__":
    # tests
    def err(code, err_type = Exception):
        try:
            code()
        except err_type, error:
            return error
        
    class Person(Record("name", "age")):
        pass

    name   = "peter"
    age    = 25

    peter  = Person(name, age)
    assert peter.name          == name 
    assert peter[0]            == name 
    assert peter.age           == age
    assert peter[1]            == age
    assert tuple(peter.values) == (name, age)
    assert tuple(peter)        == (name, age)
    assert list(peter.named_values) == [("name", name), ("age", age)]
    assert peter               == Person("peter", 25)
    assert repr(peter)         == "Person('peter', 25)"
    assert peter               == Person.from_named_values(peter.named_values)
    assert peter               == Person.from_dict(dict(peter.named_values))
    assert err(lambda : peter.height, AttributeError)
    assert err(lambda : peter[2],     IndexError)
    assert err(lambda : Person())
    assert err(lambda : Person("peter"))

    assert peter.alter(age = 29) == Person(name, 29)
    assert peter.set_age(29)    == Person(name, 29)
    assert peter.alter(name = "grandpa", age = 99) == Person("grandpa", 99)
    assert peter.set_name("grandpa").set_age(99)   == Person("grandpa", 99)

    def iget(itr, index):
        try:
            itr = iter(itr)
            for _ in xrange(index):
                itr.next()
            return itr.next()
        except StopIteration:
            raise IndexError
    
                    
    names1  = LinkedList("alice")
    names2  = names1.cons("bob")
    names2z = names1.cons("zed")
    names3  = names2.cons("charlie")

    assert list(names1)  == ["alice"]
    assert list(names2)  == ["bob", "alice"]
    assert list(names2z) == ["zed", "alice"]
    assert list(names3)  == ["charlie", "bob", "alice"]
    assert names3[1]     == "bob"
    assert names3[0]     == "charlie"
    assert err(lambda : names3[3], IndexError)

    assert (names3.first, list(names3.rest)) == ("charlie", ["bob", "alice"])

    print "passed!"