Discussion :

[Feeder_Fan]

Bonsoir,

Alors voila mon problème. J'utilise le script python supybot qui est un bot qui se connecte sur IRC et sur lequel on peut coder des plugins.

Sans entrer dans les détails, lorsque le bot se connecte au salon, on peut lui envoyer des commandes en privé. Le bot est donc à l'écoute de commandes.

Alors j'en ai crée une qui fait pleins de trucs et je voudrais qu'elle s'execute à intervalles de temps régulier.
J'ai donc pour cela commencé a faire une autre methode qui contient une vielle boucle while 1 avec un time.sleep et qui appelle la fonction de mise à jour que je veux faire executer a intervelles de temps réguliers.

Mais le seul probleme est que le bot gere une file d'attente de commandes et donc temps que la commande ne se termine pas impossible de lui en envoyer d'autre et notamment impossible d'arreter celle qu'on vient de lancer.

Alors j'aimerai savoir s'il y a une solution pour demarrer la fonction toutes les 60 secondes par exemple (sachant qu'elle prends 2 sec d'execution) mais que le programme retrouve la main.

Quelques bouts de code:

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
 
class BotSearch(callbacks.Plugin):
    def __init__(self, irc):
        self.__parent = super(BotSearch, self)
        self.__parent.__init__(irc)
        self._fichier = "bots.php"
        ...
 
    def envoyerftp(self, server, login, password, fichier):
        s = ftplib.FTP(server, login, password)
	f = open(fichier,'rb')
	s.storbinary('STOR %s'%(fichier), f)
	try:
            f.close()
	except:
            self.log.info("Erreur Quit FTP")
            irc.error("Une erreure s'est produite avec le FTP.")
 
    def creerbotlist(self, irc, msg, args):
        """Génère le fichier php des bots présents sur le chan.
        <Aucuns arguments>"""
 
        ... 
 
        channel = self._chan
        self.log.info('Récupération de la liste des bots présents.')
        L = list(irc.state.channels[channel].users)
        utils.sortBy(str.lower, L)
 
        ...
 
	irc.replySuccess()	
 
    creerbotlist = wrap(creerbotlist, ["owner"])

En fait cette classe est mon plugin et je voudrais lancer la méthode creerbotlist() a intervales réguliers mais que le bot puisse faire des choses entre temps.

Merci

[oiffrig]

A mon avis la classe threading.Timer devrait faire l'affaire

[Feeder_Fan]

Intéressant ça,

Create a timer that will run function with arguments args and keyword arguments kwargs, after interval seconds have passed.

Mais si je comprends bien, l'execution de la fonction ne vas se produire qu'une seule fois après le temps d'attente, et pas à intervalles de temps réguliers.

En fait je veux mettre a jour un FTP toutes les 10 minutes par exemple.

Merci

[oiffrig]

J'ai dit ça sans essayer, mais il doit y avoir moyen de relancer à chaque fois non?

[Feeder_Fan]

Je ne vois pas du tout et ce n'est pas faute d'avoir cherché puisque j'ai passé ma journée entière dessus.
Arf c'est pas aussi simple que je le pensais !!

[oiffrig]

Je viens de retrouver ça dans mes sources, c'est un script que j'ai écrit il y a quelques mois, il n'est pas optimisé, il y a certainement des choses qu'on pourrait réécrire

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
58
59
60
61
62
63
64
65
import threading as TH, time as TI
 
class Timer:
    def __init__(self, n, f, *args, **kargs):
        """Appelle la fonction/classe f toutes les n secondes,
        les arguments optionnels sont transmis à f"""
        if type(n) is not int:
            raise TypeError("n doit être entier")
        if n < 1:
            raise ValueError("Délai invalide (minimum 1s)")
        if not callable(f):
            raise TypeError("f ne peut pas être appelé")
        self._f = f
        self._f_args = args
        self._f_kargs = kargs
        self._n = n
        self.lance = False
        self.threads = []
 
    def _appel(self, id):
        self._f(*self._f_args, **self._f_kargs)
 
    def _boucle(self):
        while not self._fin:
            th = TH.Thread(target = self._appel, args = (len(self.threads),))
            th.start()
            self.threads.append(th)
            TI.sleep(self._n)
        for t in self.threads:
            t.join()
 
    def Go(self):
        """Lance le timer"""
        if not self.lance:
            self._fin = False
            self.thread = TH.Thread(target = self._boucle)
            self.thread.start()
            self.lance = True
 
    def Stop(self):
        """Arrete le timer"""
        if self.lance:
            self._fin = True
            self.running = False
 
if __name__ == '__main__':
    x = 1
    def f():
        global x
        print '\t' + `x`
        x += 1
 
    T = Timer(3, f)
    T.Go()
 
    try:
        i = 1
        while True:
            print i
            i += 1
            TI.sleep(1)
    except KeyboardInterrupt:
        pass
 
    T.Stop()

[Feeder_Fan]

En fait il y a une bibliotheque sur le bot qui est built-in et qui permet d'entrer une commande dans un algorithme de file d'attentes de priorités (tourniquet) que je n'avais pas vu ... Il était difficile sans avoir recours à ce genre de système d'arriver à mes fins. Si ca intéresse quelqu'un la bibliothèque c'est Schedule

Problème résolu et merci à toi oiffrig