commit
9c5fef1a4d
412 files changed
+94582
No files matched your search
@@ -0,0 +1,597 @@
|
||||
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
|
||||
Reference in new issue
Block a user