piperch 0.2.0__py3-none-any.whl

piperch/__init__.py

@@ -0,0 +1,5 @@
+from importlib.metadata import version
+
+__all__ = ["__version__"]
+
+__version__ = version("piperch")

piperch/__main__.py

@@ -0,0 +1,4 @@
+from piperch.cli import main
+
+if __name__ == "__main__":
+    main()

piperch/api/__init__.py

@@ -0,0 +1 @@
+__all__: list[str] = []

piperch/api/authors.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from anyio import to_thread
+from fastapi import APIRouter, Depends, Path, Response, status
+
+from piperch.api.dependencies import get_container
+from piperch.api.models import (
+    FollowedUserResponse,
+    FollowedUsersResponse,
+    UserProfileResponse,
+)
+from piperch.api.pixiv_images import proxied_image_url
+from piperch.application.container import AppContainer
+
+router = APIRouter(prefix="/authors", tags=["authors"])
+
+
+@router.get("/followed", response_model=FollowedUsersResponse)
+async def followed_authors(
+    container: AppContainer = Depends(get_container),
+) -> FollowedUsersResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    items = await container.pixiv.list_followed_users(settings.pixiv_cookie)
+    return FollowedUsersResponse(
+        items=[
+            FollowedUserResponse(
+                user_id=item.user_id,
+                name=item.name,
+                avatar_url=proxied_image_url(item.avatar_url),
+            )
+            for item in items
+        ]
+    )
+
+
+@router.get("/{author_id}/profile", response_model=UserProfileResponse)
+async def author_profile(
+    author_id: int = Path(gt=0),
+    container: AppContainer = Depends(get_container),
+) -> UserProfileResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    profile = await container.pixiv.get_user_profile(author_id, settings.pixiv_cookie)
+    return UserProfileResponse(
+        avatar_url=proxied_image_url(profile.avatar_url),
+        is_followed=profile.is_followed,
+    )
+
+
+@router.post("/{author_id}/follow", status_code=status.HTTP_204_NO_CONTENT)
+async def follow_author(
+    author_id: int = Path(gt=0),
+    container: AppContainer = Depends(get_container),
+) -> Response:
+    settings = await to_thread.run_sync(container.settings.get)
+    await container.pixiv.follow_user(author_id, settings.pixiv_cookie)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.delete("/{author_id}/follow", status_code=status.HTTP_204_NO_CONTENT)
+async def unfollow_author(
+    author_id: int = Path(gt=0),
+    container: AppContainer = Depends(get_container),
+) -> Response:
+    settings = await to_thread.run_sync(container.settings.get)
+    await container.pixiv.unfollow_user(author_id, settings.pixiv_cookie)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

piperch/api/converters.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from piperch.api.models import (
+    ArtworkDetailResponse,
+    ArtworkSummaryResponse,
+    DownloadItemResponse,
+    DownloadJobDetailResponse,
+    DownloadJobSummaryResponse,
+    JobCounts,
+    MediaResponse,
+    TagResponse,
+    UgoiraFrameResponse,
+)
+from piperch.domain.artworks import ArtworkDetail, ArtworkSummary
+from piperch.domain.downloads import DownloadJobDetail, DownloadJobSummary, ItemState
+
+
+def artwork_summary_response(summary: ArtworkSummary) -> ArtworkSummaryResponse:
+    return ArtworkSummaryResponse(
+        artwork_id=summary.artwork_id,
+        title=summary.title,
+        artwork_type=summary.artwork_type,
+        author_id=summary.author_id,
+        author_name=summary.author_name,
+        series_id=summary.series_id,
+        series_title=summary.series_title,
+        page_count=summary.page_count,
+        x_restrict=summary.x_restrict,
+        is_ai=summary.is_ai,
+        published_at=summary.published_at,
+        downloaded_at=summary.downloaded_at,
+        is_favorite=summary.is_favorite,
+        group_ids=list(summary.group_ids),
+    )
+
+
+def artwork_detail_response(
+    detail: ArtworkDetail,
+    local_linked_artwork_ids: list[int],
+) -> ArtworkDetailResponse:
+    return ArtworkDetailResponse(
+        **artwork_summary_response(detail.summary).model_dump(),
+        description=detail.description,
+        local_linked_artwork_ids=local_linked_artwork_ids,
+        width=detail.width,
+        height=detail.height,
+        tags=[
+            TagResponse(
+                tag_id=tag.tag_id,
+                name=tag.name,
+            )
+            for tag in detail.tags
+        ],
+        media=[
+            MediaResponse(
+                role=item.role,
+                page_index=item.page_index,
+                mime_type=item.mime_type,
+                byte_size=item.byte_size,
+            )
+            for item in detail.media
+        ],
+        ugoira_frames=[
+            UgoiraFrameResponse(file_name=item.file_name, delay_ms=item.delay_ms) for item in detail.ugoira_frames
+        ],
+    )
+
+
+def download_job_summary_response(job: DownloadJobSummary) -> DownloadJobSummaryResponse:
+    return DownloadJobSummaryResponse(
+        job_id=job.job_id,
+        source_label=job.source_label,
+        state=job.state,
+        created_at=job.created_at,
+        started_at=job.started_at,
+        finished_at=job.finished_at,
+        error_summary=job.error_summary,
+        counts=JobCounts(
+            queued=job.counts.get(ItemState.QUEUED, 0),
+            running=job.counts.get(ItemState.RUNNING, 0),
+            skipped=job.counts.get(ItemState.SKIPPED, 0),
+            succeeded=job.counts.get(ItemState.SUCCEEDED, 0),
+            failed=job.counts.get(ItemState.FAILED, 0),
+            cancelled=job.counts.get(ItemState.CANCELLED, 0),
+        ),
+    )
+
+
+def download_job_detail_response(job: DownloadJobDetail) -> DownloadJobDetailResponse:
+    return DownloadJobDetailResponse(
+        **download_job_summary_response(job.summary).model_dump(),
+        items=[
+            DownloadItemResponse(
+                item_id=item.item_id,
+                artwork_id=item.artwork_id,
+                state=item.state,
+                attempts=item.attempts,
+                error=item.error,
+            )
+            for item in job.items
+        ],
+    )

piperch/api/dependencies.py

@@ -0,0 +1,7 @@
+from fastapi import Request
+
+from piperch.application.container import AppContainer
+
+
+def get_container(request: Request) -> AppContainer:
+    return request.app.state.container

piperch/api/discovery.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from anyio import to_thread
+from fastapi import APIRouter, Depends, Path
+
+from piperch.api.dependencies import get_container
+from piperch.api.models import (
+    ArtworkDiscoveryFailureResponse,
+    ArtworkDiscoveryRequest,
+    ArtworkPreviewResponse,
+    BookmarkArtworkIdsRequest,
+    BookmarkDiscoveryRequest,
+    BookmarkFolderResponse,
+    BookmarkFoldersResponse,
+    DiscoveryItem,
+    DiscoveryRequest,
+    DiscoveryResponse,
+    FollowUpdatesDiscoveryRequest,
+    RecommendationsResponse,
+    RecommendedUserResponse,
+    RecommendedUsersResponse,
+    SearchDiscoveryRequest,
+    UserArtworkIdsResponse,
+    UserDiscoveryRequest,
+)
+from piperch.api.pixiv_images import proxied_image_url
+from piperch.application.container import AppContainer
+from piperch.domain.bookmarks import BookmarkFolderReference
+from piperch.domain.discovery import DiscoveryCandidate
+
+router = APIRouter(prefix="/discovery", tags=["discovery"])
+
+
+def _discovery_items(
+    candidates: Sequence[DiscoveryCandidate],
+    existing_ids: set[int],
+) -> list[DiscoveryItem]:
+    return [
+        DiscoveryItem(
+            artwork_id=item.artwork_id,
+            title=item.title,
+            author_name=item.author_name,
+            artwork_type=item.artwork_type,
+            page_count=item.page_count,
+            x_restrict=item.x_restrict,
+            is_ai=item.is_ai,
+            thumbnail_url=proxied_image_url(item.thumbnail_url),
+            in_library=item.artwork_id in existing_ids,
+        )
+        for item in candidates
+    ]
+
+
+@router.post("", response_model=DiscoveryResponse)
+async def discover(
+    request: DiscoveryRequest,
+    container: AppContainer = Depends(get_container),
+) -> DiscoveryResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    next_page: int | None = None
+    failures: list[ArtworkDiscoveryFailureResponse] = []
+    if isinstance(request, ArtworkDiscoveryRequest):
+        result = await container.pixiv.discover_artworks(
+            request.inputs,
+            request.page,
+            settings.pixiv_cookie,
+        )
+        candidates, next_page = result.candidates, result.next_page
+        failures = [
+            ArtworkDiscoveryFailureResponse(artwork_id=item.artwork_id, message=item.message)
+            for item in result.failures
+        ]
+    elif isinstance(request, SearchDiscoveryRequest):
+        candidates, next_page = await container.pixiv.discover_search(
+            request.keyword,
+            request.page,
+            settings.pixiv_cookie,
+        )
+    elif isinstance(request, UserDiscoveryRequest):
+        candidates, next_page = await container.pixiv.discover_user(
+            request.user_id,
+            request.page,
+            settings.pixiv_cookie,
+        )
+    elif isinstance(request, BookmarkDiscoveryRequest):
+        candidates, next_page = await container.pixiv.discover_bookmarks(
+            BookmarkFolderReference(request.folder.visibility, request.folder.tag),
+            request.page,
+            settings.pixiv_cookie,
+        )
+    elif isinstance(request, FollowUpdatesDiscoveryRequest):
+        candidates, next_page = await container.pixiv.discover_follow_updates(
+            request.page,
+            settings.pixiv_cookie,
+        )
+    else:
+        candidates, next_page = await container.pixiv.discover_series(
+            request.series_id,
+            request.page,
+            settings.pixiv_cookie,
+        )
+    existing_ids = await to_thread.run_sync(
+        container.artworks.find_existing_ids,
+        [item.artwork_id for item in candidates],
+    )
+    return DiscoveryResponse(
+        items=_discovery_items(candidates, existing_ids),
+        page=request.page,
+        next_page=next_page,
+        failures=failures,
+    )
+
+
+@router.get("/recommendations", response_model=RecommendationsResponse)
+async def recommendations(
+    container: AppContainer = Depends(get_container),
+) -> RecommendationsResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    candidates = await container.pixiv.discover_recommended_artworks(settings.pixiv_cookie)
+    existing_ids = await to_thread.run_sync(
+        container.artworks.find_existing_ids,
+        [item.artwork_id for item in candidates],
+    )
+    return RecommendationsResponse(items=_discovery_items(candidates, existing_ids))
+
+
+@router.get("/recommended-users", response_model=RecommendedUsersResponse)
+async def recommended_users(
+    container: AppContainer = Depends(get_container),
+) -> RecommendedUsersResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    users = await container.pixiv.discover_recommended_users(settings.pixiv_cookie)
+    existing_ids = await to_thread.run_sync(
+        container.artworks.find_existing_ids,
+        [artwork.artwork_id for user in users for artwork in user.artworks],
+    )
+    return RecommendedUsersResponse(
+        items=[
+            RecommendedUserResponse(
+                user_id=user.user_id,
+                name=user.name,
+                comment=user.comment,
+                avatar_url=proxied_image_url(user.avatar_url),
+                is_followed=user.is_followed,
+                artworks=_discovery_items(user.artworks, existing_ids),
+            )
+            for user in users
+        ]
+    )
+
+
+@router.get(
+    "/artworks/{artwork_id}/preview",
+    response_model=ArtworkPreviewResponse,
+)
+async def artwork_preview(
+    artwork_id: int = Path(gt=0),
+    container: AppContainer = Depends(get_container),
+) -> ArtworkPreviewResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    urls = await container.pixiv.list_artwork_preview_urls(
+        artwork_id,
+        settings.pixiv_cookie,
+    )
+    return ArtworkPreviewResponse(urls=[url for item in urls if (url := proxied_image_url(item)) is not None])
+
+
+@router.get("/bookmark-folders", response_model=BookmarkFoldersResponse)
+async def bookmark_folders(
+    container: AppContainer = Depends(get_container),
+) -> BookmarkFoldersResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    folders = await container.pixiv.list_bookmark_folders(settings.pixiv_cookie)
+    return BookmarkFoldersResponse(
+        items=[
+            BookmarkFolderResponse(
+                visibility=folder.reference.visibility,
+                tag=folder.reference.tag,
+                kind=folder.kind,
+                name=folder.name,
+                item_count=folder.item_count,
+            )
+            for folder in folders
+        ]
+    )
+
+
+@router.post("/bookmarks/selectable-artwork-ids", response_model=UserArtworkIdsResponse)
+async def selectable_bookmark_artwork_ids(
+    request: BookmarkArtworkIdsRequest,
+    container: AppContainer = Depends(get_container),
+) -> UserArtworkIdsResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    artwork_ids = await container.pixiv.list_bookmark_artwork_ids(
+        [BookmarkFolderReference(folder.visibility, folder.tag) for folder in request.folders],
+        settings.pixiv_cookie,
+    )
+    existing_ids = await to_thread.run_sync(container.artworks.find_existing_ids, artwork_ids)
+    return UserArtworkIdsResponse(
+        artwork_ids=[artwork_id for artwork_id in artwork_ids if artwork_id not in existing_ids]
+    )
+
+
+@router.get("/users/{user_id}/selectable-artwork-ids", response_model=UserArtworkIdsResponse)
+async def selectable_user_artwork_ids(
+    user_id: int = Path(gt=0),
+    container: AppContainer = Depends(get_container),
+) -> UserArtworkIdsResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    artwork_ids = await container.pixiv.list_user_artwork_ids(user_id, settings.pixiv_cookie)
+    existing_ids = await to_thread.run_sync(container.artworks.find_existing_ids, artwork_ids)
+    return UserArtworkIdsResponse(
+        artwork_ids=[artwork_id for artwork_id in artwork_ids if artwork_id not in existing_ids]
+    )

piperch/api/downloads.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+from collections.abc import AsyncIterator
+
+from anyio import to_thread
+from fastapi import APIRouter, Depends, Query, Request, status
+from fastapi.responses import StreamingResponse
+
+from piperch.api.converters import download_job_detail_response, download_job_summary_response
+from piperch.api.dependencies import get_container
+from piperch.api.models import (
+    DownloadJobCreate,
+    DownloadJobCreated,
+    DownloadJobDetailResponse,
+    DownloadJobPage,
+)
+from piperch.application.container import AppContainer
+
+router = APIRouter(prefix="/download-jobs", tags=["downloads"])
+events_router = APIRouter(prefix="/events", tags=["downloads"])
+
+
+@router.post("", response_model=DownloadJobCreated, status_code=status.HTTP_202_ACCEPTED)
+async def create_job(
+    request: DownloadJobCreate,
+    container: AppContainer = Depends(get_container),
+) -> DownloadJobCreated:
+    container.storage.require_available()
+    job_id = await to_thread.run_sync(
+        container.downloads.create_job,
+        request.artwork_ids,
+        request.source_label,
+    )
+    container.supervisor.notify()
+    await container.events.publish_job_update(job_id)
+    return DownloadJobCreated(job_id=job_id)
+
+
+@router.get("", response_model=DownloadJobPage)
+def list_jobs(
+    page: int = Query(default=0, ge=0),
+    size: int = Query(default=20, ge=1, le=100),
+    container: AppContainer = Depends(get_container),
+) -> DownloadJobPage:
+    jobs, total = container.downloads.list_jobs(page, size)
+    return DownloadJobPage(
+        items=[download_job_summary_response(job) for job in jobs],
+        page=page,
+        size=size,
+        total_elements=total,
+        total_pages=math.ceil(total / size),
+    )
+
+
+@router.get("/{job_id}", response_model=DownloadJobDetailResponse)
+def get_job(
+    job_id: str,
+    container: AppContainer = Depends(get_container),
+) -> DownloadJobDetailResponse:
+    return download_job_detail_response(container.downloads.get_job(job_id))
+
+
+@router.post("/{job_id}/cancel", status_code=status.HTTP_202_ACCEPTED)
+async def cancel_job(
+    job_id: str,
+    container: AppContainer = Depends(get_container),
+) -> None:
+    await container.supervisor.request_cancel(job_id)
+
+
+@router.post("/{job_id}/retry", status_code=status.HTTP_202_ACCEPTED)
+async def retry_job(
+    job_id: str,
+    container: AppContainer = Depends(get_container),
+) -> None:
+    container.storage.require_available()
+    await to_thread.run_sync(container.downloads.retry, job_id)
+    container.supervisor.notify()
+    await container.events.publish_job_update(job_id)
+
+
+async def _event_stream(request: Request, container: AppContainer) -> AsyncIterator[str]:
+    yield "retry: 2000\n\n"
+    async with container.events.subscribe() as queue:
+        while not await request.is_disconnected():
+            try:
+                event = await asyncio.wait_for(queue.get(), timeout=15)
+            except TimeoutError:
+                yield ": heartbeat\n\n"
+                continue
+            data = json.dumps(event.data)
+            yield f"event: {event.name}\ndata: {data}\n\n"
+
+
+@events_router.get("/downloads", response_class=StreamingResponse)
+async def download_events(
+    request: Request,
+    container: AppContainer = Depends(get_container),
+) -> StreamingResponse:
+    return StreamingResponse(
+        _event_stream(request, container),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )

piperch/api/favorites.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from uuid import UUID
+
+from anyio import to_thread
+from fastapi import APIRouter, Depends
+from fastapi import Path as PathParameter
+
+from piperch.api.dependencies import get_container
+from piperch.api.models import (
+    FavoriteStateRequest,
+    FavoriteStateResponse,
+    FavoriteSyncPlanResponse,
+    FavoriteSyncResultResponse,
+)
+from piperch.application.container import AppContainer
+from piperch.domain.bookmarks import BookmarkFolderReference, BookmarkVisibility
+
+router = APIRouter(tags=["favorites"])
+
+
+@router.post("/favorite-sync-plans", response_model=FavoriteSyncPlanResponse)
+async def create_favorite_sync_plan(
+    container: AppContainer = Depends(get_container),
+) -> FavoriteSyncPlanResponse:
+    settings = await to_thread.run_sync(container.settings.get)
+    artwork_ids = await container.pixiv.list_bookmark_artwork_ids(
+        [
+            BookmarkFolderReference(BookmarkVisibility.PUBLIC, None),
+            BookmarkFolderReference(BookmarkVisibility.PRIVATE, None),
+        ],
+        settings.pixiv_cookie,
+    )
+    plan = await to_thread.run_sync(lambda: container.favorite_sync.create_plan(artwork_ids))
+    diff = plan.diff
+    return FavoriteSyncPlanResponse(
+        plan_id=str(plan.plan_id),
+        pixiv_favorite_count=diff.pixiv_favorite_count,
+        local_artwork_count=diff.local_artwork_count,
+        local_favorite_count=diff.local_favorite_count,
+        matched_favorite_count=diff.matched_favorite_count,
+        unavailable_locally_count=diff.unavailable_locally_count,
+        add_count=len(diff.add_artwork_ids),
+        remove_count=len(diff.remove_artwork_ids),
+    )
+
+
+@router.post(
+    "/favorite-sync-plans/{plan_id}/apply",
+    response_model=FavoriteSyncResultResponse,
+)
+async def apply_favorite_sync_plan(
+    plan_id: UUID = PathParameter(),
+    container: AppContainer = Depends(get_container),
+) -> FavoriteSyncResultResponse:
+    result = await to_thread.run_sync(lambda: container.favorite_sync.apply_plan(plan_id))
+    return FavoriteSyncResultResponse(added=result.added, removed=result.removed)
+
+
+@router.put("/artworks/{artwork_id}/favorite", response_model=FavoriteStateResponse)
+async def replace_favorite_state(
+    request: FavoriteStateRequest,
+    artwork_id: int = PathParameter(gt=0),
+    container: AppContainer = Depends(get_container),
+) -> FavoriteStateResponse:
+    await to_thread.run_sync(container.favorites.get_state, artwork_id)
+    settings = await to_thread.run_sync(container.settings.get)
+    await container.pixiv.sync_bookmark_state(
+        artwork_id,
+        request.is_favorite,
+        settings.pixiv_cookie,
+    )
+    state = await to_thread.run_sync(
+        lambda: container.favorites.replace_state(
+            artwork_id,
+            is_favorite=request.is_favorite,
+        )
+    )
+    return FavoriteStateResponse(
+        artwork_id=state.artwork_id,
+        is_favorite=state.is_favorite,
+    )