Discussion :

[tchernobill]

bonjour à tous,


Apres avoir cherché sur le net je n'arrive pas à trouver de solution pour pouvoir passer un argument à un exe python.

j'utilise py2exe pour une petit appli que je distribue sous windows, elle est graphique (glade). j'aimerai que lorsque cette appli est en marche on puisse lui passer un argument.

ex:
je fais un .bat pour lancer l'appli et ensuite je lui envois un message à afficher

1. "c:\mypython.exe" << je lance mon appli via un 1er .bat. Une fenetre s'affiche "bonjour..."


2 "c:\mypython.exe -lancewordpad" << je lance un 2eme .bat qui va en quelque sorte dire à l'appli en train de tourner "lance wordpad"


Attention, je ne veux pas le faire en une seule étape, car l'application doit tourner en fond et faire d'autres choses. je ne veux pas l'ancer une application qui va lancer une autre application, je veux lancer une application qui "écoute" et qui peut interpreter ce que je lui envoi via une ligne de commande.

j'espere avoir été clair

PS: j'ai trouvé comment récupérer un argument passé en ligne de commande mais seulement au lancement de l'application (là: http://forums.devshed.com/python-pro...de-515005.html ), pas lorsqu'elle est déjà lancée.

Merci de m'avoir lu,
@bientot j'espere

[N.tox]

Regardes dans la faq, la partie pour éviter d'avoir plusieurs fois le même programme python qui tourne en même temps. Tu pourrais adapter le concept (modifié évidemment) à ton problème. Mais comme j'y connais rien en serveur, je ne saurais t'en dire plus .

[DelphiManiac]

J'aurais tendance à te préconiser xmlrpc (c'est de base dans python).

En gros tu lances une première application, qui est en attente, et après tu en lances une deuxième ponctuellement qui appelle une fonction de la première et se termine. L'avantage de xmlrpc, c'est que de plus, cela permets de faire des appels au travers du réseau.

[alexdevl]

Il y a la solution suivante :
Tu lance l'application A qui tourne en tâche de fond et qui scrute un fichier .txt périodiquement.

Tu lance une applic B qui seulement met à jour le fichier .txt
exemple : applicB.py commande

fichier.txt devient commande

[oiffrig]

Pour ma part, je rejoindrais la proposition de DelphiManiac, xmlrpc permet de faire communiquer des programmes facilement, sinon tu peux aussi utiliser directement les sockets pour faire communiquer tes deux programmes.
Dans tous les cas, une architecture client-serveur est à mon avis la solution la plus adaptée.
Pour xmlrpc : Serveur SimpleXMLRPCServer, client xmlrpclib

[tchernobill]

Pour ma part, je rejoindrais la proposition de DelphiManiac, xmlrpc permet de faire communiquer des programmes facilement, sinon tu peux aussi utiliser directement les sockets pour faire communiquer tes deux programmes.
Dans tous les cas, une architecture client-serveur est à mon avis la solution la plus adaptée.
Pour xmlrpc : Serveur SimpleXMLRPCServer, client xmlrpclib

bonjour,

merci d'avoir répondu si vite !


J'ai essayé xmlrpc mais mon appli freeze, une fois le serveur lancé, je ne peux plus contrôler l'application. j'ai essayé de lancer le serveur dans un gobject.idle_add mais aucune difference.

Voici un code test (très sale je l'avoue mais c'est pour tester):

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
46
47
48
49
50
51
52
53
54
55
56
57
 
import gtk 
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
 
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)
 
# Create server
server = SimpleXMLRPCServer(("localhost", 8000),
                            requestHandler=RequestHandler)
server.register_introspection_functions()
 
# Register pow() function; this will use the value of
# pow.__name__ as the name, which is just 'pow'.
server.register_function(pow)
 
# Register a function under a different name
def adder_function(x,y):
    return x + y
server.register_function(adder_function, 'add')
 
# Register an instance; all the methods of the instance are
# published as XML-RPC methods (in this case, just 'div').
class MyFuncs:
    def div(self, x, y):
        return x // y
 
server.register_instance(MyFuncs())
 
 
 
 
w = gtk.Window()  
 
boite_v = gtk.VBox(False,1) 
boite_v.set_border_width(10)
w.add(boite_v)
boite_v.show
 
aligna = gtk.Alignment(0.5, 0.5, 0, 0)
boite_v.pack_start(aligna, False, False, 1)
aligna.show()
 
 
 
t = gtk.Button("Fermer")
aligna.add(t)
t.show()
 
 
w.show_all() 
 
# Run the server's main loop
server.serve_forever()
gtk.main()

[oiffrig]

Normal, tu demande au serveur de tourner indéfiniment, ça se fait en mode bloquant, il faut que tu le lances dans un thread séparé

[tchernobill]

Normal, tu demande au serveur de tourner indéfiniment, ça se fait en mode bloquant, il faut que tu le lances dans un thread séparé

ben je cherche justement dans cette voie.... j'ai testé deux trois scripts de thread sans succes.

Mais merci pour l'aide en tous cas, cette m"thode est très interressante.

[oiffrig]

Je suppose que tu utilises la gestion de threads de pyGTK. Je ne connais pas, mais apparemment il y a pas mal d'infos dans leur FAQ concernant les threads.

[tchernobill]

Je suppose que tu utilises la gestion de threads de pyGTK. Je ne connais pas, mais apparemment il y a pas mal d'infos dans leur FAQ concernant les threads.

bonjour,

j'ai testé tous leurs exemples sans succès mais j'ai quand meme reussi en utilisant les thread python (natif ?)

je fais comme celà :
thread.start_new_thread(server.serve_forever, ())

et maintenant ça marche.
Par contre celà m'apporte un nouveau probleme... :/

Lorsque j'appelle une fonction qui a ete enregistrée (register_function) et que cette fonction fait elle même appel à une fonction du Main Thread catastrophe... la fonction du mainthread essais de s'executé dans le thread créé à l'occasion du serveur.

J'ai cherché sans trop de succès dans la doc de thread de python + quelques forums comment executer une fonction dans le main thread plutot que le thread en cours.

Je suis preneur pour n'importe quelle piste.

Merci de m'avoir lu.

[pacificator]

Je te conseille d'utiliser les evenements (event) pour passer des informations à ton interface graphique.
Dans ce source utilisant wxpython, la création d"evenements personnalisés permet de lancer le thread sans bloquer l'interface et de poster des events vers celle-ci.

Des mecanismes similaires existent avec pyGTK (signal_handler, emit).