I want to rename my files so that they are name with the same name as the folder.
I have a main folder that has around 1000 folders. each of these folders have another file within it. in that very last folder, I have files with different extentions. and I want to rename the files that have pdb extention.
here's the strcuture of my folders :
pv----|
|--m10\ pk\ result0.pdb result1.pdb result2.pdb
|--m20\ pk\ result0.pdb result1.pdb result2.pdb
|--m30\ pk\ result0.pdb result1.pdb result2.pdb
I want something like this :
pv----|
|--m10\ pk\ m10_result0.pdb m10_result1.pdb m10_result2.pdb
|--m20\ pk\ m20_result0.pdb m20_result1.pdb m20_result2.pdb
|--m30\ pk\ m30_result0.pdb m30_result1.pdb m30_result2.pdb
that's the code I made but It's not working ..
for d in MD_PR2 / * / * /
do
(cd "$d" && for file in *.pdb ; do mv "$file" "${file/result/$d_result}" ; done)
done
my code is deleting "result" of each file's name and I don't know. it becomes 0.pdb , 1.pdb ..etc
thank you very much
Before:
user#pc:~$ tree
.
├── m10
│ └── pk
│ ├── result0.pdb
│ ├── result1.pdb
│ └── result2.pdb
├── m20
│ └── pk
│ ├── result0.pdb
│ ├── result1.pdb
│ └── result2.pdb
└── m30
└── pk
├── result0.pdb
├── result1.pdb
└── result2.pdb
Your code is not working because $d_result is being interpreted as a variable name, not as a concatenation of $d and _result. I suggest using ${d}_result.
However I would suggest another approach, one that doesn't need to cd into each directory.
Code:
shopt -s globstar
for file in **; do
if [[ "$file" =~ ".pdb" ]] ; then
mv "$file" `echo $file | sed -e 's/\(.*\)\/\(.*\)\/\(.*.pdb\)/\1\/\2\/\1_\2_\3/'`;
fi;
done;
After:
user#pc:~$ tree
.
├── m10
│ └── pk
│ ├── m10_pk_result0.pdb
│ ├── m10_pk_result1.pdb
│ └── m10_pk_result2.pdb
├── m20
│ └── pk
│ ├── m20_pk_result0.pdb
│ ├── m20_pk_result1.pdb
│ └── m20_pk_result2.pdb
└── m30
└── pk
├── m30_pk_result0.pdb
├── m30_pk_result1.pdb
└── m30_pk_result2.pdb
Code explanation:
shopt -s globstar: Allow for ** to be expanded into "all files and directories recursively"
Variable "file" contains filenames including directories
Check "file" against "$file" =~ ".pdb" to ignore working with directories
Generate newfilename with sed:
Search and replace: s/search/replace/
Find something like dir1/dir2/smthg.pdb: (.*)/(.*)/(.*.pdb)
Replace with dir1/dir2/dir1_dir2_smthg.pdb: \1/\2/\1_\2_\3 (replace with \1_\2_\3 if you also want to move renamed files into parent dir)
(I removed some backslashes for readability)
mv file to newfilename
Related
I have this folder-strucutre, with really heavy high-quality images in each subfolder
tree -d ./
Output:
./
├── 1_2dia-pedro
├── 3dia-pedro
│ ├── 101MSDCF
│ └── 102MSDCF
├── 4dia-pedro
└── Wagner
├── 410_0601
├── 411_0701
├── 412_0801
├── 413_2101
├── 414_2801
├── 415_0802
├── 416_0902
├── 417_1502
├── 418_1602
├── 419_1702
├── 420_2502
└── 421_0103
18 directories
And, I want to compress it, just like I would do with ffmpeg, or imagemagick.
e.g.,
ffmpeg -i %%F -q:v 10 processed/%%F"
mogrify -quality 3 $F.png
I'm currently think of creating a vector of the directories, using shopt, as discussed here
shopt -s globstar dotglob nullglob
printf '%q\n' **/*/
Then, create a new folder-compressed, with the same structure
mkdir folder-compressed
<<iterate the array-vector-out-of-shopt>>
Finally, compress, for each subfolder, something in the lines of
mkdir processed
for f in *.jpg;
do ffmpeg -i "$f" -q:v 1 processed/"${f%.jpg}.jpg";
done
Also, I read this question, and this procedure seems close to what I would like,
for f in mydir/**/*
do
# operations here
done
Major problem: I'm bash newbie. I know all tools needed are at my disposal!
EDIT: There is a program that, for the particular purpose of compressing images with lossless quality, gives us a a-liner, and a lot of options to this compression. The caveat: make another copy of the original folder-structure-files, because it will change them permanently in the folder-structure-files you give it.
cp -r ./<folder-structure-files> ./<folder-structure-files-copy>
image_optim -r ./<folder-structure-files-copy>
I think #m0hithreddy solution is pretty cool, though. Certainly, I will be using that logic elsewhere anytime soon.
Instead of pre-mkdiring directories, you can create the required directories on the fly. Recursion solutions look elegant to me then compared to loops. Here is a straight-forward approach. I echoed the file names and directories to keep track of whats going on. I am not ffmpeg pro, I used cp instead but should work fine for your use case.
Shell script:
source=original/
destination=compressed/
f1() {
mkdir -p ${destination}${1}
for file in `ls ${source}${1}*.jpg 2>/dev/null`
do
echo 'Original Path:' ${file}
echo 'Compressed Path:' ${destination}${1}$(basename $file) '\n'
cp ${file} ${destination}${1}$(basename $file)
done
for dir in `ls -d ${source}${1}*/ 2>/dev/null`
do
echo 'Enter sub-directory:' ${dir} '\n'
f1 ${dir#*/}
done
}
f1 ''
Terminal Session:
$ ls
original script.sh
$ tree original/
original/
├── f1
│ ├── f16
│ │ └── f12.jpg
│ ├── f5
│ │ └── t4.jpg
│ └── t3.txt
├── f2
│ └── t5.txt
├── f3
├── f4
│ └── f10
│ ├── f2
│ │ └── f6.jpg
│ └── f3.jpg
├── t1.jpg
└── t2.txt
8 directories, 8 files
$ sh script.sh
Original Path: original/t1.jpg
Compressed Path: compressed/t1.jpg
Enter sub-directory: original/f1/
Enter sub-directory: original/f1/f16/
Original Path: original/f1/f16/f12.jpg
Compressed Path: compressed/f1/f16/f12.jpg
Enter sub-directory: original/f1/f5/
Original Path: original/f1/f5/t4.jpg
Compressed Path: compressed/f1/f5/t4.jpg
Enter sub-directory: original/f2/
Enter sub-directory: original/f3/
Enter sub-directory: original/f4/
Enter sub-directory: original/f4/f10/
Original Path: original/f4/f10/f3.jpg
Compressed Path: compressed/f4/f10/f3.jpg
Enter sub-directory: original/f4/f10/f2/
Original Path: original/f4/f10/f2/f6.jpg
Compressed Path: compressed/f4/f10/f2/f6.jpg
$ tree compressed/
compressed/
├── f1
│ ├── f16
│ │ └── f12.jpg
│ └── f5
│ └── t4.jpg
├── f2
├── f3
├── f4
│ └── f10
│ ├── f2
│ │ └── f6.jpg
│ └── f3.jpg
└── t1.jpg
8 directories, 5 files
I am trying to do an iterative renaming of certain files in all directories.
homefolder/folder1/ouput/XXXXX_ab.png
homefolder/folder1/ouput/XXXXX_abcdefg.png
homefolder/folder2/ouput/XXXXX_ab.png
homefolder/folder2/ouput/XXXXX_abcdefg.png
homefolder/folder3/ouput/XXXXX_ab.png
homefolder/folder3/ouput/XXXXX_abcdefg.png
...
homefolder/folder500/ouput/XXXXX_ab.png
homefolder/folder500/ouput/XXXXX_abcdefg.png
I want to get the folder name (ex. folder1, folder2, ... folder500) and pass it to the two png files as a prefix and remove those five Xs at the beginning of each file.
The pattern of those png files are:
XXXXX_ab.png
XXXXX_abcdrfg.png
so only the first five characters are different in each subdirectory, which will be replaced by the name of its parent directory, those folder names.
the results will be:
homefolder/folder1/ouput/folder1_ab.png
homefolder/folder1/ouput/folder1_abcdefg.png
homefolder/folder2/ouput/folder2_ab.png
homefolder/folder2/ouput/folder2_abcdefg.png
homefolder/folder3/ouput/folder3_ab.png
homefolder/folder3/ouput/folder3_abcdefg.png
...
homefolder/folder500/ouput/folder500_ab.png
homefolder/folder500/ouput/folder500_abcdefg.png
at the end of renaming, create a copy of these two newly renamed files inside another folder in the homefolder, for example all_png_folder.
find . -iname "*_ab.png" -exec rename _ab.png folder1_ab.png '{}' \;
find . -name "*_ab.png" -exec cp {} ./all_png_folder \;
Here is a start, the copying at the end should be a trivial addition.
#!/usr/bin/env bash
files=$(find . -type f -name "*_ab.png" -or -name "*_abcdefg.png")
for file in $files; do
foldername=$(cut -d '/' -f 2 <<< $file)
# The name of the png-file minus the leading xxxxxx
pngfile=$(basename "$file" | cut -d '_' -f 2)
destinationdir=$(dirname "$file")
mv $file "$destinationdir/$foldername"'_'"$pngfile"
done
Demo
$ tree
.
├── folder1
│ └── ouput
│ ├── foo_bar.png
│ ├── xxxxx_abcdefg.png
│ └── xxxxx_ab.png
├── folder2
│ └── ouput
│ ├── xxxxx_abcdefg.png
│ └── xxxxx_ab.png
└── rename.sh
4 directories, 6 files
$ ./rename.sh
$ tree
.
├── folder1
│ └── ouput
│ ├── folder1_abcdefg.png
│ ├── folder1_ab.png
│ └── foo_bar.png
├── folder2
│ └── ouput
│ ├── folder2_abcdefg.png
│ └── folder2_ab.png
└── rename.sh
I need to batch rename multiple images and want to use the parent directory as base name. To prevent one overwriting the other, a suffix must be added. The order of the renaming process musts follow the timestamp of the file. Because the 'first' file is a featured image for the site I'm using it for.
Tree:
└── main
├── white tshirt
│ ├── IMG_1.jpg
│ ├── IMG_2.jpg
│ ├── IMG_3.jpg
│ └── IMG_4.jpg
├── black tshirt
│ ├── IMG_1.jpg
│ ├── IMG_2.jpg
│ ├── IMG_3.jpg
│ └── IMG_4.jpg
└── red tshirt
├── IMG_1.jpg
├── IMG_2.jpg
├── IMG_3.jpg
└── IMG_4.jpg
Goal:
└── main
├── white tshirt
│ ├── white-tshirt-1.jpg
│ ├── white-tshirt-2.jpg
│ ├── white-tshirt-3.jpg
│ └── white-tshirt-4.jpg
├── black tshirt
│ ├── black-tshirt-1.jpg
│ ├── black-thisrt-2.jpg
│ ├── black-tshirt-3.jpg
│ └── black-tshirt-4.jpg
└── red tshirt
├── red-tshirt-1.jpg
├── red-tshirt-2.jpg
├── red-tshirt-3.jpg
└── red-tshirt-4.jpg
Replacing spaces with dashes is not required, but preferred. Platform: Debian 8
I think this should do the job:
#!/bin/sh
for dir in *; do
if [ ! -d "$dir" ]; then
continue
fi
cd "$dir"
pref=$(echo "$dir" | tr ' ' -)
i=1
ls -tr | while read f; do
ext=$(echo "$f" | sed 's/.*\.//')
mv "$f" "${pref}-${i}.$ext"
i=$(expr $i + 1)
done
cd ..
done
Invoke the script inside your main directory and make sure there are only your target folders in it. Also make sure your files'names do not contain the character '\'
I have a collection of 271,568 files I need to sort, all in the same directory. Luckily, they are all conveniently named based on what folder they should be in.
For example, a small portion of the files might look like:
.
├── file.sort.shamwow
├── file.sort.shamwow.abc
├── file.sort.shamwow.example.alsoafile
├── file.sort.shamwow.example.file
├── foo.bar
├── foo.bar.a
├── foo.bar.b
├── foo.lel
├── foo.wow.a.50
└── foo.wow.b
When they are finished being sorted, they should look like:
.
├── file
│ └── sort
│ └── shamwow
│ ├── example
│ │ ├── file.sort.shamwow.example.alsoafile
│ │ └── file.sort.shamwow.example.file
│ ├── file.sort.shamwow
│ └── file.sort.shamwow.abc
└── foo
├── bar
│ ├── foo.bar
│ ├── foo.bar.a
│ └── foo.bar.b
├── foo.lel
└── wow
├── foo.wow.a.50
└── foo.wow.b
So that file foo.wow.a.50 would be placed inside of directory wow that is inside of directory foo, and so on for all the files.
The program I want would sort the files based on where the dots are into directories. However, if there is only one file in that folder (ex. foo/wow/a.50) then it won't create a new folder just for that file.
Right now, my half-functional script looks like:
#!/bin/bash
#organization for gigantic folder
> foo.txt
for f in *; do
d=${f:3}
d=${d%%.*}
d=${d%%.*}
echo $d
if grep -Fxq "$d" foo.txt
then
mkdir -p $d
mv $f $d
else
echo $d >> foo.txt
fi
done
rm foo.txt
But it doesn't really work that well.
Can someone either fix my code, or make their own to sort this mess? Thanks!
Ignoring that your requested output is impossible to represent on a filesystem (requires the same names to refer to both a file and a directory):
#!/bin/bash
# ^^^^- must be bash shebang, must be shell 4.0 or newer
# first pass: count directory references
declare -A refcounts=( )
for f in *; do
f_part=$f
while [[ $f_part = *.* ]]; do
refcounts[$f_part]=$(( ${refcounts[$f_part]} + 1 ))
f_part=${f_part%.*}
done
refcounts[$f_part]=$(( ${refcounts[$f_part]} + 1 ))
done
# second pass: use that information
# ...this is some ugly code, but I don't have the time right now to make it simpler.
for f in *; do
f_part=${f%%.*}
f_rest=${f#*.}
while : "f=$f; f_part=$f_part; f_rest=$f_rest"; do
new_piece=${f_rest%%.*}
[[ $new_piece ]] || break
f_part_next=${f_part}.$new_piece
f_rest_next=${f_rest#"$new_piece"}; f_rest_next=${f_rest_next#.}
if [[ $f_rest = *.* ]] && (( ${refcounts[${f_part_next}]:-0} > 1 )); then
f_part=$f_part_next
f_rest=$f_rest_next
else
break
fi
done
dest="${f_part//"."/"/"}/${f_rest}"
mkdir -p -- "${dest%/*}"
mv -- "$f" "$dest"
done
I've inherited a structure like the below, a result of years of spaghetti code...
gallery
├── 1
│ ├── deleteme1
│ ├── deleteme2
│ ├── deleteme3
│ └── full
│ ├── file1
│ ├── file2
│ └── file3
├── 2
│ ├── deleteme1
│ ├── deleteme2
│ ├── deleteme3
│ └── full
│ ├── file1
│ ├── file2
│ └── file3
└── 3
├── deleteme1
├── deleteme2
├── deleteme3
└── full
├── file1
├── file2
└── file3
In reality, this folder is thousands of subfolders large. I only need to keep ./gallery/{number}/full/* (i.e. the full folder and all files within, from each numbered directory within gallery), with everything else no longer required and needs to be deleted.
Is it possible to construct a one-liner to handle this? I've experimented with find/maxdepth/prune could not find an arragement which met my needs.
(Update: To clarify, all folders contain files - none are empty)
Using PaddyD answer you can first clean unwanted directories and then delete them:
find . -type f -not -path "./gallery/*/full/*" -exec rm {} + && find . -type d -empty -delete
This can easily be done with bash extglobs, which allow matching all files that don't match a pattern:
shopt -s extglob
rm -ri ./gallery/*/!(full)
How about:
find . -type d -empty -delete