നോഷനും പൈത്തണും ഉപയോഗിച്ച് ഒരു ഹോം ലൈബ്രറി ഉണ്ടാക്കുന്നു

എന്റെ ഇലക്ട്രോണിക് ലൈബ്രറിയിൽ എങ്ങനെ മികച്ച രീതിയിൽ പുസ്തകങ്ങൾ വിതരണം ചെയ്യാം എന്നതിൽ എനിക്ക് എപ്പോഴും താൽപ്പര്യമുണ്ട്. അവസാനം, പേജുകളുടെയും മറ്റ് ഗുണങ്ങളുടെയും എണ്ണത്തിന്റെ യാന്ത്രിക കണക്കുകൂട്ടൽ ഉപയോഗിച്ചാണ് ഞാൻ ഈ ഓപ്ഷനിലേക്ക് വന്നത്. പൂച്ചയ്ക്ക് കീഴിലുള്ള എല്ലാ താൽപ്പര്യക്കാരോടും ഞാൻ ചോദിക്കുന്നു.

ഭാഗം 1. ഡ്രോപ്പ്ബോക്സ്

എന്റെ എല്ലാ പുസ്തകങ്ങളും ഡ്രോപ്പ്ബോക്സിലാണ്. ഞാൻ എല്ലാം വിഭജിച്ച 4 വിഭാഗങ്ങളുണ്ട്: പാഠപുസ്തകം, റഫറൻസ്, ഫിക്ഷൻ, നോൺ-ഫിക്ഷൻ. പക്ഷേ ഞാൻ റഫറൻസ് പുസ്തകങ്ങൾ മേശയിൽ ചേർക്കാറില്ല.

മിക്ക പുസ്തകങ്ങളും .epub ആണ്, ബാക്കിയുള്ളവ .pdf ആണ്. അതായത്, അന്തിമ പരിഹാരം എങ്ങനെയെങ്കിലും രണ്ട് ഓപ്ഷനുകളും ഉൾക്കൊള്ളണം.

പുസ്തകങ്ങളിലേക്കുള്ള എന്റെ വഴികൾ ഇതുപോലെയാണ്:

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

പുസ്തകം ഫിക്ഷൻ ആണെങ്കിൽ, വിഭാഗം (അതായത്, മുകളിലുള്ള കേസിൽ "ഡിസൈൻ") നീക്കം ചെയ്യും.

ഫോൾഡർ സമന്വയിപ്പിക്കുന്ന അവരുടെ ആപ്ലിക്കേഷൻ ഉള്ളതിനാൽ, ഡ്രോപ്പ്ബോക്സ് API-യെ ബുദ്ധിമുട്ടിക്കേണ്ടതില്ലെന്ന് ഞാൻ തീരുമാനിച്ചു. അതായത്, പ്ലാൻ ഇതാണ്: ഞങ്ങൾ ഫോൾഡറിൽ നിന്ന് പുസ്‌തകങ്ങൾ എടുക്കുന്നു, ഓരോ ബുക്കും ഒരു വേഡ് കൗണ്ടറിലൂടെ പ്രവർത്തിപ്പിക്കുക, അത് നോഷനിൽ ചേർക്കുക.

ഭാഗം 2. ഒരു വരി ചേർക്കുക

മേശ തന്നെ ഇതുപോലെയായിരിക്കണം. ശ്രദ്ധിക്കുക: നിരയുടെ പേരുകൾ ലാറ്റിനിൽ ഉണ്ടാക്കുന്നതാണ് നല്ലത്.

ഔദ്യോഗികമായത് ഇതുവരെ ഡെലിവർ ചെയ്തിട്ടില്ലാത്തതിനാൽ ഞങ്ങൾ അനൗദ്യോഗിക ധാരണ API ഉപയോഗിക്കും.

നോട്ടിലേക്ക് പോകുക, Ctrl + Shift + J അമർത്തുക, Application -> Cookies എന്നതിലേക്ക് പോകുക, token_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-ൽ പേജുകൾ എണ്ണുന്നതിന് ഞങ്ങൾ ഒരു കാര്യം എഴുതാം. ഞങ്ങൾ ഉപയോഗിക്കുന്നു 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