user/bkfeh

   1 #!/usr/bin/env bash
   2 # Desc: Wrapper for feh that accepts directory paths via posargs or stdin lines.
   3 # Version: 0.3.4
   4 # Ref/Attrib: [1] Tange, Ole. GNU Parallel with Bash Array. 2019-03-24. https://unix.stackexchange.com/a/508365/411854
   5 # Depends: GNU Parallel, GNU Bash v5.1.16, feh 3.6.3, GNU Coreutils 9.4 (b2sum, cp)
   6
   7 #===Declare local functions===
   8 yell() { echo "$0: $*" >&2; } # print script path and all args to stderr
   9 die() { yell "$*"; exit 111; } # same as yell() but non-zero exit status
  10 must() { "$@" || die "cannot $*"; } # runs args as command, reports args if command fails
  11 checkapp() {
  12     # Desc: If arg is a command, save result in assoc array 'appRollCall'
  13     # Usage: checkapp arg1 arg2 arg3 ...
  14     # Version: 0.1.1
  15     # Input: global assoc. array 'appRollCall'
  16     # Output: adds/updates key(value) to global assoc array 'appRollCall'
  17     # Depends: bash 5.0.3
  18     local returnState
  19
  20     #===Process Args===
  21     for arg in "$@"; do
  22         if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
  23             appRollCall[$arg]="true";
  24             if ! [ "$returnState" = "false" ]; then returnState="true"; fi;
  25         else
  26             appRollCall[$arg]="false"; returnState="false";
  27         fi;
  28     done;
  29
  30     #===Determine function return code===
  31     if [ "$returnState" = "true" ]; then
  32         return 0;
  33     else
  34         return 1;
  35     fi;
  36 } # Check that app exists
  37 checkfile() {
  38     # Desc: If arg is a file path, save result in assoc array 'fileRollCall'
  39     # Usage: checkfile arg1 arg2 arg3 ...
  40     # Version: 0.1.1
  41     # Input: global assoc. array 'fileRollCall'
  42     # Output: adds/updates key(value) to global assoc array 'fileRollCall';
  43     # Output: returns 0 if app found, 1 otherwise
  44     # Depends: bash 5.0.3
  45     local returnState
  46
  47     #===Process Args===
  48     for arg in "$@"; do
  49         if [ -f "$arg" ]; then
  50             fileRollCall["$arg"]="true";
  51             if ! [ "$returnState" = "false" ]; then returnState="true"; fi;
  52         else
  53             fileRollCall["$arg"]="false"; returnState="false";
  54         fi;
  55     done;
  56
  57     #===Determine function return code===
  58     if [ "$returnState" = "true" ]; then
  59         return 0;
  60     else
  61         return 1;
  62     fi;
  63 } # Check that file exists
  64 checkdir() {
  65     # Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
  66     # Usage: checkdir arg1 arg2 arg3 ...
  67     # Version 0.1.1
  68     # Input: global assoc. array 'dirRollCall'
  69     # Output: adds/updates key(value) to global assoc array 'dirRollCall';
  70     # Output: returns 0 if app found, 1 otherwise
  71     # Depends: Bash 5.0.3
  72     local returnState
  73
  74     #===Process Args===
  75     for arg in "$@"; do
  76         if [ -d "$arg" ]; then
  77             dirRollCall["$arg"]="true";
  78             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
  79         else
  80             dirRollCall["$arg"]="false"; returnState="false";
  81         fi
  82     done
  83
  84     #===Determine function return code===
  85     if [ "$returnState" = "true" ]; then
  86         return 0;
  87     else
  88         return 1;
  89     fi
  90 } # Check that dir exists
  91 displayMissing() {
  92     # Desc: Displays missing apps, files, and dirs
  93     # Usage: displayMissing
  94     # Version 0.1.1
  95     # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
  96     # Output: stderr: messages indicating missing apps, file, or dirs
  97     # Depends: bash 5, checkAppFileDir()
  98     local missingApps value appMissing missingFiles fileMissing
  99     local missingDirs dirMissing
 100
 101     #==BEGIN Display errors==
 102     #===BEGIN Display Missing Apps===
 103     missingApps="Missing apps  :";
 104     #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
 105     for key in "${!appRollCall[@]}"; do
 106         value="${appRollCall[$key]}";
 107         if [ "$value" = "false" ]; then
 108             #echo "DEBUG:Missing apps: $key => $value";
 109             missingApps="$missingApps""$key ";
 110             appMissing="true";
 111         fi;
 112     done;
 113     if [ "$appMissing" = "true" ]; then  # Only indicate if an app is missing.
 114         echo "$missingApps" 1>&2;
 115     fi;
 116     unset value;
 117     #===END Display Missing Apps===
 118
 119     #===BEGIN Display Missing Files===
 120     missingFiles="Missing files:";
 121     #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
 122     for key in "${!fileRollCall[@]}"; do
 123         value="${fileRollCall[$key]}";
 124         if [ "$value" = "false" ]; then
 125             #echo "DEBUG:Missing files: $key => $value";
 126             missingFiles="$missingFiles""$key ";
 127             fileMissing="true";
 128         fi;
 129     done;
 130     if [ "$fileMissing" = "true" ]; then  # Only indicate if an app is missing.
 131         echo "$missingFiles" 1>&2;
 132     fi;
 133     unset value;
 134     #===END Display Missing Files===
 135
 136     #===BEGIN Display Missing Directories===
 137     missingDirs="Missing dirs:";
 138     #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
 139     for key in "${!dirRollCall[@]}"; do
 140         value="${dirRollCall[$key]}";
 141         if [ "$value" = "false" ]; then
 142             #echo "DEBUG:Missing dirs: $key => $value";
 143             missingDirs="$missingDirs""$key ";
 144             dirMissing="true";
 145         fi;
 146     done;
 147     if [ "$dirMissing" = "true" ]; then  # Only indicate if an dir is missing.
 148         echo "$missingDirs" 1>&2;
 149     fi;
 150     unset value;
 151     #===END Display Missing Directories===
 152
 153     #==END Display errors==
 154 } # Display missing apps, files, dirs
 155 check_depends() {
 156     if ! checkapp feh parallel bkshuf b2sum; then
 157         displayMissing;
 158         die "FATAL:Missing apps.";
 159     fi;
 160     return 0;
 161 }; # check dependencies
 162 checkInt() {
 163     # Desc: Checks if arg is integer
 164     # Usage: checkInt arg
 165     # Input: arg: integer
 166     # Output: - return code 0 (if arg is integer)
 167     #         - return code 1 (if arg is not integer)
 168     # Example: if ! checkInt $arg; then echo "not int"; fi;
 169     # Version: 0.0.1
 170     local returnState
 171
 172     #===Process Arg===
 173     if [[ $# -ne 1 ]]; then
 174         die "ERROR:Invalid number of arguments:$#";
 175     fi;
 176
 177     RETEST1='^[0-9]+$'; # Regular Expression to test
 178     if [[ ! $1 =~ $RETEST1 ]] ; then
 179         returnState="false";
 180     else
 181         returnState="true";
 182     fi;
 183
 184     #===Determine function return code===
 185     if [ "$returnState" = "true" ]; then
 186         return 0;
 187     else
 188         return 1;
 189     fi;
 190 } # Checks if arg is integer
 191 read_stdin() {
 192     # Desc: Consumes stdin; outputs as stdout lines
 193     # Input: stdin (consumes)
 194     # Output: stdout (newline delimited)
 195     # Example: printf "foo\nbar\n" | read_stdin
 196     # Depends: GNU bash (version 5.1.16)
 197     # Version: 0.0.1
 198     local input_stdin output;
 199
 200     # Store stdin
 201     if [[ -p /dev/stdin ]]; then
 202         input_stdin="$(cat -)";
 203     fi;
 204
 205     # Store as output array elements
 206     ## Read in stdin
 207     if [[ -n $input_stdin ]]; then
 208         while read -r line; do
 209             output+=("$line");
 210         done < <(printf "%s\n" "$input_stdin");
 211     fi;
 212
 213     # Print to stdout
 214     printf "%s\n" "${output[@]}";
 215 }; # read stdin to stdout lines
 216 read_psarg() {
 217     # Desc: Reads arguments; outputs as stdout lines
 218     # Input: args
 219     # Output: stdout (newline delimited)
 220     # Example: read_psarg "$@"
 221     # Depends: GNU bash (version 5.1.16)
 222     # Version: 0.0.1
 223     local input_psarg output;
 224
 225     # Store arguments
 226     if [[ $# -gt 0 ]]; then
 227         input_psarg="$*";
 228     fi;
 229
 230     # Store as output array elements
 231     ## Read in positional arguments
 232     if [[ -n $input_psarg ]]; then
 233         for arg in "$@"; do
 234             output+=("$arg");
 235         done;
 236     fi;
 237
 238     # Print to stdout
 239     printf "%s\n" "${output[@]}";
 240 }; # read positional argument to stdout lines
 241 find_flist() {
 242     # Desc: print file list to stdout via `find` using script parameters
 243     # Input: arg1: path to dir
 244     #        var: find_depth
 245     #        var: pattern_find_iregex
 246     #        var: find_size
 247     if [[ ! -d "$1" ]]; then return 1; fi;
 248     must find "$1" -maxdepth "$fdepth" -type f -iregex "$firegex" -size +"$fsize";
 249 }; # print file list to stdout from dir with script parameters
 250 save_sample() {
 251     # Usage: save_sample arg1
 252     # Input: arg1   list_paths        (list of files to take samples from)
 253     #        envvar BKFEH_SAMPLE_DIR  (environment variable set outside of this script)
 254     #        envvar BKFEH_SAMPLE_SIZE (space limit for sample dir files)
 255     # Depends: GNU Parallel, GNU find, GNU Coreutils 8.32 (cut, find, du)
 256     #   BK-2020-03: bkshuf (0.0.1), yell()
 257     local list_paths
 258     sample_count="100"; # max number of images to put in sample dir
 259     sample_max_space="10000000"; # max bytes to put in sample dir
 260     n_fail_max="10"; # max failures to save sample file (e.g. due to space limits)
 261
 262     # Load environment variables if set
 263     if [[ ! -v BKFEH_SAMPLE_DIR ]]; then return 0; fi; # return early if environment var not set.
 264     if [[ -v BKFEH_SAMPLE_SIZE ]] && checkInt "$BKFEH_SAMPLE_SIZE"; then
 265         sample_max_space="$BKFEH_SAMPLE_SIZE";
 266     fi;
 267     if [[ -v BKFEH_SAMPLE_COUNT ]] && checkInt "$BKFEH_SAMPLE_COUNT"; then
 268         sample_count="$BKFEH_SAMPLE_COUNT";
 269     fi;
 270
 271     if [[ -n "$1" ]]; then
 272         list_paths="$1"; # newline-delimited list of file paths to sample from
 273     else
 274         yell "ERROR:NO paths available to sample.";
 275     fi;
 276
 277     if [[ -d "$BKFEH_SAMPLE_DIR" ]]; then
 278         #sample_dir="$BKFEH_SAMPLE_DIR";
 279         yell "STATUS:Environment variable BKFEH_SAMPLE_DIR set. Clearing and saving samples...";
 280
 281         ## clear previous sample
 282         count_prev_samples="$(find "$BKFEH_SAMPLE_DIR" -maxdepth 1 -type f | wc -l)";
 283         yell "STATUS:Deleting $count_prev_samples previous samples...";
 284         find "$BKFEH_SAMPLE_DIR" -maxdepth 1 -type f -exec rm '{}' \; ;
 285
 286         ## save random sample
 287         yell "STATUS:Saving random sample of size $sample_count to $BKFEH_SAMPLE_DIR...";
 288         list_paths_sample="$(echo "$list_paths" | bkshuf "$sample_count" | head -n"$sample_count")";
 289         n_samp=0; # init sample file counter
 290         n_fail=0; # init failure counter
 291         sample_log="$BKFEH_SAMPLE_DIR"/paths.txt;
 292         printf "%s,%s,%s\n" "n_samp" "file_hash" "file_path" >> "$sample_log";
 293         while read -r line && [[ "$n_fail" -le "$n_fail_max" ]]; do
 294             if [[ -z "$line" ]]; then continue; fi;
 295             ### check size limit
 296             sample_act_space="$(du -bd1 "$BKFEH_SAMPLE_DIR" | cut -f1 )"; # actual used space
 297             cand_space="$(du -bd1 "$line" | cut -f1 )"; # size of candidate file to add
 298             sample_req_space="$((sample_act_space + cand_space))";
 299             if [[ ! "$sample_req_space" -lt "$sample_max_space" ]]; then ((n_fail++)); continue; fi;
 300
 301             ### Customize file names
 302             n_samp_w="$(printf "%s" "$sample_count" | wc -c)";
 303             n_samp_fmt="%0""$n_samp_w""d";
 304             n_samp_dd="$(printf "$n_samp_fmt" "$n_samp")"; # sample number fixed-width
 305             file_path="$line";
 306             #file_dir="$(dirname "$line")";
 307             file_name="$(basename "$line")";
 308             file_hash="$(b2sum -l32 "$line" | awk '{print $1}')"; # use file hash to avoid clobbering
 309             file_ext="${file_name##*.}";
 310             file_name="${file_name%.*}";
 311             file_shortname="${file_name:0:32}";
 312             file_name_new="$n_samp_dd"_"$file_hash".."$file_shortname"."$file_ext";
 313             file_path_new="$BKFEH_SAMPLE_DIR"/"$file_name_new";
 314             if [[ "$sample_req_space" -lt "$sample_max_space" ]]; then
 315                 #### add file to sample dir
 316                 must cp --update=none "$file_path" "$file_path_new";
 317                 #### note path in sample dir log
 318                 printf "%s,%s,%s\n" "$n_samp_dd" "$file_hash" "$file_path" \
 319                        >> "$sample_log";
 320             fi;
 321             ((n_samp++));
 322         done < <( echo "$list_paths_sample" );
 323     else
 324         yell "ERROR:Does not exist: $BKFEH_SAMPLE_DIR";
 325     fi;
 326 }; # save sample of files
 327
 328 main() {
 329     # Depends: read_stdin_psarg() v0.0.1, check_depends()
 330     local re_dotfile;
 331     declare -a dirs_stdin dirs_psarg;
 332     declare -a paths_images;
 333     declare list_paths_images;
 334     check_depends;
 335
 336     #Populate dirs_stdin and dirs_psarg arrays
 337     ## Read stdin as lines
 338     re_dotfile="^\."; # first char is a dot
 339     while read -r line; do
 340         line="$(readlink -e "$line")";
 341         # Check if dir
 342         if [[ ! -d "$line" ]]; then
 343             echo "ERROR:Not a dir:$line" 1>&2;
 344             continue;
 345         fi;
 346         dir_name="$(basename "$line")";
 347         # Exclude dotdirs
 348         if [[ "$dir_name" =~ $re_dotfile ]]; then
 349             echo "ERROR:Is a dotdir:$line" 1>&2;
 350             continue
 351         fi;
 352         dirs_stdin+=("$line");
 353     done < <(read_stdin);
 354     ## Read positional arguments as lines
 355     re_dotfile="^\."; # first char is a dot
 356     while read -r line; do
 357         line="$(readlink -e "$line")";
 358         # Check if dir
 359         if [[ ! -d "$line" ]]; then
 360             echo "ERROR:Not a dir:$line" 1>&2;
 361             continue;
 362         fi;
 363         dir_name="$(basename "$line")";
 364         # Exclude dotdirs
 365         if [[ "$dir_name" =~ $re_dotfile ]]; then
 366             echo "ERROR:Is a dotdir:$line" 1>&2;
 367             continue
 368         fi;
 369         dirs_psarg+=("$line");
 370     done < <(read_psarg "$@");
 371
 372     # Catch all arrays empty
 373     if [[ "${#dirs_stdin[@]}" -le 0 ]] && [[ "${#dirs_psarg[@]}" -le 0 ]]; then
 374         die "FATAL:No valid directories provided.";
 375     fi;
 376
 377     # Generate file list
 378     # Find settings
 379     firegex=".+\(jpg\|jpeg\|gif\|png\|webm\)$"; # update according to `find . -type f | grep -Eo "\.([[:alnum:]])+$" | sort -u`
 380     fsize="10k"; # default: minimum "10k"
 381     export firegex fsize ; # export for parallel
 382     ## Call find_filelist() in parallel for positional argument input
 383     if [[ "${#dirs_psarg[@]}" -gt 0 ]]; then
 384         fdepth=10; export fdepth; # 10 for dirs from positional arguments
 385         paths_images+=("$( parallel find_flist {} "$fdepth" "$firegex" "$fsize" ::: "${dirs_psarg[@]}" )"); # See [1]
 386     fi;
 387     ## Call find_filelist() in parallel for stdin input
 388     if [[ "${#dirs_stdin[@]}" -gt 0 ]]; then
 389         fdepth=1; export fdepth; # 1 ofr dirs from stdin
 390         paths_images+=("$( parallel find_flist {} "$fdepth" "$firegex" "$fsize" ::: "${dirs_stdin[@]}" )"); # See [1]
 391     fi;
 392
 393     # Convert paths_images array into file list
 394     for i in "${!paths_images[@]}"; do
 395         list_paths_images="$(printf "%s\n%s" "${paths_images[$i]}" "$list_paths_images")";
 396
 397         # Get stats
 398         file_count="$(wc -l < <(echo -n "$list_paths_images"))";
 399         echo "$DEBUG:file_count:$file_count"
 400     done;
 401
 402     # Sort, remove duplicate paths
 403     list_paths_images="$(echo "$list_paths_images" | sort -u | tr -s '\n')";
 404
 405     # Remove paths with dotfiles
 406     list_paths_images="$(echo "$list_paths_images" | grep -viE "/\." )";
 407
 408     # Write
 409     list_paths_images_tmp="/dev/shm/$(date +%Y%m%dT%H%M%S.%N%z)"..feh_paths.txt;
 410     must echo -n "$list_paths_images" > "$list_paths_images_tmp";
 411
 412     # Print stats
 413     yell "STATUS:Built file list in $SECONDS seconds.";
 414
 415     # Run feh with filelist
 416     feh --full-screen --auto-zoom --draw-filename --filelist "$list_paths_images_tmp" -D 16 --stretch --scale-down && \
 417         must rm "$list_paths_images_tmp" &
 418
 419     # Save sample to path in env. var. BKFEH_SAMPLE_DIR if set
 420     save_sample "$list_paths_images";
 421
 422 };
 423 export -f yell die must read_stdin read_psarg find_flist;
 424 #==END Define local functions==
 425
 426 main "$@";
 427
 428 # Author: Steven Baltakatei Sandoval
 429 # License: GPLv3+