नोशन और पायथन के साथ एक होम लाइब्रेरी बनाना

मेरी हमेशा से इस बात में रुचि रही है कि अपनी इलेक्ट्रॉनिक लाइब्रेरी में पुस्तकों का सर्वोत्तम वितरण कैसे किया जाए। अंत में, मैं पृष्ठों और अन्य उपहारों की संख्या की स्वचालित गणना के साथ इस विकल्प पर आया। मैं सभी इच्छुक व्यक्तियों से अनुरोध करता हूं।

भाग 1. ड्रॉपबॉक्स

मेरी सभी पुस्तकें ड्रॉपबॉक्स पर हैं। ऐसी 4 श्रेणियां हैं जिनमें मैंने सब कुछ विभाजित किया है: पाठ्यपुस्तक, संदर्भ, फिक्शन, नॉन-फिक्शन। लेकिन मैं तालिका में संदर्भ पुस्तकें नहीं जोड़ता।

अधिकांश पुस्तकें .epub हैं, बाकी .pdf हैं। अर्थात्, अंतिम समाधान में किसी तरह दोनों विकल्प शामिल होने चाहिए।

किताबों तक पहुंचने के मेरे रास्ते कुछ इस तरह हैं:

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

यदि पुस्तक काल्पनिक है, तो श्रेणी (अर्थात्, उपरोक्त मामले में "डिज़ाइन") हटा दी जाती है।

मैंने ड्रॉपबॉक्स एपीआई से परेशान न होने का फैसला किया, क्योंकि मेरे पास उनका एप्लिकेशन है जो फ़ोल्डर को सिंक्रनाइज़ करता है। अर्थात्, योजना यह है: हम फ़ोल्डर से पुस्तकें लेते हैं, प्रत्येक पुस्तक को एक शब्द काउंटर के माध्यम से चलाते हैं, और इसे नोशन में जोड़ते हैं।

भाग 2. एक पंक्ति जोड़ें

तालिका स्वयं कुछ इस प्रकार दिखनी चाहिए. ध्यान दें: कॉलम नाम लैटिन में बनाना बेहतर है।

हम अनौपचारिक नोशन एपीआई का उपयोग करेंगे, क्योंकि आधिकारिक एपीआई अभी तक वितरित नहीं किया गया है।

नोशन पर जाएं, Ctrl + Shift + J दबाएं, एप्लिकेशन -> कुकीज़ पर जाएं, टोकन_v2 कॉपी करें और इसे टोकन कहें। फिर हम लाइब्रेरी साइन के साथ उस पेज पर जाते हैं जिसकी हमें ज़रूरत है और लिंक को कॉपी करते हैं। हम इसे धारणा कहते हैं.

फिर हम नोटियन से जुड़ने के लिए कोड लिखते हैं।

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. शब्दों, घंटों और अन्य प्रसन्नताओं की गिनती करना

ये तो और भी मुश्किल काम है. जैसा कि हमें याद है, हमारे पास दो प्रारूप हैं: ईपीयूबी और पीडीएफ। यदि ईपीयूबी के साथ सब कुछ स्पष्ट है - शब्द संभवतः वहां हैं, तो पीडीएफ के बारे में सब कुछ इतना स्पष्ट नहीं है: इसमें केवल चिपकी हुई छवियां शामिल हो सकती हैं।

तो पीडीएफ में शब्दों की गिनती के लिए हमारा कार्य इस तरह दिखेगा: हम पृष्ठों की संख्या लेते हैं और एक निश्चित स्थिरांक (प्रति पृष्ठ शब्दों की औसत संख्या) से गुणा करते हैं।

यहां यह है:

def get_words_count(pages_number):
    return pages_number * WORDS_PER_PAGE

A4 पेज के लिए यह Words_PER_PAGE लगभग 300 है।

आइए अब पृष्ठों की गिनती के लिए एक फ़ंक्शन लिखें। हम इस्तेमाल करेंगे पीपीडीएफ2.

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