Discussion :

[shaiHulud]

Bonjour,

J'ai cette classe

Code :

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

1
2
3
4
5
 
class A:
    with some_context():
        x = f(0)
        y = f(1)

Pour laquelle il est très important que f() soit appelée au sein du context manager ouvert.

Je voudrais automatiser ce with à l'aide d'une métaclasse, de sorte que ceci soit équivalent:

Code :

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

1
2
3
4
 
class B(meta=M):    
    x = f(0)
    y = f(1)

Si j'essaie de décorer B, c'est trop tard : ses attributs x,y ont été évalués, et f() a été appelée sans contexte.

Est-ce qu'une métaclasse me donne un hook suffisement tôt (avant que f() soit appelée) pour ajouter mon contexte ? Il faudrait que cela ait lieu avant que les attributs de classe soient construits !

Merci d'avance !

[wiztricks]

Salut,

Est-ce qu'une métaclasse me donne un hook suffisement tôt (avant que f() soit appelée) pour ajouter mon contexte ?

non car, si vous aviez un peu regardé:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>> class A(type):
...     def __new__(cls, name, bases, dict):
...         print (dict)
...         return super().__new__(cls, name, bases, dict)
...
>>> class B(metaclass=A):
...     x = 0
...     y = 1
...
{'y': 1, '__module__': '__main__', '__qualname__': 'B', 'x': 0}
>>>

x et y sont des attributs et se retrouvent dans le dict passé dans le __new__ de la metaclass (et plus tôt n'est pas possible).

Par contre, rien ne vous empêche d'écrire:

Code :

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

1
2
3
4
5
6
7
class A:
      x = None
      y = None
 
with ...:
      A.x = f(0)
      A.y = f(1)

ou plus concis:

Code :

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

1
2
with ...:
      A = type('A', (), { x = f(0), y = f(1) }

Donc pas besoin des metaclass.
- W

[Pyramidev]

Bonjour,

x et y sont des attributs et se retrouvent dans le dict passé dans le __new__ de la metaclass (et plus tôt n'est pas possible).

En fait, il existe un hook __prepare__ qui, quand il est présent, est appelé avant le __new__ de la métaclasse. Il est même appelé avant les évaluations de x et de y.

[wiztricks]

En fait, il existe un hook __prepare__ qui, quand il est présent, est appelé avant le __new__ de la métaclasse. Il est même appelé avant les évaluations de x et de y.

Ah oui, je l'avais oublié celui là mais difficile voire impossible à utiliser dans ce contexte: on peux toujours retourner un dictionnaire avec les bonnes valeurs de x et y mais elles seront ré-initialisées ensuite.
La seule solution serait d'avoir une sorte de typage, i.e une classe Toto qui prenne f et ses arguments en paramètres:

Code :

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

1
2
3
class B(metaclass=A):
         x = Toto(f, 0)
         y = Toto(f, 1)

puis dans l'__init__ de la metaclass on récupère les attributs associés à des instances de Toto pour les ré-initialiser.

- W

[Pyramidev]

On pourrait aussi faire le travail de the_context.__enter__ dans __prepare__(metacls, name, bases, **kwds) et celui de the_context.__exit__ dans le __new__(cls, name, bases, namespace, **kwds) de la métaclasse. the_context pourrait faire partie des arguments de kwds.

Ainsi, x = f(0) et y = f(0) seraient bien exécutés entre ce que ferait the_context.__enter__ et ce que ferait the_context.__exit__.

Mais avant de s'embarquer dans une solution compliquée, il faudrait que l'on connaisse le contexte pour savoir si c'est pertinent. shaiHulud, à quoi correspondent f et some_context() ?

[shaiHulud]

Tout d'abord merci beaucoup pour vos réponses.

J'essaie d'automatiser la création de namespace en tensorflow. L'exemple complet serait

Code :

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

1
2
3
4
5
 
class A:
    with tensorflow.name_scope("A"):
        x = tensorflow.Variable(0, name="x")
        y = tensorflow.Variable(1, name="y")

Lorsque le contexte tensorflow.name_scope est ouvert, le nom des variables sont changés, par example ici de "x" en "A/x".

Mon but est que l'utilisateur puisse écrire une classe A sans avoir à s'occuper des name_scope. Je veux automatiser ces name_scope avec une métaclasse (ou autre, décorateur ...).

Le contexte que j'utiliserai au final wrappera - mais sera un peu plus compliqué que - tensorflow.name_scope : je veux un namescope pour les méthodes/attributes de classe, un autre par instance, et enfin un namescope imbriqué "instance_2/foo_1" pour chaque appel à chaque méthode foo. Je suis capable pour l'instant de gérer tous ces namescope par décoration, sauf celui des attributs de classe.


@ wiztricks: avec des factory (Toto), un decorateur suffirait. Mais je ne veux pas que l'utilisateur codant la classe A soit autant affecté. Il doit écrire du code tensorflow de base :
x = tensorflow.Variable(0, name="x") et non pas x = Factory(tensorflow.Variable, 0, name="x").

@ Pyramidev: j'étais justement en train d'essayer ta suggestion. Ca semble fonctionner, mais j'ai quelques questions:
* Ou assigner le contexte ouvert par __prepare__ pour être récupérable dans __new__. Je le mets dans la metaclasse, mais si plusieurs classes utilisent la même, il y aura des interférences ?
* A plus forte raison dans le cas threadé.
* Comment gérer proprement les exceptions ?

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
""" Some mocking """
class struct: pass
class _name_scope(object):
    def __init__(self, *a): self.a = a
    def __enter__(self):
        print("in _name_scope", self.a)
        return self
    def __exit__(self, *b):
        print("out _name_scope", self.a)
        return self
def _Variable(*a, **k):
    print("Variable", a, k)
    return a[0]
 
tf = struct() #py3 mocking
tf.name_scope = _name_scope
tf.Variable = _Variable
tf.int32 = None
 
class Meta_(type):                    
    @classmethod # Py3 only ...
    def __prepare__(metacls, name, bases):
        #print("prepare", metacls, name, bases) #prepare <class '__main__.Meta_'> TestMeta ()        
        metacls.opened = tf.name_scope("TestMeta").__enter__()
        return {}        
 
    def __new__(cls, name, bases, classdict):
       # print("new", cls, name, bases, classdict)
        # new <class '__main__.Meta_'> TestMeta () {'cm': <__main__._name_scope object at 0x101826710>, '__module__': '__main__', '__qualname__': 'TestMeta', 'cx': 0, '__init__': <function TestMeta.__init__ at 0x1018239d8>}
        cls.opened.__exit__(None, None, None) # cls_ is Meta_
        return type.__new__(cls, name, bases, dict(classdict))
 
class TestMeta(metaclass=Meta_):            
    cx = tf.Variable(0, trainable=False, dtype=tf.int32, name="cx")
    def __init__(self):
        self.x = tf.Variable(0, trainable=False, dtype=tf.int32, name="x")
 
 
def demo_meta():
    t= TestMeta()
    print(t.cx, t.x)
 
if __name__ == '__main__':
    demo_meta()

Enfin, une autre approche serait:

Code :

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

1
2
3
 
with tf.name_scope("scope"):
    from a import A

Mais je n'ai pas envie d'appliquer le context à tout l'import (y compris aux import situés dans a.py). Voyez-vous un mécanisme d'import avancé qui permette de n'executer que A pendant l'import (ca me semble déraisonnable, mais bon ...) ?