from __future__ import annotations import re from pathlib import Path from typing import Any from pixiv_app.core.auth import SessionStore from pixiv_app.core.downloader import download_user_works, fetch_user_profile, fetch_user_work_ids from pixiv_app.core.library_importer import LegacyDownloadImporter from pixiv_app.core.library import DEFAULT_LIBRARY_DB, PixivLibrary from pixiv_app.core.paths import app_session_file from pixiv_app.core.thumbnails import DEFAULT_THUMBNAIL_DIR, ThumbnailCache class LocalGalleryService: def __init__( self, *, db_path: str | Path = DEFAULT_LIBRARY_DB, thumbnail_dir: str | Path = DEFAULT_THUMBNAIL_DIR, ) -> None: self.db_path = Path(db_path) library = PixivLibrary(self.db_path) library.close() self.thumbnail_cache = ThumbnailCache(db_path=self.db_path, cache_dir=thumbnail_dir) def list_artworks( self, *, query: str = "", search_scope: str = "all", tag: str = "", artist_id: int | None = None, artwork_type: str = "", include_restricted: bool = True, limit: int = 60, offset: int = 0, ensure_thumbnails: bool = True, ) -> dict[str, Any]: limit = max(1, min(int(limit), 200)) offset = max(0, int(offset)) library = PixivLibrary(self.db_path) try: where: list[str] = [] params: list[Any] = [] joins = """ LEFT JOIN artists ar ON ar.artist_id = a.artist_id LEFT JOIN followed_artists fa ON fa.artist_id = a.artist_id AND fa.enabled = 1 LEFT JOIN thumbnail_cache tc ON tc.artwork_id = a.artwork_id AND tc.page_index = 0 LEFT JOIN artwork_files af ON af.artwork_id = a.artwork_id AND af.page_index = 0 LEFT JOIN artwork_ocr_texts ocr ON ocr.artwork_id = a.artwork_id """ if query: like = f"%{query}%" if search_scope == "ocr": where.append("(ocr.status = 'done' AND ocr.ocr_text LIKE ?)") params.append(like) elif search_scope == "title": where.append("(a.title LIKE ? OR a.caption LIKE ? OR ar.name LIKE ?)") params.extend([like, like, like]) elif search_scope == "tags": joins += """ LEFT JOIN artwork_tags at_search ON at_search.artwork_id = a.artwork_id LEFT JOIN tags t_search ON t_search.tag_id = at_search.tag_id """ where.append("t_search.name LIKE ?") params.append(like) else: joins += """ LEFT JOIN artwork_tags at_search ON at_search.artwork_id = a.artwork_id LEFT JOIN tags t_search ON t_search.tag_id = at_search.tag_id """ where.append( "(a.title LIKE ? OR a.caption LIKE ? OR ar.name LIKE ? OR t_search.name LIKE ? " "OR (ocr.status = 'done' AND ocr.ocr_text LIKE ?))" ) params.extend([like, like, like, like, like]) if tag: joins += """ JOIN artwork_tags at_filter ON at_filter.artwork_id = a.artwork_id JOIN tags t_filter ON t_filter.tag_id = at_filter.tag_id """ where.append("t_filter.name = ?") params.append(tag) if artist_id is not None: where.append("a.artist_id = ?") params.append(int(artist_id)) if artwork_type: where.append("a.type = ?") params.append(artwork_type) else: where.append("a.type IN ('illust', 'manga')") if not include_restricted: where.append("a.x_restrict = 0") where_sql = "WHERE " + " AND ".join(where) if where else "" total = library.connection.execute( f"SELECT COUNT(DISTINCT a.artwork_id) AS total FROM artworks a {joins} {where_sql}", params, ).fetchone()["total"] rows = library.connection.execute( f""" SELECT a.artwork_id, a.type, a.title, a.artist_id, ar.name AS artist_name, ar.account AS artist_account, a.page_count, a.bookmark_count, a.like_count, a.view_count, a.x_restrict, a.ai_type, a.thumbnail_url, CASE WHEN fav.artwork_id IS NULL THEN 0 ELSE 1 END AS is_favorite, CASE WHEN fa.artist_id IS NULL THEN 0 ELSE 1 END AS is_followed, COALESCE(tc.thumbnail_path, '') AS thumbnail_path, COALESCE(af.file_path, '') AS primary_file_path, CASE WHEN ocr.status = 'done' AND ocr.ocr_text LIKE ? THEN 'ocr' ELSE '' END AS matched_by, a.updated_at FROM artworks a {joins} LEFT JOIN favorites fav ON fav.artwork_id = a.artwork_id {where_sql} GROUP BY a.artwork_id ORDER BY a.updated_at DESC, a.artwork_id DESC LIMIT ? OFFSET ? """, [f"%{query}%" if query else "", *params, limit, offset], ).fetchall() items = [dict(row) for row in rows] if ensure_thumbnails: self._ensure_list_thumbnails(items) items = self._refresh_thumbnail_paths(library, items) return {"total": int(total), "limit": limit, "offset": offset, "items": items} finally: library.close() def get_artwork(self, artwork_id: int, *, ensure_thumbnails: bool = True) -> dict[str, Any] | None: if ensure_thumbnails: self.thumbnail_cache.ensure_for_artwork(artwork_id) library = PixivLibrary(self.db_path) try: row = library.connection.execute( """ SELECT a.*, ar.name AS artist_name, ar.account AS artist_account , CASE WHEN fav.artwork_id IS NULL THEN 0 ELSE 1 END AS is_favorite , CASE WHEN fa.artist_id IS NULL THEN 0 ELSE 1 END AS is_followed FROM artworks a LEFT JOIN artists ar ON ar.artist_id = a.artist_id LEFT JOIN favorites fav ON fav.artwork_id = a.artwork_id LEFT JOIN followed_artists fa ON fa.artist_id = a.artist_id AND fa.enabled = 1 WHERE a.artwork_id = ? """, (artwork_id,), ).fetchone() if row is None: return None files = library.connection.execute( """ SELECT f.*, tc.thumbnail_path, tc.width AS thumbnail_width, tc.height AS thumbnail_height FROM artwork_files f LEFT JOIN thumbnail_cache tc ON tc.artwork_id = f.artwork_id AND tc.page_index = f.page_index WHERE f.artwork_id = ? ORDER BY f.page_index ASC """, (artwork_id,), ).fetchall() tags = library.connection.execute( """ SELECT t.name, t.translated_name FROM tags t JOIN artwork_tags at ON at.tag_id = t.tag_id WHERE at.artwork_id = ? ORDER BY t.name ASC """, (artwork_id,), ).fetchall() history = library.connection.execute( """ SELECT status, downloaded_pages, skipped_pages, failed_pages, message, finished_at FROM download_history WHERE artwork_id = ? ORDER BY finished_at DESC LIMIT 20 """, (artwork_id,), ).fetchall() return { "artwork": dict(row), "files": [dict(item) for item in files], "tags": [dict(item) for item in tags], "history": [dict(item) for item in history], } finally: library.close() def list_tags(self, *, query: str = "", limit: int = 100) -> list[dict[str, Any]]: library = PixivLibrary(self.db_path) try: params: list[Any] = [] where = "" if query: where = "WHERE t.name LIKE ? OR t.translated_name LIKE ?" params.extend([f"%{query}%", f"%{query}%"]) rows = library.connection.execute( f""" SELECT t.name, t.translated_name, COUNT(at.artwork_id) AS artwork_count FROM tags t LEFT JOIN artwork_tags at ON at.tag_id = t.tag_id {where} GROUP BY t.tag_id ORDER BY artwork_count DESC, t.name ASC LIMIT ? """, [*params, max(1, min(int(limit), 500))], ).fetchall() return [dict(row) for row in rows] finally: library.close() def list_artists(self, *, query: str = "", limit: int = 100) -> list[dict[str, Any]]: library = PixivLibrary(self.db_path) try: params: list[Any] = [] where = "" if query: where = "WHERE ar.name LIKE ? OR ar.account LIKE ?" params.extend([f"%{query}%", f"%{query}%"]) rows = library.connection.execute( f""" SELECT ar.artist_id, ar.name, ar.account, COUNT(a.artwork_id) AS artwork_count FROM artists ar LEFT JOIN artworks a ON a.artist_id = ar.artist_id {where} GROUP BY ar.artist_id ORDER BY CASE WHEN COALESCE(NULLIF(ar.name, ''), NULLIF(ar.account, '')) = '' THEN 1 ELSE 0 END, COALESCE(NULLIF(ar.name, ''), NULLIF(ar.account, ''), CAST(ar.artist_id AS TEXT)) ASC, artwork_count DESC LIMIT ? """, [*params, max(1, min(int(limit), 500))], ).fetchall() return [dict(row) for row in rows] finally: library.close() def get_artist(self, artist_id: int, *, limit: int = 60, offset: int = 0) -> dict[str, Any] | None: library = PixivLibrary(self.db_path) try: row = library.connection.execute( """ SELECT ar.*, COUNT(a.artwork_id) AS artwork_count, CASE WHEN fa.enabled = 1 THEN 1 ELSE 0 END AS is_followed, fa.last_synced_at, fa.last_error FROM artists ar LEFT JOIN artworks a ON a.artist_id = ar.artist_id LEFT JOIN followed_artists fa ON fa.artist_id = ar.artist_id WHERE ar.artist_id = ? GROUP BY ar.artist_id """, (artist_id,), ).fetchone() if row is None: return None return { "artist": dict(row), "artworks": self.list_artworks(artist_id=artist_id, limit=limit, offset=offset), } finally: library.close() def list_favorites(self, *, limit: int = 60, offset: int = 0) -> dict[str, Any]: library = PixivLibrary(self.db_path) try: total = library.connection.execute( """ SELECT COUNT(*) AS total FROM favorites fav JOIN artworks a ON a.artwork_id = fav.artwork_id WHERE a.type IN ('illust', 'manga') """ ).fetchone()["total"] rows = library.connection.execute( """ SELECT a.artwork_id, a.type, a.title, a.artist_id, ar.name AS artist_name, ar.account AS artist_account, a.page_count, a.bookmark_count, a.like_count, a.view_count, a.x_restrict, a.ai_type, a.thumbnail_url, 1 AS is_favorite, CASE WHEN fa.artist_id IS NULL THEN 0 ELSE 1 END AS is_followed, COALESCE(tc.thumbnail_path, '') AS thumbnail_path, COALESCE(af.file_path, '') AS primary_file_path, fav.created_at AS favorite_at FROM favorites fav JOIN artworks a ON a.artwork_id = fav.artwork_id LEFT JOIN artists ar ON ar.artist_id = a.artist_id LEFT JOIN followed_artists fa ON fa.artist_id = a.artist_id AND fa.enabled = 1 LEFT JOIN thumbnail_cache tc ON tc.artwork_id = a.artwork_id AND tc.page_index = 0 LEFT JOIN artwork_files af ON af.artwork_id = a.artwork_id AND af.page_index = 0 WHERE a.type IN ('illust', 'manga') ORDER BY fav.created_at DESC LIMIT ? OFFSET ? """, (max(1, min(int(limit), 200)), max(0, int(offset))), ).fetchall() items = [dict(row) for row in rows] self._ensure_list_thumbnails(items) items = self._refresh_thumbnail_paths(library, items) return {"total": int(total), "limit": limit, "offset": offset, "items": items} finally: library.close() def set_favorite(self, artwork_id: int, favorite: bool, note: str = "") -> dict[str, Any]: library = PixivLibrary(self.db_path) try: library.set_favorite(artwork_id, favorite, note) return {"artwork_id": artwork_id, "favorite": favorite} finally: library.close() def list_followed_artists(self) -> list[dict[str, Any]]: library = PixivLibrary(self.db_path) try: rows = library.connection.execute( """ SELECT fa.artist_id, COALESCE(NULLIF(fa.name, ''), NULLIF(ar.name, ''), '') AS name, COALESCE(NULLIF(ar.account, ''), '') AS account, fa.enabled, fa.last_synced_at, fa.last_error, COUNT(a.artwork_id) AS artwork_count FROM followed_artists fa LEFT JOIN artists ar ON ar.artist_id = fa.artist_id LEFT JOIN artworks a ON a.artist_id = fa.artist_id WHERE fa.enabled = 1 GROUP BY fa.artist_id ORDER BY CASE WHEN COALESCE(NULLIF(fa.name, ''), NULLIF(ar.name, ''), NULLIF(ar.account, '')) = '' THEN 1 ELSE 0 END, COALESCE(NULLIF(fa.name, ''), NULLIF(ar.name, ''), NULLIF(ar.account, ''), CAST(fa.artist_id AS TEXT)) ASC, fa.artist_id ASC """ ).fetchall() return [dict(row) for row in rows] finally: library.close() def set_followed_artist(self, artist_ref: int | str, followed: bool, name: str = "") -> dict[str, Any]: artist_id = self._resolve_artist_id(artist_ref) clean_name = self._clean_name(name) account = "" if followed and not clean_name: try: profile = fetch_user_profile( artist_id, cookie=str(SessionStore(app_session_file()).load().get("cookie", "")).strip(), ) profile_info = profile.get("profile") if isinstance(profile.get("profile"), dict) else {} clean_name = self._clean_name( profile.get("name") or profile.get("userName") or profile.get("displayName") or profile_info.get("name") ) account = self._clean_name(profile.get("account") or profile.get("userAccount")) except Exception: clean_name = "" library = PixivLibrary(self.db_path) try: if clean_name or account: library.upsert_artist_profile(artist_id, name=clean_name, account=account) library.set_followed_artist(artist_id, followed, clean_name) return { "artist_id": artist_id, "followed": followed, "name": clean_name, "account": account, "cloud_synced": False, } finally: library.close() def _resolve_artist_id(self, artist_ref: int | str) -> int: text = str(artist_ref).strip() if not text: raise ValueError("Please enter a Pixiv artist ID, profile URL, or synced artist name.") if text.lower().startswith("artist_") and text[7:].isdigit(): return int(text[7:]) match = re.search(r"/users/(\d+)", text) if match: return int(match.group(1)) if text.isdigit(): return int(text) lookup = text.lstrip("@") library = PixivLibrary(self.db_path) try: rows = [ dict(row) for row in library.connection.execute( """ SELECT artist_id, name, account FROM artists WHERE lower(name) = lower(?) OR lower(account) = lower(?) ORDER BY CASE WHEN lower(account) = lower(?) THEN 0 WHEN lower(name) = lower(?) THEN 1 ELSE 2 END, artist_id ASC """, (lookup, lookup, lookup, lookup), ).fetchall() ] finally: library.close() if len(rows) == 1: return int(rows[0]["artist_id"]) if not rows: raise ValueError("Could not resolve Pixiv artist ID from that name. Enter an ID/profile URL or sync the artist first.") choices = ", ".join(str(int(row["artist_id"])) for row in rows[:5]) raise ValueError(f"Artist name matched multiple Pixiv users; use an ID instead: {choices}") @staticmethod def _clean_name(value: Any) -> str: text = str(value or "").strip() return "" if text.lower() in {"none", "null", "undefined"} else text def scan_legacy_downloads(self, *, root: str | Path = "Sakura_Downloads") -> dict[str, Any]: summary = LegacyDownloadImporter(db_path=self.db_path).scan(root) self.thumbnail_cache.build_missing(limit=500) return summary.__dict__ def sync_followed_artists( self, *, cookie: str = "", max_new_per_artist: int = 20, download: bool = True, save_root: str | Path = "Sakura_Downloads", ) -> dict[str, Any]: if not cookie: cookie = str(SessionStore(app_session_file()).load().get("cookie", "")).strip() if not cookie: raise ValueError("No Pixiv cookie available. Save a session in the GUI first or pass cookie explicitly.") library = PixivLibrary(self.db_path) try: followed = library.connection.execute( """ SELECT fa.artist_id, COALESCE(NULLIF(fa.name, ''), NULLIF(ar.name, ''), NULLIF(ar.account, ''), '') AS name, COALESCE(NULLIF(ar.account, ''), '') AS account FROM followed_artists fa LEFT JOIN artists ar ON ar.artist_id = fa.artist_id WHERE fa.enabled = 1 ORDER BY fa.artist_id """ ).fetchall() finally: library.close() results: list[dict[str, Any]] = [] for row in followed: artist_id = int(row["artist_id"]) artist_name = self._clean_name(row["name"]) artist_account = self._clean_name(row["account"]) library = PixivLibrary(self.db_path) try: existing = { int(item["artwork_id"]) for item in library.connection.execute( "SELECT artwork_id FROM artworks WHERE artist_id = ? AND type IN ('illust', 'manga')", (artist_id,), ).fetchall() } finally: library.close() try: _, work_ids = fetch_user_work_ids(user_id=artist_id, cookie=cookie) new_ids = [work_id for work_id in work_ids if work_id not in existing][: max(0, int(max_new_per_artist))] downloaded = 0 if download and new_ids: _, download_results = download_user_works( user_id=artist_id, cookie=cookie, max_workers=3, request_delay=0.2, save_root=save_root, work_ids=new_ids, ) downloaded = len([item for item in download_results if item.ok]) library = PixivLibrary(self.db_path) try: library.mark_artist_synced(artist_id) finally: library.close() cloud_synced = False cloud_alerts = 0 results.append( { "artist_id": artist_id, "remote_count": len(work_ids), "new_count": len(new_ids), "downloaded": downloaded, "cloud_synced": cloud_synced, "alerts": cloud_alerts, "error": "", } ) except Exception as exc: library = PixivLibrary(self.db_path) try: library.mark_artist_synced(artist_id, error=str(exc)) finally: library.close() results.append({"artist_id": artist_id, "remote_count": 0, "new_count": 0, "downloaded": 0, "alerts": 0, "error": str(exc)}) return {"artists": results} def build_missing_thumbnails(self, *, limit: int = 200) -> list[dict[str, Any]]: return [item.__dict__ for item in self.thumbnail_cache.build_missing(limit=limit)] def get_thumbnail_path(self, artwork_id: int, *, page_index: int = 0) -> Path | None: self.thumbnail_cache.ensure_for_artwork(artwork_id) library = PixivLibrary(self.db_path) try: row = library.connection.execute( """ SELECT thumbnail_path FROM thumbnail_cache WHERE artwork_id = ? AND page_index = ? """, (artwork_id, page_index), ).fetchone() if row is None: return None path = Path(str(row["thumbnail_path"])) return path if path.exists() else None finally: library.close() def get_source_file_path(self, artwork_id: int, *, page_index: int = 0) -> Path | None: library = PixivLibrary(self.db_path) try: row = library.connection.execute( """ SELECT file_path FROM artwork_files WHERE artwork_id = ? AND page_index = ? """, (artwork_id, page_index), ).fetchone() if row is None: return None path = Path(str(row["file_path"])) return path if path.exists() else None finally: library.close() def _ensure_list_thumbnails(self, items: list[dict[str, Any]]) -> None: for item in items: if item.get("thumbnail_path"): continue if not item.get("primary_file_path"): continue self.thumbnail_cache.ensure_for_artwork(int(item["artwork_id"])) def _refresh_thumbnail_paths(self, library: PixivLibrary, items: list[dict[str, Any]]) -> list[dict[str, Any]]: artwork_ids = [int(item["artwork_id"]) for item in items] if not artwork_ids: return items placeholders = ",".join("?" for _ in artwork_ids) rows = library.connection.execute( f""" SELECT artwork_id, thumbnail_path FROM thumbnail_cache WHERE page_index = 0 AND artwork_id IN ({placeholders}) """, artwork_ids, ).fetchall() thumbs = {int(row["artwork_id"]): str(row["thumbnail_path"]) for row in rows} for item in items: item["thumbnail_path"] = thumbs.get(int(item["artwork_id"]), item.get("thumbnail_path", "")) return items