ಕಲ್ಪನೆ ಮತ್ತು ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಹೋಮ್ ಲೈಬ್ರರಿಯನ್ನು ತಯಾರಿಸುವುದು

ನನ್ನ ಎಲೆಕ್ಟ್ರಾನಿಕ್ ಲೈಬ್ರರಿಯಲ್ಲಿ ಪುಸ್ತಕಗಳನ್ನು ಹೇಗೆ ವಿತರಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನಾನು ಯಾವಾಗಲೂ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇನೆ. ಕೊನೆಯಲ್ಲಿ, ಪುಟಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಇತರ ಗುಡಿಗಳ ಸ್ವಯಂಚಾಲಿತ ಲೆಕ್ಕಾಚಾರದೊಂದಿಗೆ ನಾನು ಈ ಆಯ್ಕೆಗೆ ಬಂದಿದ್ದೇನೆ. ನಾನು ಬೆಕ್ಕಿನ ಅಡಿಯಲ್ಲಿ ಎಲ್ಲಾ ಆಸಕ್ತ ವ್ಯಕ್ತಿಗಳನ್ನು ಕೇಳುತ್ತೇನೆ.

ಭಾಗ 1. ಡ್ರಾಪ್ಬಾಕ್ಸ್

ನನ್ನ ಎಲ್ಲಾ ಪುಸ್ತಕಗಳು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿವೆ. ನಾನು ಎಲ್ಲವನ್ನೂ ವಿಂಗಡಿಸಿದ 4 ವರ್ಗಗಳಿವೆ: ಪಠ್ಯಪುಸ್ತಕ, ಉಲ್ಲೇಖ, ಕಾದಂಬರಿ, ಕಾಲ್ಪನಿಕವಲ್ಲದ. ಆದರೆ ನಾನು ಉಲ್ಲೇಖ ಪುಸ್ತಕಗಳನ್ನು ಟೇಬಲ್‌ಗೆ ಸೇರಿಸುವುದಿಲ್ಲ.

ಹೆಚ್ಚಿನ ಪುಸ್ತಕಗಳು .epub, ಉಳಿದವು .pdf. ಅಂದರೆ, ಅಂತಿಮ ಪರಿಹಾರವು ಹೇಗಾದರೂ ಎರಡೂ ಆಯ್ಕೆಗಳನ್ನು ಒಳಗೊಂಡಿರಬೇಕು.

ಪುಸ್ತಕಗಳಿಗೆ ನನ್ನ ಮಾರ್ಗಗಳು ಹೀಗಿವೆ:

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

ಪುಸ್ತಕವು ಕಾಲ್ಪನಿಕವಾಗಿದ್ದರೆ, ವರ್ಗವನ್ನು (ಅಂದರೆ ಮೇಲಿನ ಸಂದರ್ಭದಲ್ಲಿ "ವಿನ್ಯಾಸ") ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

ಫೋಲ್ಡರ್ ಅನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವ ಅವರ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಾನು ಹೊಂದಿರುವುದರಿಂದ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ API ನೊಂದಿಗೆ ತಲೆಕೆಡಿಸಿಕೊಳ್ಳದಿರಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ. ಅಂದರೆ, ಯೋಜನೆ ಹೀಗಿದೆ: ನಾವು ಫೋಲ್ಡರ್‌ನಿಂದ ಪುಸ್ತಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಪ್ರತಿ ಪುಸ್ತಕವನ್ನು ವರ್ಡ್ ಕೌಂಟರ್ ಮೂಲಕ ರನ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ನೋಷನ್‌ಗೆ ಸೇರಿಸುತ್ತೇವೆ.

ಭಾಗ 2. ಒಂದು ಸಾಲನ್ನು ಸೇರಿಸಿ

ಟೇಬಲ್ ಸ್ವತಃ ಈ ರೀತಿ ಇರಬೇಕು. ಗಮನ: ಲ್ಯಾಟಿನ್ ಭಾಷೆಯಲ್ಲಿ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಮಾಡುವುದು ಉತ್ತಮ.

ನಾವು ಅನಧಿಕೃತ ನೋಟ API ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಏಕೆಂದರೆ ಅಧಿಕೃತ ಒಂದನ್ನು ಇನ್ನೂ ವಿತರಿಸಲಾಗಿಲ್ಲ.

Notion ಗೆ ಹೋಗಿ, Ctrl + Shift + J ಒತ್ತಿ, ಅಪ್ಲಿಕೇಶನ್ -> ಕುಕೀಸ್‌ಗೆ ಹೋಗಿ, ಟೋಕನ್_v2 ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಅದನ್ನು TOKEN ಎಂದು ಕರೆ ಮಾಡಿ. ನಂತರ ನಾವು ಲೈಬ್ರರಿ ಚಿಹ್ನೆಯೊಂದಿಗೆ ನಮಗೆ ಅಗತ್ಯವಿರುವ ಪುಟಕ್ಕೆ ಹೋಗಿ ಲಿಂಕ್ ಅನ್ನು ನಕಲಿಸಿ. ನಾವು ಅದನ್ನು NOTION ಎಂದು ಕರೆಯುತ್ತೇವೆ.

ನಂತರ ನಾವು ನೋಟಿಗೆ ಸಂಪರ್ಕಿಸಲು ಕೋಡ್ ಅನ್ನು ಬರೆಯುತ್ತೇವೆ.

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

ಮುಂದೆ, ಟೇಬಲ್‌ಗೆ ಸಾಲನ್ನು ಸೇರಿಸಲು ಕಾರ್ಯವನ್ನು ಬರೆಯೋಣ.

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] == "Художественное":
            row.author = tags[2]

        elif tags[0] == "Нехудожественное":
            row.tags = tags[2]

        elif tags[0] == "Учебники":
            row.tags = tags[2]

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

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

ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ. ನಾವು ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಟೇಬಲ್ಗೆ ಹೊಸ ಸಾಲನ್ನು ತೆಗೆದುಕೊಂಡು ಸೇರಿಸುತ್ತೇವೆ. ಮುಂದೆ, ನಾವು ನಮ್ಮ ಮಾರ್ಗವನ್ನು "/" ಉದ್ದಕ್ಕೂ ವಿಭಜಿಸುತ್ತೇವೆ ಮತ್ತು ಟ್ಯಾಗ್‌ಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಟ್ಯಾಗ್‌ಗಳು - “ಕಲೆ”, “ವಿನ್ಯಾಸ”, ಯಾರು ಲೇಖಕರು, ಮತ್ತು ಹೀಗೆ. ನಂತರ ನಾವು ಪ್ಲೇಟ್ನ ಎಲ್ಲಾ ಅಗತ್ಯ ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ.

ಭಾಗ 3. ಪದಗಳು, ಗಂಟೆಗಳು ಮತ್ತು ಇತರ ಸಂತೋಷಗಳನ್ನು ಎಣಿಸುವುದು

ಇದು ಹೆಚ್ಚು ಕಷ್ಟಕರವಾದ ಕೆಲಸವಾಗಿದೆ. ನಮಗೆ ನೆನಪಿರುವಂತೆ, ನಾವು ಎರಡು ಸ್ವರೂಪಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ: epub ಮತ್ತು pdf. ಎಪಬ್ನೊಂದಿಗೆ ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗಿದ್ದರೆ - ಪದಗಳು ಬಹುಶಃ ಇವೆ, ನಂತರ ಎಲ್ಲವೂ ಪಿಡಿಎಫ್ ಬಗ್ಗೆ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ: ಇದು ಸರಳವಾಗಿ ಅಂಟಿಕೊಂಡಿರುವ ಚಿತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.

ಆದ್ದರಿಂದ PDF ನಲ್ಲಿ ಪದಗಳನ್ನು ಎಣಿಸುವ ನಮ್ಮ ಕಾರ್ಯವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ: ನಾವು ಪುಟಗಳ ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿರದಿಂದ ಗುಣಿಸುತ್ತೇವೆ (ಪ್ರತಿ ಪುಟಕ್ಕೆ ಸರಾಸರಿ ಪದಗಳ ಸಂಖ್ಯೆ).

ಇಲ್ಲಿ ಅವಳು:

def get_words_count(pages_number):
    return pages_number * WORDS_PER_PAGE

A4 ಪುಟಕ್ಕಾಗಿ ಈ WORDS_PER_PAGE ಸರಿಸುಮಾರು 300 ಆಗಿದೆ.

ಈಗ ಪುಟಗಳನ್ನು ಎಣಿಸಲು ಕಾರ್ಯವನ್ನು ಬರೆಯೋಣ. ನಾವು ಬಳಸುತ್ತೇವೆ pyPDF2.

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

ಮುಂದೆ, ಎಪಬ್‌ನಲ್ಲಿ ಪುಟಗಳನ್ನು ಎಣಿಸಲು ನಾವು ಒಂದು ವಿಷಯವನ್ನು ಬರೆಯುತ್ತೇವೆ. ನಾವು ಉಪಯೋಗಿಸುತ್ತೀವಿ epub_converter. ಇಲ್ಲಿ ನಾವು ಪುಸ್ತಕವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಅದನ್ನು ಸಾಲುಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ ಮತ್ತು ಪ್ರತಿ ಸಾಲಿಗೆ ಪದಗಳನ್ನು ಎಣಿಸುತ್ತೇವೆ.

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)

ಈಗ ಸಮಯವನ್ನು ಲೆಕ್ಕ ಹಾಕೋಣ. ನಾವು ನಮ್ಮ ನೆಚ್ಚಿನ ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಓದುವ ವೇಗದಿಂದ ಭಾಗಿಸುತ್ತೇವೆ.

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

ಭಾಗ 4. ಎಲ್ಲಾ ಭಾಗಗಳನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

ನಮ್ಮ ಪುಸ್ತಕಗಳ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ನಾವು ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಮಾರ್ಗಗಳ ಮೂಲಕ ಹೋಗಬೇಕಾಗಿದೆ. ನೋಟಿನಲ್ಲಿ ಈಗಾಗಲೇ ಪುಸ್ತಕವಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ: ಇದ್ದರೆ, ನಾವು ಇನ್ನು ಮುಂದೆ ಸಾಲನ್ನು ರಚಿಸಬೇಕಾಗಿಲ್ಲ.
ನಂತರ ನಾವು ಫೈಲ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸಬೇಕು, ಇದನ್ನು ಅವಲಂಬಿಸಿ, ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸಿ. ಕೊನೆಯಲ್ಲಿ ಪುಸ್ತಕವನ್ನು ಸೇರಿಸಿ.

ನಾವು ಪಡೆಯುವ ಕೋಡ್ ಇದು:

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)

ಮತ್ತು ಪುಸ್ತಕವನ್ನು ಸೇರಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಕಾರ್ಯವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

ತೀರ್ಮಾನಕ್ಕೆ

ಈ ಲೇಖನವನ್ನು ಓದಿದ ಎಲ್ಲರಿಗೂ ಧನ್ಯವಾದಗಳು. ಇದು ನಿಮಗೆ ಹೆಚ್ಚು ಓದಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ :)

ಮೂಲ: www.habr.com