Add PDF thumbnails to the _app

[skip ci]

Author: khemarato

scripts/gdrive_app.py

@@ -17,9 +17,88 @@
 from gdrive import gcache
 
 from PySide6.QtSvg import QSvgRenderer
-from PySide6.QtCore import QByteArray, Qt
-from PySide6.QtGui import QPainter
+from PySide6.QtCore import QByteArray, Qt, QRunnable, QObject, Signal, QThreadPool, Slot
+from PySide6.QtGui import QPainter, QImage
 
+from collections import OrderedDict
+from functools import lru_cache
+import pdfutils as pdfutils
+import gdrive_base as gdrive_base
+from strutils import thumbnail_path_for_file
+
+class ThumbnailSignals(QObject):
+    result = Signal(str, QImage)
+
+class ThumbnailWorker(QRunnable):
+    def __init__(self, file_data):
+        super().__init__()
+        self.file_data = file_data
+        self.signals = ThumbnailSignals()
+
+    @Slot()
+    def run(self):
+        file_id = self.file_data.get('id', '')
+        mime = self.file_data.get('mimeType', '')
+        img = None
+        
+        try:
+            from gdrive import gcache
+            cache_path = gcache.get_cache_path_for_file(self.file_data)
+            if cache_path and cache_path.exists():
+                if mime == 'application/pdf':
+                    thumbnail_bytes = pdfutils.get_cached_pdf_thumbnail(cache_path, size='large')
+                    img = QImage()
+                    img.loadFromData(thumbnail_bytes)
+            else:
+                thumb_path = thumbnail_path_for_file(f"gdrive_{file_id}", size='large')
+                if thumb_path.exists():
+                    img = QImage(str(thumb_path))
+                else:
+                    if mime == 'application/pdf':
+                        thumbnail_bytes = gdrive_base.fetch_preview_image(file_id, size=256)
+                        if thumbnail_bytes:
+                            img = QImage()
+                            img.loadFromData(thumbnail_bytes)
+                            thumb_path.parent.mkdir(parents=True, exist_ok=True)
+                            thumb_path.write_bytes(thumbnail_bytes)
+        except Exception as e:
+            print(f"Error fetching thumbnail for {file_id}: {e}")
+            
+        if img and not img.isNull():
+            self.signals.result.emit(file_id, img)
+
+class ThumbnailKickoffWorker(QRunnable):
+    def __init__(self, items, callback):
+        super().__init__()
+        self.items = items
+        self.callback = callback
+
+    @Slot()
+    def run(self):
+        pool = QThreadPool.globalInstance()
+        for item in self.items:
+            worker = ThumbnailWorker(item)
+            worker.signals.result.connect(self.callback)
+            pool.start(worker)
+
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.cache = OrderedDict()
+        self.capacity = capacity
+
+    def get(self, key: str):
+        if key not in self.cache:
+            return None
+        self.cache.move_to_end(key)
+        return self.cache[key]
+
+    def put(self, key: str, value: Any):
+        self.cache[key] = value
+        self.cache.move_to_end(key)
+        if len(self.cache) > self.capacity:
+            self.cache.popitem(last=False)
+
+@lru_cache(maxsize=None)
 def get_icon(icon_enum, is_filled=False, color: Optional[str] = None) -> QIcon:
     if color is None:
         if QApplication.instance():
@@ -86,6 +165,11 @@ def __init__(self):
         self.history_index = -1
         self.current_folder_id = None
 
+        self.threadpool = QThreadPool.globalInstance()
+        self.threadpool.setMaxThreadCount(12)
+        self.thumbnail_cache = LRUCache(500)
+        self.item_mapping = {}
+        
         self.init_ui()
         self.load_root("my_drive")
 
@@ -212,10 +296,12 @@ def on_nav_clicked(self, item: QListWidgetItem):
 
     def populate_files(self, items: List[Dict[str, Any]]):
         self.file_view.clear()
+        self.item_mapping.clear()
 
         # Sort folders first, then files, both alphabetically
         folders = []
         files = []
+        items_needing_thumbnails = []
         for item in items:
             mime = item.get('mimeType', '')
             if mime == 'application/vnd.google-apps.folder':
@@ -229,11 +315,33 @@ def populate_files(self, items: List[Dict[str, Any]]):
         for item in folders + files:
             name = item.get('name', 'Unknown')
             mime = item.get('mimeType', '')
+            file_id = item.get('id', '')
 
             list_item = QListWidgetItem(name)
-            list_item.setIcon(get_mime_icon(mime))
+            
+            cached_pixmap = self.thumbnail_cache.get(file_id)
+            if cached_pixmap:
+                list_item.setIcon(QIcon(cached_pixmap))
+            else:
+                list_item.setIcon(get_mime_icon(mime))
+                if mime == 'application/pdf':
+                    items_needing_thumbnails.append(item)
+            
             list_item.setData(Qt.UserRole, item)
             self.file_view.addItem(list_item)
+            self.item_mapping[file_id] = list_item
+            
+        if items_needing_thumbnails:
+            kickoff_worker = ThumbnailKickoffWorker(items_needing_thumbnails, self.on_thumbnail_loaded)
+            self.threadpool.start(kickoff_worker)
+
+    def on_thumbnail_loaded(self, file_id: str, img: QImage):
+        pixmap = QPixmap.fromImage(img)
+        self.thumbnail_cache.put(file_id, pixmap)
+        if file_id in self.item_mapping:
+            item = self.item_mapping[file_id]
+            if item.listWidget() == self.file_view:
+                item.setIcon(QIcon(pixmap))
 
     def on_item_activated(self, item: QListWidgetItem):
         file_data = item.data(Qt.UserRole)

scripts/gdrive_base.py

@@ -217,7 +217,7 @@ def get_file_contents(fileid, verbose=True):
   return buffer
 
 def fetch_preview_image(fileid: str, size=1000) -> bytes | None:
-  """Fetches the thumbnail image for a file and returns it in a BytesIO buffer"""
+  """Fetches the thumbnail image for a file and returns it as raw bytes"""
   try:
     file_metadata = execute(session().files().get(fileId=fileid, fields="thumbnailLink"))
     thumbnail_url = file_metadata.get('thumbnailLink')

scripts/local_gdrive.py

@@ -828,7 +828,17 @@ def _move_to_trash(self, file_id: str, trashed_time: str = None):
                 self.cursor.execute("UPDATE trashed_drive_items SET trashed_time = ? WHERE id = ?", (trashed_time, file_id))
             return
 
-        self.cursor.execute("INSERT INTO trashed_drive_items SELECT * FROM drive_items WHERE id = ?", (file_id,))
+        self.cursor.execute("""
+            INSERT INTO trashed_drive_items (
+                id, version, name, original_name, mime_type, parent_id, 
+                modified_time, size, owner, md5_checksum, shortcut_target
+            )
+            SELECT 
+                id, version, name, original_name, mime_type, parent_id, 
+                modified_time, size, owner, md5_checksum, shortcut_target
+            FROM drive_items 
+            WHERE id = ?
+        """, (file_id,))
         self.cursor.execute("DELETE FROM drive_items WHERE id = ?", (file_id,))
 
         if trashed_time:

scripts/pdfutils.py

@@ -36,10 +36,13 @@ def render_pdf_thumbnail(path, min_d_size=256, max_d_size=512, type='png') -> by
   pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom))
   return pix.tobytes(type)
 
-def get_shared_cached_pdf_thumbnail(pdf_path: Path, size='large') -> bytes:
+def get_cached_pdf_thumbnail(pdf_path: Path, size='large') -> bytes:
   thumbnail_path = thumbnail_path_for_file(pdf_path, shared=True, size=size)
   if thumbnail_path.is_file():
     return thumbnail_path.read_bytes()
+  alt_path = thumbnail_path_for_file(pdf_path, shared=False, size=size)
+  if alt_path.is_file():
+    return alt_path.read_bytes()
   tsize = THUMBNAIL_SIZES[size]
   thebytes = render_pdf_thumbnail(
     pdf_path,