sandbox/minitraits.py

import types

class AttributeBase(object):
    
    def __get__(self, inst, cls=None):
        if inst is None:
            return self
        try:
            return inst._attributes[self.name]
        except KeyError:
            raise AttributeError("object has no attribute %r" % self.name)
    
    def __set__(self, inst, value):
        actualValue = self.validate(inst, self.name, value)
        inst._attributes[self.name] = actualValue
    
    def validate(self, inst, name, value):
        raise NotImplementedError("validate must be implemented by a subclass")

class NameFinder(type):
    
    def __new__(cls, name, bases, classdict):
        attributeList = []
        for k,v in classdict.iteritems():
            if isinstance(v, AttributeBase):
                v.name = k
                attributeList.append(k)
        classdict['_attributeList'] = attributeList
        return type.__new__(cls, name, bases, classdict)

class HasAttributes(object):
    __metaclass__ = NameFinder
    
    def __init__(self):
        self._attributes = {}
    
    def getAttributeNames(self):
        return self._attributeList
    
    def getAttributesOfType(self, t, default=None):
        result = {}
        for a in self._attributeList:
            if self.__class__.__dict__[a].__class__ == t:
                try:
                    value = getattr(self, a)
                except AttributeError:
                    value = None
                result[a] = value
        return result

class TypedAttribute(AttributeBase):
    
    def validate(self, inst, name, value):
        if type(value) != self._type:
            raise TypeError("attribute %s must be of type %s" % (name, self._type))
        else:
            return value

# class Option(TypedAttribute):
#     
#     _type = types.IntType
# 
# class Param(TypedAttribute):
#     
#     _type = types.FloatType
# 
# class String(TypedAttribute):
#     
#     _type = types.StringType
        
class TypedSequenceAttribute(AttributeBase):
    
    def validate(self, inst, name, value):
        if type(value) != types.TupleType and type(value) != types.ListType:
            raise TypeError("attribute %s must be a list or tuple" % (name))
        else:
            for item in value:
                if type(item) != self._subtype:
                    raise TypeError("attribute %s must be a list or tuple of items with type %s" % (name, self._subtype))
            return value

# class Instance(AttributeBase):
#     
#     def __init__(self, cls):
#         self.cls = cls
#     
#     def validate(self, inst, name, value):
#         if not isinstance(value, self.cls):
#             raise TypeError("attribute %s must be an instance of class %s" % (name, self.cls))
#         else:
#             return value
        

# class OptVec(TypedSequenceAttribute):
#     
#     _subtype = types.IntType
# 
# class PrmVec(TypedSequenceAttribute):
#     
#     _subtype = types.FloatType
# 
# class StrVec(TypedSequenceAttribute):
#     
#     _subtype = types.StringType
# 
# 
# class Bar(HasAttributes):
#     
#     a = Option()
# 
# class Foo(HasAttributes):
#     
#     a = Option()
#     b = Param()
#     c = String()
#     d = OptVec()
#     e = PrmVec()
#     f = StrVec()
#     h = Instance(Bar)