¿Es seguro hacer una clase de estilo antiguo en una clase de estilo nuevo con Herencia múltiple?

Question

En un programa que estoy escribiendo, quería hacer un ConfigParser de solo lectura para que pueda usarse de forma segura globalmente. No me di cuenta de esto, pero al parecer el SafeConfigParser es una clase de estilo antiguo, con lo que tenía a la subclase de esta manera:

class ConstParser(SafeConfigParser, object): 
    """This is a implementation of the SafeConfigParser that can't 
     write any values. This is to ensure that it can only be filled 
     once and won't get messy with multiple modules writing to it.""" 
    def __init__(self, files, defaults={}): 
     super(ConstParser, self).__init__(defaults) 
     self.read(files) 
    def set(self, *args, **argd): 
     raise NotImplementedError() 
    def write(self, *args, **argd): 
     raise NotImplementedError() 
    def remove_option(self, *args, **argd): 
     raise NotImplementedError() 
    def remove_section(self, *args, **argd): 
     raise NotImplementedError() 

Si yo no uso de objetos como un mixin, la llamada a SafeConfigParser de __init__ método no funcionó. Ahora, estoy seguro de que hay mejores formas de hacer lo que quiero hacer, pero ahora tengo curiosidad: ¿está bien hacerlo en general?

Quiero decir, no puedo pensar en ninguna razón por la que esto sería algo malo, pero todavía me da malos sentimientos. ¿Están justificados, o solo estoy siendo paranoico?

Answer 1

reemplaza la llamada:

super(ConstParser, self).__init__(defaults) 

con:

SafeConfigParser.__init__(self, defaults) 

y funciona muy bien sin la herencia múltiple.