Kindle Clippings To TXT App in Python using GUI • Computer Science blog

I started reading more often on my Kindle. However, after finishing a book I decided I wanted to share some of the important snippets from the book to my blog. Fortunately, Kindle stores the highlighted text into a file called My Clippings. Said file contains all the notes from all the books arranged by date of creation. This leads, of course, to having a document that lacks organization and one where you cannot just copy and paste ALL the text from one specific book.

Hence, I thought of a tool that could allow me to get the clips of the books I want to extract and copy and paste into the blog seamlessly. The process I did was as follows:

What do I want to achieve?
What do I need to achieve so?
Can I do it with the current tools?
How can I cover different scenarios?
How can I make it more organized?
What details am I missing?
Reiterate

By doing so, I was able to come up with a functional code that managed to parse the original file, create a dictionary of titles and traverse line by line until it was able to store tuples with date and text as the value of the key title.

Here I share the final result of the code:

import os
import re
import tkinter as tk
from tkinter import filedialog, messagebox
# Regex pattern for highlight/note lines
line_pattern = re.compile(r'^- Your (Highlight|Note).*Added on (.+)$')
invalid_filename_chars = r'<>:"/\|?*'

def parse_file(filepath):
    """
    Parse the input file to extract highlights by book.
    Returns a dictionary { book_title: [(date, highlight_text), ...], ... }.
    """
    with open(filepath, 'r', encoding='utf-8') as f:
        lines = f.readlines()

    book_highlights = {}
    current_book = None
    current_date = None
    collecting_highlight = False
    highlight_text_buffer = []

    for line in lines:
        line = line.strip('\n')

        if line == '==========':
            if collecting_highlight and highlight_text_buffer:
                highlight_text = '\n'.join(highlight_text_buffer).strip()
                # Skip one-word highlights
                if len(highlight_text.split()) > 2:
                    if current_book not in book_highlights:
                        book_highlights[current_book] = []
                    book_highlights[current_book].append((current_date, highlight_text))
                highlight_text_buffer = []
                collecting_highlight = False
            continue

        match = line_pattern.match(line)
        if match:
            highlight_or_note = match.group(1)
            date_str = match.group(2).strip()
            if highlight_or_note == 'Highlight':
                current_date = date_str
                collecting_highlight = True
                highlight_text_buffer = []
            else:
                # It's a note, ignore
                collecting_highlight = False
                highlight_text_buffer = []
            continue

        if line and not line.startswith('-') and not collecting_highlight:
            current_book = line.strip('\uFEFF').strip()
            continue

        if collecting_highlight:
            highlight_text_buffer.append(line.strip())

    return book_highlights

def sanitize_filename(name):
    for ch in invalid_filename_chars:
        name = name.replace(ch, '')
    return name.strip()

def browse_file():
    filepath = filedialog.askopenfilename(
        title="Select Highlights File",
        filetypes=[("Text Files", "*.txt"), ("All files", "*.*")]
    )
    if filepath:
        file_path_var.set(filepath)
        load_books()

def choose_output_folder():
    directory = filedialog.askdirectory(title="Select Output Folder")
    if directory:
        output_path_var.set(directory)

def load_books():
    # Clear existing checkbuttons
    for widget in checks_frame.winfo_children():
        widget.destroy()

    filepath = file_path_var.get()
    if not filepath:
        return

    global book_highlights, book_vars
    book_highlights = parse_file(filepath)
    book_vars = {}

    if not book_highlights:
        tk.Label(checks_frame, text="No highlights found.").pack(anchor="w", padx=5, pady=5)
        return

    # Create checkbuttons for each book
    for book in book_highlights.keys():
        var = tk.BooleanVar(value=False)
        book_vars[book] = var
        cb = tk.Checkbutton(checks_frame, text=book, variable=var, anchor="w", justify="left", wraplength=500)
        cb.pack(fill='x', anchor='w', padx=5, pady=2)

def export_selected():
    if not file_path_var.get():
        messagebox.showwarning("No File", "Please choose a highlights file first.")
        return

    export_dir = output_path_var.get().strip()
    if not export_dir:
        messagebox.showwarning("No Output Folder", "Please select an output folder.")
        return

    selected_books = [book for book, var in book_vars.items() if var.get()]

    if not selected_books:
        messagebox.showwarning("No Selection", "Please select at least one book.")
        return

    for book_title in selected_books:
        highlights = book_highlights[book_title]

        sanitized_title = sanitize_filename(book_title)
        out_path = os.path.join(export_dir, sanitized_title + '.txt')

        with open(out_path, 'w', encoding='utf-8') as out:
            for date_str, text in highlights:
                out.write(f"Date: {date_str}\n{text}\n\n---\n\n")

    messagebox.showinfo("Export Complete", "Selected books have been exported.")

def close_app():
    root.destroy()

root = tk.Tk()
root.title("Highlight Exporter")

file_path_var = tk.StringVar()
output_path_var = tk.StringVar()

# Top frame for file selection
top_frame = tk.Frame(root)
top_frame.pack(padx=10, pady=10, fill=tk.X)

tk.Label(top_frame, text="Select Highlights File:").pack(side=tk.LEFT)
tk.Entry(top_frame, textvariable=file_path_var, width=50).pack(side=tk.LEFT, padx=5)
tk.Button(top_frame, text="Browse...", command=browse_file).pack(side=tk.LEFT)

# Output frame for output folder selection
output_frame = tk.Frame(root)
output_frame.pack(padx=10, pady=10, fill=tk.X)

tk.Label(output_frame, text="Select Output Folder:").pack(side=tk.LEFT)
tk.Entry(output_frame, textvariable=output_path_var, width=50).pack(side=tk.LEFT, padx=5)
tk.Button(output_frame, text="Browse...", command=choose_output_folder).pack(side=tk.LEFT)

# Middle frame with "Books Found:" label and scrollable area for checkboxes
middle_frame = tk.Frame(root)
middle_frame.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)

tk.Label(middle_frame, text="Books Found:").pack(anchor=tk.W)

# Create a frame with a scrollbar for the checkbuttons
scroll_frame = tk.Frame(middle_frame)
scroll_frame.pack(fill=tk.BOTH, expand=True)

canvas = tk.Canvas(scroll_frame)
canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

scrollbar = tk.Scrollbar(scroll_frame, orient="vertical", command=canvas.yview)
scrollbar.pack(side=tk.RIGHT, fill='y')

checks_frame = tk.Frame(canvas)
canvas.create_window((0,0), window=checks_frame, anchor='nw')

def on_canvas_configure(event):
    canvas.configure(scrollregion=canvas.bbox("all"))

canvas.bind('<Configure>', on_canvas_configure)
canvas.configure(yscrollcommand=scrollbar.set)

# Bottom frame for Export and Close buttons
bottom_frame = tk.Frame(root)
bottom_frame.pack(padx=10, pady=10, fill=tk.X)

tk.Button(bottom_frame, text="Export Selected Highlights", command=export_selected).pack(side=tk.LEFT, padx=5)
tk.Button(bottom_frame, text="Close", command=close_app).pack(side=tk.RIGHT, padx=5)

root.mainloop()

Topics to Understand

In order to be able to come up with this solution, it is paramount to understand the following programming structures:

Basic Python Syntax and Data Structures
To reach this solution, you need to understand the fundamentals of Python, how to declare variables, write loops and conditionals, and manage data in lists and dictionaries.
Python basics

book_highlights = {}    # dictionary to store highlights by book
highlight_text_buffer = []  # list to accumulate lines of a highlight

# Simple conditional and loop
if collecting_highlight:
    for line in highlight_text_buffer:
        # process each line
        pass

File Input/Output (I/O)
Being able to read from and write to files is crucial for loading highlight data and exporting results.
File I/O in Python

# Reading from the file and closing once finished
with open(filepath, 'r', encoding='utf-8') as f:
    lines = f.readlines()

# Writing into a file
with open(out_path, 'w', encoding='utf-8') as out:
    out.write("Some text\n")

String Manipulation and Methods
Processing lines of text, trimming whitespace, splitting into words, and replacing characters is essential for cleaning and filtering highlights.
String Methods
```
line = line.strip('\n')
highlight_text = '\n'.join(highlight_text_buffer).strip()
if len(highlight_text.split()) > 2:
    highlight_text = highlight_text.replace('\uFEFF', '')
```

Regular Expressions (re)
Identifying the format of highlight lines requires pattern matching, which can be done effectively with regular expressions.
re — Regular expression operations

line_pattern = re.compile(r'^- Your (Highlight|Note).*Added on (.+)$')
match = line_pattern.match(line)
if match:
    highlight_or_note = match.group(1)
    date_str = match.group(2).strip()

Functions
Structuring code into functions improves organization and makes the code more maintainable and reusable.
Defining Functions
```
def parse_file(filepath):
    # code that parses the file and returns a dictionary
    return book_highlights
```
Modules and Imports
Leveraging Python’s standard library and organizing code across modules simplifies coding tasks and adds clarity.
The import system
```
import os
import re
import tkinter as tk
from tkinter import filedialog, messagebox
```

tkinter GUI Development
Building a graphical user interface allows users to interact with the application in a more intuitive way, selecting files, folders, and options.
tkinter — Python Interface to Tcl/Tk

root = tk.Tk()
root.title("Highlight Exporter")

top_frame = tk.Frame(root)
top_frame.pack(padx=10, pady=10, fill=tk.X)

tk.Label(top_frame, text="Select Highlights File:").pack(side=tk.LEFT)
tk.Entry(top_frame, textvariable=file_path_var, width=50).pack(side=tk.LEFT, padx=5)
tk.Button(top_frame, text="Browse...", command=browse_file).pack(side=tk.LEFT)

Error and Warning Dialogs (messagebox)
Providing user feedback through dialogs ensures that the user knows when prerequisites are not met, such as missing file selections.
tkinter.messagebox
```
if not file_path_var.get():
    messagebox.showwarning("No File", "Please choose a highlights file first.")
```
Path and Filename Handling (os.path)
Proper handling of file paths and sanitizing filenames ensures that output can be saved reliably on different operating systems.
os.path — Common pathname manipulations
```
out_path = os.path.join(export_dir, sanitized_title + '.txt')
```
Packaging With PyInstaller (Optional)
Finally, turning the script into a standalone executable lets you distribute the tool without requiring users to have Python installed.
PyInstaller Documentation
Terminal window
```
pyinstaller --onefile --noconsole highlight_exporter.py
```