[Risolto] Script per copiare files in più directory

[LuisGis]

Salve,
Vorrei fare uno script per copiare files in più directory.
Ovvero dentro la cartella ./Musica/wav, ho migliaia di files musicali .wav e dovrei ordinarli per durata, ma in alternativa, posso orinarli per dimensioni ed in ordine crescente per poi spostarli dentro 20 cartelle (cartella01, cartella02, cartella03… fino alla cartella20), facendo in modo che le 20 cartelle abbiano, grossomodo, le stesse dimensioni.
Per far ciò ho pensato di spostare il primo file dentro la cartella01, il secondo file dentro la cartella02 e così via fino ad arrivare alla cartella20 per poi ripartire dalla cartella01.
La directory è così strutturata
./Musica/wav
./Musica/cartella01 …..cartella020
Potete aiutarmi?
Grazie

[vaeVictis]

Io imposterei la cosa in questo modo:
1) in due variabili inserisci il path della directory e il numero di directory in cui vuoi suddividerla
2) con il comando du (e le opportune opzioni) vedi il peso totale della directory e lo metti in una variabile
3) dividi il peso totale appena ottenuto per il numero di directory (in cui vuoi suddividere) e ottieni il peso della singola directory
4) con find (e le opportune opzioni) crei una lista con il peso dei file e il nome del file (opzione -ls) e la ordini con il comando sort
5) leggi i nomi dei file e li copi/sposti nella prima directory, sommando il peso dei vari file spostati; quando il peso complessivo supera quello della singola directory (calcolato al punto 3) ) crei la directory successiva e ricominci da capo.

Al momento ho buttato giù tutto tranne il punto 5). Domani ti posto lo script.

Ma tu vuoi copiare il contenuto o spostarlo?

p.s.: sui file wav sinceramente non saprei come fare a vederne la durata. Però secondo me ordinarli per durata è poco utile.

[UbuNuovo]

Per video e audio uso sempre exiftool

Codice: Seleziona tutto

exiftool /path/file | grep 'Duration'

[vaeVictis]

Sì, ma ordinarli per durata non ha senso nell'ottica di una divisione per peso equilibrata, comunque.

[LuisGis]

Grazie per le risposte,
Desidero spostare i files

[UbuNuovo]

@Vae: Sì, secondo me ha poco senso ordinare i file per durata o peso per poi distribuirli in directory con lo stesso peso|durata ciclicamente.
Nel senso: la prima avrà il primo file più leggero|corto, la seconda il secondo più leggero|corto fino ... non ne vedo l'utilità.
Capirei di più: La prima directory i file più corti, la seconda quelli un po' più lunghi... e così via fino all'ultima con i file più pesanti|lunghi.

[vaeVictis]

UbuNuovo non ti ho capito

Nel senso: la prima avrà il primo file più leggero|corto, la seconda il secondo più leggero|corto fino ... non ne vedo l'utilità.
Capirei di più: La prima directory i file più corti, la seconda quelli un po' più lunghi... e così via fino all'ultima con i file più pesanti|lunghi.

[UbuNuovo]

@Vae:Mi riferivo al metodo proposto da LuisGis:

Per far ciò ho pensato di spostare il primo file dentro la cartella01, il secondo file dentro la cartella02 e così via fino ad arrivare alla cartella20 per poi ripartire dalla cartella01

Si otterrebbero directory con sequenze di file disordinate.
Il tuo metodo invece mi convince, farei anch'io allo stesso modo, così da ottenere i file più brevi|leggeri nella directory01 e quelli più lunghi|pesanti nella directory20.

[vaeVictis]

Ah, ok. Io sinceramente avevo capito male quanto chiesto da LuisGis. Per questo non avevo capito cosa intendevi, UbuNuovo.
Per ora ho quasi finito lo script, devo testarlo e poi lo posto. Però ho ragionato seguendo la mia logica. Se va bene magari LuisGis può usare questo, altrimenti si modifica.

[UbuNuovo]

Mi avete incuriosito, ho appena fatto uno script anch'io.

[LuisGis]

Grazie per tutti i vostri suggerimenti.
Lo scopo è di avere directory che abbiano, all’incirca la stessa durata.
Grazie

[vaeVictis]

Allora, io userei uno script del genere (per il momento stampa solo a video le info, come spiegato sotto. Poi se va bene si cambiano un paio di righe e fa lo spostamento)
Ci tengo a precisare che lo script divide i file, in ordine crescente di peso, dentro N directory, ognuna delle quali pesa 1/N del peso della cartella iniziale.
Non è proprio quello che avevi chiesto

Per far ciò ho pensato di spostare il primo file dentro la cartella01, il secondo file dentro la cartella02 e così via fino ad arrivare alla cartella20 per poi ripartire dalla cartella01.

ma è molto simile. Se non va bene, fallo presente e si pensa a sviluppare lo script secondo le tue esigenze.

Codice: Seleziona tutto

#! /bin/bash

usage() { echo "Usage:" 
          echo "$0 -d dirPath -n dirNum"
          echo "dirPath: path della directory da analizzare"
          echo "dirNum: numero di directory in cui suddividere"
          exit 1 
        }

dir_flag=0
subDirNum_flag=o
while getopts ":d:n:" arg; do
    case $arg in
        d)
        dirPath="$OPTARG"
        dir_flag=1
        if [[ ! -d "$dirPath" ]]; then
            echo "$dirPath: directory non esistente"
            usage
        fi
        ;;
        n)
        subDirNum="$OPTARG"
        subDirNum_flag=1
        if ! [[ $subDirNum =~ ^[0-9]+$ ]] ; then
            echo "$subDirNum: non è un numero intero positivo"
            usage
        fi
        ;;
        \? ) echo "Opzione sconosciuta: -$OPTARG" >&2; exit 1;;
        :  ) echo "Manca l'argomento per l'opzione -$OPTARG" >&2; exit 1;;
    esac
done

if [[ $dir_flag -eq 0 ]] || [[ $subDirNum_flag -eq 0 ]]; then
    echo "Mancano parametri obbligatori"
    usage
fi


totSize=$(du -d0 -b "$dirPath" | grep -o '^\S*')
sizePerDir=$(expr $totSize / $subDirNum)

echo "divido la cartella $dirPath, che pesa $totSize, in cartelle che pesano $sizePerDir"

dirSuffix=1
totalSizeMoved=0
find "$dirPath" -maxdepth 1 -type f -ls | sort -n -k7 | while read record; do
    fileSize=$(echo $record | cut -d' ' -f 7)
    filePath="$(echo $record | cut -d' ' -f 11-)"
    echo "sposto il file $filePath che pesa $fileSize nella directory $(printf "$dirPath/cartella%0${#subDirNum}d" $dirSuffix)"
    totalSizeMoved=$(expr $totalSizeMoved + $fileSize)
    echo "spostati in tutto $totalSizeMoved"
    if [[ $totalSizeMoved -gt $sizePerDir ]]; then
        totalSizeMoved=0
        dirSuffix=$(expr $dirSuffix + 1)
    fi
done

Ho chiamato lo script qui sul mio pc suddivisioneDirectory.sh

Si usa così:

Codice: Seleziona tutto

./suddivisioneDirectory.sh 
Mancano parametri obbligatori
Usage:
./suddivisioneDirectory.sh -d dirPath -n dirNum
dirPath: path della directory da analizzare
dirNum: numero di directory in cui suddividere

quindi si lancia con un comando del tipo:

Codice: Seleziona tutto

./suddivisioneDirectory.sh -d dirPath -n dirNum

In questo modo è più generico in quanto si può decidere di volta in volta la directory da "smembrare" e il numero di directory in cui smembrarla.
I file li trovi all'interno della cartella da smembrare, suddivisi in directory dal nome "cartella01" "cartella02" e così via. Da notare che il numero suffisso dopo cartella ha il corretto padding (se le cartelle sono meno di 10 avrà una sola cifra, altrimenti ci sarà il padding con 0).

Ciò detto, lo script è composto da:
1) una funzione che serve per stampare a video il modo di uso e uscire se vengono passati male i parametri.
2) un loop while con getopts per controllare i parametri passati
3) il loop vero e proprio per lo spostamento:

Codice: Seleziona tutto

dirSuffix=1
totalSizeMoved=0
find "$dirPath" -maxdepth 1 -type f -ls | sort -n -k7 | while read record; do
    fileSize=$(echo $record | cut -d' ' -f 7)
    filePath="$(echo $record | cut -d' ' -f 11-)"
    echo "sposto il file $filePath che pesa $fileSize nella directory $(printf "$dirPath/cartella%0${#subDirNum}d" $dirSuffix)"
    totalSizeMoved=$(expr $totalSizeMoved + $fileSize)
    echo "spostati in tutto $totalSizeMoved"
    if [[ $totalSizeMoved -gt $sizePerDir ]]; then
        totalSizeMoved=0
        dirSuffix=$(expr $dirSuffix + 1)
    fi
don

Mi sembra di facile comprensione, ma in caso chiedi pure.

Provalo, al momento stampa solo a video le informazioni su quello che poi farà una volta che (verificato che funzioni a dovere) vengono cambiati alcuni comandi come ti indicherò se tutto funziona.

Fai sapere

[UbuNuovo]

Poi lo guardo per bene, te hai fatto lo script con getopts, io ho fatto solo una prova al volo:
elenco_wav deriva dai miei file wav sparsi nel disco, non ne ho moltissimi.

Codice: Seleziona tutto

#!/bin/bash
# Descrizione: copia file wav ordinati per peso in 20 directory

elenco_wav=$(locate -i '*.wav')
while read f;do 
	du -b "$f"
done <<< "$elenco_wav" | sort -n > elenco_wav_ordinati.txt

peso_tot=$(awk '{b+=$1} END {print b}' < elenco_wav_ordinati.txt)
peso_dir=$(($peso_tot / 20))

peso=0
i=1
[ -d "$dir$i" ] || mkdir "dir$i"
while read r;do 
	f_temp=$(grep -Po '^\d+\s\K.+' <<< "$r")
	peso_temp=$(grep -Po '^\d+' <<< "$r")
	peso=$(( $peso + $peso_temp ))
	if [ $peso -le $peso_dir ]
		then 
			cp "$f_temp" "dir$i/"
		else
			((i++))
			peso=$peso_temp
			mkdir "dir$i"
			cp "$f_temp" "dir$i/"
	fi
done < elenco_wav_ordinati.txt

exit

Per quanto riguarda la durata, se i file sono realizzati con la stessa risoluzione sonora, peso e durata vanno di pari passo, visto che i file wav non sono compressi.
Altrimenti bisognerebbe ordinare per durata.

Ho visto che con du -b si ottiene un risultato più preciso rispetto al conteggio dei blocchi che si ottiene con ls

edit:
@vaeVictis ora l'ho guardato meglio, devi solo creare le directory e sostituire l'azione descritta con mv, l'hai fatto per provare soltanto ed avere un riscontro.
In questi casi io uso un semplice echo a precedere cp o mv; il tuo metodo è a prova di profano.
Io ho messo cp al posto di mv per provare lo script
Abbiamo usato strumenti diversi ma la logica degli script è la stessa.

[vaeVictis]

Ho visto che con du -b si ottiene un risultato più preciso rispetto al conteggio dei blocchi che si ottiene con ls

Codice: Seleziona tutto

$ du -d0 -b /media/vaevictis/MiniElements/File\ System\ Finale/Musica/SKA/The\ Specials/2000\ -\ Skinhead\ Girl/06\ -\ You\ Don\'t\ Know\ Like\ I\ Know.mp3 
3752524	/media/vaevictis/MiniElements/File System Finale/Musica/SKA/The Specials/2000 - Skinhead Girl/06 - You Don't Know Like I Know.mp3

Codice: Seleziona tutto

$ du -d0 -B1 /media/vaevictis/MiniElements/File\ System\ Finale/Musica/SKA/The\ Specials/2000\ -\ Skinhead\ Girl/06\ -\ You\ Don\'t\ Know\ Like\ I\ Know.mp3 
3756032	/media/vaevictis/MiniElements/File System Finale/Musica/SKA/The Specials/2000 - Skinhead Girl/06 - You Don't Know Like I Know.mp3

Codice: Seleziona tutto

$ find /media/vaevictis/MiniElements/File\ System\ Finale/Musica/SKA/The\ Specials/2000\ -\ Skinhead\ Girl/06\ -\ You\ Don\'t\ Know\ Like\ I\ Know.mp3 -ls
115212518   3668 -rwxr-xr-x   1 vaevictis vaevictis  3752524 feb 19  2005 /media/vaevictis/MiniElements/File\ System\ Finale/Musica/SKA/The\ Specials/2000\ -\ Skinhead\ Girl/06\ -\ You\ Don't\ Know\ Like\ I\ Know.mp3

du -b dà la stessa cifra di find con -ls
du -B1, è nello script perché mi sono sbagliato a non modificarlo, ora modifico lo script.

edit:
@vaeVictis ora l'ho guardato meglio, devi solo creare le directory e sostituire l'azione descritta con mv, l'hai fatto per provare soltanto ed avere un riscontro.
In questi casi io uso un semplice echo a precedere cp o mv; il tuo metodo è a prova di profano.
Io ho messo cp al posto di mv per provare lo script

Lo so come fai gli script, generalmente li leggo
Ho preferito stampare le operazioni in linguaggio umano per il momento

[UbuNuovo]

Giusto! Io al primo tentativo ho usato ls e mi creava 19 directory invece di 20, probabilmente perché ho moltissimi file piccolissimi e qualcuno di diversi mega.

edit:
Ho provato ad ordinare per durata ma a dividere nelle directory per peso; il risultato cambia radicalmente!

Codice: Seleziona tutto

#!/bin/bash
# Descrizione: copia file wav ordinati per peso in 20 directory

elenco_wav='elenco_wav.txt'

while read f;do 
	dur=$(exiftool "$f" | grep -Poi '^duration +: \K.*')
	p=$(du -b "$f")
	if grep -qP '^\d+:' <<< "$dur";
		then
			read h m s < <(awk -F":" '{print $1,$2,$3}' <<< "$dur")
			sec=$(( ($h *60*60) + ($m *60) + $s ))
			echo -e "$sec\t$p"
		else
			dur_pulita=$(grep -Po '^.+(?= )' <<< "$dur")
			echo -e "$dur_pulita\t$p"
	fi
done < "$elenco_wav" | sort -n > elenco_wav_ordinati_per_lunghezza.txt

peso_tot=$(awk '{b+=$2} END {print b}' < elenco_wav_ordinati_per_lunghezza.txt)
peso_dir=$(($peso_tot / 20))

peso=0
i=1
[ -d "$dir$i" ] || mkdir "dir$i"
while read r;do 
	f_temp=$(awk -F"\t" '{print $3}' <<< "$r")
	peso_temp=$(awk -F"\t" '{print $2}' <<< "$r")
	peso=$(( $peso + $peso_temp ))
	if [ $peso -le $peso_dir ]
		then 
			cp "$f_temp" "dir$i/"
		else
			((i++))
			peso=$peso_temp
			mkdir "dir$i"
			cp "$f_temp" "dir$i/"
	fi
done < elenco_wav_ordinati_per_lunghezza.txt

exit

Non va bene! Si deve calcolare la divisione per directory in base a durata_totale/numero_dir_volute.
Exiftool rallenta tantissimo l'elaborazione, ci vuole quasi un minuto per 740 file.
Domani non so se avrò tempo ma si deve trovare un altro strumento per ricavare la durata.


ri-edit:
@mikexu
sox è molto più veloce e non si devono fare conversioni, ha l'opzione per ottenere la durata in secondi:

Codice: Seleziona tutto

#!/bin/bash
# Descrizione: copia file wav ordinati per peso in 20 directory

elenco_wav='elenco_wav.txt'

while read f;do 
	dur=$(sox --info -D "$f")
	p=$(du -b "$f")
	echo -e "$dur\t$p"
done < "$elenco_wav" | sort -n > elenco_wav_ordinati_per_lunghezza.txt

peso_tot=$(awk '{b+=$2} END {print b}' < elenco_wav_ordinati_per_lunghezza.txt)
peso_dir=$(($peso_tot / 20))

peso=0
i=1
[ -d "$dir$i" ] || mkdir "dir$i"
while read r;do 
	f_temp=$(awk -F"\t" '{print $3}' <<< "$r")
	peso_temp=$(awk -F"\t" '{print $2}' <<< "$r")
	peso=$(( $peso + $peso_temp ))
	if [ $peso -le $peso_dir ]
		then 
			cp "$f_temp" "dir$i/"
		else
			((i++))
			peso=$peso_temp
			mkdir "dir$i"
			cp "$f_temp" "dir$i/"
	fi
done < elenco_wav_ordinati_per_lunghezza.txt

exit

Questo è molto più veloce, però va fatta una versione che spartisce nelle directory in base alla durata, questo ordina per durata ma spartisce in base al peso.

[UbuNuovo]

In teoria forse dovrebbe funzionare una cosa del genere:

Codice: Seleziona tutto

#!/bin/bash
# Descrizione: copia file wav ordinati per peso in 20 directory

elenco_wav='elenco_wav.txt'
function calc(){ awk "BEGIN{ print $* }";}

while read f;do 
	echo -e "$(sox --info -D "$f")\t$f"
done < "$elenco_wav" | sort -n > elenco_wav_ordinati_per_lunghezza.txt

durata_tot=$(awk '{b+=$1} END {print b}' < elenco_wav_ordinati_per_lunghezza.txt)
durata_dir=$(calc "$durata_tot / 20")

# echo $durata_tot
# echo $durata_dir

durata=0
i=1
[ -d "$dir$i" ] || mkdir "dir$i"
while read r;do 
	f_temp=$(awk -F"\t" '{print $2}' <<< "$r")
	durata_temp=$(awk -F"\t" '{print $1}' <<< "$r")
	durata=$(calc "$durata + $durata_temp" )
	if (( $(echo "$durata <= $durata_tot" |bc -l) ))
		then 
			cp "$f_temp" "dir$i/"
		else
			((i++))
			durata=$durata_temp
			mkdir "dir$i"
			cp "$f_temp" "dir$i/"
	fi
done < elenco_wav_ordinati_per_lunghezza.txt

exit

Ma in pratica a me non crea 20 directory ma due, una con tutti i file cortissimi ed uno con un file lunghissimo.
Forse con tantissimi file funge oppure c'è qualche errore.

edit
Alla fine se i wav fossero canzoni converrebbe usare un semplice:

Codice: Seleziona tutto

#!/bin/bash

dir_origine='musica_wav'
nome_dir='./dir_wav'
n_directory=20

ordinati=$(while read f;do 
	echo -e "$(sox --info -D "$f")\t$f"
done < <(find "$dir_origine" -type f -iname '*.wav') | sort -n )

i=1
[ -d "$nome_dir$i" ] || mkdir -p "$nome_dir$i"
while read r;do
	if [ $i -gt $n_directory ]; then i=1;fi
	f_temp=$(awk -F"\t" '{print $2}' <<< "$r")
	[ -d "$nome_dir$i" ] || mkdir -p "$nome_dir$i"
	cp "$f_temp" "$nome_dir$i"
	((i++))
done <<< "$ordinati"

exit

[vaeVictis]

Ma aspettare che intervenga l'autore della discussione invece di riempire di mille varianti che forse manco servono?

[UbuNuovo]

L'ho appena scritto sopra, mi ero fissato con l'ordinamento, ma alla fine se interessano durate simili andava bene il metodo di LuisGis

[LuisGis]

edit
Alla fine se i wav fossero canzoni converrebbe usare un semplice:

Codice: Seleziona tutto

#!/bin/bash

dir_origine='musica_wav'
nome_dir='./dir_wav'
n_directory=20

ordinati=$(while read f;do 
	echo -e "$(sox --info -D "$f")\t$f"
done < <(find "$dir_origine" -type f -iname '*.wav') | sort -n )

i=1
[ -d "$nome_dir$i" ] || mkdir -p "$nome_dir$i"
while read r;do
	if [ $i -gt $n_directory ]; then i=1;fi
	f_temp=$(awk -F"\t" '{print $2}' <<< "$r")
	[ -d "$nome_dir$i" ] || mkdir -p "$nome_dir$i"
	cp "$f_temp" "$nome_dir$i"
	((i++))
done <<< "$ordinati"

exit

Dato che i files .wav sono canzoni ho provato questo script.

Preciso che
Ho la directory musica con lo script .sh
dentro la directory musica ho la directory musica_wav che contiene tuti files .wav

lanciando lo script vengono create 20 directory vuote
dir_waw1
dir_wav2
Ecc.

e lo script da il seguente errore:
./prova.sh: riga 10: sox: comando non trovato
./prova.sh: riga 10: sox: comando non trovato
./prova.sh: riga 10: sox: comando non trovato
ripetuto molte volte
e
cp: impossibile eseguire stat di '': File o directory non esistente
cp: impossibile eseguire stat di '': File o directory non esistente
cp: impossibile eseguire stat di '': File o directory non esistente
anch'esso ripetuto molte volte .

[UbuNuovo]

Devi installare sox