Contenu | Rechercher | Menus

Annonce

Si vous rencontrez des soucis à rester connecté sur le forum (ou si vous avez perdu votre mot de passe) déconnectez-vous et reconnectez-vous depuis cette page, en cochant la case "Me connecter automatiquement lors de mes prochaines visites". Attention, le forum rencontre actuellement quelques difficultés. En cas d'erreur 502, il ne faut pas re-valider l'envoi d'un message ou l'ouverture d'une discussion, au risque de créer un doublon.

La section divers se réorganise ! De nouvelles sous-sections à venir. (plus d'infos + donner son avis)

#851 Le 09/01/2010, à 00:36

epictete

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

SCRIPT « C'EST DANS L'AIR » ET LOGICIEL « ARTE+7 RECORDER »

Bonjour, au post #99, page 4, à cette adresse :

http://forum.ubuntu-fr.org/viewtopic.php?pid=1698887#p1698887

Beudbeud nous avait fourni un remarquable script pour enregistrer automatiquement l'émission C dans l'air de France5 et la stocker avec la date et le titre.

Malheureusement ce script ne fonctionnait plus. Il a bien voulu se pencher sur la question, trouver le problème (nouveau codage php des pages de France5 et émission du jour disponible seulement à 20 heures) et écrire une nouvelle version.

Voici donc son nouveau script :

#!/bin/bash -x
#script de beudbeud
 
#creation du répertoire
mkdir -p $HOME/Vidéos/c_dans_l_air/

#récupération de l'id
IDART=`wget -O - -q http://www.france5.fr/c-dans-l-air/index-fr.php?page=accueil | grep 'href="index-fr.php?page=resume&id_article=' | awk -F'"' '{print $2}'`

#récupération du titre de l'émission
TITREBASE=`wget -O - -q "http://www.france5.fr/c-dans-l-air/$IDART" | grep 'class="t18 bleuclair bold' | awk -F">" '{print $2}' | awk -F"<" '{print $1}'`
TITRE=`echo $TITREBASE | iconv -c | tr '[àâäéèêëîïôöùûü]' '[aaaeeeeiioouuu]' | sed -e "s/[[:space:]]/_/g" | sed -e "s/\/$//" | sed -e "s/'/_/g" |  sed -e "s/-/_/g" | sed -e "s/__/_/g"`

#récupération de la date de l'émission
DATE=`date +%d%m%Y`

#récupération du lien mms
URL="http://www.france5.fr/c-dans-l-air/$IDART"
FILE1=`wget -O - -q "$URL" | grep mms | awk -F='"' '{print $2}' | awk -F'"' '{print $1}'`

#téléchargement
mimms -c $FILE1 $HOME/Vidéos/c_dans_l_air/"$DATE"_"$TITRE".wmv

#message de fin
echo message:enregistrement de c dans lair terminé| zenity --notification --listen --window-icon="info"

De plus, il faut maintenant paramétrer cron pour 20:10 heures :

crontab -e

et on ajoute les lignes suivantes :

DISPLAY=":0.0"
# m h  dom mon dow   command
10 20 * * 2,3,4,5,6 emplacement/du/script/cdanslair.sh

ou si on utilise fcron

fcrontab -e

et ensuite

	&10 20 * * 2,3,4,5,6 emplacement/du/script/cdanslair.sh

Merci à Beudbeud pour sa disponibilité et sa patience face à un newbie, un nouvel exemple de la belle mentalité qui règne sur ubuntu.fr.


Ne passez pas à côté de son génial soft arte+7recorder qui vous permet de télécharger les émissions mises à disposition sur le site de vidéo à la demande d’Arte pendant 7 jours après la diffusion hertzienne : http://plus7.arte.tv.

Vous trouverez ici une présentation du logiciel avec des screenshots démonstratifs :

http://www.generation-linux.fr/index.php?post/2009/02/21/Arte-en-voici-en-voila

Le fil expliquant l'installation sur ubuntu.fr :

http://forum.ubuntu-fr.org/viewtopic.php?id=229961&p=1

L'usage est enfantin : une fenêtre vous présente toutes les émissions disponibles des 7 derniers jours, vous n'avez qu'à choisir celle qui vous intéresse pour que le téléchargement commence ! À ne pas rater.

Dernière modification par epictete (Le 09/01/2010, à 00:38)


Promouvoir et défendre le logiciel libre : http://www.april.org
Foundation for a Free Information Infrastructure : http://www.ffii.org/Home
               « La liberté, la liberté, les gens n'ont que ce mot-là à la bouche ! » Françoise de Panafieu (UMP).
               « Rien ne justifie qu'on cherche à préserver la liberté de l'Internaute » Chantal Brunel (UMP).

Hors ligne

#852 Le 09/01/2010, à 10:37

Bushman02

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Retour en arrière (suite aux posts 828-29-30) :
Pour les les scripts qui marchaient jusque-là et qui ne fonctionnent plus avec imagemagick, il suffit de remplacer ce dernier par graphicsmagick-imagemagick : tout rentre dans l'ordre.

Hors ligne

#853 Le 10/01/2010, à 00:17

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Salut à tous

Si comme moi vous avez été un jour sur W€€ndows et que vous avez ensuite copié certains de vos dossiers sur votre système Linux (Par exemple tout le dossier Musique) il y a fort à parier que celui çi est truffé de fichiers indésirables du genre "Thumbs.db", de fichiers "txt" ou "nfo" vantant les mérites de tel ou tel tracker torrent...

Voiçi donc un petit script pour faire le ménage sans avoir à explorer toute l'arborescence :

ATTENTION ! Ce script fait usage de la commande "rm"... Faites trés attention, je ne saurais ètre responsable de son mauvais usage et d'éventuelles pertes de données. Vous ètes de grands garçons/filles.

#! /bin/bash

echo -e "\033[00;32m";
clear;

########################################################################
#
#
#         Ce script permet de trier/effacer l'arborescence
#           complète d'un dossier par types d'extensions
#
#     Exemple :  Effacer tous les "thumbs.db" produits par W€€ndows
#
########################################################################


read -p "Analyser le dossier courant ? O/n :" REP

if [ "$REP" = o ] || [ "$REP" = O ]
    then
	DIR=$PWD
elif [ "$REP" = n ]
	then
	read -p "Indiquer le chemin du dossier à analyser : " DIR ;
        cd $DIR;
elif  [ -z "$REP" ]
    then
	echo"";
	echo "Indiquez un dossier !";
	sleep 4;
	exit
fi

#liste et compte les extensions
#
CONTENU=`find . -type f | sed 's/.*\.//' | sort | uniq -c`

echo "Ce dossier contient :";
echo"$CONTENU";

echo "indiquez les types de fichiers à effacer en séparant"
echo "les extensions par un espace :";
echo "exemple : mp3 txt db";
echo "";
read -p ":" EXT ;

echo "ATTENTION ! Tous les fichiers dont les extensions sont \"$EXT\" vont ètre" ;
echo "effacés de manière IRREVERSIBLE ! " ;
echo"Pour annuler faite Ctrl+c." ;
read -p "Si vous ètes sur de ce que vous faite tapez \"Entrée\" : " OK ;

#Efface les extensions choisies
#
for FILES in $EXT
    do
	find . -name \*.$FILES -exec rm \-v {} \;
done

#quitte
#
echo ""
read -p "Fin....appuyez sur Entrée pour quitter" QUIT ;
echo -e "\033[00m";
clear;
exit 0;

Dernière modification par Goda (Le 10/01/2010, à 09:17)


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#854 Le 10/01/2010, à 00:52

Shrat

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Pourquoi -f?

Hors ligne

#855 Le 10/01/2010, à 09:16

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

C'est vrai....:rolleyes:


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#856 Le 10/01/2010, à 15:09

BorX

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Goda a écrit :
for FILES in $EXT
    do
	find . -name \*.$FILES -exec rm \-v {} \;
done
unset FILES
for ext in $EXT; do
  [ -n "$FILES" ] && FILES="$FILES -o"
  FILES="$FILES -iname '*.$ext'"
done
eval "find . \( $FILES \) -ls -delete"

-> On fait qu'une seule passe
-> On évite les erreurs habituelles avec -exec rm \-v {} \;

Goda a écrit :

" Read The F$$$$$ Manual "      --->  man man

Dernière modification par BorX (Le 10/01/2010, à 15:14)

Hors ligne

#857 Le 10/01/2010, à 20:15

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Yep
Je comprend pas tout alors je vais reader le F$$$$$ Manual !

A plus


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#858 Le 10/01/2010, à 20:58

Shrat

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Tu fais tout plein de find goda. Brox récupère tout de suite les fichiers à effacer. C'est plus économe.

man test est cool quand on débute.

Sinon je me bas farouchement contre ce réflexe du -f. Çaynul!

Hors ligne

#859 Le 10/01/2010, à 21:15

draco31.fr

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Bonsoir à tous,
Un petit script qui permet de classer les éléments du dossier courant en vu de les graver sur un minimum de DVD.
Tout les sous-dossiers sont considérés comme insécables, l'idée étant qu'il représentent un album ogg ou tout les épisodes d'une série, ou tout les fichiers d'un projet ... donc à ne pas éparpiller sur plusieurs supports.
Si jamais un sous-dossier est trop gros pour le DVD, on splitte le dossier en respectant l'ordre alphabétique en autant de DVD/CD que le minimum nécessaire.
J'ai mis plusieurs contrôles pour ne pas créer des DVD à moitié vide, donc le script est à adapter à vos besoins.
Bien entendu, rien n'est optimisé, et c'est codé avec les pieds (les miens en l'occurence lol )

Si quelqu'un veut le rendre plus propre et plus "professionnel", qu'il s'en donne à coeur joie.
Mais obligation de rendre publique le code modifié pour en faire profiter tout le monde !!

EDIT : J'allais oublier : à la fin du script, il vous indique la commande à lancer pour restaurer les fichiers comme à l'origine.
Donc pas de soucis, si vous êtes pas content du résultat, la commande est même ajoutée à l'historique bash tongue

#!/bin/bash
echo "Traitement de $PWD"
# Constantes (calcul en octets)
declare -i tailleDVD=4700000000
declare -t tailleCD=700000000

# Normal
BLK='\e[0;30m' # Black - Regular
RED='\e[0;31m' # Red
GRN='\e[0;32m' # Green
YLW='\e[0;33m' # Yellow
BLU='\e[0;34m' # Blue
PUR='\e[0;35m' # Purple
CYN='\e[0;36m' # Cyan
WHT='\e[0;37m' # White

# Bold
BLDBLK='\e[1;30m' # Black - Bold
BLDRED='\e[1;31m' # Red
BLDGRN='\e[1;32m' # Green
BLDYLW='\e[1;33m' # Yellow
BLDBLU='\e[1;34m' # Blue
BLDPUR='\e[1;35m' # Purple
BLDCYN='\e[1;36m' # Cyan
BLDWHT='\e[1;37m' # White

# Underline
UNDBLK='\e[4;30m' # Black - Underline
UNDRED='\e[4;31m' # Red
UNDGRN='\e[4;32m' # Green
UNDYLW='\e[4;33m' # Yellow
UNDBLU='\e[4;34m' # Blue
UNDPUR='\e[4;35m' # Purple
UNDCYN='\e[4;36m' # Cyan
UNDWHT='\e[4;37m' # White

# Background
BAKBLK='\e[40m'   # Black - Background
BAKRED='\e[41m'   # Red
BAKGRN='\e[42m'   # Green
BAKYLW='\e[43m'   # Yellow
BAKBLU='\e[44m'   # Blue
BAKPUR='\e[45m'   # Purple
BAKCYN='\e[46m'   # Cyan
BAKWHT='\e[47m'   # White

# Text Reset
NC='\e[0m'    # Text Reset - No Color

# pourcentage minimum pour graver un support
declare -i taux_remplissage=51

declare -i tailleDVD_min=$(( $tailleDVD * $taux_remplissage / 100 ))

# Variables diverses
declare -i ligne_max=0
declare -i ligne_min=1
declare -i ligne_sep=0
declare -i num_ligne=0

# libellé du type de support en court d'utilisation
declare support="DVD"

# Sauvegarde du dernier fichier de restoration existant dans le répertoire de travail
rm -v ".$(basename $0).restore.*"
cp ".$(basename $0).restore" ".$(basename $0).restore.$(date -r .$(basename $0).restore --rfc-3339=seconds -u)" 2>/dev/null

# Nettoyage des fichiers temporaires du précédent run
rm ".$(basename $0).restore" .liste_taille2 .liste_taille .liste_a_regrouper .liste_trt_differe .liste_combinaison .liste_combinaison2 2>/dev/null

#-----
echo "rm -v \".$(basename $0).restore\"" >> ".$(basename $0).restore"
echo "echo -e \"Suppression du fichier de restauration\"" >> ".$(basename $0).restore"
#-----

#####################################################
# Listing des éléments du dossier et de leur taille
#####################################################
du -B 1 -s * | sort -n > .liste_taille
fgrep -v "_$(basename $0)" .liste_taille > .liste_taille2 && mv .liste_taille2 .liste_taille
echo -e "${RED}================================$NC"
echo -e "    n°\ttaille\t\tlibellé"
echo -e "${RED}--------------------------------$NC"
cat -n .liste_taille
echo -e "${RED}================================$NC"

# Parcours de la liste, Analyse des éléments pour trouver la limite dû à la taille du support
OLD_IFS="$IFS"
while read ligne
do
    if [ ${ligne%$'\t'*} -gt $tailleDVD ]
    then
        echo "W: \"${ligne#*$'\t'}\" est plus grand qu'un DVD !"
    else
        num_ligne+=1
        if [ ${ligne%$'\t'*} -le 4096 ]
        then
            ligne_min+=1
        fi
    fi
done < .liste_taille
echo "================================"

# Récapitulatif de l'analyse
ligne_sep=$((num_ligne+1))
echo "I: Traitement de la liste à partir de la ligne n°$ligne_min"
echo "I: Traitement différé à partir de la ligne n°$ligne_sep"

# liste des éléments inférieurs à la taille max
tail -n +$ligne_min .liste_taille | head -n $((ligne_sep - ligne_min)) > .liste_a_regrouper
# liste des éléments supérieurs à la taille max
tail -n +$ligne_min .liste_taille | tail -n +$((ligne_sep - ligne_min +1)) > .liste_trt_differe

########################################
# Liste à regrouper
########################################
function regrouper_element()
{
#=======================================
# Traitement dossier courant
#=======================================
declare -a tab_taille
declare -a tab_element
declare -i index_max=0
declare -i index=0
declare -i nb_element_max=0
declare -i taille=0
declare stt_compare_min_max="false"
declare stt_calcul_nb_element_max="false"

# Charger la liste des élements à regrouper dans un tableau
while read ligne
do
    tab_taille+=( "${ligne%$'\t'*}" )
    tab_element+=( "${ligne#*$'\t'}" )
done < .liste_a_regrouper

echo "I: Création du dossier : _$(basename $0)"
mkdir "_$(basename $0)" 2>/dev/null
#-----
echo "rmdir -v \"_$(basename $0)\"" >> ".$(basename $0).restore"
echo "echo -e \"I: Suppression du dossier : _$(basename $0)\"" >> ".$(basename $0).restore"
#-----
# Si la somme "plus petit élement" + "plus grand élément" dépasse un DVD, on peut classer le plus grand (pas de combinaison possible)
echo -e "${GRN}Traitement des éléments non regroupables ...$NC"
while [ $stt_compare_min_max == "false" ]
do
    index_max=$((${#tab_taille[*]} - 1))
    if [ $index_max -le 0 ]
    then
        stt_compare_min_max="true"
    else
        taille=$((${tab_taille[0]} + ${tab_taille[$index_max]} ))
        if [ $taille -gt $tailleDVD ]
        then
            # Script/log pour restorer à l'état initial
            #-----
            echo "mv -v \"./_$(basename $0)/${tab_element[$index_max]}\" \"./${tab_element[$index_max]}\"" >> ".$(basename $0).restore"
            echo "echo -e \"> Restauration de l'élément n°$index_max : \"" >> ".$(basename $0).restore"
            #-----
            echo -e -n "> Déplacement du n°$index_max : "
            mv -v "${tab_element[$index_max]}" "./_$(basename $0)/${tab_element[$index_max]}"
            unset tab_element[$index_max]
            unset tab_taille[$index_max]
        else
            stt_compare_min_max="true"
            #echo "Index max final = $index_max"
        fi
    fi
done

# On cherche le nombre d'éléments maximum que l'on peut ajouter sans dépasser la taille du support
# On part du plus petit élément vers le plus gros.
taille=0
index=0
index_max=$((${#tab_taille[*]} - 1))
while [ $stt_calcul_nb_element_max == "false" ]
do
    if [ $index -gt $index_max ]
    then
        stt_calcul_nb_element_max="true"
        nb_element_max=$index_max
    else
        taille+=${tab_taille[$index]}
        if [ $taille -gt $tailleDVD ]
        then
            nb_element_max=$(($index - 1))
            stt_calcul_nb_element_max="true"
        fi
    fi
    index+=1
done

# la somme des 2 plus petits éléments dépasse la taille d'un DVD, aucune combinaison ne sera possible !
# En théorie, index_max ne devrait pas dépasser 1
if [ $nb_element_max -le 0 ]
then
    echo "W: Aucune combinaison possible, classement en cours des éléments restants ..."
    #-----
    echo "echo -e \"I: $(basename $0) > Restauration terminée\"" >> ".$(basename $0).restore"
    #-----
    index=0
    while [ $index -le $index_max ]
    do
        # Script/log pour restorer à l'état initial
        #-----
        echo -e "mv -v \"./_$(basename $0)/${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> ".$(basename $0).restore"
        #-----
        mv -v "./${tab_element[$index]}" "./_$(basename $0)/${tab_element[$index]}"
        index+=1
    done
    # Quitte le script
    echo "I: Regroupement des éléments terminé"
    #-----
    echo "echo \"W: Restauration des éléments restants ...\"" >> ".$(basename $0).restore"
    #-----
    return 0
fi

declare -i nb_element=$nb_element_max
declare -i taille_temp=0
declare -i index_base=0
declare -i index_max=$((${#tab_taille[*]} - 1))
declare lib_index=""
# Parcours de tout l'index pour toutes les combinaisons
while [ $index_base -le $index_max ]
do
    taille=0
    nb_element=1

    # Recherche du nombre d'éléments maxi pour cette base
    index=$index_base
    while [ $index -le $index_max ]
    do
        taille+=${tab_taille[$index]}
        if [ $taille -gt $tailleDVD ]
        then
            nb_element_max=$(($index - $index_base))
            break
        fi
        index+=1
    done

    # Parcours des combinaisons en partant de la plus longue petite suite vers la plus courte petite suite pour cette base
    nb_element=$(($nb_element_max + $index_base -1))
    while [ $nb_element -ge $index_base ]
    do
        # Somme des N éléments depuis la base (on ne dépasse pas le nombre d'élément max pour cette base)
        taille=0
        lib_index="_"
        index=$index_base
        while [ $index -lt $nb_element ]
        do
            taille+=${tab_taille[$index]}
            lib_index+=${index}_
            index+=1
        done

        # Recherche des combinaisons possibles à partir de cette base + 1 élément sans dépasser la taille max
        while [ $index -le $index_max ]
        do
            taille_temp=$(($taille + ${tab_taille[$index]}))
            if [ $taille_temp -le $tailleDVD ]
            then
                echo -e "$taille_temp\t${lib_index}${index}_" >> .liste_combinaison
            else
                break
            fi
            index+=1
        done
        nb_element=$(($nb_element - 1))
    done
    index_base+=1
done

# trier la liste des combinaisons par taille décroissante / enlever les doublons
sort -nru .liste_combinaison > .liste_combinaison2 && mv .liste_combinaison2 .liste_combinaison

# Affichage de la liste triée (peut-être long ...) : Est-ce utile à l'utilisateur ?
echo -e "${RED}================================$NC"
echo -e "    n°\ttaille\t\tcombinaison"
echo -e "${RED}--------------------------------${WHT}"
cat -n .liste_combinaison | head -n 20
echo -e "${RED}================================$NC"

# Sauvegarde de la liste pour débugging
#cp -v .liste_combinaison .liste_combinaison.bak

# Lecture du fichier des combinaisons, regroupement des éléments dans des dossiers
IFS="$OLD_IFS"
declare stt_fin_fichier_combinaison="false"
declare old_ligne=""
declare -a combinaison
declare -a ligne
while [ $stt_fin_fichier_combinaison == "false" ]
do
    read -a ligne < .liste_combinaison || break
    if [ "${ligne[1]}" == "$old_ligne" ]
    then
        # Debug : Arrêt de la boucle dans le cas où read lirait toujours la même ligne (pb de remplassement/mv ...)
        #echo "Fin de fichier détectée"
        stt_fin_fichier_combinaison="true"
    else        
        echo "Traitement de la combinaison ${ligne[1]} / Taille ${ligne[0]}"
        combinaison=( ${ligne[1]//_/ } )
        # S'il y a plus d'un élément, il faut les regrouper dans un dossier !
        if [ ${#combinaison[@]} -gt 1 ]
        then
            cible="DVD${ligne[1]}/"
            mkdir -p "./_$(basename $0)/$cible"
            #-----
            # En cas de restore, il faudra supprimer le dossier créé
            echo "rmdir -v \"./_$(basename $0)/$cible\"" >> ".$(basename $0).restore"
            #-----            
        else
            cible=""
        fi

        for index in ${combinaison[@]}
        do
            echo -e -n "> Déplacement du n°$index : "
            #-----
            echo "mv -v \"./_$(basename $0)/$cible${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> ".$(basename $0).restore"
            echo "echo -e \"> Restauration de l'élément n°$index\"" >> ".$(basename $0).restore"
            #-----
            mv -v "./${tab_element[$index]}" "./_$(basename $0)/$cible${tab_element[$index]}"
            fgrep -v "_${index}_" .liste_combinaison > .liste_combinaison2
            mv .liste_combinaison2 .liste_combinaison
        done

        # Pour gérer la fin de fichier si ça merdois :D
        old_ligne=${ligne[1]}
    fi
done
}

########################################
# Liste à traitement différé
########################################
function partitionner_element()
{
declare -ai tab_taille_max
declare -a  tab_dossier
declare -ai tab_taille tab_index_max tab_index_moyen
declare -a  tab_element
declare -i  somme_max somme_moyenne nb_DVD_max taille_moyenne taille

echo "I: Partitionnement des éléments plus grand qu'un DVD."

while read ligne
do
    tab_taille_max+=( "${ligne%$'\t'*}" )
    tab_dossier+=( "${ligne#*$'\t'}" )
done < .liste_trt_differe

#echo "tab_taille_max=${tab_taille_max[*]}"
#echo "tab_dossier=${tab_dossier[*]}"

## Pour chaque élément plus grand que le support
for i in ${!tab_dossier[*]}
do
	declare -a  tab_element
	declare -ai tab_taille tab_index_max tab_index_moyenne	
	element="${tab_dossier[$i]}"	
	echo -e "\n${BLDGRN}Traitement de l'élément ${BLDCYN}$element${NC}"
	if ! [ -d "$element" ]
	then
		echo "W: $element ne peut pas être divisé."
		break
	fi

	# On peut traiter le dossier
	#-----
	echo "cd .." >> ".$(basename $0).restore"
	#-----
	cd "$element"

	# Taille et nom de chaque élément du dossier
#	echo -e "Liste à traiter :\n$(du -B 1 -s *)"
	du -B 1 -s * > .tmp
	
	echo -e "$RED================================$NC"
    echo -e "    n°\ttaille\t\tlibellé"
    echo -e "$RED--------------------------------${WHT}"
    cat -n .tmp
    echo -e "$RED--------------------------------$NC"
    echo -e "${CYN} Total\t${tab_taille_max[$i]}\t${tab_dossier[$i]}$NC"
    echo -e "$RED================================$NC"

	
	while read ligne 
	do
		#echo "ligne=$ligne"
		taille="${ligne%$'\t'*}"
		element="${ligne#*$'\t'}"
		# Tout les éléments doivent faire moins qu'un DVD
		if [ $taille -le $tailleDVD ]
		then
			tab_taille+=( "$taille" )
			tab_element+=( "$element" )
		else
			echo "${tab_dossier[$i]} contient des éléments plus grand qu'un DVD, pas de partitionnement possible !"
			break 2 # sortir du while et du for ?
		fi
	done < .tmp
	rm .tmp

#    echo "tab_taille=${tab_taille[*]}"
#    echo "tab_element=${tab_element[*]}"

	# Parcours des éléments pour trouver la meilleure méthode de partitionnement
	# NB : On préfèrera répartir le poids sur l'ensemble des supports, plutôt que de graver le dernier avec presque rien.	

	# Nombre de DVD si rempli au max (ne tient pas compte de la taille des éléments)
	declare -i nb_DVD_min=$(( ${tab_taille_max[$i]} / $tailleDVD ))

	# Taille moyenne de chaque élément
	declare -i taille_moyenne_element=$((${tab_taille_max[$i]} / (${#tab_element[*]} + 1) ))
	
	# Si taille homogène, nombre d'élément à mettre par DVD
	declare -i nb_element_par_DVD=$(( $tailleDVD / $taille_moyenne_element ))
	
	# Si DVD rempli avec nombre d'élément moyen au max 
	declare -i nb_DVD_max=$(( $((${#tab_element[*]})) / $nb_element_par_DVD +1))
	declare -i taille_max_DVD=$(( $taille_moyenne_element * $nb_element_par_DVD ))
	
	# Si élément réparti sur max DVD
	declare -i taille_moyenne=$(( ${tab_taille_max[$i]} / $nb_DVD_max ))
    declare -i nb_element_par_DVD_reparti=$(( $taille_moyenne / $taille_moyenne_element ))

    echo
    echo -e "${GRN}I: Répartition prévisionnelle :\n"
    echo -e "$CYN\t--- Récap ---$NC"
    echo -e "\tTaille totale :                   $(converti_unite ${tab_taille_max[$i]})"
	echo -e "\tNombre d'éléments à répartir :    ${#tab_element[*]}"
	echo -e "\tTaille moyenne d'un élément :     $(converti_unite $taille_moyenne_element)"
	echo
	echo -e "$PUR\t--- Configuration DVD min ---$NC"
    echo -e "\tNombre de DVD minimum requis :    $nb_DVD_min"
	echo -e "\tNombre max d'éléments par DVD :   $nb_element_par_DVD"
	echo -e "\tRemplissage max par DVD :         $(converti_unite $taille_max_DVD) / $(( 100 * $taille_max_DVD / $tailleDVD))%"
    echo
    echo -e "$YLW\t--- Configuration DVD homogène ---$NC"
	echo -e "\tNombre de DVD maximum supposé :   $nb_DVD_max"
	echo -e "\tNombre moyen d'éléments par DVD : $nb_element_par_DVD_reparti"  
	echo -e "\tRemplissage min par DVD :         $(converti_unite $taille_moyenne) / $(( 100 * $taille_moyenne / $tailleDVD))%"
    echo

    #read

	#taille_DVD_max=$(( $tab_taille_max[$i] / $nb_DVD_min ))   # Poids moyen de chaque DVD si réparti uniquement sur DVD

	declare -i somme_max=0
	declare -i somme_moyenne=0
	declare -i nb_DVD=0	
	
	# Balayer l'index pour chaque élément
	for index in ${!tab_element[*]}
	do
		somme_max+=${tab_taille[$index]}
		somme_moyenne+=${tab_taille[$index]}
		#echo -e "$index Ajout: ${tab_taille[$index]}\tTotal: somme_max=$somme_max\tsomme_moyenne=$somme_moyenne"
		# On a dépassé la taille d'un DVD complet !
		if [ $somme_max -gt $tailleDVD ]
		then	
			#echo "somme_max dépasse la taille d'un DVD"
			tab_index_max+=( $(( $index - 1 )) )
			nb_DVD+=1
			somme_max=${tab_taille[$index]}
		fi
		# On a dépassé la moyenne, on garde la position si ça rentre sur un DVD (sinon on prend moyenne basse).		
		if [ $somme_moyenne -gt $taille_moyenne ]
		then
			#echo "somme_moyenne dépasse le remplissage moyen : $taille_moyenne"
			if [ $somme_moyenne -gt $tailleDVD ]
			then
				tab_index_moyenne+=( $(($index - 1)) )
				somme_moyenne=${tab_taille[$index]}			
			else
				somme=$somme_moyenne				
				tab_index_moyenne+=( $index )
				somme_moyenne=0
			fi
		fi		
	done

### DEBUG
#    echo "finale somme_max=$(converti_unite $somme_max)"
#    echo "finale somme_moyenne=$(converti_unite $somme_moyenne)"
#    echo "tab_index_max=${tab_index_max[*]}"
#    echo "nb_DVD=$nb_DVD"
#    echo "tab_index_moyenne=${tab_index_moyenne[*]}"
#    read
### DEBUG


	declare -i DVD_max=0 DVD_reparti=0 multi_CD # balises pour orienter les traitements ...
	declare -i index_max somme nb_CD nb_DVD_full nb_DVD_moyenne index
	declare support dest cas_DVDmax cas_DVDmoyen lib_DVDmax lib_DVDmoyen

	nb_DVD_full=${#tab_index_max[*]}
	nb_DVD_moyen=${#tab_index_moyenne[*]}
	nb_CD=0

	# Si le dernier élément termine un DVD dans la moyenne, on ne compte pas le dernier DVD (cf. comparaison taille_max)
	if [ $somme_moyenne -eq 0 ]
	then
		nb_DVD_moyen=$(( $nb_DVD_moyen - 1 ))
		somme_moyenne=$somme
	fi 	
	
	# Si le reste rentre sur 1 CD, on garde le remplissage max	
	if [ $somme_max -le $tailleCD ]
	then
		echo -e "${PUR}I: Configuration DVD min : restant sur 1 CD.$NC"
		nb_CD=1
		multi_CD=0
		#DVD_max=1
	# Si le reste ne rempli pas un DVD au minimum demandé, étudier la répartition en plusieurs CD.
	elif [ $somme_max -lt $tailleDVD_min ]
	then
		echo -e "${PUR}I: Configuration DVD min :\tcalcul répartition restant sur plusieurs CD..."				
		# Premier index désignant l'élément qui suit le dernier élément dans un DVD :
		#echo -e "tab_index_max=${tab_index_max[*]}\tnb_DVD_full=$nb_DVD_full"
		index=${tab_index_max[$(($nb_DVD_full - 1))]}
		index+=1 # index départ
		#echo "index_depart=$index"
		
		# Nombre max d'éléments dans le dossier (Attention : 1 de + que le nombre d'entrée dans tab_element !!)
		index_max=${#tab_element[*]}
		#echo "index_max=$index_max"
		
		nb_CD=0
		multi_CD=1	
		while [ $index -lt $index_max ]
		do			
			# Si un des éléments restants dépasse la taille d'un CD, pas la peine de continuer !
			if [ ${tab_taille[$index]} -gt $tailleCD ]
			then
			    echo -e "\n${RED}W: Configuration DVD min :\tun des éléments restant dépasse la taille d'un CD.$NC"
				# Pas de CD supplémentaire
				nb_CD=0
				multi_CD=0
				
				# Remettre à zero le tableau des index max
				index=$index_max
				index_max=${#tab_index_max[*]}			
				while [ $index -lt $index_max ]
				do
					unset ${tab_index_max[$index]}
					index+=1
				done 
				break
			fi						

            #echo -e "n°$index\t${tab_taille[$index]}\t${tab_element[$index]} rentre sur un CD."

			# L'élément rentre dans un CD ... essayons de l'ajouter aux précédents.			
			somme+=${tab_taille[$index]}
			
			# Si ça dépasse du CD, on complète le tableau d'index
			if [ $somme -gt $tailleCD ]
			then
				#echo "Besoin d'un CD supplémentaire ..."
				nb_CD+=1
				tab_index_max+=( $(( $index -1)) )
				somme=${tab_taille[$index]}
			fi
			index+=1
		done
		if [ $multi_CD -gt 0 ]
		then
			#DVD_max=1
			nb_CD+=1
			echo -e "\t\t\t\t---> Mode multiCD sur $nb_CD CDs.$NC"
		fi
	fi

    echo -e "${RED}--------------------------------$NC"
    if [ $nb_CD -gt 0 ]
    then
        echo -e "${PUR}Configuration DVD min :\n${WHT} > Remplissage de $nb_DVD_full DVD complet, restant sur $nb_CD CD(s) ou 1 DVD.$NC"
    else
        echo -e "${PUR}Configuration DVD min :\n${WHT} > Remplissage de $nb_DVD_full DVD complet, restant sur 1 DVD.$NC"
    fi

    if [ $somme_moyenne -gt $tailleCD ]
    then
        echo -e "${YLW}Configuration DVD homogène :\n${WHT} > Remplissage de $(($nb_DVD_moyen+1)) DVD."
    else
        echo -e "${YLW}Configuration DVD homogène :\n${WHT} > Remplissage de $nb_DVD_moyen DVD et 1 CD."
    fi
    echo -e "${RED}--------------------------------$NC"

### DEBUG
#    read
### DEBUG

	# On a le choix entre :
	#  - soit :
	#  		A.    DVD au max + 1DVD_maxi	<=> DVD_max=0
	#  		B1    DVD au max + 1DVD_mini	<=> DVD_max=1
	#  		B2 ou DVD au max + nCD + 1CD	<=> DVD_max=1 + multi_CD=1 / nb_CD>1
	#  		C. ou DVD au max + 1CD			<=> DVD_max=1 + multi_CD=0 / nb_CD=1
	#  - soit :
	#		D.    DVD moyenne + 1DVD
	#		E. ou DVD moyenne + 1CD
				
	# Comparaison du nombre de CD/DVD nécessaire, on prend le moins couteux :
	#------------------------------------------------------------------------*

    if [ $somme_max -gt $tailleDVD_min ]
    then
        cas_DVDmax="A"
        lib_DVDmax="1 DVD\t"
    elif [ $somme_max -gt $tailleCD ]
    then
        cas_DVDmax="B"
        lib_DVDmax="$nb_CD CD ou 1 DVD"
    else
        cas_DVDmax="C"
        lib_DVDmax="1 CD\t"
    fi
    
    if [ $somme_moyenne -gt $tailleCD ]
    then
        cas_DVDmoyen="D"
        lib_DVDmoyen="1 DVD"
    else
        cas_DVDmoyen="E"
        lib_DVDmoyen="1 CD"
    fi

	echo -e "\n${GRN}Choix de la configuration :$NC"
    echo -e "${RED}================================================$NC"	
	echo -e "\t\t${PUR}DVD min\t\t${YLW}DVD homogène$NC"
    echo -e "${RED}------------------------------------------------$NC"
	echo -e "Nb support max\t${PUR}$((${#tab_index_max[*]}+1))\t\t${YLW}$(($nb_DVD_moyen+1))$NC"
	echo -e "Nb support min\t${PUR}$(($nb_DVD_full+1))\t\t${YLW}$(($nb_DVD_moyen+1))$NC"
	echo -e "Configuration\t${PUR}$cas_DVDmax\t\t${YLW}$cas_DVDmoyen$NC"
	echo -e "Reste\t\t${PUR}$(converti_unite $somme_max)\t${YLW}$(converti_unite $somme_moyenne)$NC"
	echo -e "soit\t\t${PUR}$lib_DVDmax\t${YLW}$lib_DVDmoyen$NC"
    echo -e "${RED}------------------------------------------------$NC"
		
	# moins de DVD_max (CD inclus) que de DVD_moyenne
	if [ ${#tab_index_max[*]} -lt $nb_DVD_moyen ]  # Cas A, B2, C
	then
		echo "> Configuration DVD min prends moins de support (mode max)."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
		DVD_max=1
		DVD_reparti=0
	# moins de DVD_max (CD exclus, avec 1DVD_mini) que de DVD_moyenne
	elif [ $nb_DVD_full -lt $nb_DVD_moyen ]  # Cas B1
	then
	    echo "> Configuration DVD min prends moins de support (mode min)."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
		DVD_max=1
		DVD_reparti=0
		multi_CD=0
		# Remettre à zero le tableau des index max
		index=$nb_DVD_full
		index_max=${#tab_index_max[*]}			
		while [ $index -lt $index_max ]
		do
			unset ${tab_index_max[$index]}
			index+=1
		done
		nb_CD=0
	fi

	# moins de DVD_moyenne que de DVD_max (???)	
	if [ $nb_DVD_moyen -lt $nb_DVD_full ]  # Cas D ou E
	then
		echo "> Configuration DVD homogène prends moins de support."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
		DVD_max=0
		DVD_reparti=1
	fi

	# On a le choix entre :
	#  - soit :
	#  		A.    DVD au max + 1DVD_maxi	<=> DVD_max=0
	#  		B1    DVD au max + 1DVD_mini	<=> DVD_max=1
	#  		B2 ou DVD au max + nCD + 1CD	<=> DVD_max=1 + multi_CD=1 / nb_CD>1
	#  		C. ou DVD au max + 1CD			<=> DVD_max=1 + multi_CD=0 / nb_CD=1
	#  - soit :
	#		D.    DVD moyenne + 1DVD
	#		E. ou DVD moyenne + 1CD

	# Pour le même nombre de support, on préfère :
	#---------------------------------------------*

	#        	 .----+----. 
	#	     	 | D  | E  |	   
	#	.--------+----+----+
	#	| 1	: A  | D  | E  | => toujours moyenne
	#	| 2	: B1 | D  | E  | => toujours moyenne    
	#	| 3	: B2 | B2 | E* | => Cas particulier
	#	| 4	: C  | C  | E  | => Cas particulier
	#	°--------+----+----°
	# 	 (*) uniquement si taille_moyenne > tailleDVD_min ; sinon B2	



    if [ $cas_DVDmax == "A" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo -e "> Configuration DVD min utilise un DVD en dernier rempli à ${GRN}plus de $taux_remplissage%.$NC"
        echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
        DVD_max=0
        DVD_reparti=1
    fi

    if [ $cas_DVDmax == "C" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ] && [ $cas_DVDmoyen == "D" ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo "> Configuration DVD min utilise un CD en dernier."
        echo "> Configuration DVD homogène utilise un DVD en dernier."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
        DVD_max=1
        DVD_reparti=0        
    fi 

    if [ $cas_DVDmax == "C" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ] && [ $cas_DVDmoyen == "E" ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo "> Configuration DVD min utilise un CD en dernier."
        echo "> Configuration DVD homogène utilise un CD en dernier."
        echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
        DVD_max=0
        DVD_reparti=1        
    fi 

    # Cas B1
    if [ $cas_DVDmax == "B" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo -e "> Configuration DVD min utilise un DVD en dernier rempli à ${RED}moins de $taux_remplissage%.$NC"
        echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
        DVD_max=0
        DVD_reparti=1        
    fi

    # Cas B2
    if [ $cas_DVDmax == "B" ] && [ ${#tab_index_max[*]} -eq $nb_DVD_moyen ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo "> Configuration DVD min utilise plusieurs CDs."
        # Cas D
        if [ $cas_DVDmoyen == "D" ]
        then
            echo "> Configuration DVD homogène utilise un DVD en dernier."
            echo -e "${PUR}I: Configuration DVD min retenue.$NC"
            DVD_max=1
            DVD_reparti=0
        # Cas E avec DVD moyen > DVD min
        elif [ $taille_moyenne -gt $tailleDVD_min ]
        then
            echo "> Configuration DVD homogène utilise un CD en dernier."
            echo -e "> Configuration DVD homogène utilise un DVD rempli à ${GRN}plus de $taux_remplissage%.$NC"       
            echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
            DVD_max=0
            DVD_reparti=1        
        # Cas E avec DVD moyen < DVD min
        else
            echo "> Configuration DVD homogène utilise un CD en dernier."
            echo -e "> Configuration DVD homogène utilise un DVD rempli à ${RED}moins de $taux_remplissage%.$NC"
            echo -e "${PUR}I: Configuration DVD min retenue.$NC"
            DVD_max=1
            DVD_reparti=0
        fi
    fi 


	support="DVD"
	index=0
	
#	echo -e "DVD_max=$DVD_max\tDVD_reparti=$DVD_reparti"
	
	# Traitement DVD max + reste
	if [ $DVD_max -eq 1 ]
	then
		echo
        echo -e "${RED}================================$NC"	
		echo -e "${GRN}Traitement configuration DVD min$NC"
        echo -e "${RED}--------------------------------$NC"

		if [ ${tab_index_max[ $(( ${#tab_index_max[*]} - 1 )) ]} -lt $(( ${#tab_element[*]} -1 )) ]
		then
		    tab_index_max+=( $(( ${#tab_element[*]} - 1 )) )
		fi

		for j in ${!tab_index_max[*]}
		do
			# On a dépassé le nombre d'éléments sur DVD full, et il reste des CD.
			if [ $j -gt $nb_DVD_full ] && [ $nb_CD -gt 0 ]
			then
				support="CD"
			fi
			
			# Création du dossier de destination dans le dossier courant
			dest="Part_$(( $j + 1 ))_$support"			
			echo -e "\n${CYN}>> Création du dossier $NC$dest"
			mkdir "$dest"
			#-----
			echo "rmdir -v \"$dest\"" >> "../.$(basename $0).restore"
			echo "echo -e \">> Suppresion du dossier $dest\"" >> "../.$(basename $0).restore"
			echo "echo" >> "../.$(basename $0).restore"
			#-----
			while [ $index -le ${tab_index_max[$j]} ]
			do
			    echo -e "${WHT} > Déplacement élément n°$(($index +1)) :\n   $PUR${tab_element[$index]}$NC" 
				mv "${tab_element[$index]}" "./$dest/${tab_element[$index]}"
                #-----
			    echo "mv -v \"./$dest/${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \"   ${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \" > Restauration élément n°$(($index +1)) :\"" >> "../.$(basename $0).restore" 
			    #-----
				index+=1
			done
			index=$(( ${tab_index_max[$j]} + 1 ))
		done
	fi

	if [ $DVD_reparti -eq 1 ] 
	then
		if [ $somme_moyenne -le $tailleCD ]
		then	
			nb_CD=1
		else
			nb_CD=0
		fi
	fi
	
	# Traitement DVD moyenne + reste
	if [ $DVD_reparti -eq 1 ]
	then
		echo
        echo -e "${RED}================================$NC"	
		echo -e "${GRN}Traitement configuration DVD homogène$NC"
        echo -e "${RED}--------------------------------$NC"

### DEBUG		
#		echo "tab_index_moyenne max : ${tab_index_moyenne[$((${#tab_index_moyenne[*]} - 1))]}"
#		echo "tab element max : $(( ${#tab_element[*]} -1 ))"
### DEBUG
		
		if [ ${tab_index_moyenne[ $(( ${#tab_index_moyenne[*]} - 1 )) ]} -lt $(( ${#tab_element[*]} -1 )) ]
		then
		    tab_index_moyenne+=( $(( ${#tab_element[*]} - 1 )) )
		fi
		
		for j in ${!tab_index_moyenne[*]}
		do
			# On a dépassé le nombre d'éléments sur DVD full, et il reste des CD.
			if [ $j -gt $nb_DVD_moyen ] && [ $nb_CD -gt 0 ]
			then
				support="CD"
			fi
			# Création du dossier de destination dans le dossier courant
			dest="Part_$(( $j + 1 ))_$support"			
			echo -e "\n${CYN}>> Création du dossier $NC$dest"
			mkdir "$dest"
			#------
			echo "rmdir -v \"$dest\"" >> "../.$(basename $0).restore"
			echo "echo -e \"\\n>> Suppression du dossier $dest\""  >> "../.$(basename $0).restore"
			#------
			while [ $index -le ${tab_index_moyenne[$j]} ]
			do
			    echo -e "${WHT} > Déplacement élément n°$(($index +1)) :\n   $YLW${tab_element[$index]}$NC"
				mv "${tab_element[$index]}" "./$dest/${tab_element[$index]}"
                #-----
			    echo "mv -v \"./$dest/${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \"   ${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \" > Restauration élément n°$(($index +1)) :\"" >> "../.$(basename $0).restore" 
			    #-----
				index+=1
			done
			index=$(( ${tab_index_moyenne[$j]} + 1 ))
		done
	fi	

### DEBUG	
#	read
### DEBUG	
	
	unset tab_element tab_taille tab_index_max tab_index_moyenne
	cd ..
	#-----
	echo "cd \"${tab_dossier[$i]}\"" >> ".$(basename $0).restore"
	echo "echo -e \"Restauration dossier : ${tab_dossier[$i]}\"" >> ".$(basename $0).restore"
	#-----
	
done	
}

function converti_unite()
{
    declare -i taille=$1
    declare -i major=0
    declare -i minor=0
    declare dec
    declare -i index=0
    declare -a tab_unite=( "o" "kio" "Mio" "Gio" "Tio" )
    major=$taille
    while [ $major -ge 1024 ]
    do
        taille=$major
        major=$(( $taille / 1024 ))
        minor=$(( $taille % 1024 ))
        index+=1
    done
    dec=$minor
    while [ ${#dec} -lt 3 ]
    do
        dec="0$dec"
    done
    echo -n "$major,$dec ${tab_unite[$index]}"
}

regrouper_element
partitionner_element

declare -a tab_restore
declare -i index

echo -E "#!/bin/bash" >> ".$(basename $0).restore"

# Remettre les actions de restoration dans l'ordre pour supprimer les dossiers créés APRES avoir replacé le contenu !!
echo -e "\n${BLDRED}I: Création du script pour restauration...$NC"
while read ligne
do
    tab_restore+=( "$ligne" )
done < ".$(basename $0).restore"
index=${#tab_restore[*]}
while [ $index -gt 0 ]
do
    echo "${tab_restore[$(( $index - 1))]}" >> ".$(basename $0).restore2"
    index=$(( $index - 1))
done
#sort -r ".$(basename $0).restore" > ".$(basename $0).restore2"
mv ".$(basename $0).restore2" ".$(basename $0).restore"

# Nettoyage des fichiers temporaires du run
rm .liste_taille2 .liste_taille .liste_a_regrouper .liste_trt_differe .liste_combinaison .liste_combinaison2 2>/dev/null

echo -e "\n${BLDGRN}I: Pour restaurer les élements dans leurs chemins initiaux, lancer la commande suivante :$NC"
echo "  source .$(basename $0).restore" | tee -a $HISTFILE

exit 0

Dernière modification par draco31.fr (Le 10/01/2010, à 21:22)

Hors ligne

#860 Le 11/01/2010, à 12:05

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

@ Shrat

Rhaaaaaaaa j'avais pas percuté qu'il y avais une page de man pour test...à chaque fois que je doute je cherche dans http://abs.traduc.org/abs-fr/index.html mais c'est pas toujours facile de s'y retrouver. Et puis des fois on à tendance à chercher une solution en utilisant les cmd que l'on connais alors qu'il y en à des plus efficaces et directes. Dur dur d'optimiser son code...

PS: Shrat : Tu écrit souvent au Pape ? ;-)

@ BorX

Désolé mais je suis débutant, y'a des trucs que je comprend pas dans ta solution.

--> Si on remplace mon bout de code par le tien, à quoi sert le "unset FILES" au début vu que la variable n'est pas initialisée ?

--> C'est quoi "-iname" ? J'ai pas du bien chercher car je trouve rien la dessus :-(

--> Juste pour confirmation : "eval" sert à considérer le contenu de la variable (en l'occurence des extensions séparées par des espaces) comme des paramètres distincts (autrement dit ça tient compte des espaces)...j'ai bon ?


Merci pour les conseils

Dernière modification par Goda (Le 11/01/2010, à 12:39)


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#861 Le 11/01/2010, à 13:00

BorX

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

smile
La solution que je propose est un peu compliquée par eval.

Initialement, je voulais mettre l'accent sur l'option -delete de find (à privilégier à -exec rm {} \; qui a plus de chance de boguer ; ce dont on se passe volontiers quand on efface des trucs).
Cette option -delete est décrite dans la manpage de find, tout comme l'option -iname qui fait la même chose que -name mais sans tenir compte de la casse (ainsi, on recherche aussi bien les fichiers .mp3 que .MP3 ou .Mp3).
Grâce à l'option -o, je dis à find de trouver toutes sortes de fichiers, en n'effectuant qu'une seule passe sur l'arborescence :
find . \( -iname "*.txt" -o -iname "*.mp3" -o -iname "*.db" \) -ls -delete

Enfin, eval...
eval n'est pas toujours évident à utiliser, et il est en général préférable de s'en passer, quand on peut.
eval exécute la chaîne de caractères qu'on lui passe en paramètre, comme si cette chaîne de caractères était une commande à part entière. Ça permet de lancer du code dynamique (formé à partir de variables).
Ce qui est le cas ici, $FILES contenant du code, construit préalablement. En effet :
find . \( $FILES \) -ls -delete
ne marchait pas. Avec le eval, c'était plus commode pour moi sur le coup, mais il y a peut-être une solution plus carrée (l'utilisation de eval complique toujours le déboguage).

Ah oui, le unset FILES... C'est juste pour m'assurer que la variable est vide avant de rentrer dans la boucle qui agit sur elle par concaténation... tongue

Hors ligne

#862 Le 11/01/2010, à 13:04

BorX

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Ah oui, et pour le [ -n "$FILES" ] && FILES="$FILES -o".
J'aurais pu écrire :

if [ -n "$FILES" ]

  then

    FILES="$FILES -o"

fi

Mais je supporte pas de prendre autant de lignes pour si peu... Alors j'encourage toujours à réduire tant qu'on peut. big_smile
Même sans aller jusqu'à se passer du if, on peut au moins faire ça :

if [ -n "$FILES" ]; then
    FILES="$FILES -o"
fi

Ça simplifie considérablement la lecture... tongue

Dernière modification par BorX (Le 11/01/2010, à 13:05)

Hors ligne

#863 Le 11/01/2010, à 13:27

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Ah merci merci !
J'aime quand c'est clair comme ça !
Pour "unset" c'est ce que je m'etais dit...que c'etais une précaution.

En ce qui concerne "-iname"...autant pour moi, j'ai mal lu ton code et du coup je n'avais pas capté que c'etais une option de find.

Pour "eval" c'est bon de savoir à quoi ça sert au cas ou... :-)

Encore merçi d'avoir pris le temps de m'expliquer aussi clairement. :-)


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#864 Le 11/01/2010, à 19:41

Dom32

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Ça serait cool de le réécrire en entier pour les ignares comme moi !!! Il a sacrément utile ce petit script cool

Hors ligne

#865 Le 12/01/2010, à 00:00

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Content que ça interesse du monde....

Comme ça c'est plus propre, bien qu'il y ai suremment encore moyen d'optimiser mais bon...

(J'ai aussi corrigé quelques petites bourdes...et il n'y a plus de problème avec les chemins contenant des espaces)

#! /bin/bash

echo -e "\033[00;32m";
clear;

########################################################################
#
#         Ce script permet de trier/effacer le contenu d'un
#        dossier et des sous dossiers par types d'extensions.
#
#     Exemple :  Effacer tous les "thumbs.db" produits par W€€ndows
#
########################################################################


read -p "Analyser le dossier courant ? O/n :" REP

if [ "$REP" = o ] || [ "$REP" = O ]; then
   	DIR=$PWD
elif [ "$REP" = n ]; then
	read -p "Indiquer le chemin du dossier à analyser : " DIR ;
	cd "$DIR";
elif  [ -z "$REP" ]; then
	echo"";
	echo "Indiquez un dossier !";
	sleep 4;
	exit 1
fi

#liste et compte les extensions
#
CONTENU=`find . -type f | sed 's/.*\.//' | sort | uniq -c`

echo "Ce dossier contient :";
echo "$CONTENU";

echo "indiquez les types de fichiers à effacer en séparant"
echo "les extensions par un espace :";
echo "exemple : mp3 txt db";
echo "";
read -p ":" EXT ;

echo "ATTENTION ! Tous les fichiers dont les extensions sont \"$EXT\" vont ètre" ;
echo "effacés de manière IRREVERSIBLE ! " ;
echo ""
echo "Pour annuler faite Ctrl+c." ;
read -p "Si vous ètes sur de ce que vous faite tapez \"Entrée\" : " OK ;


#Efface les extensions choisies
#
unset $FILES
for ext in $EXT; do
  [ -n "$FILES" ] && FILES="$FILES -o"
  FILES="$FILES -iname '*.$ext'"
done
eval "find . \( $FILES \) -ls -delete"

#Quitte
#
echo ""
read -p "Fin....appuyez sur Entrée pour quitter" QUIT ;
echo -e "\033[00m";
clear;
exit 0;

A plus


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#866 Le 12/01/2010, à 08:50

draco31.fr

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Je trouve dommage que l'on demande confirmation uniquement pour la totalité des fichiers trouvés.
N'y aurait-il pas moyen de demander confirmation pour chaque fichier avant suppression ?

Par exemple, j'ai 20 fichiers qui correspondent aux motifs, mais je ne veux pas supprimer le 6ième fichier ... comment je fais ?
L'idée serait de dire "OK" pour les 5 premiers, puis "Non" au 6ième, puis "OK pour tous" pour les restants.
C'est faisable avec find -delete ???

Hors ligne

#867 Le 12/01/2010, à 10:48

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Ben il doit bien y avoir moyen de demander confirmation pour chaque fichier (pour dire ensuite "ok a tous" ça doit déja etre moins simple) ----> Via l'option "-ok" de find ? Elle permet d'executer une cmd aprés confirmation...
Ou alors à grand coup de "if then" mais ça risque d'ètre fastidieux.

Mais bon, à la base ce script est pensé pour traiter des moyennes-grosses quantités de fichiers...En ce qui me concerne je l'ai écrit pour faire le ménage dans ma musique (effacer toutes les couvertures en jpg, les thumbs.db et les .m3u) soit en tout 200 ou 300 fichiers. Du coup ça devenais valable de prendre le temps d'écrire un script plutot que de les chercher à la main... En revanche si tu veux effacer 20 fichier sauf 1 ça vas sans doutes plus vite à la main que d'écrire un script (en allant renommer ton fichier en .bak avant de lancer le script par exemple).
Bon, aprés libre à chaqu'un d'adapter le script à ses besoins spécifiques...parceque écrire un code capable de faire fâce a tous les cas de figures ça tiens de la gageure !

J'en profite au passage pour exprimer mon intense satisfaction d'utiliser un système Linux et d'en ètre arrivé à un niveau de compréhension (certe modeste) permettant de coder (presque tout seul wink ) un petit utilitaire qui dépanne bien comme celui-çi...Comment aurais-je fait sous W€€ndows ? (j'aurais sans doute été chercher sur clubic).

GNU/Linux c'est trop bien, qu'on se le dise ! big_smile


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#868 Le 12/01/2010, à 12:57

Dom32

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Sans vouloir mettre le "bordel", les scripts fonctionnent aussi avec W, et heureusement, sinon quel taf pour gérer un parc de PC ;-)

Hors ligne

#869 Le 12/01/2010, à 13:13

Goda

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Oui oui, j'ai déja fait des .bat mais ça ne m'avais pas semblé aussi souple et accessible...mais bon on vas quand même pas se mettre à troller wink


" Read The F$$$$$ Manual "      --->  man man

Pensez à passer en RÉSOLU...(en éditant le titre du 1er message)

Hors ligne

#870 Le 12/01/2010, à 17:33

Levi59

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Script déplacé. (disponible dans ma signature)

J'ai ouvert un topic pour l'améliorer donc si quelqu'un peut aider... Merci davance!
Lien:http://forum.ubuntu-fr.org/viewtopic.ph … 9#p3209519

Dernière modification par Levi59 (Le 14/01/2010, à 12:11)

Hors ligne

#871 Le 12/01/2010, à 21:22

Shrat

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

draco31.fr a écrit :

Je trouve dommage que l'on demande confirmation uniquement pour la totalité des fichiers trouvés.
N'y aurait-il pas moyen de demander confirmation pour chaque fichier avant suppression ?

Par exemple, j'ai 20 fichiers qui correspondent aux motifs, mais je ne veux pas supprimer le 6ième fichier ... comment je fais ?
L'idée serait de dire "OK" pour les 5 premiers, puis "Non" au 6ième, puis "OK pour tous" pour les restants.
C'est faisable avec find -delete ???

rm -i

@Goda : C'est quoi cette histoire de pape?

Hors ligne

#872 Le 12/01/2010, à 21:55

n3o51

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

bonsoir

c'est génial ça levi Merci je teste des que j'ai 5 min


Welcome to the real world
________________________________

Hors ligne

#873 Le 12/01/2010, à 22:07

Levi59

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

De rien!

N'hésitez pas à rapporter tout problème ou toute amélioration du code...

Hors ligne

#874 Le 13/01/2010, à 01:49

niko_las

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

brt a écrit :

SCRIPT : "Sauver des arbres"

Qui n'a jamais essayé d'imprimer en deux pages par feuilles, recto-verso, (sur une imprimante recto) sans se planter ?
J'ai rédigé un petit script python qui donne des instructions pour que tout fonctionne bien :
...
- J'aimerais faire évoluer ce script, pour qu'il communique directement avec cups, m'enfin j'en suis encore loin.

Bonjour,
voici mon premier script "Sauvons des arbres", qui communique directement avec cups.
Ce script utilise zenity pour un peu plus d'interaction.
Il permet d'imprimer un pdf  en deux pages par feuilles, recto-verso (simple ou en livret A5 sur du A4 plié en 2), en choisissant l'imprimante de destination parmi celles installées (sous cups).

Pour cela il faut avoir cups d'installé, ainsi pdfnup (disponible dans le paquet pdfjam), et pdfbook pour le mode livret (à compiler soi-même, on peut le trouver ici : ftp://cam.ctan.org/tex-archive/support/pdfbook.zip)

Trêve de blabla, voici le script

#!/bin/bash
#!/bin/bash
#Propose d'imprimer un pdf format A4 en 2 page par feuilles recto-verso (simple ou livret), pour des imprimantes ne gérant pas le recto verso.
#(avec choix de l'imprimante en fonction des imprimantes installées)
#nécessite cups, ainsi que le programme pdfnup disponible dans le paquet pdfjam
#L'impression en mode livret nécessite l'installation de pdfbook (à compiler soi-même, on peut le trouver ici : ftp://cam.ctan.org/tex-archive/support/pdfbook.zip)

rvsimple="recto-verso simple"
livret="mode livret"
fich=$1
#Si aucun fichier n'est donné en argument, on en choisi un
if test $# -eq 0; then
 if ! fich=`zenity --title="Entrez le fichier pdf à imprimer" --file-selection`; then exit;  fi
fi

#choix de l'imprimante (l'imprimante par défaut est proposée par défaut ;)
if ! lpr=$(zenity --entry --title="imprimante" --text="Choix de l'imprimante" --entry-text="$(lpstat -d | awk -F": " '{print $2}')" $(lpstat -a | awk -F" " '{print $1}')); then exit; fi

basefich=`dirname $fich`/`basename $fich pdf`
tmpfich="$basefich"1.book.pdf

if ! choix=$(zenity --list --title="choix du format" --column="choix"  --column="format" \
	 --radiolist true  "$rvsimple" \
	--radiolist false "$livret" ); then exit; fi

if ! $(zenity --title="Poursuivre l'impression?" --question --text="Impression du fichier $fich en mode $choix sur l'imprimante $lpr ! \nContinuez?"); then exit ; fi

#mise en page (2 pages par feuilles selon le mode choisi)
if [ "$choix" = "$livret" ]; then
pdfbook -2 "$fich" "$tmpfich" 
else
pdfnup --nup 2 "$fich" --paper a4paper --orient landscape --outfile "$tmpfich" 
fi
#attendre que la mise en page soit finie
wait
#impression du recto
lp -d "$lpr" -o page-set=odd -o number-up=1 -o outputorder=reverse "$tmpfich" | zenity --title="Impressio du recto" --progress --pulsate --auto-close
if ! $(zenity --title="Recto imprimé" --question --text="Recto envoyé à l'impression \nAttendez la fin de l'impression et retournez les feuilles dans le bac de l'imprimante! \nContinuez?"); then
rm "$tmpfich"
exit
fi

#impression du verso
lp -d "$lpr" -o page-set=even -o number-up=1 "$tmpfich" | zenity --title="Impressio du verso" --progress --pulsate --auto-close
rm "$tmpfich"

#confirmation
zenity --title="Impression ok" --info --text="Verso envoyé à l'impression"

Usage :

sh ./print-pdf2book.sh document.pdf

ou alors, a placer dans les scripts nautilus, et l'utiliser en cliquant sur une fichier pdf.

Si aucun fichier n'est donné en argument, un fenêtre apparait et permet de choisir un fichier.

Le plus gros problème reste de savoir comment retourner  les feuilles (attention, je crois que ce n'est pas pareil en r&v simple et en livret, à vous de tester).

Pour info, c'est une modif' dun script trouvé ici : http://memo-gf.blogspot.com/2008/03/a5book.html (j'en remercie l'auteur, jusque là je n'avais jamais jeté un oeil à Zenity).

NB : il est ultra facile de réécrire ce script pour des fichiers ps, mais personnellement, j'imprime plus de pdf.

PS : si qqn à besoin d'une version ligne de commande seulement (en enlevant l'utilisation de zenity), qu'il me le fasse savoir.

Dernière modification par niko_las (Le 13/01/2010, à 03:10)

Hors ligne

#875 Le 18/01/2010, à 15:43

GouxMathieu

Re : [ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Bonjour à tous et à toutes smile Je soumets ces propositions à votre bon plaisir, en espérant que ce que je propose n'est pas dénué de tout sens commun et que vous voudrez bien étudier mon "cas". Je chercherai en effet deux scripts distincts, afin d'automatiser certaines opérations fastidieuses à accomplir en manuel. Si ces scripts existent déjà, je ne les ai pas trouvés sur Internet, tout du moins, sauf si je n'ai pas cherché au bon endroit... Bref, voici les deux scripts qui me feraient plaisir (j'espère bien décrire mes ambitions...) :

-------------------------

Script 1

Le premier script concerne Nautilus. J'ai une arborescence de fichiers construite telle que plusieurs dossiers portent, au caractère près, le même nom (Mettons "Dossier"), mais ne sont donc pas au même chemin. J'aimerai pouvoir, en me mettant à la racine de mon arbre de dossiers, copier un même fichier (Mettons, "Fichier.jpg") dans tous les dossiers "Dossier" et ce de façon automatique. Est-ce possible ?

----------------------------------

Script 2

Le deuxième script concerne également Nautilus. Je possède un certain nombre de fichiers musicaux, organisés selon une arborescence du type Artiste/Année - Album/(Disc x, si besoin)/Piste1.mp3, Piste2.mp3. Je voudrais quelque chose qui pourrait sélectionner de façon aléatoire un nombre donnée de fichiers musicaux .mp3 (ils sont tous au même format), et me les copier dans un autre dossier en conservant l'arborescence cité en vue de pouvoir les stocker proprement et de façon maniaque sur un lecteur mp3. Est-ce possible ? J'ajoute que j'aimerai beaucoup fixer le nombre de fichiers musicaux ainsi exportés.

En espérant que ces "challenges" tentent certains d'entre vous,

Je vous remercie d'avance !

Goux Mathieu

Hors ligne

Haut de page ↑