Mettre une fonction à dormir

Version imprimable

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:

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

15/09/2006, 12h38
oiffrig

A mon avis la classe threading.Timer devrait faire l'affaire
15/09/2006, 13h56
Feeder_Fan

Intéressant ça,

Citation:

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
15/09/2006, 18h09
oiffrig

J'ai dit ça sans essayer, mais il doit y avoir moyen de relancer à chaque fois non?
15/09/2006, 19h08
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 !!

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:

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

16/09/2006, 19h55
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 :aie:

Problème résolu et merci à toi oiffrig