+
+ 
+
+ 
+
+ 
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{}
".format(text)) + item.setToolTip(f"{text}
") item.setData(Qt.UserRole, data) self.high_table.setItem(0, HIGHLIGHT_H, item) comment = data["comment"] item = QTableWidgetItem(comment) - item.setToolTip("{}
".format(comment)) if comment else None + item.setToolTip(f"{comment}
") if comment else None self.high_table.setItem(0, COMMENT_H, item) date = data["date"] @@ -1207,434 +1831,311 @@ def create_highlight_row(self, data): chapter = data["chapter"] item = XTableWidgetIntItem(chapter) item.setToolTip(chapter) - self.high_table.setItem(0, CHAPTER_H, item) - - path = data["path"] - item = QTableWidgetItem(path) - item.setToolTip(path) - self.high_table.setItem(0, PATH_H, item) - - self.high_table.setSortingEnabled(True) - - # noinspection PyUnusedLocal - def high_view_selection_update(self, selected, deselected): - """ When a row in high_table gets selected - - :type selected: QModelIndex - :parameter selected: The selected row - :type deselected: QModelIndex - :parameter deselected: The deselected row - """ - try: - if not self.filter.isVisible(): - self.sel_high_view = self.high_view_selection.selectedRows() - else: - self.sel_high_view = [i for i in self.high_view_selection.selectedRows() - if not self.high_table.isRowHidden(i.row())] - except IndexError: # empty table - self.sel_high_view = [] - self.toolbar.activate_buttons() - - def on_highlight_column_clicked(self, column): - """ Sets the current sorting column - - :type column: int - :parameter column: The column where the sorting is applied - """ - if column == self.col_sort_h: - self.col_sort_asc_h = not self.col_sort_asc_h - else: - self.col_sort_asc_h = True - self.col_sort_h = column - - # noinspection PyUnusedLocal - def on_highlight_column_resized(self, column, oldSize, newSize): - """ Gets the column size - - :type column: int - :parameter column: The resized column - :type oldSize: int - :parameter oldSize: The old size - :type newSize: int - :parameter newSize: The new size - """ - if column == HIGHLIGHT_H: - self.highlight_width = newSize - elif column == COMMENT_H: - self.comment_width = newSize - - def find_in_books(self, highlight): - """ Finds the current highlight in the "Books View" - - :type highlight: str|unicode - :parameter highlight: The highlight we are searching for - """ - data = self.parent_book_data - - for row in range(self.file_table.rowCount()): - item = self.file_table.item(row, TITLE) - row_data = item.data(Qt.UserRole) - try: # find the book row - if data["stats"]["title"] == row_data["stats"]["title"]: - self.views.setCurrentIndex(BOOKS_VIEW) - self.toolbar.books_view_btn.setChecked(True) - self.toolbar.setup_buttons() - self.toolbar.activate_buttons() - self.file_table.selectRow(row) # select the book - self.on_file_table_itemClicked(item) - for high_row in range(self.high_list.count()): # find the highlight - if (self.high_list.item(high_row) - .data(Qt.UserRole)["text"] == highlight): - self.high_list.setCurrentRow(high_row) # select the highlight - return - except KeyError: # old metadata with no "stats" - continue - - # ___ ___________________ HIGHLIGHTS LIST STUFF _________________ - - def populate_high_list(self, data, path=""): - """ Populates the Highlights list of `Book` view - - :type data: dict - :param data: The item/book's data - :type path: str|unicode - :param path: The item/book's path - """ - space = (" " if self.status.act_page.isChecked() and - self.status.act_date.isChecked() else "") - line_break = (":\n" if self.status.act_page.isChecked() or - self.status.act_date.isChecked() else "") - def_date_format = self.date_format == DATE_FORMAT - highlights = self.get_highlights_from_data(data, path) - for i in sorted(highlights, key=self.sort_high4view): - chapter_text = i["chapter"] - if chapter_text and self.status.act_chapter.isChecked(): - chapter_text = "[{0}]\n".format(chapter_text) - page_text = (_("Page ") + i["page"] - if self.status.act_page.isChecked() else "") - date = i["date"] if def_date_format else self.get_date_text(i["date"]) - date_text = "[" + date + "]" if self.status.act_date.isChecked() else "" - high_text = i["text"] if self.status.act_text.isChecked() else "" - line_break2 = ("\n" if self.status.act_comment.isChecked() and i["comment"] - else "") - high_comment = line_break2 + "● " + i["comment"] if line_break2 else "" - highlight = (page_text + space + date_text + line_break + chapter_text + - high_text + high_comment + "\n") - - highlight_item = QListWidgetItem(highlight, self.high_list) - highlight_item.setData(Qt.UserRole, i) - - def get_highlights_from_data(self, data, path=""): - """ Get the HighLights from the .sdr data - - :type data: dict - :param data: The lua converted book data - :type path: str|unicode - :param path: The book's path - """ - authors = data.get("stats", {}).get("authors", NO_AUTHOR) - title = data.get("stats", {}).get("title", NO_TITLE) - - highlights = [] - for page in data["highlight"]: - for page_id in data["highlight"][page]: - highlight = self.get_highlight_info(data, page, page_id) - if highlight: - # noinspection PyTypeChecker - highlight.update({"authors": authors, "title": title, - "path": path}) - highlights.append(highlight) - return highlights - - @staticmethod - def get_highlight_info(data, page, page_id): - """ Get the highlight's info (text, comment, date and page) - - :type data: dict - :param data: The highlight's data - :type page: int - :param page The page where the highlight starts - :type page_id: int - :param page_id The count of this page's highlight - """ - highlight = {} - try: - high_stuf = data["highlight"][page][page_id] - date = high_stuf["datetime"] - text4check = high_stuf["text"] - chapter = high_stuf.get("chapter", "") - pat = r"Page \d+ (.+?) @ \d+-\d+-\d+ \d+:\d+:\d+" - text = text4check.replace("\\\n", "\n") - comment = "" - for idx in data["bookmarks"]: # check for comment text - if text4check == data["bookmarks"][idx]["notes"]: - bkm_text = data["bookmarks"][idx].get("text", "") - if not bkm_text or (bkm_text == text4check): - break - bkm_text = re.sub(pat, r"\1", bkm_text, 1, re.DOTALL | re.MULTILINE) - if text4check != bkm_text: # there is a comment - comment = bkm_text.replace("\\\n", "\n") - break - highlight["date"] = date - highlight["text"] = text - highlight["comment"] = comment - highlight["chapter"] = chapter - highlight["page"] = str(page) - highlight["page_id"] = page_id - except KeyError: # blank highlight - return - return highlight - - @Slot(QPoint) - def on_high_list_customContextMenuRequested(self, point): - """ When a highlight is right-clicked - - :type point: QPoint - :param point: The point where the right-click happened - """ - if self.sel_high_list: - menu = QMenu(self.high_list) - if QT6: # QT6 requires exec() instead of exec_() - menu.exec_ = getattr(menu, "exec") - - action = QAction(_("Comments"), menu) - action.triggered.connect(self.on_edit_comment) - action.setIcon(self.ico_file_edit) - menu.addAction(action) - - action = QAction(_("Copy"), menu) - action.triggered.connect(self.on_copy_highlights) - action.setIcon(self.ico_copy) - menu.addAction(action) - - action = QAction(_("Delete"), menu) - action.triggered.connect(self.on_delete_highlights) - action.setIcon(self.ico_delete) - menu.addAction(action) - - menu.exec_(self.high_list.mapToGlobal(point)) - - @Slot() - def on_high_list_itemDoubleClicked(self): - """ An item on the Highlight List is double-clicked - """ - self.on_edit_comment() - - def on_edit_comment(self): - """ Opens a window to edit the selected highlight's comment - """ - if self.file_table.isVisible(): # edit comments from Book View - row = self.sel_high_list[-1].row() - comment = self.high_list.item(row).data(Qt.UserRole)["comment"] - elif self.high_table.isVisible(): # edit comments from Highlights View - row = self.sel_high_view[-1].row() - high_data = self.high_table.item(row, HIGHLIGHT_H).data(Qt.UserRole) - comment = high_data["comment"] - else: - return - self.edit_high.high_edit_txt.setText(comment) - # self.edit_high.high_edit_txt.setFocus() - self.edit_high.exec_() - - def edit_comment_ok(self): - """ Change the selected highlight's comment - """ - text = self.edit_high.high_edit_txt.toPlainText() - if self.file_table.isVisible(): - high_index = self.sel_high_list[-1] - high_row = high_index.row() - high_data = self.high_list.item(high_row).data(Qt.UserRole) - high_text = high_data["text"].replace("\n", "\\\n") - - row = self.sel_idx.row() - item = self.file_table.item - data = item(row, TITLE).data(Qt.UserRole) - - for bookmark in data["bookmarks"].keys(): - if high_text == data["bookmarks"][bookmark]["notes"]: - data["bookmarks"][bookmark]["text"] = text.replace("\n", "\\\n") - break - item(row, TITLE).setData(Qt.UserRole, data) - - if not self.db_mode: # Loaded mode - path = item(row, PATH).text() - self.save_book_data(path, data) - else: # Archived mode - self.update_book2db(data) - self.on_file_table_itemClicked(item(row, 0), reset=False) - - elif self.high_table.isVisible(): - data = self.parent_book_data - row = self.sel_high_view[-1].row() - high_data = self.high_table.item(row, HIGHLIGHT_H).data(Qt.UserRole) - high_text = high_data["text"].replace("\n", "\\\n") + self.high_table.setItem(0, CHAPTER_H, item) - for bookmark in data["bookmarks"].keys(): - if high_text == data["bookmarks"][bookmark]["notes"]: - data["bookmarks"][bookmark]["text"] = text.replace("\n", "\\\n") - high_data["comment"] = text - break - self.high_table.item(row, HIGHLIGHT_H).setData(Qt.UserRole, high_data) - self.high_table.item(row, COMMENT_H).setText(text) + # path = data["path"] + path = data.get("meta_path", "") + item = QTableWidgetItem(path) + item.setToolTip(path) + self.high_table.setItem(0, PATH_H, item) - if not self.db_mode: # Loaded mode - book_path, ext = splitext(high_data["path"]) - path = join(book_path + ".sdr", "metadata{}.lua".format(ext)) - self.save_book_data(path, data) - else: # Archived mode - self.update_book2db(data) - path = self.high_table.item(row, PATH_H).text() - for row in range(self.file_table.rowCount()): - if path == self.file_table.item(row, TYPE).data(Qt.UserRole)[0]: - self.file_table.item(row, TITLE).setData(Qt.UserRole, data) - break + self.high_table.setSortingEnabled(True) - self.reload_highlights = True + # noinspection PyUnusedLocal + def high_view_selection_update(self, selected, deselected): + """ When a row in high_table gets selected - def on_copy_highlights(self): - """ Copy the selected highlights to clipboard + :type selected: QModelIndex + :parameter selected: The selected row + :type deselected: QModelIndex + :parameter deselected: The deselected row """ - clipboard_text = "" - for highlight in sorted(self.sel_high_list): - row = highlight.row() - text = self.high_list.item(row).text() - clipboard_text += text + "\n" - self.copy_text_2clip(clipboard_text) + try: + if not self.filter.isVisible(): + self.sel_high_view = self.high_view_selection.selectedRows() + else: + self.sel_high_view = [i for i in self.high_view_selection.selectedRows() + if not self.high_table.isRowHidden(i.row())] + except IndexError: # empty table + self.sel_high_view = [] + self.toolbar.activate_buttons() - def on_delete_highlights(self): - """ The delete highlights action was invoked + def on_highlight_column_clicked(self, column): + """ Sets the current sorting column + + :type column: int + :parameter column: The column where the sorting is applied """ - if not self.db_mode: - if self.edit_lua_file_warning: - text = _("This is an one-time warning!\n\nIn order to delete highlights " - "from a book, its \"metadata\" file must be edited. This " - "contains a small risk of corrupting that file and lose all the " - "settings and info of that book.\n\nDo you still want to do it?") - popup = self.popup(_("Warning!"), text, buttons=2, - button_text=(_("Yes"), _("No"))) - if popup.buttonRole(popup.clickedButton()) == QMessageBox.RejectRole: - return - else: - self.edit_lua_file_warning = False - text = _("This will delete the selected highlights!\nAre you sure?") + if column == self.col_sort_h: + self.col_sort_asc_h = not self.col_sort_asc_h else: - text = _("This will remove the selected highlights from the Archive!\n" - "Are you sure?") - popup = self.popup(_("Warning!"), text, buttons=2, - button_text=(_("Yes"), _("No"))) - if popup.buttonRole(popup.clickedButton()) == QMessageBox.RejectRole: - return - self.delete_highlights() + self.col_sort_asc_h = True + self.col_sort_h = column - def delete_highlights(self): - """ Delete the selected highlights + # noinspection PyUnusedLocal + def on_highlight_column_resized(self, column, oldSize, newSize): + """ Gets the column size + + :type column: int + :parameter column: The resized column + :type oldSize: int + :parameter oldSize: The old size + :type newSize: int + :parameter newSize: The new size """ - row = self.sel_idx.row() - data = self.file_table.item(row, TITLE).data(Qt.UserRole) + if column == HIGHLIGHT_H: + self.highlight_width = newSize + elif column == COMMENT_H: + self.comment_width = newSize - for highlight in self.sel_high_list: - high_row = highlight.row() - high_data = self.high_list.item(high_row).data(Qt.UserRole) - pprint(high_data) - page = high_data["page"] - page_id = high_data["page_id"] - del data["highlight"][page][page_id] # delete the highlight - - # delete the associated bookmark - text = high_data["text"] - for bookmark in data["bookmarks"].keys(): - if text == data["bookmarks"][bookmark]["notes"]: - del data["bookmarks"][bookmark] - - for i in data["highlight"].keys(): - if not data["highlight"][i]: # delete page dicts with no highlights - del data["highlight"][i] - else: # renumbering the highlight keys - contents = [data["highlight"][i][j] for j in sorted(data["highlight"][i])] - if contents: - for l in data["highlight"][i].keys(): # delete all the items and - del data["highlight"][i][l] - for k in range(len(contents)): # rewrite them with the new keys - data["highlight"][i][k + 1] = contents[k] + def find_in_books(self, highlight, hi_row): + """ Finds the current highlight in the "Books View" - contents = [data["bookmarks"][bookmark] for bookmark in sorted(data["bookmarks"])] - if contents: # renumbering the bookmarks keys - for bookmark in data["bookmarks"].keys(): # delete all the items and - del data["bookmarks"][bookmark] - for content in range(len(contents)): # rewrite them with the new keys - data["bookmarks"][content + 1] = contents[content] + :type highlight: str|unicode + :parameter highlight: The highlight we are searching for + """ + data, meta_path = self.get_parent_book_data(hi_row) - if not data["highlight"]: # change icon if no highlights - item = self.file_table.item(row, 0) - item.setIcon(self.ico_empty) + for row in range(self.file_table.rowCount()): + item = self.file_table.item(row, TITLE) + row_meta_path = self.file_table.item(row, PATH).data(0) + try: # find the book row + if meta_path == row_meta_path: + self.toolbar.books_view_btn.click() + self.toolbar.setup_buttons() + self.toolbar.activate_buttons() + self.file_table.selectRow(row) # select the book + self.on_file_table_itemClicked(item) + for high_row in range(self.high_list.count()): # find the highlight + if (self.high_list.item(high_row) + .data(Qt.UserRole)["text"] == highlight): + self.high_list.setCurrentRow(high_row) # select the highlight + return + except KeyError: # old metadata with no "stats" + continue - if not self.db_mode: - path = self.file_table.item(row, PATH).text() - self.save_book_data(path, data) - else: - self.update_book2db(data) - item = self.file_table.item - item(row, TITLE).setData(Qt.UserRole, data) - self.on_file_table_itemClicked(item(row, 0), reset=False) - self.reload_highlights = True + # ___ ___________________ SYNC GROUPS TABLE STUFF _______________ - def save_book_data(self, path, data): - """ Saves the data of a book to its lua file + @Slot(QTableWidgetItem) + def on_sync_table_itemClicked(self, item): + """ When an item of the sync_table is clicked - :type path: str|unicode - :param path: The path to the book's data file - :type data: dict - :param data: The book's data + :type item: QTableWidgetItem + :param item: The item (cell) that is clicked """ - times = os.stat(path) # read the file's created/modified times - encode_data(path, data) - os.utime(path, (times.st_ctime, times.st_mtime)) # reapply original times - if self.file_table.isVisible(): - self.on_file_table_itemClicked(self.file_table.item(self.sel_idx.row(), 0), - reset=False) + # row = item.row() + # # path = self.high_table.item(row, HIGHLIGHT_H).data(Qt.UserRole)["path"] + # print(row) # noinspection PyUnusedLocal - def high_list_selection_update(self, selected, deselected): - """ When a highlight in gets selected + def sync_view_selection_update(self, selected, deselected): + """ When a row in sync_table gets selected :type selected: QModelIndex - :parameter selected: The selected highlight + :parameter selected: The selected row :type deselected: QModelIndex - :parameter deselected: The deselected highlight - """ - self.sel_high_list = self.high_list_selection.selectedRows() - - def set_highlight_sort(self): - """ Sets the sorting method of displayed highlights + :parameter deselected: The deselected row """ - self.high_by_page = self.sender().data() try: - row = self.sel_idx.row() - self.on_file_table_itemClicked(self.file_table.item(row, 0), False) - except AttributeError: # no book selected - pass + self.sel_sync_view = self.sync_view_selection.selectedRows() + except IndexError: # empty table + self.sel_sync_view = [] + self.toolbar.activate_buttons() - def sort_high4view(self, data): - """ Sets the sorting method of displayed highlights + def create_sync_row(self, data, quiet=False): + """ Creates a sync_table row from the given data - :type data: tuple - param: data: The highlight's data + :type data: dict|list + :param data: The sync_group data + :type quiet: bool + :param quiet: Switch to the Sync view """ - return int(data["page"]) if self.high_by_page else data["date"] + if self.current_view != SYNC_VIEW and not quiet: + self.toolbar.sync_view_btn.setChecked(True) + self.toolbar.change_view() - def sort_high4write(self, data): - """ Sets the sorting method of written highlights + self.sync_table.setSortingEnabled(False) + if isinstance(data, dict): + count = self.sync_table.rowCount() + self.sync_table.insertRow(count) + wdg = self.create_sync_widget(data) + wdg.idx = count + self.sync_groups.append(data) + self.sync_table.setCellWidget(count, 0, wdg) + self.sync_table.setRowHeight(count, wdg.sizeHint().height()) + wdg.check_data() + else: + for idx, data in enumerate(data): + self.sync_table.insertRow(idx) + wdg = self.create_sync_widget(data) + self.sync_table.setCellWidget(idx, 0, wdg) + self.sync_table.setRowHeight(idx, wdg.sizeHint().height()) + wdg.on_power_btn_clicked(data.get("enabled", True)) + wdg.idx = idx + self.sync_groups.append(data) + wdg.check_data() + self.sync_table.setSortingEnabled(True) + # noinspection PyTypeChecker + QTimer.singleShot(0, self.save_sync_groups) + + def create_sync_widget(self, data): + wdg = SyncGroup(self) + wdg.data = data + wdg.power_btn.setChecked(data.get("enabled", True)) + wdg.title_lbl.setText(data.get("title", "")) + wdg.sync_pos_chk.setChecked(data.get("sync_pos", True)) + wdg.merge_chk.setChecked(data.get("merge", True)) + wdg.sync_db_chk.setChecked(data.get("sync_db", False)) + + items = deepcopy(data.get("items", [{"path": "", "data": {}}])) + for item in items: + wdg.add_item(item) + return wdg + + def synchronize_group(self, group, multi=False): + """ Start the process of syncing/merging the group + + :type group: SyncGroup + :param group: The group to be processed + """ + group.on_refresh_btn_clicked() + if not group.sync_items[0].ok: + self.popup(_(f'Error in group "{group.data["title"]}"!'), + _("There is a problem with the first metadata file path!\nCheck " + "the Tooltip that appears while hovering the mouse over it."), + icon=QMessageBox.Critical) + return + sync2db = group.sync_db_chk.isChecked() + group_changed = sync2db + to_process = [] + for idx, item in enumerate(group.sync_items): + if not item.ok: + continue + info = group.data["items"][idx] + mod_time = os.stat(info["path"]).st_mtime + to_process.append((info, mod_time)) + to_process = sorted(to_process, key=lambda x: x[1], reverse=True) + to_process = [i[0] for i in to_process] + + if sync2db: + book_data = {"data": group.data["items"][0]["data"], + "path": group.data["items"][0]["path"]} + db_idx = self.check4archive_merge(book_data) + if db_idx: + db_data = self.books[db_idx]["data"] + to_process.append({"data": db_data, "path": ""}) + + if len(to_process) > 1: + if group.sync_pos_chk.isChecked(): + self.sync_pos(to_process) + group_changed = True + if group.merge_chk.isChecked(): + items = [] + for book_info in to_process: # book_info: {"path": str, "data": dict} + data = book_info["data"] + total = data.get("doc_pages", data.get("stats", {}).get("pages", 0)) + if group.new_format: + items.append((data["annotations"], total)) + else: + items.append((data["highlight"], data["bookmarks"], total, + book_info["path"])) + if group.new_format: + self.merge_new_highs(items) + else: + self.merge_old_highs(items) + group_changed = True + + if group_changed: + for item in deepcopy(to_process): + if item["path"]: # db version has no path + item["data"]["annotations_externally_modified"] = True + self.save_book_data(item["path"], item["data"]) + + if sync2db: # add the newest version of the book to db + new_data = deepcopy(to_process[0]) + path = new_data["path"] + data = new_data["data"] + date = str(datetime.fromtimestamp(getmtime(path))).split(".")[0] + md5 = data["partial_md5_checksum"] + self.delete_books_from_db([md5]) # remove the existing version if any + try: # clean up data that can be cluttered + new_data["stats"]["performance_in_pages"] = {} + new_data["page_positions"] = {} + new_data.pop("annotations_externally_modified", None) + except KeyError: + pass + self.add_books2db([{"md5": md5, "path": path, "date": date, + "data": json.dumps(data)}]) + self.update_new_values(group) + text = _("Synchronization process completed") + else: + text = _("Nothing to sync") - :type data: tuple - param: data: The highlight's data + if not multi: # one group Sync + self.popup(_("Information"), text, QMessageBox.Information) + else: # multiple Sync operations + if group_changed: + return True # needed for counting the number of groups changed + + def update_new_values(self, group): + """ Updates the book table after sync_groups execution """ - if self.high_by_page and self.status.act_page.isChecked(): - page = data[3] - if page.startswith("Page"): - page = page[5:] - return int(page) - else: - return data[0] + self.reload_highlights = True + row_infos = {} + for idx, item in enumerate(group.data["items"]): + if not group.sync_items[idx].ok: + continue + path = item["path"] + for row in range(self.file_table.rowCount()): + if self.file_table.item(row, PATH).text() == path: + row_infos[row] = item + break + for row in row_infos: + data = row_infos[row]["data"] + self.file_table.item(row, TITLE).setData(Qt.UserRole, data) + hi_count = self.get_item_stats(data)["high_count"] + if hi_count and hi_count != "0": + self.file_table.item(row, TITLE).setIcon(self.ico_label_green) + self.file_table.item(row, HIGH_COUNT).setText(hi_count) + self.file_table.item(row, HIGH_COUNT).setToolTip(hi_count) + if group.sync_pos_chk.isChecked(): + percent = str(int(data.get("percent_finished", 0) * 100)) + "%" + self.file_table.item(row, PERCENT).setText(percent) + self.file_table.item(row, PERCENT).setToolTip(percent) + + def update_sync_groups(self): + """ Update the sync groups in memory and on disk + """ + del self.sync_groups[:] + for i in range(self.sync_table.rowCount()): + wdg = self.sync_table.cellWidget(i, 0) + wdg.idx = i # update the index of widget + wdg.check_data() + self.sync_groups.append(wdg.data) + + self.save_sync_groups() + + def load_sync_groups(self): + """ Load the sync groups from a file + """ + try: + with open(SYNC_FILE, "r", encoding="utf-8") as f: + sync_groups = json.load(f) + except (IOError, ValueError): # no json file exists or corrupted file + return + self.create_sync_row(sync_groups, quiet=True) + + def save_sync_groups(self): + """ Save the sync groups to a file + """ + sync_groups = deepcopy(self.sync_groups) + sync_groups = [i for i in sync_groups if i["items"][0].get("path")] + with open(SYNC_FILE, "w+", encoding="utf-8") as f: + items = [i for grp in sync_groups for i in grp["items"] if i.get("path")] + for item in items: + item["data"] = {} + item["path"] = normpath(item["path"]) + json.dump(sync_groups, f, indent=4) # ___ ___________________ MERGING - SYNCING STUFF _______________ @@ -1666,18 +2167,20 @@ def same_book(self, data1, data2, book1="", book2=""): def wrong_book(self): """ Shows an info dialog if the book MD5 of two metadata are different """ - text = _("It seems that the selected metadata file belongs to a different book..") + text = _("It seems that the selected metadata file belongs to a different file..") self.popup(_("Book mismatch!"), text, icon=QMessageBox.Critical) @staticmethod - def same_cre_version(data): + def same_cre_version(data1, data2): """ Check if the supplied metadata have the same CRE version - :type data: list[dict] - :param data: The data to get checked + :type data1: dict + :param data1: The data of the first book + :type data2: dict + :param data2: The data of the second book """ try: - if data[0]["cre_dom_version"] == data[1]["cre_dom_version"]: + if data1["cre_dom_version"] == data2["cre_dom_version"]: return True except KeyError: # no "cre_dom_version" key (older metadata) pass @@ -1698,21 +2201,33 @@ def wrong_cre_version(self): "and does not change that often.") self.popup(_("Version mismatch!"), text, icon=QMessageBox.Critical) - def check4archive_merge(self): + def check4archive_merge(self, book_data): """ Check if the selected books' highlights can be merged with its archived version + + :type book_data: dict + :param book_data: The data of the book """ - idx = self.sel_idx - data1 = self.file_table.item(idx.row(), idx.column()).data(Qt.UserRole) - book_path = self.file_table.item(idx.row(), TYPE).data(Qt.UserRole)[0] + data1 = book_data["data"] + book_path = book_data["path"] for index, book in enumerate(self.books): data2 = book["data"] if self.same_book(data1, data2, book_path): - if self.same_cre_version([data1, data2]): + if self.same_cre_version(data1, data2): return index return False + def wrong_meta_format(self): + """ Shows an info dialog if the format of the two metadata are different + """ + text = _("Can not merge these highlights, because their metadata format are " + "different!\nThere was a re-write of the highlight/bookmark " + "structure of KOReader that make them incompatible.\n\nRe-open the " + "books with a newer version of KOReader to update them and then merge " + "them using KOHighlights.") + self.popup(_("Metadata format mismatch!"), text, icon=QMessageBox.Critical) + def merge_menu(self): """ Creates the `Merge/Sync` button menu """ @@ -1751,18 +2266,8 @@ def on_merge_highlights(self, to_archived=False, filename=""): :type filename: str|unicode :param filename: The path to the metadata file to merge the book with """ - if self.high_merge_warning: - text = _("Merging highlights is experimental so, always do backups ;o)\n" - "Because of the different page formats and sizes, some page " - "numbers in {} might be inaccurate. " - "Do you want to continue?").format(APP_NAME) - popup = self.popup(_("Warning!"), text, buttons=2, - button_text=(_("Yes"), _("No")), - check_text=DO_NOT_SHOW) - self.high_merge_warning = not popup.checked - if popup.buttonRole(popup.clickedButton()) == QMessageBox.RejectRole: - return - + if self.merge_warning_stop(): + return popup = self.popup(_("Warning!"), _("The highlights of the selected entries will be merged.\n" "This can not be undone! Continue?"), buttons=2, @@ -1771,6 +2276,21 @@ def on_merge_highlights(self, to_archived=False, filename=""): if popup.buttonRole(popup.clickedButton()) == QMessageBox.AcceptRole: self.merge_highlights(popup.checked, True, to_archived, filename) + def merge_warning_stop(self): + """ Stop if the merge warning is answered "No" + """ + if self.high_merge_warning: + text = _(f"Merging highlights is experimental so, always do backups ;o)\n" + f"Because of the different page formats and sizes, some page " + f"numbers in {APP_NAME} might be inaccurate. " + f"Do you want to continue?") + popup = self.popup(_("Warning!"), text, buttons=2, + button_text=(_("Yes"), _("No")), + check_text=DO_NOT_SHOW) + self.high_merge_warning = not popup.checked + if popup.buttonRole(popup.clickedButton()) == QMessageBox.RejectRole: + return True + def merge_highlights(self, sync, merge, to_archived=False, filename=""): """ Merge highlights from the same book in two different devices @@ -1783,160 +2303,314 @@ def merge_highlights(self, sync, merge, to_archived=False, filename=""): :type filename: str|unicode :param filename: The path to the metadata file to merge the book with """ + item = self.file_table.item if to_archived: # Merge/Sync a book with archive idx1, idx2 = self.sel_idx, None - data1 = self.file_table.item(idx1.row(), TITLE).data(Qt.UserRole) - data2 = self.books[self.check4archive_merge()]["data"] - path1, path2 = self.file_table.item(idx1.row(), PATH).text(), None + data1 = item(idx1.row(), TITLE).data(Qt.UserRole) + path1, path2 = item(idx1.row(), PATH).text(), None + book_data = {"data": data1, "path": path1} + db_idx = self.check4archive_merge(book_data) + if not db_idx: + return + data2 = self.books[db_idx]["data"] elif filename: # Merge/Sync a book with a metadata file idx1, idx2 = self.sel_idx, None - data1 = self.file_table.item(idx1.row(), TITLE).data(Qt.UserRole) - book1 = self.file_table.item(idx1.row(), TYPE).data(Qt.UserRole)[0] + data1 = item(idx1.row(), TITLE).data(Qt.UserRole) + book1 = item(idx1.row(), TYPE).data(Qt.UserRole)[0] data2 = decode_data(filename) name2 = splitext(dirname(filename))[0] book2 = name2 + splitext(book1)[1] if not self.same_book(data1, data2, book1, book2): self.wrong_book() return - if not self.same_cre_version([data1, data2]): + if not self.same_cre_version(data1, data2): self.wrong_cre_version() return - path1, path2 = self.file_table.item(idx1.row(), PATH).text(), None + path1, path2 = item(idx1.row(), PATH).text(), None else: # Merge/Sync two different book files idx1, idx2 = self.sel_indexes - data1, data2 = [self.file_table.item(idx.row(), TITLE).data(Qt.UserRole) + data1, data2 = [item(idx.row(), TITLE).data(Qt.UserRole) for idx in [idx1, idx2]] - path1, path2 = [self.file_table.item(idx.row(), PATH).text() + path1, path2 = [item(idx.row(), PATH).text() for idx in [idx1, idx2]] if merge: # merge highlights - args = (data1["highlight"], data2["highlight"], - data1["bookmarks"], data2["bookmarks"]) - high1, high2, bkm1, bkm2 = self.get_unique_highlights(*args) - self.update_data(data1, high2, bkm2) - self.update_data(data2, high1, bkm1) - if data1["highlight"] or data2["highlight"]: # since there are highlights - for index in [idx1, idx2]: # set the green icon - if index: - item = self.file_table.item(idx1.row(), TITLE) - item.setIcon(self.ico_label_green) + data1_new = data1.get("annotations") is not None + data2_new = data2.get("annotations") is not None + new_type = data1_new and data2_new + datas = [data1, data2] + if path2 and (os.stat(path1).st_mtime < os.stat(path2).st_mtime): + datas = [data2, data1] # put the newer metadata first + items = [] + if new_type: # new format metadata + for data in datas: + total = data.get("doc_pages", data.get("stats", {}).get("pages", 0)) + items.append([data["annotations"], total]) + self.merge_new_highs(items) + if data1["annotations"]: # update row data for books + num = str(len([i for i in data1["annotations"].values() + if i.get("pos0")])) + for index in [idx1, idx2]: + if index: + item(index.row(), TITLE).setIcon(self.ico_label_green) + item(index.row(), HIGH_COUNT).setText(num) + item(index.row(), HIGH_COUNT).setToolTip(num) + elif (data1_new and not data2_new) or (data2_new and not data1_new): + self.wrong_meta_format() + return # different formats metadata - not supported + else: # old format metadata + for data in datas: + total = data.get("doc_pages", data.get("stats", {}).get("pages", 0)) + items.append([data["highlight"], data["bookmarks"], total]) + self.merge_old_highs(items) + if data1["highlight"]: # update row data for books + num = str(len(data1["highlight"])) + for index in [idx1, idx2]: + if index: + item(index.row(), TITLE).setIcon(self.ico_label_green) + item(index.row(), HIGH_COUNT).setText(num) + item(index.row(), HIGH_COUNT).setToolTip(num) if sync: # sync position and percent - if data1["percent_finished"] > data2["percent_finished"]: - data2["percent_finished"] = data1["percent_finished"] - data2["last_xpointer"] = data1["last_xpointer"] - else: - data1["percent_finished"] = data2["percent_finished"] - data1["last_xpointer"] = data2["last_xpointer"] - - percent = str(int(data1["percent_finished"] * 100)) + "%" - self.file_table.item(idx1.row(), PERCENT).setText(percent) - if not to_archived and not filename: - self.file_table.item(idx2.row(), PERCENT).setToolTip(percent) - - self.file_table.item(idx1.row(), TITLE).setData(Qt.UserRole, data1) + to_process = [{"data": data1, "path": path1}, {"data": data2, "path": path2}] + percent = self.sync_pos(to_process) + for index in [idx1, idx2]: + if index: + item(index.row(), PERCENT).setText(percent) + item(index.row(), PERCENT).setToolTip(percent) + + data1["annotations_externally_modified"] = True self.save_book_data(path1, data1) if to_archived: # update the db item self.update_book2db(data2) elif filename: # do nothing with the loaded file pass else: # update the second item - self.file_table.item(idx2.row(), TITLE).setData(Qt.UserRole, data2) + data2["annotations_externally_modified"] = True self.save_book_data(path2, data2) self.reload_highlights = True @staticmethod - def get_unique_highlights(high1, high2, bkm1, bkm2): - """ Get the highlights, bookmarks from the first book - that do not exist in the second book and vice versa - - :type high1: dict - :param high1: The first book's highlights - :type high2: dict - :param high2: The second book's highlights - :type bkm1: dict - :param bkm1: The first book's bookmarks - :type bkm2: dict - :param bkm2: The second book's bookmarks - """ - unique_high1 = defaultdict(dict) - for page1 in high1: - for page_id1 in high1[page1]: - text1 = high1[page1][page_id1]["text"] - for page2 in high2: - for page_id2 in high2[page2]: - if text1 == high2[page2][page_id2]["text"]: - break # highlight found in book2 - else: # highlight was not found yet in book2 - continue # no break in the inner loop, keep looping - break # highlight already exists in book2 (there was a break) - else: # text not in book2 highlights, add to unique - unique_high1[page1][page_id1] = high1[page1][page_id1] - unique_bkm1 = {} - for page1 in unique_high1: - for page_id1 in unique_high1[page1]: - text1 = unique_high1[page1][page_id1]["text"] - for idx in bkm1: - if text1 == bkm1[idx]["notes"]: # add highlight's bookmark to unique - unique_bkm1[idx] = bkm1[idx] - break - - unique_high2 = defaultdict(dict) - for page2 in high2: - for page_id2 in high2[page2]: - text2 = high2[page2][page_id2]["text"] - for page1 in high1: - for page_id1 in high1[page1]: - if text2 == high1[page1][page_id1]["text"]: - break # highlight found in book1 - else: # highlight was not found yet in book1 - continue # no break in the inner loop, keep looping - break # highlight already exists in book1 (there was a break) - else: # text not in book1 highlights, add to unique - unique_high2[page2][page_id2] = high2[page2][page_id2] - unique_bkm2 = {} - for page2 in unique_high2: - for page_id2 in unique_high2[page2]: - text2 = unique_high2[page2][page_id2]["text"] - for idx in bkm2: - if text2 == bkm2[idx]["notes"]: # add highlight's bookmark to unique - unique_bkm2[idx] = bkm2[idx] - break + def merge_new_highs(items): + """ Merge the highlights of multiple books [new format] + + :type items: [[dict, int], ...] + :param items: [[annotations, total_pg], ...] + :param items: The list of books to be processed + """ + uni_check_hi = set() + uni_highs = [] + uni_check_bkm = set() + uni_bkms = [] + for book_id, info in enumerate(items): # find all unique highlights + source = info[0] # that are not in all books + for target_id, target in enumerate(items): + if target_id == book_id: + continue # don't check self + target = target[0] + for src_hi in source.values(): + if src_hi.get("pos0"): # a highlight + hi_text = src_hi.get("text", "") + for trg_hi in target.values(): + if trg_hi.get("pos0"): # a highlight not a bookmark + if hi_text == trg_hi.get("text", ""): + if src_hi["datetime"] == trg_hi["datetime"]: + break # it's the exact same annotation + src_comm = src_hi.get("note") # try to get the + trg_comm = trg_hi.get("note") # newest change + if src_hi["datetime"] > trg_hi["datetime"]: + if src_comm: # this is the newer comment + trg_hi["note"] = src_comm + elif trg_comm: # the comment was erased lately + trg_hi.pop("note", None) + trg_hi["datetime"] = src_hi["datetime"] + else: + if trg_comm: # this is the newer comment + src_hi["note"] = trg_comm + elif src_comm: # the comment was erased lately + src_hi.pop("note", None) + src_hi["datetime"] = trg_hi["datetime"] + break # highlight found in target book + else: # highlight was not found in target book + if src_hi["pos0"] + src_hi["pos1"] not in uni_check_hi: + uni_check_hi.add(src_hi["pos0"] + src_hi["pos1"]) + uni_highs.append((src_hi, info[1])) + else: # a bookmark + if src_hi["page"] not in uni_check_bkm: + uni_check_bkm.add(src_hi["page"]) + uni_bkms.append((src_hi, info[1])) + + for info in items: # update the annotations with the unique found ones + annots = deepcopy([i for i in info[0].values()]) + total = info[1] + hi_pos_check = {i["pos0"] + i["pos1"] for i in annots if i.get("pos0")} + bkm_pos_check = {i["page"] for i in annots if i.get("page")} + for hi_info in uni_highs: + hi, hi_total = hi_info + if not hi["pos0"] + hi["pos1"] in hi_pos_check: # new highlight + new_hi = deepcopy(hi) + if hi_total != total: # re-calculate the page numbers + percent = int(new_hi["pageno"]) / hi_total + new_hi["pageno"] = str(int(round(percent * total))) + annots.append(new_hi) + for bkm_info in uni_bkms: + bkm, bkm_total = bkm_info + if not bkm["page"] in bkm_pos_check: # new bookmark + new_bkm = deepcopy(bkm) + if bkm_total != total: # re-calculate the page numbers + percent = int(new_bkm["pageno"]) / bkm_total + new_bkm["pageno"] = str(int(round(percent * total))) + annots.append(new_bkm) + info[0].clear() # repopulate the annotations + annots_upd = {} + for i, hi in enumerate(sorted(annots, key=lambda x: x["pageno"])): + annots_upd[i + 1] = hi + info[0].update(annots_upd) - return unique_high1, unique_high2, unique_bkm1, unique_bkm2 + @staticmethod + def merge_old_highs(items): + """ Merge the highlights of multiple books + + :type items: [[dict, dict, int], ...] + :param items: [[highlights, bookmarks, total_pg], ...] + :param items: The list of books to be processed + """ + uni_check = set() + all_uni_highs = {} + all_uni_bkms = {} + # Collect the highlights that are missing even from one book + for book_id, s_info in enumerate(items): + source = s_info[0] + uni_highs = defaultdict(dict) + uni_bkms = defaultdict(dict) + for target_id, t_info in enumerate(items): + if target_id == book_id: + continue # don't check self + target = t_info[0] + for src_pg in source: + for src_pg_id in source[src_pg]: + high = source[src_pg][src_pg_id] + src_text = high["text"] + for target_pg in target: + for target_pg_id in target[target_pg]: + targ = target[target_pg][target_pg_id] + if src_text == targ["text"]: # same annotation + if high["datetime"] == targ["datetime"]: + break + src_comm = "" # if one comment is newer then the + trg_comm = "" # other, we keep the newer for both + src_bkm = {} + trg_bkm = {} + for bk_idx in s_info[1]: + src_bkm = s_info[1][bk_idx] + if src_bkm["notes"] == src_text: + src_comm = src_bkm.get("text", "") + break + for bk_idx in t_info[1]: + trg_bkm = t_info[1][bk_idx] + if trg_bkm["notes"] == targ["text"]: + trg_comm = trg_bkm.get("text", "") + break + if src_bkm["datetime"] > trg_bkm["datetime"]: + if src_comm: # this is the newer comment + trg_bkm["text"] = src_comm + elif trg_comm: # the comment was erased lately + trg_bkm.pop("text", None) + trg_bkm["datetime"] = src_bkm["datetime"] + targ["datetime"] = high["datetime"] + else: + if trg_comm: # this is the newer comment + src_bkm["text"] = trg_comm + elif src_comm: # the comment was erased lately + src_bkm.pop("text", None) + src_bkm["datetime"] = trg_bkm["datetime"] + high["datetime"] = targ["datetime"] + break # highlight found in target book + else: # highlight was not found yet in target book + continue # no break in the inner loop, keep checking + break # highlight exists in target (there was a break) + else: # text not in the target book highlights, add to unique + # but not if already added + if high["pos0"] + high["pos1"] not in uni_check: + uni_check.add(high["pos0"] + high["pos1"]) + uni_highs[src_pg][src_pg_id] = high + for pg in uni_highs: + for pg_id in uni_highs[pg]: + text = uni_highs[pg][pg_id]["text"] + for bkm_idx in s_info[1]: # get the associated bookmarks + if text == s_info[1][bkm_idx]["notes"]: + uni_bkms[pg][pg_id] = s_info[1][bkm_idx] + break + if uni_highs: + all_uni_highs[book_id] = dict(uni_highs) + all_uni_bkms[book_id] = dict(uni_bkms) + + # Merge the highlights that are not on all books + for book_id in all_uni_highs: + uni_highs = all_uni_highs[book_id] + uni_bkms = all_uni_bkms[book_id] + source_total = items[book_id][2] + for item_id, target_item in enumerate(items): + target_total = target_item[2] + recalculate = source_total != target_total + all_highs = [target_item[0][pg][pg_id] + for pg in target_item[0] for pg_id in target_item[0][pg]] + all_bkms = [i for i in target_item[1].values()] + renumber = False # no change made to the highlights/bookmarks + for pg in uni_highs: + new_pg = pg + for pg_id in uni_highs[pg]: + if uni_highs[pg][pg_id] not in all_highs: # add this highlight + renumber = True # mark for renumbering the bookmarks + if recalculate: # diff total pages, recalculate page number + percent = int(pg) / target_total + new_pg = int(round(percent * source_total)) + + if new_pg in target_item[0]: # sort same page highlights + contents = target_item[0][new_pg] + contents = [contents[i] for i in contents] + extras = uni_highs[pg] + extras = [extras[i] for i in extras + if extras[i] not in contents] + highs = sorted(contents + extras, key=lambda x: x["pos0"]) + target_item[0][new_pg] = {i + 1: h + for i, h in enumerate(highs)} + else: # single highlight in page, just add it + target_item[0][new_pg] = uni_highs[pg] + all_bkms.append(uni_bkms[pg][pg_id]) + if renumber: # bookmarks added, so we must merge all and renumber them + bkm_list = target_item[1].copy() + bkm_list = [bkm_list[i] for i in bkm_list] + bkm_check = {i["pos0"] + i["pos1"] for i in bkm_list} + for bkm in all_bkms: + if bkm["pos0"] + bkm["pos1"] not in bkm_check: + bkm_list.append(bkm) + bkm_list = sorted(bkm_list, key=lambda x: x["page"]) + target_item[1].clear() + offset = 1 + for bkm in bkm_list: + target_item[1][offset] = bkm + offset += 1 @staticmethod - def update_data(data, extra_highlights, extra_bookmarks): - """ Adds the new highlights to the book's data + def sync_pos(to_process): + """ Sync the reading position of multiple books - :type data: dict - :param data: The book's data - :type extra_highlights: dict - :param extra_highlights: The other book's highlights - :type extra_bookmarks: dict - :param extra_bookmarks: The other book's bookmarks - """ - highlights = data["highlight"] - for page in extra_highlights: - if page in highlights: # change page number if already exists - new_page = page - while new_page in highlights: - new_page += 1 - highlights[new_page] = extra_highlights[page] - else: - highlights[page] = extra_highlights[page] - - bookmarks = data["bookmarks"] - original = bookmarks.copy() - bookmarks.clear() - counter = 1 - for key in original.keys(): - bookmarks[counter] = original[key] - counter += 1 - for key in extra_bookmarks.keys(): - bookmarks[counter] = extra_bookmarks[key] - counter += 1 + :type to_process: list + :param to_process: The list of books to be processed + """ + percents = [i["data"]["percent_finished"] for i in to_process + if i and i.get("data", {}).get("percent_finished", 0) > 0] + max_idx = percents.index(max(percents)) + max_percent = percents[max_idx] + max_pointer = to_process[max_idx]["data"]["last_xpointer"] + + for item in to_process: + item["data"]["percent_finished"] = max_percent + item["data"]["last_xpointer"] = max_pointer + + return str(int(max_percent * 100)) + "%" def use_meta_files(self): """ Selects a metadata files to sync/merge @@ -2067,26 +2741,37 @@ def get_sdr_folder(self, row): # ___ ___________________ SAVING STUFF __________________________ - def get_export_menu(self): + def create_export_menu(self): """ Creates the `Export Files` button menu """ - menu = QMenu(self) - for idx, item in enumerate([(_("To individual text files"), MANY_TEXT), - (_("Combined to one text file"), ONE_TEXT), - (_("To individual html files"), MANY_HTML), - (_("Combined to one html file"), ONE_HTML), - (_("To individual csv files"), MANY_CSV), - (_("Combined to one csv file"), ONE_CSV), - (_("To individual markdown files"), MANY_MD), - (_("Combined to one markdown file"), ONE_MD)]): - action = QAction(item[0], menu) - action.triggered.connect(self.export_actions) - action.setData(item[1]) - action.setIcon(self.ico_file_save) - if idx and (idx % 2 == 0): - menu.addSeparator() - menu.addAction(action) - return menu + self.export_menu.clear() + single = len(self.sel_indexes) == 1 + if single: + for idx, item in enumerate([(_("To text file"), MANY_TEXT), + (_("To html file"), MANY_HTML), + (_("To csv file"), MANY_CSV), + (_("To md file"), MANY_MD)]): + action = QAction(item[0], self.export_menu) + action.triggered.connect(self.export_actions) + action.setData(item[1]) + action.setIcon(self.ico_file_save) + self.export_menu.addAction(action) + else: + for idx, item in enumerate([(_("To individual text files"), MANY_TEXT), + (_("Combined to one text file"), ONE_TEXT), + (_("To individual html files"), MANY_HTML), + (_("Combined to one html file"), ONE_HTML), + (_("To individual csv files"), MANY_CSV), + (_("Combined to one csv file"), ONE_CSV), + (_("To individual md files"), MANY_MD), + (_("Combined to one md file"), ONE_MD)]): + action = QAction(item[0], self.export_menu) + action.triggered.connect(self.export_actions) + action.setData(item[1]) + action.setIcon(self.ico_file_save) + if idx and (idx % 2 == 0): + self.export_menu.addSeparator() + self.export_menu.addAction(action) # noinspection PyCallByClass def on_export(self): @@ -2095,13 +2780,12 @@ def on_export(self): if self.current_view == BOOKS_VIEW: if not self.sel_indexes: return + self.toolbar.export_btn.showMenu() elif self.current_view == HIGHLIGHTS_VIEW: # Save from high_table, if self.save_sel_highlights(): # combine to one file self.popup(_("Finished!"), _("The Highlights were exported successfully!"), icon=QMessageBox.Information) - return - self.toolbar.export_btn.showMenu() def export_actions(self): """ An `Export as...` menu item is clicked @@ -2146,9 +2830,8 @@ def export(self, idx): ext = "md" else: return - filename = QFileDialog.getSaveFileName(self, - _("Export to {} file").format(ext), - self.last_dir, "*.{}".format(ext))[0] + filename = QFileDialog.getSaveFileName(self, _(f"Export to {ext} file"), + self.last_dir, f"*.{ext}")[0] if not filename: return self.last_dir = dirname(filename) @@ -2156,9 +2839,9 @@ def export(self, idx): self.status.animation(False) all_files = len(self.sel_indexes) - self.popup(_("Finished!"), _("{} texts were exported from the {} processed.\n" - "{} files with no highlights.") - .format(saved, all_files, all_files - saved), + self.popup(_("Finished!"), + _(f"{saved} texts were exported from the {all_files} processed.\n" + f"{all_files - saved} files with no highlights."), icon=QMessageBox.Information) def save_multi_files(self, dir_path, format_, line_break, space): @@ -2185,8 +2868,7 @@ def save_multi_files(self, dir_path, format_, line_break, space): format_, line_break, space, sort_by) saved += 1 except IOError as err: # any problem when writing (like long filename, etc.) - self.popup(_("Warning!"), - _("Could not save the file to disk!\n{}").format(err)) + self.popup(_("Warning!"), _(f"Could not save the file to disk!\n{err}")) return saved def save_merged_file(self, filename, format_, line_break, space): @@ -2222,21 +2904,31 @@ def save_merged_file(self, filename, format_, line_break, space): text_file.write(text) return saved - def get_item_data(self, idx, format_): + def get_item_data(self, index, format_): """ Get the highlight data for an item - :type idx: QModelIndex - :param idx: The item's index + :type index: QModelIndex + :param index: The item's index :type format_: int :param format_: The output format idx """ - row = idx.row() + row = index.row() data = self.file_table.item(row, 0).data(Qt.UserRole) highlights = [] - for page in data["highlight"]: - for page_id in data["highlight"][page]: - highlights.append(self.get_formatted_high(data, page, page_id, format_)) + annotations = data.get("annotations") + if annotations: # new format metadata + for idx in annotations: + highlight = self.get_new_highlight_info(data, idx) + if highlight: + formatted_high = self.get_formatted_high(highlight, format_) + highlights.append(formatted_high) + else: # old format metadata + for page in data["highlight"]: + for page_id in data["highlight"][page]: + highlight = self.get_old_highlight_info(data, page, page_id) + if highlight: + highlights.append(self.get_formatted_high(highlight, format_)) title = self.file_table.item(row, TITLE).data(0) authors = self.file_table.item(row, AUTHOR).data(0) if authors in [OLD_TYPE, NO_AUTHOR]: @@ -2244,19 +2936,14 @@ def get_item_data(self, idx, format_): return authors, title, highlights # noinspection PyTypeChecker - def get_formatted_high(self, data, page, page_id, format_): + def get_formatted_high(self, highlight, format_): """ Create the highlight's texts - :type data: dict - :param data: The highlight's data - :type page: int - :param page The page where the highlight starts - :type page_id: int - :param page_id The idx of this page's highlight + :type highlight: dict + :param highlight: The highlight's data :type format_: int :param format_ The output format idx """ - highlight = self.get_highlight_info(data, page, page_id) linesep = "
