Discussion :

[Guigui_]

J'ai fait un bout de code qui permet de zipper un répertoire avec l'affichage d'un ProgressDialog pendant le zip (qui pourra ensuite être ajouté à notre page Sources)

Voici le 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
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
66
67
68
69
70
71
import wx
import os
import os.path
import glob
import zipfile
import zlib
import thread
import sys
 
class wxZip(wx.App):
    def OnInit(self):
        self.dlg = wx.ProgressDialog("Zip",
                                "",
                                maximum = 100,
                                parent=None,
                                style = wx.PD_CAN_ABORT
                                | wx.PD_APP_MODAL
                                | wx.PD_ELAPSED_TIME
                                | wx.PD_REMAINING_TIME
                                )
        return True
 
    def _sizedirectory(self, path):
        """ Created: 2005.12.05 - Updated: 2005.12.06
            Calcul la taille totale du repertoire a compresser """
        for i in glob.glob(path+'\\*'):
            if not self.dlg.Update(-1,'Taille totale des fichiers a compresser: '+str(self.totsize)):
                self.dlg.Destroy()
                return False
            if os.path.isdir(i): self._sizedirectory(i) 
            else: self.totsize+=os.path.getsize(i)
        return True
 
    def _zipdirectory(self, path):
        """ Created: 2005.12.05 - Updated: 2005.12.06
            Ajoute les fichiers dans le zip """        
        for i in glob.glob(path+'\\*'):
            if not self.dlg.Update(100 * self.sizeencours / self.totsize,'Taille totale des fichiers a compresser: '+str(self.totsize) \
                                   +'\nTaille des fichiers compresses: '+str(self.sizeencours)):
                self.dlg.Destroy()
                return False
            if os.path.isdir(i): self._zipdirectory(i) 
            else:
                self.zfile.write(i)
                self.sizeencours += os.path.getsize(i)
        return True
 
    def Progresszip(self, namezip, pathzip):
        """ Created: 2005.12.05 - Updated: 2005.12.06
            Methode principale """         
        ## Calcul de la taille totale des fichiers a compresser
        self.dlg.Update(-1,'Calcul de la taile totale des fichiers a compresser')
        self.totsize = 0
        if not self._sizedirectory(pathzip): exit
        self.dlg.Update(-1,'Taille totale des fichiers a compresser: '+str(self.totsize))
        ## Creation du zip
        try: self.zfile = zipfile.ZipFile(namezip,'w',compression=zipfile.ZIP_DEFLATED)
        except: self.zfile = zipfile.ZipFile(namezip,'w')
        self.sizeencours = 0
        self.pathzip = pathzip
        ## Ajout des fichiers dans le zip
        if self._zipdirectory(pathzip): self.zfile.close()
        else: ## On a appuie sur Cancel, on supprimer le zip cree
            self.zfile.close()
            os.remove(namezip)
 
 
 
app = wxZip()
thread.start_new_thread(app.MainLoop,())
app.Progresszip('python.zip', 'c:\\python24')

Ce qui me chagrine, c'est que je suis obligé de créer un nouveau thread (avant dernière-ligne), sinon, j'ai un beau sablier pendant l'exécution de l'application avec l'impossibilité d'appuyer sur Cancel.
Je trouve pas ça super propre. Ce qu'il me faudra, c'est pouvoir appeler app.Progresszip(...) après avoir lancer app.MainLoop(). En Tkinter, il y a la fonction after qui lance une fonction après un certain temps et avoir un code du type:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
app = wxZip()
lancer après 1s la fonction app.Progresszip('python.zip', 'c:\\python24')
app.MainLoop()

[loufoque]

Bon déjà, seul le thread principal doit manipuler les objets wx qui ne sont pas thread-safe.

Tu devrais faire ton traitement dans un thread séparé (et lance ça plutôt dans wxZip.OnInit), et tu peux demander au thread principal d'appeler une certaine fonction en utilisant wx.CallAfter.
Pour communiquer avec le thread secondaire tu pourras utiliser une variable que tu vérifieras pérodiquement.

Ce qu'il me faudra, c'est pouvoir appeler app.Progresszip(...) après avoir lancer app.MainLoop()

Ben si tu veux l'appeler après le app.MainLoop() il suffit de l'appeler dans le OnInit non ?
Enfin bon a priori ton truc est bloquant, donc les boutons ne seront de toutes façons pas réactifs.

Il n'est peut-être pas obligatoire d'utiliser le multithreading, voir le wiki sur les tâches longues à executer.
A priori tu peux traiter tous les évenements disponibles sur la queue avec wx.Yield().