Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

Pouvez vous m'aider a corriger mon script car maintenant j'ai un problème c'est que je…

  1. User

    Pouvez vous m'aider a corriger mon script car maintenant j'ai un problème c'est que je n'ai pas l'impréssion que le script essaye de télécharger les beatmaps qui échou depuis les autres osu mirror j'aimerai que si une beatmaps échoue au téléchargement ca essaye de la télécharger depuis un autres osu mirror sa la télécharge depuis un autres osu mirror différent jusqua ce que le téléchargement de la beatmap réussisse mais si le téléchargement de la beatmap échoue depuis tout les osu mirror la beatmaps sera qualifié de perdu voici mon script: import os import json import time import threading import requests from pathlib import Path

    Liste des sites de téléchargement disponibles

    mirrors = [ "https://kitsu.moe/api/d/", "https://chimu.moe/d/", "https://proxy.nerinyan.moe/d/", "https://beatconnect.io/b/", "https://osu.sayobot.cn/osu.php?s=", "https://storage.ripple.moe/d/", "https://akatsuki.gg/d/", "https://ussr.pl/d/", "https://osu.gatari.pw/d/", "http://storage.kawata.pw/d/", "https://catboy.best/d/", "https://kawata.pw/b/", "https://redstar.moe/b/", "https://atoka.pw/b/", "https://fumosu.pw/b/", "https://osu.direct/api/d/", ]

    Fonction pour télécharger un fichier

    def download_file(url, file_path): try: response = requests.get(url, stream=True, timeout=10)

        if response.status_code == 200:
            with open(file_path, "wb") as file:
                for chunk in response.iter_content(chunk_size=8192):
                    file.write(chunk)
            return True
    
    except requests.exceptions.RequestException as e:
        print(f"Erreur lors du téléchargement de {url} : {e}")
    
    return False
    

    Fonction pour télécharger une beatmap depuis un miroir

    def download_beatmap_from_mirror(beatmap_ids, collection_id, mirror): for beatmap_id in beatmap_ids: print(f"Début du téléchargement du beatmapset {beatmap_id}") if download_file(f"{mirror}{beatmap_id}", f"{collection_id}/{beatmap_id}.osz"): print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} réussi!") else: print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} a échoué!")

    Demande à l'utilisateur le lien de la collection

    collection_id = input("Entrez l'ID de la collection à télécharger: ")

    Récupération de la liste des beatmapsets de la collection

    response = requests.get(f"https://osucollector.com/api/collections/{collection_id}") data = response.json()

    beatmapsets = data["beatmapsets"]

    Crée un dossier avec l'ID de la collection en tant que nom

    os.makedirs(str(collection_id), exist_ok=True)

    Vérifie les beatmapsets déjà téléchargés sur le disque

    downloaded_beatmapsets = list(Path(collection_id).glob("*.osz"))

    Liste des beatmapsets à télécharger

    to_download = []

    for beatmapset in beatmapsets: beatmapset_file = Path(f"{collection_id}/{beatmapset['id']}.osz")

    if beatmapset_file in downloaded_beatmapsets:
        print(f"La beatmapset {beatmapset['id']} existe déjà sur le disque!")
    else:
        to_download.append(beatmapset["id"])
    

    print(f"{len(to_download)} beatmapsets à télécharger.")

    mirrors_count = len(mirrors) to_download_split = [[] for _ in range(mirrors_count)]

    for index, beatmap_id in enumerate(to_download): to_download_split[index % mirrors_count].append(beatmap_id)

    download_threads = []

    for i, mirror in enumerate(mirrors): thread = threading.Thread(target=download_beatmap_from_mirror, args=(to_download_split[i], collection_id, mirror)) thread.start() download_threads.append(thread)

    for thread in download_threads: thread.join()

    print("Téléchargement terminé.")

  2. Assistant

    Je vais modifier le script pour qu'il continue à changer de miroir jusqu'à ce que le téléchargement réussisse, ou jusqu'à ce qu'il ait échoué pour tous les miroirs. Voici la version modifiée du script, avec quelques commentaires pour expliquer les changements :

    import os
    import json
    import time
    import threading
    import requests
    from pathlib import Path
    
    # Liste des sites de téléchargement disponibles
    mirrors = [
        # ...
    ]
    
    # Fonction pour télécharger un fichier
    def download_file(url, file_path):
        # ...
        
    # Fonction pour télécharger une beatmap depuis un miroir
    def download_beatmap_from_mirror(beatmap_id, collection_id, mirror_index):
        mirror = mirrors[mirror_index]
        print(f"Début du téléchargement du beatmapset {beatmap_id}")
        if download_file(f"{mirror}{beatmap_id}", f"{collection_id}/{beatmap_id}.osz"):
            print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} réussi!")
            return True
        else:
            print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} a échoué!")
            return False  # Ajout d'un retour pour indiquer l'échec du téléchargement
    
    def download_beatmap(beatmap_id, collection_id):
        for i in range(len(mirrors)):
            if download_beatmap_from_mirror(beatmap_id, collection_id, i):
                return
        print(f"Le téléchargement de la beatmapset {beatmap_id} a échoué depuis tous les mirrors, elle est perdue.")
    
    # Demande à l'utilisateur le lien de la collection
    collection_id = input("Entrez l'ID de la collection à télécharger: ")
    
    # Récupération de la liste des beatmapsets de la collection
    response = requests.get(f"https://osucollector.com/api/collections/{collection_id}")
    data = response.json()
    
    beatmapsets = data["beatmapsets"]
    
    # Crée un dossier avec l'ID de la collection en tant que nom
    os.makedirs(str(collection_id), exist_ok=True)
    
    # Vérifie les beatmapsets déjà téléchargés sur le disque
    downloaded_beatmapsets = list(Path(collection_id).glob("*.osz"))
    
    # Liste des beatmapsets à télécharger
    to_download = []
    
    for beatmapset in beatmapsets:
        beatmapset_file = Path(f"{collection_id}/{beatmapset['id']}.osz")
    
        if beatmapset_file in downloaded_beatmapsets:
            print(f"La beatmapset {beatmapset['id']} existe déjà sur le disque!")
        else:
            to_download.append(beatmapset["id"])
    
    print(f"{len(to_download)} beatmapsets à télécharger.")
    
    download_threads = []
    
    for beatmap_id in to_download:
        thread = threading.Thread(target=download_beatmap, args=(beatmap_id, collection_id))
        thread.start()
        download_threads.append(thread)
    
    for thread in download_threads:
        thread.join()
    
    print("Téléchargement terminé.")
    

    Dans cette version, j'ai créé une nouvelle fonction download_beatmap qui gère le changement de miroir pour un seul beatmapset. Cette fonction est lancée dans un nouveau thread pour chaque beatmap à télécharger, ce qui permet de les télécharger en parallèle.

    La fonction download_beatmap_from_mirror a été légèrement modifiée pour qu'elle retourne un booléen indiquant si le téléchargement a réussi ou non. La fonction download_beatmap utilise cette valeur pour savoir si elle doit essayer un autre miroir, et affiche un message si le téléchargement a échoué pour tous les miroirs.

    Avec ces changements, le script devrait maintenant essayer tous les miroirs pour chaque beatmapset qui échoue à être téléchargé, et informer l'utilisateur si une beatmapset est "perdue" après avoir échoué sur tous les miroirs.

  3. User

    envoyez moi l'entierté du script

  4. Assistant

    Voici l'entierté du script modifié :

    import os
    import json
    import time
    import threading
    import requests
    from pathlib import Path
    
    # Liste des sites de téléchargement disponibles
    mirrors = [
        "https://kitsu.moe/api/d/",
        "https://chimu.moe/d/",
        "https://proxy.nerinyan.moe/d/",
        "https://beatconnect.io/b/",
        "https://osu.sayobot.cn/osu.php?s=",
        "https://storage.ripple.moe/d/",
        "https://akatsuki.gg/d/",
        "https://ussr.pl/d/",
        "https://osu.gatari.pw/d/",
        "http://storage.kawata.pw/d/",
        "https://catboy.best/d/",
        "https://kawata.pw/b/",
        "https://redstar.moe/b/",
        "https://atoka.pw/b/",
        "https://fumosu.pw/b/",
        "https://osu.direct/api/d/",
    ]
    
    # Fonction pour télécharger un fichier
    def download_file(url, file_path):
        try:
            response = requests.get(url, stream=True, timeout=10)
    
            if response.status_code == 200:
                with open(file_path, "wb") as file:
                    for chunk in response.iter_content(chunk_size=8192):
                        file.write(chunk)
                return True
    
        except requests.exceptions.RequestException as e:
            print(f"Erreur lors du téléchargement de {url} : {e}")
    
        return False
    
    # Fonction pour télécharger une beatmap depuis un miroir
    def download_beatmap_from_mirror(beatmap_id, collection_id, mirror_index):
        mirror = mirrors[mirror_index]
        print(f"Début du téléchargement du beatmapset {beatmap_id}")
        if download_file(f"{mirror}{beatmap_id}", f"{collection_id}/{beatmap_id}.osz"):
            print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} réussi!")
            return True
        else:
            print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} a échoué!")
            return False
    
    def download_beatmap(beatmap_id, collection_id):
        for i in range(len(mirrors)):
            if download_beatmap_from_mirror(beatmap_id, collection_id, i):
                return
        print(f"Le téléchargement de la beatmapset {beatmap_id} a échoué depuis tous les mirrors, elle est perdue.")
    
    # Demande à l'utilisateur le lien de la collection
    collection_id = input("Entrez l'ID de la collection à télécharger: ")
    
    # Récupération de la liste des beatmapsets de la collection
    response = requests.get(f"https://osucollector.com/api/collections/{collection_id}")
    data = response.json()
    
    beatmapsets = data["beatmapsets"]
    
    # Crée un dossier avec l'ID de la collection en tant que nom
    os.makedirs(str(collection_id), exist_ok=True)
    
    # Vérifie les beatmapsets déjà téléchargés sur le disque
    downloaded_beatmapsets = list(Path(collection_id).glob("*.osz"))
    
    # Liste des beatmapsets à télécharger
    to_download = []
    
    for beatmapset in beatmapsets:
        beatmapset_file = Path(f"{collection_id}/{beatmapset['id']}.osz")
    
        if beatmapset_file in downloaded_beatmapsets:
            print(f"La beatmapset {beatmapset['id']} existe déjà sur le disque!")
        else:
            to_download.append(beatmapset["id"])
    
    print(f"{len(to_download)} beatmapsets à télécharger.")
    
    download_threads = []
    
    for beatmap_id in to_download:
        thread = threading.Thread(target=download_beatmap, args=(beatmap_id, collection_id))
        thread.start()
        download_threads.append(thread)
    
    for thread in download_threads:
        thread.join()
    
    print("Téléchargement terminé.")
    

    Ce script modifié utilisera tous les miroirs disponibles pour essayer de télécharger chaque beatmapset et informera l'utilisateur si un beatmapset est "perdu" après avoir échoué sur tous les miroirs.

  5. User

    j'ai un problème c'est que lorsque j'ai exécuté le script ca a éssayé de télécharger toute les beatmaps de la collection d'un coup: Entrez l'ID de la collection à télécharger: 1281 191 beatmapsets à télécharger. Début du téléchargement du beatmapset 29157 Début du téléchargement du beatmapset 2459 Début du téléchargement du beatmapset 603738 Début du téléchargement du beatmapset 412938 Début du téléchargement du beatmapset 408612 Début du téléchargement du beatmapset 696315 Début du téléchargement du beatmapset 165018 Début du téléchargement du beatmapset 185177 Début du téléchargement du beatmapset 448281 Début du téléchargement du beatmapset 464398 Début du téléchargement du beatmapset 635855

    ....

  6. Assistant

    Je comprends maintenant que vous souhaitez limiter le nombre de téléchargements simultanés pour éviter de saturer votre connexion Internet ou de surcharger les miroirs. Voici une version du script qui utilisera un nombre maximum de threads pour télécharger les beatmapsets. Vous pouvez modifier la variable MAX_THREADS pour ajuster le nombre de téléchargements simultanés.

    import os
    import json
    import time
    import threading
    import requests
    from pathlib import Path
    from queue import Queue
    
    # Liste des sites de téléchargement disponibles
    mirrors = [
        # ...
    ]
    
    # Nombre maximum de téléchargements simultanés
    MAX_THREADS = 5
    
    # Fonction pour télécharger un fichier
    def download_file(url, file_path):
        # ...
    
    # Fonction pour télécharger une beatmap depuis un miroir
    def download_beatmap_from_mirror(beatmap_id, collection_id, mirror_index):
        # ...
    
    def download_beatmap(beatmap_id, collection_id):
        # ...
    
    def worker(q, collection_id):
        while not q.empty():
            beatmap_id = q.get()
            download_beatmap(beatmap_id, collection_id)
            q.task_done()
    
    # Demande à l'utilisateur le lien de la collection
    collection_id = input("Entrez l'ID de la collection à télécharger: ")
    
    # Récupération de la liste des beatmapsets de la collection
    response = requests.get(f"https://osucollector.com/api/collections/{collection_id}")
    data = response.json()
    
    beatmapsets = data["beatmapsets"]
    
    # Crée un dossier avec l'ID de la collection en tant que nom
    os.makedirs(str(collection_id), exist_ok=True)
    
    # Vérifie les beatmapsets déjà téléchargés sur le disque
    downloaded_beatmapsets = list(Path(collection_id).glob("*.osz"))
    
    # Liste des beatmapsets à télécharger
    to_download = []
    
    for beatmapset in beatmapsets:
        beatmapset_file = Path(f"{collection_id}/{beatmapset['id']}.osz")
    
        if beatmapset_file in downloaded_beatmapsets:
            print(f"La beatmapset {beatmapset['id']} existe déjà sur le disque!")
        else:
            to_download.append(beatmapset["id"])
    
    print(f"{len(to_download)} beatmapsets à télécharger.")
    
    # Création d'une file d'attente pour les beatmapsets à télécharger
    q = Queue()
    for beatmap_id in to_download:
        q.put(beatmap_id)
    
    # Lancement des threads pour télécharger les beatmapsets
    download_threads = []
    for _ in range(MAX_THREADS):
        thread = threading.Thread(target=worker, args=(q, collection_id))
        thread.start()
        download_threads.append(thread)
    
    for thread in download_threads:
        thread.join()
    
    print("Téléchargement terminé.")
    

    Dans cette version du script, j'ai ajouté une fonction worker qui prend en charge le téléchargement des beatmapsets à partir d'une file d'attente. Le nombre de threads est maintenant limité par la variable MAX_THREADS. Les beatmapsets à télécharger sont ajoutés à une file d'attente q, puis les threads sont lancés pour traiter les éléments de la file d'attente. Les threads s'arrêteront automatiquement lorsqu'il n'y aura plus d'éléments à traiter dans la file d'attente.

  7. User

    pouvez vous m'envoyer l'entierté du script avec les modification

  8. Assistant

    Voici l'entierté du script modifié pour limiter le nombre de téléchargements simultanés :

    import os
    import json
    import time
    import threading
    import requests
    from pathlib import Path
    from queue import Queue
    
    # Liste des sites de téléchargement disponibles
    mirrors = [
        "https://kitsu.moe/api/d/",
        "https://chimu.moe/d/",
        "https://proxy.nerinyan.moe/d/",
        "https://beatconnect.io/b/",
        "https://osu.sayobot.cn/osu.php?s=",
        "https://storage.ripple.moe/d/",
        "https://akatsuki.gg/d/",
        "https://ussr.pl/d/",
        "https://osu.gatari.pw/d/",
        "http://storage.kawata.pw/d/",
        "https://catboy.best/d/",
        "https://kawata.pw/b/",
        "https://redstar.moe/b/",
        "https://atoka.pw/b/",
        "https://fumosu.pw/b/",
        "https://osu.direct/api/d/",
    ]
    
    # Nombre maximum de téléchargements simultanés
    MAX_THREADS = 5
    
    # Fonction pour télécharger un fichier
    def download_file(url, file_path):
        try:
            response = requests.get(url, stream=True, timeout=10)
    
            if response.status_code == 200:
                with open(file_path, "wb") as file:
                    for chunk in response.iter_content(chunk_size=8192):
                        file.write(chunk)
                return True
    
        except requests.exceptions.RequestException as e:
            print(f"Erreur lors du téléchargement de {url} : {e}")
    
        return False
    
    # Fonction pour télécharger une beatmap depuis un miroir
    def download_beatmap_from_mirror(beatmap_id, collection_id, mirror_index):
        mirror = mirrors[mirror_index]
        print(f"Début du téléchargement du beatmapset {beatmap_id}")
        if download_file(f"{mirror}{beatmap_id}", f"{collection_id}/{beatmap_id}.osz"):
            print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} réussi!")
            return True
        else:
            print(f"Téléchargement du beatmapset {beatmap_id} depuis {mirror} a échoué!")
            return False
    
    def download_beatmap(beatmap_id, collection_id):
        for i in range(len(mirrors)):
            if download_beatmap_from_mirror(beatmap_id, collection_id, i):
                return
        print(f"Le téléchargement de la beatmapset {beatmap_id} a échoué depuis tous les mirrors, elle est perdue.")
    
    def worker(q, collection_id):
        while not q.empty():
            beatmap_id = q.get()
            download_beatmap(beatmap_id, collection_id)
            q.task_done()
    
    # Demande à l'utilisateur le lien de la collection
    collection_id = input("Entrez l'ID de la collection à télécharger: ")
    
    # Récupération de la liste des beatmapsets de la collection
    response = requests.get(f"https://osucollector.com/api/collections/{collection_id}")
    data = response.json()
    
    beatmapsets = data["beatmapsets"]
    
    # Crée un dossier avec l'ID de la collection en tant que nom
    os.makedirs(str(collection_id), exist_ok=True)
    
    # Vérifie les beatmapsets déjà téléchargés sur le disque
    downloaded_beatmapsets = list(Path(collection_id).glob("*.osz"))
    
    # Liste des beatmapsets à télécharger
    to_download = []
    
    for beatmapset in beatmapsets:
        beatmapset_file = Path(f"{collection_id}/{beatmapset['id']}.osz")
    
        if beatmapset_file in downloaded_beatmapsets:
            print(f"La beatmapset {beatmapset['id']} existe déjà sur le disque!")
        else:
            to_download.append(beatmapset["id"])
    
    print(f"{len(to_download)} beatmapsets à télécharger.")
    
    # Création d'une file d'attente pour les beatmapsets à télécharger
    q = Queue()
    for beatmap_id in to_download:
        q.put(beatmap_id)
    
    # Lancement des threads pour télécharger les beatmapsets
    download_threads = []
    for _ in range(MAX_THREADS):
        thread = threading.Thread(target=worker, args=(q, collection_id))
        thread.start()
        download_threads.append(thread)
    
    for thread in download_threads:
        thread.join()
    
    print("Téléchargement terminé.")
    

    Ce script limite le nombre de téléchargements simultanés en utilisant un nombre maximum de threads défini par la variable MAX_THREADS. Vous pouvez ajuster cette valeur en fonction de vos préférences et de la capacité de votre connexion Internet.