แงแแแแแแแแก แแแแแขแแ แแกแแแแ, แ แแแแ แแแแแแแฌแแแ แฌแแแแแแ แฉแแแก แแแแฅแขแ แแแฃแ แแแแแแแแแแแจแ. แกแแแแแแแ, แแ แแแ แแแแขแแแแ แแแแแแ แแแแ แแแแแก แ แแแแแแแแแก แแ แกแฎแแ แกแแแแแแแแแก แแแขแแแแขแฃแ แ แแแแแแแ แแจแแแแ. แแแแแแฎแแแ แงแแแแ แแแแแขแแ แแกแแแฃแ แแแ แก แแแขแแก แฅแแแจ.
แแแฌแแแ 1. Dropbox
แฉแแแ แงแแแแ แฌแแแแ dropbox-แแแ. แแ แแก 4 แแแขแแแแ แแ, แ แแแแแแจแแช แงแแแแแคแแ แ แแแแงแแแ: แกแแฎแแแแซแฆแแแแแแ, แชแแแแแ แ, แแฎแแขแแ แฃแแ แแแขแแ แแขแฃแ แ, แแ แแแฎแแขแแ แฃแแ แแแขแแ แแขแฃแ แ. แแแแ แแ แแ แแ แแแแแขแแ แกแแชแแแแแ แ แฌแแแแแแก แชแฎแ แแแจแ.
แฌแแแแแแแก แฃแแแขแแกแแแ แแ แแก .epub, แแแแแ แฉแแแ .pdf. แแแฃ แกแแแแแแ แแแแแกแแแแแ แ แแแแ แฆแแช แแ แแแ แแแ แแแแขแก แฃแแแ แคแแ แแแแแก.
แฌแแแแแแแกแแแ แฉแแแ แแแแแ แแแแฎแแแแแแ แแกแแแแ:
/ะะฝะธะณะธ/ะะตั
ัะดะพะถะตััะฒะตะฝะฝะพะต/ะะพะฒะพะต/ะะธะทะฐะนะฝ/ะฎัะธะน ะะพัะดะพะฝ/ะะฝะธะณะฐ ะฟัะพ ะฑัะบะฒั ะพั ะ ะดะพ ะฏ.epub
แแฃ แฌแแแแ แแฎแแขแแ แฃแแแ, แแแจแแ แแแขแแแแ แแ (แแแฃ แแแแแ แแแชแแแฃแ แจแแแแฎแแแแแจแ โแแแแแแแโ) แแแแฆแแแฃแแแ.
แแ แแแแแแฌแงแแแขแ แแ แจแแแแฌแฃแฎแแแแแ Dropbox API, แ แแแแแ แแแฅแแก แแแแ แแแแแแแชแแ, แ แแแแแแช แกแแแฅแ แแแแแแแก แกแแฅแแฆแแแแแก. แแแฃ แแแแแ แแกแแแแ: แฉแแแ แแแฆแแแ แฌแแแแแแก แกแแฅแแฆแแแแแแแ, แแแขแแ แแแ แแแแแแฃแ แฌแแแแก แกแแขแงแแแแแก แแ แแชแฎแแแแจแ แแ แแแแแขแแแ Notion-แจแ.
แแแฌแแแ 2. แแแแแแขแแ แฎแแแ
แแแแแ แชแฎแ แแแ แแกแ แฃแแแ แแแแแแงแฃแ แแแแแแก. แงแฃแ แแแฆแแแ: แฃแแฏแแแแกแแ แกแแแขแแแแก แกแแฎแแแแแ แแแแแแฃแ แแ แแแแแแแแ.
แฉแแแ แแแแแแแงแแแแแ แแ แแแคแแชแแแแฃแ Notion API-แก, แ แแแแแ แแคแแชแแแแฃแ แ แฏแแ แแ แแ แแก แแแฌแแแแแฃแแ.
แแแแแแแ Notion-แแ, แแแแญแแ แแ 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. แแฃ แงแแแแแคแแ แ แแแแแแแ epub-แแแ - แกแแขแงแแแแ แแแแแ แแฅ แแ แแก, แแแจแแ แงแแแแแคแแ แ แแ แช แแกแ แแแแแแแ pdf-แจแ: แแก แจแแแซแแแแ แฃแแ แแแแ แจแแแแแแแแแก แฌแแแแแแแ แกแฃแ แแแแแแกแแแ.
แแกแ แ แแ, PDF-แจแ แกแแขแงแแแแแก แแแแแแแก แฉแแแแ แคแฃแแฅแชแแ แแกแ แแแแแแงแฃแ แแแ: แแแฆแแแ แแแแ แแแแแก แ แแแแแแแแแก แแ แแแแ แแแแแแ แแแ แแแแฃแ แแฃแแแแแแ (แกแแขแงแแแแแก แกแแจแฃแแแ แ แแแแแแแแ แแแแ แแแ).
แฒแก แแฅ แแ แแก:
def get_words_count(pages_number):
return pages_number * WORDS_PER_PAGE
แแก WORDS_PER_PAGE A4 แแแแ แแแกแแแแก แแ แแก แแแแฎแแแแแแ 300.
แแฎแแ แแแแฌแแ แแ แคแฃแแฅแชแแ แแแแ แแแแแก แแแกแแแแแแแแ. แฉแแแ แแแแแแแงแแแแแ
def get_pdf_pages_number(path, filename):
pdf = PdfFileReader(open(os.path.join(path, filename), 'rb'))
return pdf.getNumPages()
แจแแแแแแ, แฉแแแ แแแแฌแแ แ แแแแแก Epub-แจแ แแแแ แแแแแก แแแกแแแแแแแแ. แฒฉแแแ แแแงแแแแแ
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. แงแแแแ แแแฌแแแแก แจแแแ แแแแ
แฉแแแ แฃแแแ แแแแแแ แแ แงแแแแ แจแแกแแซแแ แแแ แฉแแแแก แฌแแแแแแแก แกแแฅแแฆแแแแแจแ. แจแแแแแฌแแแ, แแ แแก แแฃ แแ แ แฌแแแแ Notion-แจแ: แแฃ แแ แแก, แแฆแแ แแแญแแ แแแแ แฎแแแแก แจแแฅแแแ.
แจแแแแแ แฃแแแ แแแแแกแแแฆแแ แแ แคแแแแแก แขแแแ, แแฅแแแแ แแแแแแแแแแ แ, แแแแแแแแแ แกแแขแงแแแแแก แ แแแแแแแแ. แแแกแแกแ แฃแแก แแแแแแขแแ แฌแแแแ.
แแก แแ แแก แแแแ, แ แแแแแกแแช แแแฆแแแ:
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