[Risolto]Cerca e trasforma data in file .txt

[UbuNuovo]

Vediamo se miglioro,sono partito malissimo.
Sì, meglio usare le funzioni di AWK https://www.gnu.org/software/gawk/manua ... tions.html

[vaeVictis]

@UbuNuovo

Ho finito lo script con awk.
Domani lo posto.
Per ora ti lascio il benchmark sullo stesso file su cui ho testato il tuo e il mio script precedente:

Codice: Seleziona tutto

$ time awk -f mioScriptAwk.awk dati.txt >> $(mktemp -p .) 

real	0m0,217s
user	0m0,184s
sys	0m0,032s

Si nota una leggerissima differenza

[vaeVictis]

Allora, rieccomi.

Ho rifatto alcuni controlli facendo riferimento al file di dati creato con lo script di UbuNuovo, con intervallo di date da 00-01-01 a 21-06-26 (quindi un file con 7848 date su altrettante righe).

Per quanto riguarda lo script di UbuNuovo, si ha un tempo di esecuzione:

Codice: Seleziona tutto

$ time ./ubuNuovo.sh 

real	0m33,963s
user	0m25,394s
sys	0m10,228s

Ha due criticità: con più di una data per riga sbrocca ed elimina lo spazio (gli spazi?) a inizio riga, per via dell'utilizzo di echo.

Per quanto riguarda il mio precedente script che usa sed:

Codice: Seleziona tutto

vaevictis@vaevictis-N56VV:~/Programmazione/Bash/ConversioneDate$ time ./mioScriptSed.sh 

real	0m16,370s
user	0m14,337s
sys	0m3,559s

con maxCount uguale a 1000. Non ci sono significative differenze con maxCount uguale a 2000.
La criticità è che fa più chiamate a sed e non mi piace.

Infine, si può usare gawk.
Crea un file nomeScriptAwk.awk contenente:

Codice: Seleziona tutto

{
    while (match($0, /([0-9]{2})-([0-9]{2})-([0-9]{2})/, arr) ) 
    {
        date = arr[0]
        arr[1] = (arr[1] < 70 ? 20 : 19) arr[1]
        time = sprintf("%s %s %s  1  0  0", arr[1], arr[2], arr[3])
        secs = mktime(time)
        new_date = strftime("%A, %d %B %Y", secs)
        gsub(date, new_date)
    }
    print
}

Per lanciare il comando hai varie opzioni:
1)

Codice: Seleziona tutto

gawk -f nomeScriptAwk.awk pathDelFileDaModificare >> $(mktemp -p .)

Ovviamente, se lo script awk è in una cartella differente da quella in cui sei quando lanci il comando, devi indicare per benino il percorso.
Il file di output ti viene creato in un file tmp contenuto nella directory dove lanci lo script (per modificare questo comportamento ti basta lavorare sulla redirezione dell'output nel comando qui sopra)
Il file da modificare non viene toccato.

2)

Codice: Seleziona tutto

gawk -i inplace -f nomeScriptAwk.awk pathDelFileDaModificare

Stesse considerazioni di sopra per i path.
Il file da modificare viene modificato in place, quindi perdi il file originale.

3)

Codice: Seleziona tutto

gawk -i inplace -v INPLACE_SUFFIX=.backup -f nomeScriptAwk.awk pathDelFileDaModificare

Stesse considerazioni di sopra per i path.
Il file da modificare viene modificato in place, ma ti viene creato un file di backup con lo stesso nome del file originale, più il suffisso backup.

Per quanto riguarda le performance, c'è una significativa differenza. Si passa dalle decine di secondi alla frazione di secondo!
L'opzione più lenta è la terza, per la quale:

Codice: Seleziona tutto

$ time gawk -i inplace -v INPLACE_SUFFIX=.backup -f mioScriptAwk.awk dati.txt 

real	0m0,260s
user	0m0,236s
sys	0m0,024s

L'unica criticità di questo script è che considera le date con anno a doppia cifra minore di 70 come facenti parte del 2000, quindi 30 sarà interpretato come 2030. Le date con anno a doppia cifra maggiore di 70 vengono invece considerate come facenti parte del 1900, quindi 80 sarà considerato come 1980.
È lo stesso comportamento del comando date, che come soglia ha 69 invece di 70.
Quindi non credo sia un problema.
Qualora lo dovesse essere, si risolve facilmente, basta che fai sapere.

Con questo passo e chiudo.
Fai sapere, ciao.


Edit:
Questo script ha una criticità spiegata alla fine di questo messaggio

[rai]

Con questo passo e chiudo.

momento momento momento!
@vaeVictis potresti prima spiegare un po' lo script, specialmente queste righe

Codice: Seleziona tutto

        arr[1] = (arr[1] < 70 ? 20 : 19) arr[1]
        time = sprintf("%s %s %s  1  0  0", arr[1], arr[2], arr[3])

[vaeVictis]

@vaeVictis potresti prima spiegare un po' lo script, specialmente queste righe

Codice: Seleziona tutto

        arr[1] = (arr[1] < 70 ? 20 : 19) arr[1]
        time = sprintf("%s %s %s  1  0  0", arr[1], arr[2], arr[3])

@rai
Certo.
Allora, per ogni riga letta lo script fa la seguente cosa:

1) ciclo while che si ripete finché trova in $0 un match con l'espressione regolare ([0-9]{2})-([0-9]{2})-([0-9]{2}), che viene eventualmente inserita nella variabile arr

Codice: Seleziona tutto

    while (match($0, /([0-9]{2})-([0-9]{2})-([0-9]{2})/, arr) ) 

In questo modo, posso modificare $0 (che è la riga letta) come spiegato sotto, e rifare la stessa operazione (descritta sotto) finché nella riga non siano più presenti match con l'espressione regolare e quindi non ci siano ulteriori modifiche da fare.

Se viene trovato il match, awk schiaffa tutto il match in arr[0] e siccome ho usato i gruppi schiaffa la prima parte in arr[1], la seconda in arr[2] e la terza in arr[3].
Quindi se sulla riga ci fosse la data 20-02-12, avrei:

Codice: Seleziona tutto

arr[0] = 20-02-12
arr[1] = 20
arr[1] = 02
arr[1] = 12

2) Imposto la variabile date con il contenuto di arr[0]

Codice: Seleziona tutto

        date = arr[0]

In realtà non è indispensabile, potrei usare direttamente are[0] al posto di date nel punto 7).

3) uso l'operatore ternario A ? B : C, che vuol dire: "se A è verificata, allora esegui B, altrimenti C.

Codice: Seleziona tutto

arr[1] = (arr[1] < 70 ? 20 : 19) arr[1]

Che vuol dire: se arr[1] (quindi l'anno) è minore di 70, scrivi 20, altrimenti scrivi 19.
E poi "appende" il valore arr[1] a quanto scritto.
Quindi se ho arr[1] pari a 30, diventerà 2030.
E poi sovrascrivo il valore di arr[1] (a sinistra del'uguale) con quello che ho ottenuto a destra dell'uguale.

Per capirci, è come se avessi scritto:

Codice: Seleziona tutto

if (arr[1] < 70)
    arr[1] = "20" + arr[1]
else
    arr[1] = "19" + arr[1]

Volevo solo essere un po' esoterico

4) Formatto la stringa con i valori che ho nelle varie parti di arr e schiaffo il suo risultato in time.

Codice: Seleziona tutto

        time = sprintf("%s %s %s  1  0  0", arr[1], arr[2], arr[3])

Quindi sempre nel caso di 20-02-12, in time avrò:

Codice: Seleziona tutto

2020 02 12 1 0 0

che vuol dire anno 2020, mese 02, giorno 12, ora 1, minuti 0 secondi 0

5) Ho formattato la stringa time in quel modo perché mi serve come argomento di mktime per calcolare i secondi dalla EPOCH.

Codice: Seleziona tutto

        secs = mktime(time)

6) Una volta che ho i secondi corrispondenti alla prima ora di quel particolare giorno, posso risalire alla new_date, usando la funzione strftime

Codice: Seleziona tutto

new_date = strftime("%A, %d %B %Y", secs)

Questa mi traduce i secondi in "nome giorno, giorno del mese nome mese anno"
In pratica, fa la stessa cosa che fa date con questo comando:

Codice: Seleziona tutto

$ date --date="20-02-12" "+%A, %d %B %Y"
mercoledì, 12 febbraio 2020

Ho impostato 1 come ora perché è la prima ora utile, ma tanto cambia poco, basta che si rimane "dentro alla giornata".

7) Quindi

Codice: Seleziona tutto

        gsub(date, new_date)

modifico $0 (che, ripeto, contiene la riga letta) cambiando tutte le occorrenze di date con new_date.
Quindi nel nostro esempio:

Codice: Seleziona tutto

20-02-12

viene modificata in

Codice: Seleziona tutto

mercoledì, 12 febbraio 2020

Ora, il ciclo while si ripete.
Quindi se trova un'altra data (diversa dalla prima perché ovviamente tutte quelle uguali sono state già modificate dal comando precedente), ripete la procedura descritta.
Altrimenti esce dal ciclo while e passa al punto successivo.

8 )

Codice: Seleziona tutto

    print

Stampa $0.
Questa $0 sarà quella con le modifiche effettuate, se ovviamente ha trovato date da modificare, o semplicemente quella letta, se già nel primo ciclo while non avesse dovuto trovare nulla.

Stampata la riga, legge la successiva e ricomincia tutto da capo.


p.s.: per lo script, sono stato aiutato da un utente di Stackoverflow. Io avrei continuato a provare la command substitution come da precedente messaggio, che non è però possibile... E neanche si chiama command substitution come mi ha fatto notare un altro utente samurai cintura buco nero quindicesimo dan di awk con sbidiguda prematurata

p.p.s.: @steff credo che ci siano le condizioni per bollare come risolta questa discussione e permettermi ora di dormire tranquillo
Scherzi a parte, fammi sapere. Ciao

[rai]

Grazie per la spiegazione, l'ho richiesta per sentirmi impegnato alla lettura della documentazione

il passsaggio preliminare che mi mancava è il fatto che la funzione match() mette comunque tutta la stringa matchata in arr[0]
quanto al resto,

Volevo solo essere un po' esoterico

awk, per chi non lo mastica regolarmente, si presta se non all'offuscamento almeno alla confusione
(gelata)

[vaeVictis]

Ciao!
In un messaggio aggiunto a questa discussione ieri (e giustamente quarantenato) si faceva riferimento a Python.

Dal momento che, a seguito di quel messaggio, avevo iniziato a sviluppare uno script in Python e ho finito di testarlo oggi, lo allego.

Codice: Seleziona tutto

#! /usr/bin/env python3

import argparse
import os
import locale
locale.setlocale(locale.LC_TIME, "it_IT.utf8")
import signal
import re

from sys import exit, stdin, stdout
from tempfile import NamedTemporaryFile
from datetime import datetime

def signal_handler(signal, frame):
    print()
    exit(0)

def file_path(path):
    if os.path.isfile(path):
        return path
    else:
        raise argparse.ArgumentTypeError(f"{path} is not a valid path")

def reformatDate(match):
    myDate = match.group()
    try:
        return datetime.strptime(myDate, '%y-%m-%d').strftime("%A, %d %B %Y")
    except ValueError:
        return myDate


signal.signal(signal.SIGINT, signal_handler)

parser = argparse.ArgumentParser(description='Change date in format yy-mm-dd to format "day name, dd month name YYYY')
parser.add_argument("--input", dest="inFilePath", type=file_path, help="Input file")
parser.add_argument("--suffix", dest="suffix", help="Suffix for the backup file")
group = parser.add_mutually_exclusive_group()
group.add_argument("--output", dest="outFilePath", help="Output file")
group.add_argument("--inplace", dest="inplace", default=False, action='store_true', help="Flag to modify the input file inplace")

args = parser.parse_args()

if args.inplace and (args.inFilePath is None):
    parser.error("--inplace requires --input.")

inFile = open(args.inFilePath) if args.inFilePath else stdin

if not args.inplace:
    outFile = open(args.outFilePath, 'w') if args.outFilePath else stdout
else:
    outFile = NamedTemporaryFile(dir='.', mode="w", delete=False)

r = re.compile(r'([0-9]{2}-[0-9]{2}-[0-9]{2})')
for line in inFile:
    outFile.write(r.sub(reformatDate, line))
    
if inFile is not stdin:
    inFile.close()

if outFile is not stdout:
    outFile.close()

if args.inplace:
    if args.suffix:
        os.rename(args.inFilePath, args.inFilePath + args.suffix)
    os.rename(outFile.name, args.inFilePath)

Ho cercato di fare uno script un po' versatile, che riproducesse il modo in cui viene richiamato lo script di gawk.
La gestione di questo aspetto è la stragrande maggioranza delle istruzioni dello script.
Ci sono alcuni punti che sono non molto pythonici, ma li ho lasciati così (mi riferisco al modo di aprire gli stream di input e output)

Pertanto, per avere l'help dello script:

Codice: Seleziona tutto

$ ./mioScriptPython.py -h
usage: mioScriptPython.py [-h] [--input INFILEPATH] [--suffix SUFFIX]
                          [--output OUTFILEPATH | --inplace]

Change date in format yy-mm-dd to format "day name, dd month name YYYY

optional arguments:
  -h, --help            show this help message and exit
  --input INFILEPATH    Input file
  --suffix SUFFIX       Suffix for the backup file
  --output OUTFILEPATH  Output file
  --inplace             Flag to modify the input file inplace

1)
Modalità interattiva: si scrive sul terminale e lo script modifica al volo quanto scritto. Per chiudere, ctrl+c

Codice: Seleziona tutto

$ ./mioScriptPython.py
ads lladas
ads lladas
12-05-15
martedì, 15 maggio 2012
15-06-18 sd aasd 18-06-15
giovedì, 18 giugno 2015 sd aasd venerdì, 15 giugno 2018
^C

Se si vuole redirigere l'output su un file:

Codice: Seleziona tutto

$ ./mioScriptPython.py --output fileOutput.txt

oppure:

Codice: Seleziona tutto

$ ./mioScriptPython.py >> fileOutput.txt

2)
Si indica un file di input, e l'output viene stampato sullo standard output:

Codice: Seleziona tutto

$ ./mioScriptPython.py --input pathDelFileInput

Il file di input non viene modificato.

Si indica il file di input e il file di output:

Codice: Seleziona tutto

$ ./mioScriptPython.py --input pathDelFileInput --output pathFileOutput

di nuovo, il file di input non viene modificato.
Volendo, per scrivere l'output su file, si può usare la redirezione come visto precedentemente.

3)
Modifica inplace:

Codice: Seleziona tutto

$ ./mioScriptPython.py --input pathDelFileInput --inplace

Il file di input viene sovrascritto con le modifiche, quindi si perde il contenuto iniziale.

Modifica inplace e produzione del file di backup

Codice: Seleziona tutto

$ ./mioScriptPython.py --input pathFileInput --inplace --suffix SUFFIX

Si può scegliere un qualsiasi SUFFIX, che verrà aggiunto al path del file di input.
Ovviamente, le opzioni suffix e output sono mutualmente esclusive.

Confronto con lo script di gawk
I tempi di esecuzione sono approssimativamente gli stessi.

C'è però una DIFFERENZA.
Mi sono accorto che una data potrebbe essere formattata male.
Mi sto riferendo al fatto che, dandola nel formato yy-mm-dd, potrebbe verificarsi il caso in cui mm sia maggiore di 12 o dd indichi un giorno maggiore del massimo giorno disponibile per un dato mese.
Questo script gestisce la cosa lasciando quella data problematica invariata.
Lo script di gawk, per via di come funzionano le funzioni coinvolte al suo interno, funziona in questo modo un po' bizzarro:

Codice: Seleziona tutto

$ gawk -f mioScriptAwk.awk  
12-04-30
lunedì, 30 aprile 2012
12-04-31
martedì, 01 maggio 2012
12-12-31
lunedì, 31 dicembre 2012
12-15-31
domenica, 31 marzo 2013

Non me ne ero accorto, quindi mi sembra il caso di specificarlo qui.
Si può modificare questo comportamento? Sì.
Mi va? No
Se dovesse essere un problema, si risolve con lo script Python in questo messaggio.
Il motivo per cui è difficile risolvere il problema dello script awk è dovuto al fatto che, visto che la modifica è interna al ciclo while, di sicuro non si può lasciare la data problematica invariata, poiché al successivo ciclo while sarebbe di nuovo "matchata" quella data per essere modificata, ma non sarebbe quindi modificata in quanto problematica e si entrerebbe in un loop infinito.
Si potrebbe risolvere modificando in qualche modo la struttura della data, ma anche in questo caso si dovrebbero fare dei controlli sulla data abbastanza complessi. Si capisce infatti facilmente se il mese dovesse sforare, ma per il controllo sul giorno la questione risulterebbe più complessa.
Pertanto, se la questione delle date sballate dovesse essere un problema, è meglio ricorrere allo script in Python .

[crap0101]

quel comportamento strano di awk immagino sia stato scelto di tenerlo perchè in altre situzioni può tornare utile... in pratica calcola in automatico la data "giusta" anche se numericamente non ha senso. Certo sarebbe utile poter scegliere di esser avvisati in qualche modo per date formattate in maniere che non hanno senso purtroppo mi pare che non ci sia niente del genre, nella stdlib.
Una soluzione che mi viene in mente per questo caso specifico potrebbe essere fare il controllo inverso sulla nuova data ottenuta:

Codice: Seleziona tutto

function check_date (date, new_date) {
    #new_date: qualcosa tipo "domenica, 31 marzo 2013"
    r = match(new_date,
	      /\w+, ([0-9]{2}) (\w+) ([0-9]{2})([0-9]{2})/,
	      a)
    maybe_orig = sprintf ("%d-%02d-%d", a[4], months[a[2]], a[1])
    #printf ("check_date: date: %s | new_date: %s | %s\n", date, new_date, maybe_orig)
    return maybe_orig == date
}


BEGIN {
    m = 60*60*24*28
    for (x = 1; x <= 12; x++)
        months[strftime ("%B", m*x)] = x
    #for (v in months) print v, months[v]
}
{
    match($0, /([0-9]{2})-([0-9]{2})-([0-9]{2})/, arr)
    date = arr[0]
    arr[1] = (arr[1] < 70 ? 20 : 19) arr[1]
    time = sprintf("%s %s %s  1  0  0", arr[1], arr[2], arr[3])
    secs = mktime(time)
    new_date = strftime("%A, %d %B %Y", secs)
    #gsub(date, new_date)
    c = check_date(date, new_date)
    printf ("date: %s | new_date: %s | %s\n",
	    date, new_date, c ? "OK" : "ERR")
}

# crap0101@orange:/tmp/foo$ echo 12-15-31 | awk -f a.awk
# date: 12-15-31 | new_date: domenica, 31 marzo 2013 | ERR
# crap0101@orange:/tmp/foo$ echo 12-12-31 | awk -f a.awk
# date: 12-12-31 | new_date: lunedì, 31 dicembre 2012 | OK
# crap0101@orange:/tmp/foo$

anche se sarebbe meglio fare questo genere di controllo a parte (o comunque prima) per evidenziare record formattati non correttamente.

[vaeVictis]

anche se sarebbe meglio fare questo genere di controllo a parte

Sì, ci avevo pensato, infatti.
Stavo pensando di buttare giù al volo uno script per fare un controllo preliminare.
Sto un po' incasinato, però, e non so se riesco a farlo in tempi brevi.
Anche se, con Python, la questione è di facile soluzione, perché basta intercettare l'eccezione in caso di data sballata, e magari mandare in output la riga del file e la data sballata.

Se riesco, lo posto nella prossima settimana.

[steff]

Ho messo [risolto] ma per me potete volentieri arrivare a 20 pagine di esercizi e sperimentazioni

[UbuNuovo]

Ottimo!
Ricordiamocelo per il futuro, mi riferisco sopratutto alle sostituzioni di testo con AWk.