Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

[Script/bash] Remplir aléatoirement votre baladeur MP3

stefP

J'ai le même rangement que toi pour ma musique, donc je ne peux pas te dire si ça fonctionne autrement, mais je pense que oui.

Pour le calcul du rand, effectivement, ça n'exclut pas un écrasement. Mais ce n'est pas bien grave, la taille dispo ne bougera pas alors, et tu n'auras pas de doublon.

Comme optimisation, certaines lignes avant le while sont inutiles je pense :

    
    rand=`perl -e '@c=(1..'$nbr_music');print join("",@c[map{rand @c}(1)]),' | awk '{print $1}'`
    # Définir un nombre aléatoire entre 1 et le nombre de morceaux
    fic_music=`head -$rand $rep_orig/listmusic | tail -1`
    # Choisir le morceau correspondant dans la liste
    taille_music=`du -s "$rep_orig/$fic_music"| awk '{print $1}'`
    # Définir la taille du morceau choisis
    taille_dispo=`df $rep_dest | grep /media | awk '{print $4}'`
    # Définir la taille disponible sur le répertoire de destination

Dernière chose, généralement le commentaire d'une ligne est au dessus, pas en dessous.

A plus 🙂

lylambda

la taille dispo ne bougera pas alors, et tu n'auras pas de doublon.

C'est juste, mais cela utilise bêtement des ressources système. N'y a t'il pas de possibilité simple d'éviter la remise en jeu ? Une option de commande ou autre. Sinon je suppose que ce serait possible de le scripter, avec la création d'une liste de nombre à exclure du tirage au sort au fur et à mesure de la copie.

Comme optimisation, certaines lignes avant le while sont inutiles je pense

Tu veux dire que le script fonctionnerait sans les 8 lignes que tu désignes ? Si les variables sont inexistantes avant la boucle, cela ne va t'il pas poser problème ?

Dernière chose, généralement le commentaire d'une ligne est au dessus, pas en dessous.

Arf, bon à savoir ! Hum… vais-je avoir le courage de modifier tout mes scripts ? On vas dire que c'est ma signature ^_^

En tout cas, merci pour ton retour !

lylambda

Cela aura mis du temps, mais voici une mise à jour de mon script de remplissage aléatoire de baladeur :

- la boucle de copie a été simplifié (avec tout bêtement un "while true"), ce qui réduit notablement le code (plus de variables à "préparer" avant la boucle).
- l'écrasement de morceau n'est plus possible (ajout de code évitant la remise en jeu au cours du tirage aléatoire )
- prise en compte des répertoires derrière des liens symboliques (ajout de l'option -L à find)
- réécriture des commentaires
- ajout d'un mode debug dans le terminal

Je ne vois rien d'autre pour l'améliorer. Mais tout avis est le bienvenu !

#!/bin/bash

######################################################
# Script de copie aléatoire de musique sur baladeur  #
# Écrit par lylambda, inspiré par stefP             #
# Version 4                         #
# Shell : Supprimez #++# pour activer les sorties    #
# http://forum.ubuntu-fr.org/viewtopic.php?id=200739 #
######################################################

# Définir le répertoire de destination
# /!\ À modifier selon le baladeur
rep_dest="/media/MUSIC/MUSIC"
# Définir le répertoire d'origine
# /!\ À modifier selon l'emplacement de la bibliothèque musicale
rep_orig="${HOME}/Musique"

#++#echo "Transfert musicale aléatoire de ${rep_orig} vers ${rep_dest}"
# Si le répertoire de destination existe :
if [[ -d ${rep_dest} ]]; then
    # Afficher une bulle de notification
    notify-send -i music-player "Random Music Copy" "\nSuppression des anciens morceaux"
    #++#echo "Suppression des anciens morceaux"
    # Vider le répertoire de destination
    rm -r ${rep_dest}/*
    # Créer dans le répertoire d'origine un fichier texte "listmusic"
    # --> Il liste tout les morceaux mp3, ogg et wma avec leurs dossiers parents respectifs (ex: [Auteur]/[Album]/Morceau)
    find -L ${rep_orig} \( -name '*.mp3' -o -name '*.ogg' -o -name '*.wma' \) | cut -d"/" -f5- > ${rep_orig}/listmusic
    #++#echo "Création de la liste des morceaux présents"
    # Créer dans le répertoire d'origine un fichier texte listant les nombres déjà utilisés dans le tirage aléatoire
    echo "Liste des nombres déjà utilisés" > ${rep_orig}/rand_used
    #++#echo "Initialiser de la liste des nombres déjà utilisés"
    # Compter le nombre de morceaux disponibles
    nbr_music=`wc -l ${rep_orig}/listmusic | cut -d" " -f1`
    #++#echo "${nbr_music} morceaux dans la bibliothèque"
    # Initialise le compteur de copie
    nbr_copie=0
    # Afficher une bulle de notification
    notify-send -i music-player "Random Music Copy" "\nLancement de la copie aléatoire"
    #++#echo "Lancement de la copie aléatoire"

        # Boucle de copie
            while true        
        do
        # Définir un nombre aléatoire sans remise en jeu entre 1 et le nombre de morceaux
        rand=`perl -e '@c=(1..'${nbr_music}');print join("",@c[map{rand @c}(1)]),' | awk '{print $1}'`
        test_remise=$(grep -c "${rand}" ${rep_orig}/rand_used)
        if [[ "${test_remise}" != "0" ]]; then
            echo "/!\ Morceau ${rand} déjà copié"
        else
            echo ${rand} >> ${rep_orig}/rand_used
            # Choisir le morceau correspondant dans la liste
            fic_music=`head -${rand} ${rep_orig}/listmusic | tail -1`
            # Définir la taille du morceau choisis
            taille_music=`du -s "${rep_orig}/${fic_music}"| awk '{print $1}'`
            # Définir la taille disponible sur le répertoire de destination 
            taille_dispo=`df ${rep_dest} | grep /media | awk '{print $4}'`
            # Copier le morceau et ses dossiers parents du répertoire d'origine vers le répertoire de destination
            cd $rep_orig &&    cp --parents "$fic_music" "$rep_dest" && cd
            # Compte le nombre de morceaux copiés
            nbr_copie=$((${nbr_copie}+1))
            #++#echo "Copie N°${nbr_copie} : Morceau ${rand} ${fic_music}"
            # Tester si la taille disponible est strictement inférieur à la taille du morceau
                if test ${taille_dispo} -lt ${taille_music}; then
                ##echo "Répertoire de destination plein"
                break
                fi
            fi
        done

    # Afficher une bulle de notification
    notify-send -i music-player "Random Music Copy" "\nOpération terminée :\nCopie de ${nbr_copie} morceaux"
    #++#echo "Copie de ${nbr_copie} morceaux"
    # Supprimer le fichier texte "listmusic"
    rm ${rep_orig}/listmusic
    rm ${rep_orig}/rand_used
    #++#echo "Suppression des fichiers temporaires"

# Si le répertoire de destination n'existe pas
else
    notify-send -i music-player "Random Music Copy" "\nBaladeur non-monté :\n${rep_dest} introuvable."
    #++#echo "${rep_dest} introuvable"
fi
#++#echo "Script terminé correctement"
#++#sleep 300
exit 0

cracolinux

Salut!

Peut-être que sort -R pourrait réduire considérablement la taille du script.
Style :

find ${rep_orig} -type f -iname "*.mp3" | sort -R > listing_mp3_aléatoire

Ensuite, tu prends le nombre de lignes dont tu as besoin à partir du début.

🙂

lylambda

Rhoo merci, de l'aléatoire tout simple !
Je ne connaissais pas cette fonction :-) . À vais voir ce que cela peut donner

kamui57

cracolinux a écritSalut!

Peut-être que sort -R pourrait réduire considérablement la taille du script.
Style :
find ${rep_orig} -type f -iname "*.mp3" | sort -R > listing_mp3_aléatoire
Ensuite, tu prends le nombre de lignes dont tu as besoin à partir du début.

🙂

avec tail ou head (prendre les x dernières ou premières lignes):

find ${rep_orig} -type f -iname "*.mp3" | sort -R | tail -n $nombre > listing_mp3_aléatoire
find ${rep_orig} -type f -iname "*.mp3" | sort -R | head -n $nombre > listing_mp3_aléatoire

cracolinux

#!/bin/bash

# Définir le répertoire de destination
# /!\ À modifier selon le baladeur
rep_dest="/media/trucmuche/musique"

# Définir le répertoire d'origine
# /!\ À modifier selon l'emplacement de la bibliothèque musicale
rep_orig="~/Musique"

[[ $1 == "" ]] && exit 1
nombre_tracks=$1
test_nombre=0

#++#echo "Transfert musicale aléatoire de ${rep_orig} vers ${rep_dest}"
# Si le répertoire de destination existe :
if [[ -d ${rep_dest} ]]; then
    
    # Afficher une bulle de notification
    #~ notify-send -i music-player "Random Music Copy" "\nSuppression des anciens morceaux"
    echo "Suppression des anciens morceaux"
    
    # Vider le répertoire de destination
    rm -r ${rep_dest}/*
    
    # listing
    find ${rep_orig} -type f -iname "*.mp3" | sort -R > ${rep_orig}/listmusic
    
    #copie
    while read line
    do
    ((test_nombre++))
    echo "COPIE de $(basename "$line")" 
    cp "$line" "${rep_dest}"
    [[ $test_nombre == $nombre_tracks ]] && break
    done < ${rep_orig}/listmusic
    
    #nettoyage
    rm ${rep_orig}/listmusic
    echo "FINI"
fi

Voilà une version qui prend comme argument le nombre de fichiers voulus.

lylambda

Merci à vous deux !

Comme je souhaites que le script reste générique (donc utilisable par qui veut), je préfère que le nombre de morceaux à copier soit calculé en fonction de la place disponible sur le baladeur.
Du coup, j'ai réécrit le script en utilisant la commande sort -R pour définir une liste de morceaux aléatoires qui remplis le baladeur en une fois au maximum de sa capacité. Ça complique un peu le script vis à vis de ce que vous proposez. Mais tout de même, au revoir la commande perl et le test de remise en jeu :-)

Il garde globalement les fonctions précédentes :
- Contrôle du montage du baladeur. Interruption du script en son absence
+ Contrôle de la présence de la musithèque. Interruption du script en son absence
+ Contrôle de la présence de morceaux dans la musithèque. Interruption du script en leur absence
- Suppression des anciens morceaux
- Sélection de tout les ogg, mp3 et wav de la musithèque
+ Prise en compte des répertoires derrière des liens symboliques (ajout de l'option -L à find)
- Remplissage du baladeur avec une liste aléatoire de morceaux
- La copie s'ajuste à la taille disponible et s'effectue en une fois
- Les morceaux sont rangés automatiquement selon les dossiers de tri de la musithèque (ex : [Auteur]/[Album])
- Indication du bon déroulement du script via Notify-OSD [edit]
+ Un mode verbeux disponible pour les sorties en terminal

Bon, probablement qu'un pro ou un puriste s'arracherait les cheveux à la vue du résultat, mais il fait bien ce que je lui demande ^^

#!/bin/bash

######################################################
# Script de copie aléatoire de musique sur baladeur  #
# Écrit par lylambda, inspiré par stefP             #
# Version 5                         #
# Shell : Supprimez #++# pour activer les sorties    #
# http://forum.ubuntu-fr.org/viewtopic.php?id=200739 #
######################################################

# Définir le répertoire de destination
# /!\ À modifier selon le baladeur
rep_dest="/media/MUSIC/MUSIC"
# Définir le répertoire d'origine
# /!\ À modifier selon l'emplacement de la bibliothèque musicale
rep_orig="${HOME}/Musique"
#++#echo "Transfert musicale aléatoire de ${rep_orig} vers ${rep_dest}"

# Si le répertoire de destination existe :
if [[ -d ${rep_dest} && -d ${rep_orig} ]]; then
    # Afficher une notification
    notify-send -i music-player "Random Music Copy" "\nSuppression des anciens morceaux"
    #++#echo "Suppression des anciens morceaux"
    # Vider le répertoire de destination
    rm -r ${rep_dest}/*
    # Créer dans le répertoire d'origine, un fichier texte listant de manière aléatoire les morceaux disponibles
    # --> Liste tout les morceaux mp3, ogg et wma avec leurs dossiers parents respectifs (ex: [Auteur]/[Album]/Morceau)
    find -L ${rep_orig} -type f \( -iname "*.mp3" -o -iname "*.ogg" -o -iname "*.wma" \) | sort -R > ${rep_orig}/list_music && sed -i -e "s#${rep_orig}/##g" ${rep_orig}/list_music

    # Si le répertoire d'origine contient de la musique
    if test -s ${rep_orig}/list_music; then
        #++#echo "Création de la liste des morceaux disponibles"
        # Définir la taille disponible sur le répertoire de destination
        taille_dispo=`df ${rep_dest} | awk '{print $4}' | head -2 | tail -1`
        #++#echo "Taille disponible : ${taille_dispo}"
        # Initialiser le compteur de morceaux à copier
        nbr_copie=0
        # Afficher une notification
        notify-send -i music-player "Random Music Copy" "\nChoix des morceaux à copier"

        # Lancer la boucle définissant les morceaux à copier pour remplir le répertoire de destination
        while true; do
            # Sélectionner un morceau
            fic_music=`head -n $((${nbr_copie}+1)) ${rep_orig}/list_music | tail -1`
            # Définir la taille du morceau
            taille_music=`du -s "${rep_orig}/${fic_music}"| awk '{print $1}'`
                # Si la taille disponible est strictement inférieur à la taille du morceau :
                if test "${taille_dispo}" -lt "${taille_music}"; then
                    # Créer dans le répertoire d'origine, un nouveau fichier texte listant que les morceaux sélectionnés
                    head -n ${nbr_copie} ${rep_orig}/list_music | sort > ${rep_orig}/select_music
                    #++#echo "Création de la liste des morceaux sélectionnés"
                    # Quitter la boucle 
                    break    
                fi
            # Sinon actualiser de la taille disponible
            taille_dispo=$((${taille_dispo}-${taille_music}))
            # Incrémenter le compteur de morceaux de 1 
            nbr_copie=$((${nbr_copie}+1))
            #++#echo "Sélection du morceau ${nbr_copie} : ${fic_music}"
            #++#echo "Taille prise : ${taille_music} - Taille disponible : ${taille_dispo}"
        done

        # Afficher une notification
        notify-send -i music-player "Random Music Copy" "\nLancement de la copie aléatoire"
        #++#echo "Lancement de la copie aléatoire"
        # Copier chaque morceau sélectionné
        IFS=$'\n' 
        for morceau in $(cat ${rep_orig}/select_music); do
            cd ${rep_orig} && cp --parents "${morceau}" "${rep_dest}" && cd
        done
        unset IFS 

        # Afficher une bulle de notification
        notify-send -i music-player "Random Music Copy" "\nOpération terminée :\nCopie de ${nbr_copie} morceaux"
        #++#echo "Copie de ${nbr_copie} morceaux - Place restante : ${taille_dispo}"
        # Supprimer les fichiers texte temporaires
        rm ${rep_orig}/list_music
        rm ${rep_orig}/select_music
        #++#echo "Suppression des fichiers temporaires"

    # Si le répertoire d'origine ne contient pas de musique
    else
        # Afficher une notification
        notify-send -i error "Random Music Copy" "\nMusithèque vide :\nAucun fichier mp3, ogg ou wma n'a été détecté."
        #++#echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"
    fi

# Si le répertoire de destination n'existe pas
elif [[ -d ${rep_orig} ]]; then
    # Afficher une notification
    notify-send -i error "Random Music Copy" "\nBaladeur non-monté :\n${rep_dest} introuvable."
    #++#echo "${rep_dest} introuvable"
# Si le répertoire d'origine n'existe pas
elif [[ -d ${rep_dest} ]]; then
    # Afficher une notification
    notify-send -i error "Random Music Copy" "\nMusithèque absente :\n${rep_orig} introuvable."
    #++#echo "${rep_orig} introuvable"
# Si aucun répertoire n'existe
else
    # Afficher une notification
    notify-send -i error "Random Music Copy" "\nRépertoires introuvables :\nVérifiez les variables."
    #++#echo "${rep_orig} et ${rep_dest} introuvable"
fi
#++#sleep 300
exit 0

PS1 : Pour find, quel est l'avantage de -type f -iname "*.mp3" vis à vis de -name '*.mp3' ? Dans le doute, je l'ai utilisé, mais je n'ai pas perçu de résultat différents.
PS2 : Pour pouvoir conserver l'arborescence originel de la musithèque, j'ai dut faire un vilain hack à base de :

> ${rep_orig}/list_music && sed -i -e "s#${rep_orig}/##g" ${rep_orig}/list_music

cd ${rep_orig} && cp --parents "${morceau}" "${rep_dest}" && cd

Il aurait moyen de rendre cela plus propre ?

pingouinux

Salut,

lylambda #28 a écritPS1 : Pour find, quel est l'avantage de -type f -iname "*.mp3" vis à vis de -name '*.mp3' ?

La première forme ne tient pas compte de la casse, et on récupère *.mp3 ou *.MP3

lylambda

Effectivement, l'intérêt est évident. Merci pingouinux !

pingouinux

Petite remarque sur le script du #28

# Shell : Supprimez #++# pour activer les sorties #

Il serait plus pratique de définir une varable dbg en tête de script, initialisée à False (ou même passée en argument), pour définir si on veut des sorties ou non. Chaque ligne commençant par #++# est réécrite ainsi :

        #++#echo "Création de la liste des morceaux disponibles"

devient

        if dbg : echo "Création de la liste des morceaux disponibles"

Pour avoir les sorties, il suffit juste d'initialiser dbg à True.

Correction : Ceci est codé en python. lylambda a correctement transposé le principe en bash en #34

cracolinux

pingouinux a écrit

        if dbg : echo "Création de la liste des morceaux disponibles"

Pour avoir les sorties, il suffit juste d'initialiser dbg à True.

C'est cool ça ! merci !

cracolinux

find -L ${rep_orig} -type f \( -iname "*.mp3" -o -iname "*.ogg" -o -iname "*.wma" \) | sort -R > ${rep_orig}/list_music && sed -i -e "s#${rep_orig}/##g" ${rep_orig}/list_music

peut devenir :

find -L ${rep_orig} -type f \( -iname "*.mp3" -o -iname "*.ogg" -o -iname "*.wma" \) | sort -R | sed -e "s#${rep_orig}/##g" > ${rep_orig}/list_music

enfin, je crois.

lylambda

@ cracolinux : Ta commande find est plus propre, merci ! Je remplace.

@ pingouinux : En l'état, je n'ai pas réussi à intégrer if dbg : au script. Je n'ai pas trouvé non plus de documentation à ce sujet. Les exemples indiquent toujours l'usage de fi pour clore un if et je n'ai pas trouvé d'utilisation de ":" sous cette forme. Pourrais-tu me donner un exemple de ta méthode ?
Comme je lance le script du GUI et non du terminal, je n'ai pas repris l'idée de l'argument. Par contre, l'idée d'une variable debug me plait. J'ai fait avec mes moyens (if, fi et test de chaine de caractère) pour un résultat similaire à ce que tu proposes :

#!/bin/bash

######################################################
# Script de copie aléatoire de musique sur baladeur  #
# Écrit par lylambda, inspiré par stefP             #
# Version 6                         #
# http://forum.ubuntu-fr.org/viewtopic.php?id=200739 #
######################################################

# Utiliser le mode debug en terminal ? Oui : dbg="Yes" - Non : dbg="No"
dbg="Yes"
# Définir le répertoire de destination
# /!\ À modifier selon le baladeur
rep_dest="/media/MUSIC/MUSIC"
# Définir le répertoire d'origine
# /!\ À modifier selon l'emplacement de la bibliothèque musicale
rep_orig="${HOME}/Musique"
if [ ${dbg} == "Yes" ]; then
echo "(A) : Transfert musicale aléatoire de ${rep_orig} vers ${rep_dest}"
fi

# Si le répertoire de destination existe :
if [[ -d ${rep_dest} && -d ${rep_orig} ]]; then
    # Afficher une notification
    notify-send -i music-player "Random Music Copy" "\nSuppression des anciens morceaux"
    if [ ${dbg} == "Yes" ]; then
    echo "(B) : Suppression des anciens morceaux"
    fi
    # Vider le répertoire de destination
    rm -r ${rep_dest}/*
    # Créer dans le répertoire d'origine, un fichier texte listant de manière aléatoire les morceaux disponibles
    # --> Liste tout les morceaux mp3, ogg et wma avec leurs dossiers parents respectifs (ex: [Auteur]/[Album]/Morceau)
    find -L ${rep_orig} -type f \( -iname "*.mp3" -o -iname "*.ogg" -o -iname "*.wma" \) | sort -R | sed -e "s#${rep_orig}/##g" > ${rep_orig}/list_music

    # Si le répertoire d'origine contient de la musique
    if test -s ${rep_orig}/list_music; then
        if [ ${dbg} == "Yes" ]; then
        echo "(C) : Création de la liste des morceaux disponibles"
        fi
        # Définir la taille disponible sur le répertoire de destination
        taille_dispo=`df ${rep_dest} | awk '{print $4}' | head -2 | tail -1`
        if [ ${dbg} == "Yes" ]; then
        echo "(D) : Taille disponible : ${taille_dispo}"
        fi
        # Initialiser le compteur de morceaux à copier
        nbr_copie=0
        # Afficher une notification
        notify-send -i music-player "Random Music Copy" "\nChoix des morceaux à copier"

        # Lancer la boucle définissant les morceaux à copier pour remplir le répertoire de destination
        while true; do
            # Sélectionner un morceau
            fic_music=`head -n $((${nbr_copie}+1)) ${rep_orig}/list_music | tail -1`
            # Définir la taille du morceau
            taille_music=`du -s "${rep_orig}/${fic_music}"| awk '{print $1}'`
                # Si la taille disponible est strictement inférieur à la taille du morceau :
                if test "${taille_dispo}" -lt "${taille_music}"; then
                    # Créer dans le répertoire d'origine, un nouveau fichier texte listant que les morceaux sélectionnés
                    head -n ${nbr_copie} ${rep_orig}/list_music | sort > ${rep_orig}/select_music
                    if [ ${dbg} == "Yes" ]; then
                    echo "(E) : Création de la liste des morceaux sélectionnés"
                    fi
                    # Quitter la boucle 
                    break    
                fi
            # Sinon actualiser de la taille disponible
            taille_dispo=$((${taille_dispo}-${taille_music}))
            # Incrémenter le compteur de morceaux de 1 
            nbr_copie=$((${nbr_copie}+1))
            if [ ${dbg} == "Yes" ]; then
            echo "    ${nbr_copie} : Sélection de ${fic_music}"
            echo "    Taille prise = ${taille_music} - Taille disponible = ${taille_dispo}"
            fi
        done

        # Afficher une notification
        notify-send -i music-player "Random Music Copy" "\nLancement de la copie aléatoire"
        if [ ${dbg} == "Yes" ]; then
        echo "(F) : Lancement de la copie aléatoire"
        fi
        # Copier chaque morceau sélectionné
        IFS=$'\n' 
        for morceau in $(cat ${rep_orig}/select_music); do
            cd ${rep_orig} && cp --parents "${morceau}" "${rep_dest}" && cd
        done
        unset IFS 

        # Afficher une bulle de notification
        notify-send -i music-player "Random Music Copy" "\nOpération terminée :\nCopie de ${nbr_copie} morceaux"
        if [ ${dbg} == "Yes" ]; then
        echo "(G) : Copie de ${nbr_copie} morceaux - Place restante : ${taille_dispo}"
        fi
        # Supprimer les fichiers texte temporaires
        rm ${rep_orig}/list_music
        rm ${rep_orig}/select_music
        if [ ${dbg} == "Yes" ]; then
        echo "(H) : Suppression des fichiers temporaires"
        fi

    # Si le répertoire d'origine ne contient pas de musique
    else
        # Afficher une notification
        notify-send -i error "Random Music Copy" "\nMusithèque vide :\nAucun fichier mp3, ogg ou wma n'a été détecté."
        if [ ${dbg} == "Yes" ]; then
        echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"
        fi
    fi

# Si le répertoire de destination n'existe pas
elif [[ -d ${rep_orig} ]]; then
    # Afficher une notification
    notify-send -i error "Random Music Copy" "\nBaladeur non-monté :\n${rep_dest} introuvable."
    if [ ${dbg} == "Yes" ]; then
    echo "(B) : ${rep_dest} introuvable"
    fi
# Si le répertoire d'origine n'existe pas
elif [[ -d ${rep_dest} ]]; then
    # Afficher une notification
    notify-send -i error "Random Music Copy" "\nMusithèque absente :\n${rep_orig} introuvable."
    if [ ${dbg} == "Yes" ]; then
    echo "(B) : ${rep_orig} introuvable"
    fi
# Si aucun répertoire n'existe
else
    # Afficher une notification
    notify-send -i error "Random Music Copy" "\nRépertoires introuvables :\nVérifiez les variables."
    if [ ${dbg} == "Yes" ]; then
    echo "(B) : ${rep_orig} et ${rep_dest} introuvable"
    fi
fi
if [ ${dbg} == "Yes" ]; then
echo "Fin : vous pouvez quitter le terminal"
sleep 300
fi
exit 0

Et pour ceux qui veulent, voici le script tout simple sans debug ou commentaires :

#!/bin/bash

rep_dest="/media/MUSIC/MUSIC"
rep_orig="${HOME}/Musique"

if [[ -d ${rep_dest} && -d ${rep_orig} ]]; then
    notify-send -i music-player "Random Music Copy" "\nSuppression des anciens morceaux"
    rm -r ${rep_dest}/*
    find -L ${rep_orig} -type f \( -iname "*.mp3" -o -iname "*.ogg" -o -iname "*.wma" \) | sort -R | sed -e "s#${rep_orig}/##g" > ${rep_orig}/list_music

    if test -s ${rep_orig}/list_music; then
        taille_dispo=`df ${rep_dest} | awk '{print $4}' | head -2 | tail -1`
        nbr_copie=0
        notify-send -i music-player "Random Music Copy" "\nChoix des morceaux à copier"

        while true; do
            fic_music=`head -n $((${nbr_copie}+1)) ${rep_orig}/list_music | tail -1`
            taille_music=`du -s "${rep_orig}/${fic_music}"| awk '{print $1}'`
            if test "${taille_dispo}" -lt "${taille_music}"; then
                head -n ${nbr_copie} ${rep_orig}/list_music | sort > ${rep_orig}/select_music
                break    
            fi
            taille_dispo=$((${taille_dispo}-${taille_music}))
            nbr_copie=$((${nbr_copie}+1))
        done

        notify-send -i music-player "Random Music Copy" "\nLancement de la copie aléatoire"
        IFS=$'\n' 
        for morceau in $(cat ${rep_orig}/select_music); do
            cd ${rep_orig} && cp --parents "${morceau}" "${rep_dest}" && cd
        done
        unset IFS 
        notify-send -i music-player "Random Music Copy" "\nOpération terminée :\nCopie de ${nbr_copie} morceaux"
        rm ${rep_orig}/list_music
        rm ${rep_orig}/select_music
    else
        notify-send -i error "Random Music Copy" "\nMusithèque vide :\nAucun fichier mp3, ogg ou wma n'a été détecté."
    fi

elif [[ -d ${rep_orig} ]]; then
    notify-send -i error "Random Music Copy" "\nBaladeur non-monté :\n${rep_dest} introuvable."
elif [[ -d ${rep_dest} ]]; then
    notify-send -i error "Random Music Copy" "\nMusithèque absente :\n${rep_orig} introuvable."
else
    notify-send -i error "Random Music Copy" "\nRépertoires introuvables :\nVérifiez les variables."
fi
exit 0

pingouinux

lylambda #34 a écrit@ pingouinux : En l'état, je n'ai pas réussi à intégrer if dbg : au script.

Au temps pour moi, ce que je proposais en #31 était codé en python, mais tu l'as bien transposé en bash. Tu peux éventuellement simplifier un peu, en remplaçant

dbg="Yes"
.......
        if [ ${dbg} == "Yes" ]; then
        echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"
        fi

par

dbg=true
.......
[ $dbg ] && echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"

lylambda

Avec tout ces langages, on s'y perd ;-)
Ta simplification est bien mieux, merci. Je prends !

cracolinux

Oh ben merdeuu !
Moi qui me faisais une joie... j'ai plus qu'a apprendre le python (ça doit faire 152 fois que je dis ça...)

Postmortem

Salut,

pingouinux a écrit

dbg=true
.......
[ $dbg ] && echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"

Je trouve que cette méthode prête à confusion car :

$ dbg=true
$ [ $dbg ] && echo "VRAI"
VRAI
$
$ dbg=false
$ [ $dbg ] && echo "VRAI"
VRAI
$

Personnellement, je ferais ainsi :

dbg=true
[[ $dbg != true ]] && dbg=false
........
$dbg && echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"

pingouinux

@Postmortem #38 : Tu as raison. En plus je l'avais testé, mais sans mettre les [ ], ce qui est correct. Décidément, ce n'est pas mon jour... 🙁

lylambda

Postmortem a écritJe trouve que cette méthode prête à confusion

J'avais noté le même problème que j'avais résolu avec :

# Décommenter la ligne suivante pour utiliser le mode debug en terminal
dbg=yes
…
[ $dbg ] && echo "Aucun fichier mp3, ogg ou wma n'a été détecté dans ${rep_orig}"

Il y a une contre indication à ma méthode ?

« Page précédente Page suivante »