declaración adelantada de clases en Python

Question

El siguiente programa se puede ejecutar correctamente:

class Simple(object):
    def __init__(self, name):
      self.name = name

    def __add__(self, other):
      c = Composite()
      c._members.append(self)
      c._members.append(other)
      return c

    def __repr__(self):
      return "Simple('%s')" % self.name

class Composite(object):
    def __init__(self):
      self._members = []

    def __add__(self, obj):
      if isinstance(obj, Simple):
        out = Composite()
        out._members = [k for k in self._members] + [obj]
      elif isinstance(obj, Composite):
        out = Composite()
        out._members = [k for k in self._members + obj._members]
      else:
        raise TypeError
      return out

if __name__ == "__main__":
    s1 = Simple('one')
    s2 = Simple('two')
    s3 = Simple('three')
    c1 = s1 + s2
    c2 = c1 + s3
    print c1._members
    print c2._members
    # output:
    # [Simple('one'), Simple('two')]
    # [Simple('one'), Simple('two'), Simple('three')]

Me gustaría mantener la definición de Simple, Composite y __main__ en tres archivos diferentes, pero no puede hacerlo porque no puedo Simple importación en composite.py y no puedo Composite importación en simple.py.

¿Cómo modificar la definición de clase de tal manera que se puede mantener archivos separados?

Gracias.

PS. He leído varias respuestas relacionadas con "declaración hacia adelante", pero no pude encontrar una respuesta a mi problema específico.

Answer 1

Dado que se necesitan ninguna de las referencias hasta que los métodos se llaman, las importaciones circulares puede trabajo aquí. El truco es usar referencias totalmente calificados.

import composite

class Simple(object):
   ...
  def __add__(self, other):
    c = composite.Composite()
    c._members.append(self)
    c._members.append(other)
    return c

Answer 2

El problema es que se obtiene importaciones circulares, ¿verdad?

simple importación en el método __add__ en lugar de en la parte superior del archivo para evitar la dependencia circular. Que se ralentizará el método __add__ un poco, pero por lo general no significativamente.