[R] Téléchargement d'images par paquet de 10

[Utilisateur 3309 supprimé]

bonjour,
je recherche la méthode la plus efficace/rapide pour automatiser le téléchargement de 153 images (c'est un exemple) qui se trouvent sur un site web.
les images sont numérotées de 001 a 153 sous cette forme:
http://www.monsite.com/images/001.jpg jusqu'à 153.jpg

une boucle simple avec inetget en background ne marche pas bien, je suis limité 2 téléchargements simultanés, et il faut bidouiller dans la base de registre pour augmenter la limitation. J'ai essayé en exécutant un wget.exe mais ca me lance 153x l'exécutable et ca me bouffe toute ma mémoire (4Go !!).
Donc ce qu'il me faudrait si je continue avec l'utilisation de wget.exe, c'est d'en avoir par exemple que 10 process qui se lancent et pas plus. Mais je ne vois pas comment faire ma boucle pour qu'un process se lance lorsqu'un autre a fini de télécharger.
quelqu'un a t'il un bout de code qui fait ce genre de chose ?

Merci

[TomAijerrie]

Je te conseil de les télécharger une à une pour eviter les erreurs de réseau (saturation de la ligne...)
Les télécharger par lots ne fera (je pense) pas faire aller les choses plus vites.

[Utilisateur 3309 supprimé]

je n'ai aucune erreur réseau quel que soit le moyen utilisé.
telecharger 1 par 1, ca marche met ca met beaucoup trop de temps.
Télécharger avec wget en background c'est super rapide mais ca prend toute la mémoire.
Pour moi le bon compromis c'est de controler le nombre de process wget et de le maintenir a 10 (ou plus suivant convenance).
S'il y a d'autres moyens que wget qui permettent de telecharger plusieurs images en simultané je suis preneur.

[Tlem]

Bonsoir.
Pourquoi voulez-vous vous prendre la tête à contrôler qu'il y ait toujours 10 processus Wget actifs. Si vous voulez gagner du temps, lancez 10 téléchargements Wget, et lorsque le dernier termine (plus de Wget dans les processus), on relance en relance 10. ^^

Si vous tenez à faire compliqué, vous devrez lancer chaque téléchargement Wget en récupérant chaque ID. Ensuite il faut surveiller chaque ID et si l'un d'eux ce termine alors on lance un nouveau téléchargement.

Une alternative : Lancez 10 téléchargements. Surveillez le nombre de processus Wget. Si < 10 alors on relance un téléchargement.

[orax]

aria2c à l'air de correspondre à ce que tu cherches.

Code : Tout sélectionner

-j, --max-concurrent-downloads=<N>
-P, --parameterized-uri[=true|false]

http://aria2.sourceforge.net/manual/en/html/aria2c.html

[jguinch]

J'avais bricolé un truc un peu comme tu veux, mais j'arrive pas à mettre la main dessus...

Sinon, pour faire plus simple, l'option -l de wget permet d'indiquer en entrée un fichier contenant la liste des liens à télécharger.
Tu peux par exemple créer 10 fichiers contenant chacun une partie des liens (tu divises le nombre de liens (153) par 10 = 15 liens par fichier et 3 pour le dernier)
Tu lances parallèlement 10 wget avec en entrée le nom de chaque fichier de liste : wget -l liste1.txt -P chemin_destination, puis liste2.txt ...
Quand les 10 process sont terminés, c'est fini.

Edit : j'ai retrouvé mon code et modifié les liens pour le test

► Afficher le texte

Code : Tout sélectionner

Global $iMaxDownloads = 10 ; Nombre de telechargements sumultanes max
Global $sWget = @ScriptDir & "\wget.exe" ; Emplacement de wget.exe
Global $aDownloads

$sFileList =  "http://www.7-zip.org/a/7z938.exe" & @CRLF & _
              "http://www.7-zip.org/a/7z938.msi" & @CRLF & _
              "http://www.7-zip.org/a/7z938-x64.msi" & @CRLF & _
              "http://www.7-zip.org/a/7z938-extra.7z" & @CRLF & _
              "http://www.7-zip.org/a/7z938-src.7z" & @CRLF & _
              "http://www.7-zip.org/a/lzma938.7z" & @CRLF & _
              "http://www.7-zip.org/a/7z920.exe" & @CRLF & _
              "http://www.7-zip.org/a/7z920.msi" & @CRLF & _
              "http://www.7-zip.org/a/7z920-x64.msi" & @CRLF & _
              "http://www.7-zip.org/a/7z920-ia64.msi" & @CRLF & _
              "http://www.7-zip.org/a/7z920-arm.exe" & @CRLF & _
              "http://www.7-zip.org/a/7za920.zip" & @CRLF & _
              "http://www.7-zip.org/a/7z920.tar.bz2" & @CRLF & _
              "http://www.7-zip.org/a/7z920_extra.7zs" & @CRLF & _
              "http://www.7-zip.org/a/lzma920.tar.bz2"
Local $aFiles = StringRegExp($sFileList, "\N+", 3)



Local $sOutput
_WgetMultiple($aFiles, @ScriptDir & "\download")

While $aDownloads[0][0]   ; $aDownloads[0][0] contient le nombre de fichiers restants a telecharger

    ; On affiche la progression ##############################
    ConsoleWrite(@CRLF & "#################################################" & @CRLF)
    For $i = 1 To UBound($aDownloads) - 1
        Switch Number($aDownloads[$i][3])   ; $aDownloads[$i][3] contient l'avancement en %
            Case 0
                $sOutput = "En attente"
            Case 100
                $sOutput = "Terminé"
            Case -1
                $sOutput = "Erreur"
            Case Else
                $sOutput = $aDownloads[$i][3] & "%"
        EndSwitch
        ConsoleWrite($aDownloads[$i][0] & " = " & $sOutput & @CRLF)
    Next
    ; ########################################################
    Sleep(1000)
WEnd



Func _WgetMultiple($aLnk, $sDest)
    If NOT IsArray($aLnk) Then Return SetError(1, 0, 0)
    If NOT FileExists($sDest) Then
        If NOT DirCreate($sDest) Then SetError(2, 0, 0)
    EndIf
    
    Local $aTmp[UBound($aLnk) + 1][4]
    $aTmp[0][0] = UBound($aLnk)
    $aTmp[0][1] = 0
    
    For $i = 0 To UBound($aLnk) - 1
        $aTmp[$i + 1][0] = $aLnk[$i]
        $aTmp[$i + 1][1] = 0
        $aTmp[$i + 1][2] = $sDest
    Next
    $aDownloads = $aTmp
    
    AdlibRegister("_AdlibDownload")
EndFunc


Func _AdlibDownload()
    Local $aPercent
    For $i = 1 To UBound($aDownloads) - 1
        If $aDownloads[$i][1] > 0 Then
            If ProcessExists($aDownloads[$i][1]) Then
                $aPercent = StringRegExp( StderrRead($aDownloads[$i][1]), "(\d+)%", 1)
                If IsArray($aPercent) Then 
                    $aDownloads[$i][3] = $aPercent[0]
                EndIf
            Else
                If $aDownloads[$i][3] Then
                    $aDownloads[$i][3] = 100
                Else
                    $aDownloads[$i][3] = -1
                EndIf
                $aDownloads[$i][1] = -1
                $aDownloads[0][0] -= 1
                $aDownloads[0][1] -= 1
            EndIf
        EndIf
        
        If $aDownloads[$i][1] = 0 AND $aDownloads[0][1] < $iMaxDownloads Then
            $aDownloads[$i][1] = Run (  $sWget & ' -P "' & $aDownloads[$i][2] & '" ' & $aDownloads[$i][0], "", @SW_HIDE, 4)
            $aDownloads[0][1] += 1
        EndIf
    Next
    
    If $aDownloads[0][0] = 0 Then AdlibUnRegister("_AdlibDownload")
EndFunc
 

Mais je préfère largement la solution proposée par Orax ^^

[Tlem]

Bonsoir.
La solution d'Orax présente en effet certains intérêts. Mais Cetipabo fera comme avec Wget une boucle qui lancera aussi un certain nombre de téléchargement simultané (X fois la ligne de commande) et donc la ressource mémoire va diminuer d'autant.

Je pense que aria2 utilisé avec une liste de fichiers devrait résoudre une bonne partie du problème.

Code : Tout sélectionner

aria2c -i ListeFichiers.txt

Envoyé de mon appareil mobile avec Tapatalk.

[orax]

Normalement une seule instance de aria2 suffira. J'ai fait un essai avec cette commande :

Code : Tout sélectionner

aria2c -j10 -Z -P http://.../images/[000-100].jpg

J'ai bien un téléchargement de 10 images en même temps (en parallèle).

[Utilisateur 3309 supprimé]

Merci Tlem, Jguinch et Orax,
je connaissais Aria2 mais ne l'avais jamais utilisé car wget avait toujours fait l'affaire, je pense que c'est maintenant l'occasion
Ce sera je pense assez facile à mettre en œuvre avec en plus peu de ligne de code

Merci beaucoup !

[Tlem]

Re.
Ne connaissant pas aria2c, j'ai fait quelques recherches et tests. ^^

aria2c présente en effet quelques avantages, mais par rapport à la dernière version de Wget autonome que j'ai trouvé (la version 1.11.4), il y a une sacré différence de taille.

Ceci dit, si la taille de l'exécutable n'est pas un problème, le téléchargement de plusieurs fichiers pour un total de 150Mo me donne :

Wget v1.11.4 (392 Ko) a eu une consommation mémoire de 1452 Ko.
aria2 v1.18.10 (4187 Ko) à eu une consommation mémoire dynamique comprise entre 1400 Ko et 3000 Ko.

Le serveur sur lequel j'ai fait le test ne supportant pas les connexions multiples, je n'ai vu aucune différence de temps dans le téléchargement. Par contre si le serveur supporte cette fonctionnalité, je suppose qu'un gain de temps certain devrait être visible. ^^

[Utilisateur 3309 supprimé]

Merci pour le feedback Tlem.

Dans mon cas Aria2c fonctionne du feu de dieu, je l'adopte direct ! je télécharge avec 16 connexions simultanées environ 200 images en une 20ene de secondes, avec une consommation mémoire tout a fait correcte sur un PC standard, 11Mo.

D'autre part j'apprécie la syntaxe [000-100].jpg grace au paramètre -P