¿Cómo determinar la cantidad de tiempo que queda en un "sueño"?

Yo tengo:

sleep 210m && for i in $(seq 1 5); do echo -e '\a'; sleep 0.5; done 

funcionando como un temporizador simple y sin lujos para recordarme cuándo se debe hacer algo. Eso sleep 210mes PID 25347.

Estoy tratando de averiguar cuánto tiempo queda en el sueño. Lo mejor que se me ocurrió, y puse la cantidad de sueño original (210 minutos) es:

$ echo "210 60 * $(ps -o etimes= 25347) - 60 ~ r n [:] P p" | dc
78:11

^{(Explicación: el primer bit calcula el número de segundos en la suspensión original; el $(ps…)bit obtiene el tiempo desde que la suspensión comenzó en segundos, luego el resto los resta y se muestra en minutos y segundos).}

Se me ocurre que esto sería útil en general; ¿Hay una mejor manera de hacer esto? ¿O al menos una forma inteligente de analizar el tiempo de sueño ps -o args?

Admite sleepargumentos GNU o Solaris 11 (una o más <double>[smhd]duraciones, por lo que también funcionaría con implementaciones tradicionales que admitan solo un número entero decimal (como en FreeBSD), pero no con aquellos que aceptan argumentos más complejos como las duraciones ISO-8601 ). Usar en etimelugar de etimescomo eso es más portátil (Unix estándar).

remaining_sleep_time() { # arg: pid
  ps -o etime= -o args= -p "$1" | perl -MPOSIX -lane '
    %map = qw(d 86400 h 3600 m 60 s 1);
    $F[0] =~ /(\d+-)?(\d+:)?(\d+):(\d+)/;
    $t = -($4+60*($3+60*($2+24*$1)));
    for (@F[2..$#F]) {
      s/\?//g;
      ($n, $p) = strtod($_);
      $n *= $map{substr($_, -$p)} if $p;
      $t += $n
    }
    print $t'
}

(el s/\?//ges deshacerse de los ?caracteres que procps' psusa como reemplazo para los caracteres de control. Sin él, no se analizaría sleep $'\r1d'o sleep $'\t1d'... Desafortunadamente, en algunas configuraciones Cregionales, incluida la configuración regional, se usa en .lugar de ?. No hay mucho que podamos hacer en ese caso, ya que no hay forma de distinguir \t5dentre un .5d(medio día)).

Pase el pid como argumento.

Eso también supone que el argv[0]pasado a sleepno contiene espacios en blanco y que el número de argumentos es lo suficientemente pequeño como para que no se trunca ps.

Ejemplos:

$ sleep infinity & remaining_sleep_time "$!"
Inf
$ sleep 0xffp-6d &
$ remaining_sleep_time "$!"
344249
$ sleep 1m 1m 1m 1m 1m & remaining_sleep_time "$!"
300

Para una [[[ddd-]HH:]MM:]SSsalida en lugar de solo el número de segundos, reemplace el print $tcon:

$output = "";
for ([60,"%02d\n"],[60,"%02d:"],[24,"%02d:"],[inf,"%d-"]) {
  last unless $t;
  $output = sprintf($_->[1], $t % $_->[0]) . $output;
  $t = int($t / $_->[0])
}
printf "%s", $output;

Esto parecía un problema divertido de resolver; dado que thrig cubría una opción de perl, aquí hay un script bash que hace algo similar. No realiza suficientes verificaciones de errores (supone que está pasando un PID válido de un comando de suspensión). Maneja la misma sintaxis que el núcleoutils sleep de GNU , a saber:

• sufijos s | m | h | d para segundos / minutos / horas / días
• múltiples parámetros de tiempo se suman

#!/usr/bin/env bash

# input: PID of a sleep command
# output: seconds left in the sleep command

function parse_it_like_its_sleep {
  # $1 = one sleep parameter
  # print out the seconds it translates to

  mult=1
  [[ $1 =~ ([0-9][0-9]*)(s|m|h|d) ]] && {
    n=${BASH_REMATCH[1]}
    suffix=${BASH_REMATCH[2]}
  } || {
    n=$1
  }
  case $suffix in
    # no change for 's'
    (m) mult=60;;
    (h) mult=$((60 * 60));;
    (d) mult=$((60 * 60 * 24));;
  esac
  printf %d $((n * mult))
}

# TODO - some sanity-checking for $1
set -- $(ps -o etimes=,args= $1)
[[ $2 = "sleep" ]] || exit 1
elapsed=$1
shift 2
total=0
for arg
do
  # TODO - sanity-check $arg
  s=$(parse_it_like_its_sleep $arg)
  total=$((total + s))
done
printf "%d seconds left\n" $((total - elapsed))

Esto podría hacerse mejor con un script que puede mostrar el tiempo restante cuando se aplica una señal QUIT(generalmente control+\) INFO.

#!/usr/bin/env perl
#
# snooze - sleep for a given duration, with SIGINFO or SIGQUIT
# (control+\ typically) showing how much time remains. Usage:
#
#   snooze 3m; make-noise-somehow
#
# or with
#
#   snooze 25m bread; make-noise-somehow
#
# one can then elsewhere
#
#   pkill -INFO snooze-bread

use strict;
use warnings;
use Term::ReadKey qw(ReadMode);

my %factors = ( s => 1, m => 60, h => 3600, d => 86400 );

my $arg = shift or die "Usage: $0 sleep-time [label]\n";
my $to_sleep = 0;
while ( $arg =~ m/([0-9]+)([smhd])?/g ) {
    my $value  = $1;
    my $factor = $2;
    $value *= $factors{$factor} if $factor;
    $to_sleep += $value;
}
die "nothing to die to sleep to sleep no more for\n" if $to_sleep == 0;

my $label = shift;
$0 = $label ? "snooze-$label" : "snooze";

ReadMode 2;    # noecho to hide control+\s from gunking up the message

sub remainder { warn "$0: " . deltatimefmt($to_sleep) . " remaining\n" }

sub restore {
    ReadMode 0;
    warn "$0: " . deltatimefmt($to_sleep) . " remainds\n";
    exit 1;
}

# expect user to mash on control+\ or whatever generates SIGINFO
for my $name (qw/ALRM INFO QUIT/) {
    $SIG{$name} = \&remainder;
}

# back to original term settings if get blown away
for my $name (qw/HUP INT TERM USR1 USR2/) {
    $SIG{$name} = \&restore;
}

$SIG{TSTP} = 'IGNORE';    # no Zees for you!

while ( $to_sleep > 0 ) {
    $to_sleep -= sleep $to_sleep;
}

ReadMode 0;
exit;

sub deltatimefmt {
    my $difference = shift;

    return "0s" if $difference == 0;

    my $seconds = $difference % 60;
    $difference = ( $difference - $seconds ) / 60;
    my $minutes = $difference % 60;
    $difference = ( $difference - $minutes ) / 60;

    #  my $hours = $difference;
    my $hours = $difference % 24;
    $difference = ( $difference - $hours ) / 24;
    my $days  = $difference % 7;
    my $weeks = ( $difference - $days ) / 7;

    # better way to do this?
    my $temp = ($weeks) ? "${weeks}w " : q{};
    $temp .= ($days)    ? "${days}d "    : q{};
    $temp .= ($hours)   ? "${hours}h "   : q{};
    $temp .= ($minutes) ? "${minutes}m " : q{};
    $temp .= ($seconds) ? "${seconds}s"  : q{};
    return $temp;
}

Debería ser bastante fácil con el módulo tqdm python.

Muestra una buena barra de progreso visual y se puede usar como una tubería de Unix.

https://pypi.python.org/pypi/tqdm

El siguiente fragmento de Python cuenta 100 segundos

import time
from tqdm import tqdm
for i in tqdm(range(100)):
    time.sleep(1)

55% | ██████████ | 55/100 [00:55 <00:45, 1.00s / it]