[books] Fix koreader imports, maybe forever

vrobbler/apps/books/koreader.py

@@ -1,9 +1,8 @@
 import logging
 import re
 import sqlite3
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from enum import Enum
-from zoneinfo import ZoneInfo
 
 import requests
 from books.constants import BOOKS_TITLES_TO_IGNORE
@@ -174,7 +173,7 @@ def build_book_map(rows) -> dict:
     return book_id_map
 
 
-def build_page_data(page_rows: list, book_map: dict, user_tz=None) -> dict:
+def build_page_data(page_rows: list, book_map: dict) -> dict:
     """Given rows of page data from KoReader, parse each row and build
     scrobbles for our user, loading the page data into the page_data
     field on the scrobble instance.
@@ -275,10 +274,14 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
                     continue
 
                 timestamp = user.profile.get_timestamp_with_tz(
-                    datetime.fromtimestamp(int(first_page.get("start_ts")))
+                    datetime.fromtimestamp(
+                        int(first_page.get("start_ts"))
+                    )
                 )
                 stop_timestamp = user.profile.get_timestamp_with_tz(
-                    datetime.fromtimestamp(int(last_page.get("end_ts")))
+                    datetime.fromtimestamp(
+                        int(last_page.get("end_ts"))
+                    )
                 )
 
                 scrobble = Scrobble.objects.filter(
@@ -326,6 +329,80 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
 
             last_page_number = page_number
             prev_page_stats = stats
+
+        # Handle leftover pages that never triggered a session gap
+        if scrobble_page_data:
+            scrobble_page_data = dict(
+                sorted(
+                    scrobble_page_data.items(),
+                    key=lambda x: x[1]["start_ts"],
+                )
+            )
+            try:
+                first_page = scrobble_page_data.get(
+                    list(scrobble_page_data.keys())[0]
+                )
+                last_page = scrobble_page_data.get(
+                    list(scrobble_page_data.keys())[-1]
+                )
+            except IndexError:
+                logger.error(
+                    "Could not process book, no page data found",
+                    extra={"scrobble_page_data": scrobble_page_data},
+                )
+                continue
+
+            playback_position_seconds = sum(
+                p["duration"] for p in scrobble_page_data.values()
+            )
+
+            timestamp = user.profile.get_timestamp_with_tz(
+                datetime.fromtimestamp(
+                    int(first_page.get("start_ts"))
+                )
+            )
+            stop_timestamp = user.profile.get_timestamp_with_tz(
+                datetime.fromtimestamp(
+                    int(last_page.get("end_ts"))
+                )
+            )
+
+            scrobble = Scrobble.objects.filter(
+                timestamp=timestamp,
+                book_id=book_id,
+                user_id=user.id,
+            ).first()
+
+            if not scrobble:
+                logger.info(
+                    f"Queueing scrobble for {book_id}, page {list(scrobble_page_data.keys())[0]}"
+                )
+                log_data = {
+                    "koreader_hash": book_dict.get("hash"),
+                    "page_data": scrobble_page_data,
+                    "pages_read": len(scrobble_page_data.keys()),
+                }
+                if hasattr(timestamp.tzinfo, "tzname"):
+                    tz = timestamp.tzinfo.tzname
+                if hasattr(timestamp.tzinfo, "name"):
+                    tz = timestamp.tzinfo.name
+                scrobbles_to_create.append(
+                    Scrobble(
+                        book_id=book_id,
+                        user_id=user.id,
+                        source="KOReader",
+                        media_type=Scrobble.MediaType.BOOK,
+                        timestamp=timestamp,
+                        log=log_data,
+                        stop_timestamp=stop_timestamp,
+                        playback_position_seconds=playback_position_seconds,
+                        in_progress=False,
+                        played_to_completion=True,
+                        long_play_complete=False,
+                        timezone=tz,
+                    )
+                )
+
     if pages_not_found:
         logger.info(f"Pages not found for books: {set(pages_not_found)}")
     return scrobbles_to_create
@@ -355,9 +432,6 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
 
     new_scrobbles = []
     user = User.objects.filter(id=user_id).first()
-    tz = ZoneInfo("UTC")
-    if user:
-        tz = user.profile.tzinfo
 
     is_os_file = "https://" not in file_path
     if is_os_file:
@@ -373,7 +447,6 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
         book_map = build_page_data(
             cur.execute("SELECT * from page_stat_data ORDER BY id_book, start_time"),
             book_map,
-            tz,
         )
         new_scrobbles = build_scrobbles_from_book_map(book_map, user)
     else:
@@ -390,7 +463,7 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
             _sqlite_bytes(file_path), max_buffer_size=1_048_576
         ):
             if table_name == "page_stat_data":
-                book_map = build_page_data(rows, book_map, tz)
+                book_map = build_page_data(rows, book_map)
                 new_scrobbles = build_scrobbles_from_book_map(book_map, user)
 
     logger.info(f"Creating {len(new_scrobbles)} new scrobbles")