Discussion :

[kango]

Bonjour,

Je cherche un moyen pour pouvoir remonter au "caller" d'une fonction, mais je ne veux pas seulement son nom, je souhaite obtenir l'objet.

Le module inspect me permet de remonter au nom du caller avec la méthode stack. Elle me permet aussi de remonter aux frames mais je ne sais pas comment les manipuler.

Voici un exemple de ce que je voudrais faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class Toto(object):
    get_caller() # => retourn l'objet class Toto
    def test(self):
        get_caller() # => retourne l'objet fonction test

si quelqu'un a déjà essayé de faire ceci, je suis preneur de toute info

D'avance merci

[vincent.mbg]

Bonsoir et bienvenue dans le monde de la Programmation Orienté Aspect

Utilise les décorateurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
def get_caller( foo ):
    print( foo )
    return foo
 
class Toto( object ):
    @get_caller # => retourne l'objet class Toto
    def __init__( self ) :
        pass
 
    @get_caller # => retourne l'objet fonction test
    def test(self):
        pass

[kango]

Merci pour la réponse, je ne me suis jamais vraiment penché sur ces décorateurs (enfin à part les properties, classmethod et staticmethod), il va vraiment falloir que je m'y mette

Je me rends compte que je n'ai pas été assez précis dans ma question.

En fait, je n'ai besoin du caller qu'au moment de l'initialisation de la classe pour "customiser" la metaclass.

Avec un décorateur sur le init, à chaque création d'instance je vais déclencher le mécanisme.

J'ai cru comprendre que le mécanisme que je veux mettre en place s'appelle un "class advisor".

Voici un exemple pour mieux comprendre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import inspect
def test(name):
    caller = inspect.stack()[1][0]
    print caller.f_locals.keys()
    def advisor(name,bases,d):
        print "in advisor !"
        return type(name,bases,d)
    caller.f_locals["__defaultMetaclass__"] = caller.f_locals["__metaclass__"]
    caller.f_locals["__metaclass__"] = advisor
class Meta(type):
    def __new__(cls,name,bases,d):
        print "in __new__"
        return type.__new__(cls,name,bases,d)
class Item(object):
    __metaclass__ = Meta
    test("toto")
    def __init__(self):
        object.__init__(self)

Dans l'exemple ci-dessus j'ai substitué la metaclass de Item par ma fonction advisor. Ce que je voudrais pouvoir faire, c'est faire en sorte qu'advisor fasse sa customisation de la classe et qu'il transmette ensuite la main à la métaclasse par défaut (celle que j'ai sauvegardé sous le nom "__defaultMetaclass__") et je ne sais pas comment l'invoquer.

J'ai remarqué qu'en fait le caller de la métaclasse d'une classe est le module dans lequel est défini cette même classe.

J'ai besoin de dissocier les mécanismes de customization de la class via la métaclasse et via le class advisor afin de pouvoir utiliser l'un sans l'autre.

Je ne sais pas si c'est compréhensible, j'ai du mal à l'exprimer autrement.

[kango]

finalement, j'ai trouvé un package qui fait déjà ce que je souhaite: PyProtocols (c'est souvent bien mieux que de réinventer la roue :p)

Voici la solution pour ceux que ça intéresse:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from protocols.advice import addClassAdvisor
 
def advice(name):
    def callback(cls):
        print "in callback"
        print cls
        setattr(cls,"__flagadvice__",True)
        return cls
    addClassAdvisor(callback)
 
class Meta(type):
    def __new__(cls,name,bases,d):
        print "in __new__"
        d["__flagmeta__"] = True
        return type.__new__(cls,name,bases,d)
class Base(object):
    __metaclass__ = Meta
    advice("base")
    def __init__(self):
        object.__init__(self)
class Derived(Base):
    advice("derived")
    def __init__(self):
        Base.__init__(self)
 
print Base.__dict__
print Derived.__dict__

Les classes ont bien été customisées à la fois par l'advisor et la metaclass et de manière indépendente l'une de l'autre. L'héritage ne pose pas de problème