Creiamo una biblioteca domestica con Notion e Python

Sono sempre stato curioso di come migliorare l'organizzazione dei libri nella mia biblioteca elettronica. Alla fine sono arrivato a una soluzione con un conteggio automatico delle pagine e altre utilità. Invito tutti gli interessati a leggere oltre.

Parte 1. Dropbox

Tutti i miei libri sono su Dropbox. Ho suddiviso il tutto in 4 categorie: Manuale, Riferimento, Narrativa, Non narrativa. Ma non aggiungo i riferimenti in tabella.

La maggior parte dei libri è in formato .epub, gli altri sono .pdf. Quindi la soluzione finale deve coprire entrambe le opzioni.

I percorsi per i libri sono più o meno questi:

/Книги/Нехудожественное/Новое/Дизайн/Юрий Гордон/Книга про буквы от А до Я.epub 

Se il libro è di narrativa, la categoria (cioè "Design" nel caso sopra) viene rimossa.

Ho deciso di non complicarmi con l'API di Dropbox, fortunatamente ho già la loro app che sincronizza la cartella. Quindi il piano è questo: prendiamo i libri dalla cartella, passiamo ogni libro attraverso il contatore di parole e lo aggiungiamo in Notion.

Parte 2. Aggiungiamo una riga

La tabella dovrebbe apparire più o meno come segue. ATTENZIONE: è meglio usare l'alfabeto latino per i nomi delle colonne.

Useremo l'API non ufficiale di Notion, perché quella ufficiale non è ancora disponibile.

Andiamo in Notion, premiamo Ctrl + Shift + J, poi andiamo in Applicazione -> Cookies, copiamo token_v2 e lo chiamiamo TOKEN. Poi andiamo nella pagina desiderata con la tabella della biblioteca e copiamo il link. Lo chiamiamo NOTION.

Poi scriviamo il codice per connetterci a Notion.

database = client.get_collection_view(NOTION)
current_rows = database.default_query().execute()

Successivamente scriviamo una funzione per aggiungere una riga nella tabella.

def add_row(path, file, words_count, pages_count, hours):
    row = database.collection.add_row()
    row.title = file

    tags = path.split("/")

    if len(tags) >= 1:
        row.what = tags[0]

    if len(tags) >= 2:
        row.state = tags[1]

    if len(tags) >= 3:
        if tags[0] == "Narrativa":
            row.author = tags[2]

        elif tags[0] == "Non narrativa":
            row.tags = tags[2]

        elif tags[0] == "Manuali":
            row.tags = tags[2]

    if len(tags) >= 4:
        row.author = tags[3]

    row.hours = hours
    row.pages = pages_count
    row.words = words_count

Cosa sta succedendo qui? Prendiamo e aggiungiamo una nuova riga alla tabella nella prima riga. Poi dividiamo il nostro percorso per " / " e otteniamo i tag. I tag sono in termini di "Narrativa", "Design", chi è l'autore e così via. Poi impostiamo tutti i campi necessari nella tabella.

Parte 3. Contiamo le parole, le ore e altre meraviglie

Questo è un compito un po' più difficile. Come sappiamo, abbiamo due formati: ePub e PDF. Se per l'ePub è tutto chiaro — ci sono sicuramente delle parole, per il PDF la situazione non è così netta: potrebbe essere composto semplicemente da immagini unite.

Quindi la funzione per contare le parole nei PDF sarà la seguente: prendiamo il numero di pagine e lo moltiplichiamo per una costante (il numero medio di parole per pagina).

Eccola qui:

def get_words_count(pages_number):
    return pages_number * WORDS_PER_PAGE

Questo WORDS_PER_PAGE per una pagina A4 è circa 300.

Ora scriviamo una funzione per contare le pagine. Useremo PyPDF2.

def get_pdf_pages_number(path, filename):
    pdf = PdfFileReader(open(os.path.join(path, filename), 'rb'))
    return pdf.getNumPages()

Poi scriviamo un pezzo di codice per contare le pagine negli ePub. Utilizziamo epub_converter. Qui prendiamo il libro, lo convertiamo in righe e per ogni riga contiamo le parole.

def get_epub_pages_number(path, filename):
    book = open_book(os.path.join(path, filename))
    lines = convert_epub_to_lines(book)
    words_count = 0

    for line in lines:
        words_count += len(line.split(" "))

    return round(words_count / WORDS_PER_PAGE)

Ora calcoliamo il tempo di lettura. Prendiamo il nostro amato numero di parole e lo dividiamo per la vostra velocità di lettura.

def get_reading_time(words_count):
    return round(((words_count / WORDS_PER_MINUTE) / 60) * 10) / 10

Parte 4. Mettiamo insieme tutto

Dobbiamo percorrere tutti i possibili percorsi nella nostra cartella dei libri. Controlliamo se il libro è già presente in Notion: se sì, non è necessario creare la riga.
Poi dobbiamo determinare il tipo di file, a seconda di questo calcolare il numero di parole. Infine aggiungere il libro.

Ecco quindi il codice che otteniamo:

for root, subdirs, files in os.walk(BOOKS_DIR):
    if len(files) > 0 and check_for_excusion(root):
        for file in files:
            array = file.split(".")
            filetype = file.split(".")[len(array) - 1]
            filename = file.replace("." + filetype, "")
            local_root = root.replace(BOOKS_DIR, "")

            print("Dir: {}, file: {}".format(local_root, file))

            if not check_for_existence(filename):
                print("Dir: {}, file: {}".format(local_root, file))

                if filetype == "pdf":
                    count = get_pdf_pages_number(root, file)

                else:
                    count = get_epub_pages_number(root, file)

                words_count = get_words_count(count)
                hours = get_reading_time(words_count)
                print("Pages: {}, Words: {}, Hours: {}".format(count, words_count, hours))
                add_row(local_root, filename, words_count, count, hours)

E la funzione per controllare se il libro è stato aggiunto è la seguente:

def check_for_existence(filename):
    for row in current_rows:
        if row.title in filename:
            return True

        elif filename in row.title:
            return True

    return False

Conclusione

Grazie a tutti coloro che hanno letto questo articolo. Spero che vi aiuti a leggere di più 🙂

Fonte: habr.com