obteniendo la ruta de clase o espacio de nombre de una clase en python, incluso si está anidado

Question

Actualmente estoy escribiendo un módulo de serialización en Python que puede serializar clases definidas por el usuario. para hacer esto, necesito obtener el espacio de nombre completo del objeto y escribirlo en un archivo. Puedo usar esa cadena para recrear el objeto.

por ejemplo, suponer que tenemos la estructura de la clase siguiente en un archivo denominado A.py

class B: 
    class C: 
     pass 

ahora con la suposición de que my_klass_string es la cadena "A::B::C"

klasses = my_klass_string.split("::") 
if globals().has_key(klasses[0]): 
    klass = globals()[klasses[0]] 
else: 
    raise TypeError, "No class defined: %s} " % klasses[0] 
if len(klasses) > 1: 
    for klass_string in klasses: 
     if klass.__dict__.has_key(klass_string): 
      klass = klass.__dict__[klass_string] 
     else: 
      raise TypeError, "No class defined: %s} " % klass_string    
klass_obj = klass.__new__(klass) 

puedo crear una instancia de la clase C aunque se encuentra en la clase B en el módulo A. el código anterior es equivalente a llamar eval(klass_obj = A.B.C.__new__(A.B.C))

nota: estoy usando __new__() aquí porque estoy reconstitución de un objeto serializado y no quiero a inicializar el objeto como no sé qué parámetros de la clase __init__ métodos toma. Quiero crear el objeto sin llamar init y luego asignar atributos a él más tarde.

de cualquier manera que pueda crear un objeto de la clase A.B.C de una cadena. ¿Cómo voy por el otro lado? ¿Cómo obtengo una cadena que describe la ruta completa a la clase desde una instancia de esa clase, incluso si la clase está anidada?

Answer 1

No se puede obtener la "ruta completa a la clase dada una instancia de la clase ", por la sencilla razón de que no hay tal cosa en Python. Para ejemplo, construyendo en su ejemplo:

>>> class B(object): 
...  class C(object): 
...    pass 
... 
>>> D = B.C 
>>> x = D() 
>>> isinstance(x, B.C) 
True 

Cuál debe ser la "ruta de clase" de x ser? D o B.C? Ambos son igualmente válidos, y por lo tanto, Python no le da ningún medio para decirle a uno desde el otro.

De hecho, incluso el módulo de Python pickle ha Problemas decapado objeto x:

>>> import pickle 
>>> t = open('/tmp/x.pickle', 'w+b') 
>>> pickle.dump(x, t) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "/usr/lib/python2.6/pickle.py", line 1362, in dump 
    Pickler(file, protocol).dump(obj) 
    ... 
    File "/usr/lib/python2.6/pickle.py", line 748, in save_global 
    (obj, module, name)) 
    pickle.PicklingError: Can't pickle <class '__main__.C'>: it's not found as __main__.C 

Así que, en general, no veo otra opción de añadir un atributo a todas sus clases (por ejemplo, _class_path), y su código de serialización sería mirar hacia arriba para grabar el nombre de la clase en el formato serializado:

class A(object): 
    _class_path = 'mymodule.A' 
    class B(object): 
    _class_path = 'mymodule.A.B' 
    ... 

incluso se puede hacer esto de forma automática con some metaclass magic (pero también lea los otros comentarios en the same SO post para advertencias que pueden aplicarse si hace el D=B.C anterior).

Dicho esto, si usted puede limitar su código de serialización a (1) casos de las clases de nuevo estilo, y (2) las clases se definen en el de nivel superior de un módulo, a continuación, puedes copiar lo pickle hace (función save_global en las líneas 730--768 en pickle.py de Python 2.6).

La idea es que todas las clases de nuevo estilo define atributos __name__ y __module__, que son cadenas que se expanden al nombre de clase (como que se encuentran en las fuentes) y el nombre del módulo (como se encuentra en sys.modules); por el ahorro de estos se puede importar más tarde el módulo y obtener una instancia de la clase:

__import__(module_name) 
class_obj = getattr(sys.modules[module_name], class_name) 

Answer 2

Actualmente estoy escribiendo un módulo de serialización en Python que puede serializar las clases definidas por el usuario.

No. La biblioteca estándar ya incluye uno. Dependiendo de cómo cuente, en realidad, incluye al menos dos (pickle y shelve).

Answer 3

No puede, de ninguna manera razonable y no loca. Supongo que podría encontrar el nombre de clase y el módulo, y luego, para cada nombre de clase, verificar que exista en el módulo, y si no, recorrer todas las clases que existen en el módulo de forma jerárquica hasta que lo encuentre.

Pero como no hay ninguna razón para tener una jerarquía de clases así, no es un problema. :-)

Además, sé que usted no quiere oír esto a estas alturas de su trabajo, pero:

multiplataforma serialización es un tema interesante, pero hacerlo con objetos de este tipo es poco probable ser muy útil, ya que el sistema de destino debe tener exactamente la misma jerarquía de objetos instalada. Por lo tanto, debe tener dos sistemas escritos en dos idiomas diferentes que sean exactamente equivalente. Eso es casi imposible y es probable que no valga la pena.

Por ejemplo, no podría usar ningún objeto de la biblioteca estándar de Pythons, ya que esos no existen en Ruby. El resultado final es que debe crear su propia jerarquía de objetos que al final solo use tipos básicos como cadenas y números. Y en ese caso, sus objetos acaban de convertirse en contención para las primitivas básicas, y entonces también puede serializar todo con JSON o XML de todos modos.

Answer 4

Hay dos maneras de hacer esto.

Solución 1

La primera de ellas va a través del colector de basura.

B -> __dict__ -> C 

este es el código:

>>> class B(object): 
    class C(object): 
     pass 

>>> gc.get_referrers(B.C) # last element in the list 
[<attribute '__dict__' of 'C' objects>, <attribute '__weakref__' of 'C' objects>, (<class '__main__.C'>, <type 'object'>), {'__dict__': <attribute '__dict__' of 'B' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'B' objects>, 'C': <class '__main__.C'>, '__doc__': None}] 

>>> gc.get_referrers(gc.get_referrers(B.C)[-1]) # first element in this list 
[<class '__main__.B'>, [<attribute '__dict__' of 'C' objects>, <attribute '__weakref__' of 'C' objects>, (<class '__main__.C'>, <type 'object'>), {'__dict__': <attribute '__dict__' of 'B' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'B' objects>, 'C': <class '__main__.C'>, '__doc__': None}]] 

>>> gc.get_referrers(gc.get_referrers(B.C)[-1])[0] 
<class '__main__.B'> 

Algoritmo:

1. búsqueda de un dictionairy clase con el mismo __module__ como C
2. tomar la clase, utilice la 'C' atributo
3. si esta clase está anidada. hacer 1.recurively

Solución 2

uso del archivo de origen. use inspeccionar para obtener las líneas de la clase y escanear hacia arriba las nuevas clases que anidan.

Nota: No conozco ninguna manera clara en python 2, pero Python 3 proporciona una.