add attribs & methods

Version imprimable

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:

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()

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:

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:

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

08/11/2011, 14h44
pfeuh

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

Citation:

Envoyé par wiztricks

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... :oops:

A+

Pfeuh

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:

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

Salut,

Citation:

Envoyé par wiztricks

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 :ccool: 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:

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'

Bonsoir,

Citation:

Envoyé par pfeuh

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

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:

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())

Code:

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:

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:

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:

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 :evil:. 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:

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)).

j'allais oublier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class dnd_base:
    def dummyFunc(self):
        return self.dummyVar.upper()
 
def factory(base_class):
    cls = type(base_class)
    return cls('DND_%s' % base_class.__name__,
               (base_class, dnd_base), {'dummyVar': None})
 
if __name__ == "__main__":
 
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
 
    win = factory(Tk.Tk)
    fen = win()
    print(fen.dummyVar)
    fen.dummyVar = "azerty"
    print(fen.dummyFunc())

@++

Salut PauseKawa,

Citation:

Envoyé par PauseKawa

vous voulez passer outre un héritage simple

C'est parce que ce "dnd patch" ne doit pas s'appliquer à une classe précise, mais à n'importe quel widget Tkinter.

Citation:

Envoyé par PauseKawa

Votre choix vient il de la simplicité du second code ?

On parle bien du même second code, celui là?
Code:

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
il a l'inconvénient d'écraser la classe originale mais l'avantage de simplifier l'écriture des méthodes à ajouter.

Celui que j'ai retenu est un mix de toutes les propositions:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 def dummyFunc(self): self['bg'] = self.dummyVar def factory(base_class, *args, **kwds): cls = type(base_class) options = {'dummyVar': "light blue", 'dummyFunc': dummyFunc} return cls('DND_%s' % base_class.__name__, (base_class,), options) if __name__ == "__main__": try: import Tkinter as Tkinter except: import tkinter as Tkinter fen = factory(Tkinter.Tk)() fen.dummyFunc() for index, dndclass in enumerate([Tkinter.Button, Tkinter.Label, Tkinter.Radiobutton, Tkinter.Checkbutton]): widget = factory(dndclass)(text=str(dndclass)) widget.grid() widget.dummyFunc() fen.mainloop()
A+

Pfeuh