Discussion :

[pfeuh]

Salut,

Pour un projet avec du drag & drop, je dois rajouter des attributs et des méthodes à un ensemble de classes tkinter. Dans l'exemple ci-dessous je rajoute l’attribut dummyVar et la méthode dummyFunc aux classes Tk et Button. La façon de faire avec "exec" étant à mon sens très propice aux critiques, je me demandais si quelqu'un avait quelquechose de plus conventionnel?

A+

Pfeuh

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
 
class_template = """
class DND(_classname_):
    def __init__(self, *args, **kwds):
        _classname_.__init__(self, *args, **kwds)
        self.dummyVar = None
    def dummyFunc(self):
        return self.dummyVar.upper()
"""
 
def getDND(classname, *args, **kwds):
    exec class_template.replace('_classname_', classname)
    obj = DND(*args, **kwds)
    return obj
 
if __name__ == "__main__":
 
    try:import Tkinter
    except: import tkinter as Tkinter
 
    win = getDND('Tkinter.Tk')
    bt = getDND('Tkinter.Button', win, text='DND object', width=50, height=3)
    bt.grid()
    # test
    assert win.dummyVar == None
    win.dummyVar = 'azerty'
    assert win.dummyFunc() == 'AZERTY'
    assert bt.dummyVar == None
    bt.dummyVar = 'qwerty'
    assert bt.dummyFunc() == 'QWERTY'
 
    win.mainloop()

[wiztricks]

Salut,

L'idée de base est "bonne": getDND "fabrique" une sous-classe de l'objet Tk qu'on lui donne... mais "laissez à l’interpréteur le soin de se débrouiller avec les strings des scripts..."

Ce qui donne:

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
classmap = {}  # stores class.
 
def factory(base):
 
    class _wraps_(base, object):
        def __init__(self, *args, **kwds):
            base.__init__(self, *args, **kwds)
            self.dummyVar = None
        def dummyFunc(self):
            return self.dummyVar.upper()
 
    name = 'DND_%s' % base.__name__
    cls = classmap.get(name, None)
    if not cls:
        cls  = type(name, (_wraps_,), {})  
        classmap[name] = cls
    return cls

notes:
1. Normalement "classmap" est le dict d'un "module"
2. Ca fonctionne sous Python 2, version ou Tkinter n'est pas "new-style class". Normalement le {} de "type" devrait pouvoir contenir la déclaration des "fonctions", et bases pourrait être réduit à (base,)

Pour ce qui est de "l'utilisation", j'ai séparé construction de la classe et construction de l'instance...

Code :

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

1
2
3
4
5
6
7
8
9
10
if __name__ == "__main__":
 
    try:
        import Tkinter as tk
    except:
        import tkinter as tk
 
    win = factory(tk.Tk)()
    bt = factory(tk.Button)(win, text='DND object', width=50, height=3)
    bt.grid()

Bon courage,
- W

[pfeuh]

Merci wiztricks, c'est exactement ce qu'il me fallait.

mais "laissez à l’interpréteur le soin de se débrouiller avec les strings des scripts..."

Pour cela, il m'eût fallu des connaissances que je n'ai pas...

A+

Pfeuh

[wiztricks]

Salut,

Une autre façon de faire "pas très naturelle" pour ceux qui viennent des langages POO compilés est le "patch" dynamique des classes.

Code :

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

1
2
3
4
5
6
7
8
def dummyFunc(self):
        return self.dummyVar.upper()
 
def factory(cls):
    if not hasattr(cls, 'dummyVar'):
        setattr(cls, 'dummyVar', None)
        setattr(cls, 'dummyFunc', dummyFunc)
    return cls

On passe toujours par "factory". Mais on "taggue" la mise à jour de la classe via l'existence d'un attribut.
note: j'ai le souvenir d'une entrée qui wrappait les classes tk mais je ne la retrouve pas.
- W

[pfeuh]

Salut,

Une autre façon de faire "pas très naturelle"

Je trouve que c'est une super idée, elle me semble même très naturelle dans la démarche Par contre, sauf erreur, on ne travaille pas sur une copie de la classe mais sur l'original, donc une fois qu'elle est modifiée, l'original est définitivement perdu.

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
 
def dummyFunc(self):
        return self.dummyVar.upper()
 
def factory(cls):
    if not hasattr(cls, 'dummyVar'):
        setattr(cls, 'dummyVar', None)
        setattr(cls, 'dummyFunc', dummyFunc)
    return cls
 
if __name__ == "__main__":
 
    import Tkinter
 
    root = Tkinter.Tk()
    WINDOW = factory(Tkinter.Toplevel)
 
    win1 = WINDOW()
    win1.dummyVar = 'azerty'
    assert win1.dummyFunc() == 'AZERTY'
 
    win2 = Tkinter.Toplevel()
    win2.dummyVar = 'uiop'
    assert win2.dummyFunc() == 'UIOP'

[PauseKawa]

Bonsoir,

Je trouve que c'est une super idée, elle me semble même très naturelle dans la démarche

Le fait de modifier ('patcher') la classe elle même ? Moi pas.

Pour un code 'simple' cela passe mais la solution 'métaclass factory' proposé par wiztricks en premier me semble bien plus propre.
Votre choix vient il de la simplicité du second code ? Dans ce cas vous pouvez réduire le premier (désolé pour le temps passé wiztricks)

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
def factory(base_class, cls_opts):
    cls = type(base_class)
    return cls('DND_%s' % base_class.__name__, (base_class,), cls_opts)
 
if __name__ == "__main__":
 
    try:
        import Tkinter as tk
    except:
        import tkinter as tk
 
    def dummyFunc(self):
        return self.dummyVar.upper()
 
    options = {'dummyVar': None, 'dummyFunc': dummyFunc}
 
    win = factory(tk.Tk, options)
    fen = win()
    fen.dummyVar = "azerty"
    print(fen.dummyFunc())

ou

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
def factory(base_class):
    def dummyFunc(self):
        return self.dummyVar.upper()
 
    cls = type(base_class)
    return cls('DND_%s' % base_class.__name__, (base_class,),
               {'dummyVar': None, 'dummyFunc': dummyFunc})
 
if __name__ == "__main__":
 
    try:
        import Tkinter as tk
    except:
        import tkinter as tk
 
    win = factory(tk.Tk)
    fen = win()
    fen.dummyVar = "azerty"
    print(fen.dummyFunc())

(Vous remarquerez au passage la souplesse du code. Pour type voir (*))

A vrais dire c'est ce qui était fait dans new.py avec type.

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 Tkinter as Tk
from new import classobj
 
def factory(base_class):
    def dummyFunc(self):
        return self.dummyVar.upper()
 
    return classobj('DND_%s' % base_class.__name__,
                    (base_class,),
                    {'dummyFunc': dummyFunc, 'dummyVar': None})
 
root = Tk.Tk()
dnd_top = factory(Tk.Toplevel)()
dnd_top.dummyVar = "azerty"
print(dnd_top.dummyFunc())
tk_top = Tk.Toplevel()
print(hasattr(tk_top, 'dummyFunc'))
root.mainloop()

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
import Tkinter as Tk
 
# +- from new import classobj. deprecated since Python 2.6,
# removed in Python 3.0
# ie from types import ClassType as classobj
#
# types.ClassType code
class _C:
    def _m(self):
        pass
#
classobj = type(_C)
# +- use the types module instead.
def factory(base_class):
    def dummyFunc(self):
        return self.dummyVar.upper()
 
    return classobj('DND_%s' % base_class.__name__,
                    (base_class,),
                    {'dummyFunc': dummyFunc, 'dummyVar': None})
 
root = Tk.Tk()
dnd_top = factory(Tk.Toplevel)()
dnd_top.dummyVar = "azerty"
print(dnd_top.dummyFunc())
tk_top = Tk.Toplevel()
print(hasattr(tk_top, 'dummyFunc'))
root.mainloop()

Ceci dit vous voulez passer outre un héritage simple

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
try:
    import Tkinter as Tk
except:
    import tkinter as Tk
 
class Dnd_Toplevel(Tk.Toplevel):
    def __init__(self, *args, **kwargs):
        Tk.Toplevel.__init__(self, *args, **kwargs)
        dummyVar = None
    def dummyFunc(self):
        return self.dummyVar.upper()
 
root = Tk.Tk()
top = Dnd_Toplevel(root)
top.dummyVar = "azerty"
print(top.dummyFunc())

Et vous vous en êtes pas mal tiré avec exec (Non, exec is not . C'est du Python)/replace. Bien vu.

@+

* type, le built-in 'usine' de (méta)classe.
type(nom_de_la_classe, tuple des parents (tuple vide possible si pas de parent), dico des attributs/méthodes a ajouter)

Code :

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

1
2
3
>>> Foo = type('new_class', tuple(), {})
>>> Foo
<class '__main__.new_class'>

Edit pour enlever une grosse bêtise print(fen.__class__ == type(fen)).