class temlate_new(object):
    def __init__( self, cl, params ):
        self.cl = cl
        self.params = params
        pass
    
    def __call__( self, **kw ):
        name = self.cl.__name__ + repr(self.params)
        bases = self.cl.__bases__     
        
        for key, value in self.params.iteritems():
            if type( kw[key] ) is not value:
                print "Template", name, "is invalid param", key, "need type", repr( value )
                return
                
        dicts = {}
        dicts.update( self.cl.__dict__ )
        dicts.update( kw )                
        
        return type( name, bases, dicts )
        pass
   
class template_declaration(object):
    def __init__( self, **params ):
        self.params = params
        pass
        
    def __call__( self, cl ):
        return temlate_new( cl, self.params )
        pass
    pass

def template( **kw ):
    return template_declaration(**kw)
    pass

    
@template(T = str)
class Test(object):
    def __init__(self):
        pass
        
    def foo(self):
        print self.T
    pass
    
    
test_t = Test(T = "1")
test = test_t()

print test

test.foo()

IRO>>вот написал себе костыль, имеет ли оно право на жизнь? или я плохо знаю питон?

@template(TypeElement = str)
class MonadChild(Object):
    def __init__(self, **params):
        super(MonadChild, self).__init__( **params )

        self.elements = []
        pass

    def addElement(self, **params):
        params["Group"] = self.group

        element = ObjectManager.createObject( self.TypeElement, **params )

        self.elements.append(element)
        pass

    def getElements(self):
        return self.elements
        pass

    def _onActivate(self, scene):
        Object._onActivate( self, scene )

        for element in self.elements:
            element.activate( scene )
        pass

class ObjectPuff(MonadChild(TypeElement = "ObjectPuffElement"), Object):
    def __init__(self, **params):
        super(ObjectPuff, self).__init__( **params )

        self.params["Deep"] = self.params.get("Deep", 0)
        pass
    pass

IRO>Буду рад если покажешь как можно было проще без классов

def template_new(klass, params):
  def fun(**kwargs):
    name = klass.__name__ + repr(self.params)
    bases = klass.__bases__

    for k, v in params.iteritems():
      # вот эта проверка типов аукнется гемором
      if type(kwargs[k]) is not value:
        raise TypeError("Template {0}. Invalid parameter: {1}, need type: {2!r}".format(name, k, v))

    attrs = dict(klass.__dict__, **kwargs)
    return type(name, bases, attrs)
  return fun

def template(**params):
  def fun(klass):
    return template_new(klass, params)
  return fun

class Identity(object):
  DUMMY, PASSWORD, OPENID, OAUTH = range(4)

  #... attributes, methods


ident.kind = Identity.OPENID
ident.url = "garbage"

IRO>>может у нас диалог "слепого с глухим"

template<class T>
class MonadChild
{
public:
  MonadChild()
  {
  }

public:
  void addElements( Params & _params )
  {
    T * element = Factory.createObject<T>( _params )

    m_elements.push_back(element)
  }

...

protected:
  std::vector<T *> m_elememts;
}

class Node
 : public MonadChild<Node>
{
...
}

class template_new(object):
    s_template = {}

    def __init__( self, cl, params ):
        self.cl = cl
        self.params = params

        if self.cl not in template_new.s_template:
            template_new.s_template[self.cl] = {}

        self.cache = template_new.s_template[self.cl]
        pass

    def __call__( self, **kw ):
        name = self.cl.__name__ + repr(self.params)

        if name in self.cache:
            return self.cache[name]
            pass

        bases = self.cl.__bases__

        for key, value in self.params.iteritems():
            if type( kw[key] ) is not value:
                raise TypeError("Template {0}. is invalid parameter: {1}, need type: {2!r}".format(name,key,value) )
                return

        attrs = dict(self.cl.__dict__, **kw)
        
        template_type = type( name, bases, attrs )

        self.cache[name] = template_type
        
        return template_type
        pass

class template_declaration(object):
    def __init__( self, **params ):
        self.params = params
        pass

    def __call__( self, cl ):
        return template_new( cl, self.params )
        pass
    pass

def template( **kw ):
    if kw is None:
        raise TypeError( "template decorator need template params" )
        pass

    return template_declaration(**kw)
    pass

IRO>template<class T>
IRO>class MonadChild
IRO>{
IRO>...
IRO>}
IRO>

class MonadChild(object):
    def __init__(self):
        self.elements = []
    def add_element(self, *params):
        element = self.T(*params)
        self.elements.append(element)

class Node(MonadChild):
    def __init__(self, *whatever):
        super(Node, self).__init__()
        self.T = Node
        self.whatever = whatever
    def __repr__(self):
        return '<Node "' + `self.whatever` +'">'

n = Node()
n.add_element(42)
n.add_element(42, 13)
print 'root', n
print 'nodes', n.elements

class MonadChild(object):
    def __init__(self):
        self.elements = []
    def add_element(self, *params):
        element = self.T(*params)
        self.elements.append(element)

class Node(MonadChild):
    def __init__(self, *whatever):
        super(Node, self).__init__()
        self.whatever = whatever
    def __repr__(self):
        return '<Node "' + `self.whatever` +'">'

Node.T = Node

n = Node()
n.add_element(42)
n.add_element(42, 13)
print 'root', n
print 'nodes', n.elements