Appel de modules reciproque

Bonjour a tous.

Voila, j'ai developpe une interface graphique en python ( sous Linux
).
J'ai scinde le code en different modules distinct representant chacun
une fenetre de l'interface.
Un dernier module est responsable de la gestion des evenements dans
l'interface.

Mon probleme est le suivant.
Lorsque je lance l'interface, j'importe le module de fonction.
Celui-ci ayant besoin de certains elements de l'interface, il importe
le module d'interface.

Bilan des operations ca coince.
Je ne vois pas comment resoudre ce probleme.

Je vous donne un exemple tres simplifie de ce que j'essais de faire:

gui.py:
###################################################
#!/usr/local/bin/python2.2

import Tkinter
from Tkinter import *

print "inside gui: Before import fct"
import fct
print "inside gui: after import fct"

class Gui:
print "inside Gui class"
def __init__(self, myParent):
print "frame declaration"
self.frame = Frame(myParent)
print "frame declared and button declaration"
self.button = Button(self.frame, text = "Click n here",
command = lambda:
self.testFunction("Hello world")
)
print "button declared"

self.frame.pack(expand = 1)
self.button.pack()

def testFunction(self, text):
print "Inside Gui "+text
fct.give(text)


root = Tk()
gui = Gui(root)
root.mainloop()
##########################################################

fct.py
##########################################################
print "inside fct: Before import gui"
import gui
print "inside fct: after import gui"

def give(textgive):
print "inside fct "+textgive
gui.button.config(text = "clicked")

##########################################################

si je lance le code par :
python gui
Ca coince (>_<)

Quelqu'un pourrait'il eclairer ma lanterne?
D'avance merci
Alexandre

Mamantins wrote:

Bonjour a tous.

Voila, j'ai developpe une interface graphique en python ( sous Linux
).
J'ai scinde le code en different modules distinct representant chacun
une fenetre de l'interface.
Un dernier module est responsable de la gestion des evenements dans
l'interface.

Mon probleme est le suivant.
Lorsque je lance l'interface, j'importe le module de fonction.
Celui-ci ayant besoin de certains elements de l'interface, il importe
le module d'interface.

Bilan des operations ca coince.
Je ne vois pas comment resoudre ce probleme.

Je vous donne un exemple tres simplifie de ce que j'essais de faire:

gui.py:
###################################################
#!/usr/local/bin/python2.2

import Tkinter
from Tkinter import *

print "inside gui: Before import fct"
import fct
print "inside gui: after import fct"

class Gui:
print "inside Gui class"
def __init__(self, myParent):
print "frame declaration"
self.frame = Frame(myParent)
print "frame declared and button declaration"
self.button = Button(self.frame, text = "Click n here",
command = lambda:
self.testFunction("Hello world")
)
print "button declared"

self.frame.pack(expand = 1)
self.button.pack()

def testFunction(self, text):
print "Inside Gui "+text
fct.give(text)


root = Tk()
gui = Gui(root)
root.mainloop()
##########################################################

fct.py
##########################################################
print "inside fct: Before import gui"
import gui
print "inside fct: after import gui"

def give(textgive):
print "inside fct "+textgive
gui.button.config(text = "clicked")

##########################################################

si je lance le code par :
python gui
Ca coince (>_<)

Quelqu'un pourrait'il eclairer ma lanterne?
D'avance merci
Alexandre

La solution la plus simple: fais l'un des "import" non pas au niveau du module,
mais dans la fonction qui l'utilise. Exemple, dans gui.py:

def testFunction(self, text):
import fct
print "Inside Gui "+text
fct.give(text)

et retire le "import fct" du module.

Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le
module gui, de mettre ta fonction give dans une classe, d'instancier cette
classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:

--gui.py--------------------------------------------
from Tkinter import *

class Gui(Tk):
def __init__(self, myFct):
Tk.__init__(self)
self.fct = myFct
self.frame = Frame(self)
... # Tout pareil après...

def testFunction(self, text):
self.fct.give(text)
----------------------------------------------------

--fct.py--------------------------------------------
import gui

class Fct:
def __init__(self):
self.gui = gui.Gui(self)
self.gui.mainloop()

def give(self, textgive):
self.gui.button.config(text = "clicked")

if __name__ == '__main__':
fct = Fct()
----------------------------------------------------

et tu lances:
python fct.py

Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet
"fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer
le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin,
c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode
"give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.

HTH