s

app/services/domains/publications/listing.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.services.domains.publication_identifiers import application as identifier_service
 from app.services.domains.publications.modes import (
     MODE_ALL,
     MODE_UNREAD,
@@ -44,7 +45,10 @@ async def list_for_user(
         publication_list_item_from_row(row, latest_run_id=latest_run_id)
         for row in result.all()
     ]
-    return rows
+    return await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=rows,
+    )
 
 
 async def retry_pdf_for_user(
@@ -54,12 +58,19 @@ async def retry_pdf_for_user(
     scholar_profile_id: int,
     publication_id: int,
 ) -> PublicationListItem | None:
-    return await get_publication_item_for_user(
+    item = await get_publication_item_for_user(
         db_session,
         user_id=user_id,
         scholar_profile_id=scholar_profile_id,
         publication_id=publication_id,
     )
+    if item is None:
+        return None
+    hydrated = await identifier_service.overlay_publication_items_with_display_identifiers(
+        db_session,
+        items=[item],
+    )
+    return hydrated[0] if hydrated else item
 
 
 async def list_unread_for_user(

app/services/domains/publications/pdf_queue.py

@@ -17,11 +17,16 @@ from app.db.models import (
     User,
 )
 from app.db.session import get_session_factory
+from app.services.domains.publication_identifiers import application as identifier_service
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+from app.services.domains.publications.pdf_resolution_pipeline import (
+    PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE,
+    resolve_publication_pdf_outcome_for_row,
+)
 from app.services.domains.publications.types import PublicationListItem
 from app.services.domains.unpaywall.application import (
     FAILURE_RESOLUTION_EXCEPTION,
     OaResolutionOutcome,
-    resolve_publication_oa_outcomes,
 )
 from app.settings import settings
 
@@ -57,6 +62,7 @@ class PdfQueueListItem:
     last_attempt_at: datetime | None
     resolved_at: datetime | None
     updated_at: datetime
+    display_identifier: DisplayIdentifier | None = None
 
 
 @dataclass(frozen=True)
@@ -118,6 +124,7 @@ def _item_from_row_and_job(
         pdf_attempt_count=int(job.attempt_count) if job is not None else 0,
         pdf_failure_reason=job.last_failure_reason if job is not None else None,
         pdf_failure_detail=job.last_failure_detail if job is not None else None,
+        display_identifier=row.display_identifier,
     )
 
 
@@ -366,8 +373,11 @@ async def _fetch_outcome_for_row(
     row: PublicationListItem,
     request_email: str | None,
 ) -> OaResolutionOutcome:
-    outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
-    outcome = outcomes.get(row.publication_id)
+    pipeline_result = await resolve_publication_pdf_outcome_for_row(
+        row=row,
+        request_email=request_email,
+    )
+    outcome = pipeline_result.outcome
     if outcome is not None:
         return outcome
     return _failed_outcome(row=row)
@@ -417,6 +427,11 @@ async def _persist_outcome(
         if publication is None or job is None:
             return
         _apply_publication_update(publication, doi=outcome.doi, pdf_url=outcome.pdf_url)
+        await identifier_service.sync_identifiers_for_publication_resolution(
+            db_session,
+            publication=publication,
+            source=outcome.source,
+        )
         _apply_job_outcome(job, outcome=outcome)
         event_type, status = _result_event(outcome)
         db_session.add(
@@ -794,6 +809,18 @@ def _queue_item_from_row(row: tuple) -> PdfQueueListItem:
     )
 
 
+async def _hydrated_queue_items(
+    db_session: AsyncSession,
+    *,
+    rows: list[tuple],
+) -> list[PdfQueueListItem]:
+    items = [_queue_item_from_row(row) for row in rows]
+    return await identifier_service.overlay_pdf_queue_items_with_display_identifiers(
+        db_session,
+        items=items,
+    )
+
+
 async def list_pdf_queue_items(
     db_session: AsyncSession,
     *,
@@ -811,7 +838,7 @@ async def list_pdf_queue_items(
                 offset=bounded_offset,
             )
         )
-        return [_queue_item_from_row(row) for row in result.all()]
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
     if normalized_status is None:
         result = await db_session.execute(
             _all_queue_select(
@@ -819,7 +846,7 @@ async def list_pdf_queue_items(
                 offset=bounded_offset,
             )
         )
-        return [_queue_item_from_row(row) for row in result.all()]
+        return await _hydrated_queue_items(db_session, rows=list(result.all()))
     result = await db_session.execute(
         _tracked_queue_select(
             limit=bounded_limit,
@@ -827,7 +854,7 @@ async def list_pdf_queue_items(
             status=normalized_status,
         )
     )
-    return [_queue_item_from_row(row) for row in result.all()]
+    return await _hydrated_queue_items(db_session, rows=list(result.all()))
 
 
 async def count_pdf_queue_items(

app/services/domains/publications/pdf_resolution_pipeline.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from urllib.parse import urlparse
+
+import httpx
+
+from app.services.domains.publications.types import PublicationListItem
+from app.services.domains.scholar.publication_pdf import (
+    ScholarPublicationLinkCandidate,
+    ScholarPublicationLinkCandidates,
+    fetch_link_candidates_from_scholar_publication_page,
+)
+from app.services.domains.unpaywall import pdf_discovery as pdf_discovery_service
+from app.services.domains.unpaywall.application import OaResolutionOutcome, resolve_publication_oa_outcomes
+from app.settings import settings
+
+logger = logging.getLogger(__name__)
+
+PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE = "scholar_publication_page"
+PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED = "scholar_publication_page_unlabeled_fallback"
+PDF_PATH_TOKEN = "/pdf/"
+HTTP_TIMEOUT_FLOOR_SECONDS = 0.5
+
+
+@dataclass(frozen=True)
+class PipelineOutcome:
+    outcome: OaResolutionOutcome | None
+    scholar_candidates: ScholarPublicationLinkCandidates | None
+
+
+async def resolve_publication_pdf_outcome_for_row(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> PipelineOutcome:
+    candidates = await _safe_scholar_candidates(row.pub_url)
+    labeled = _labeled_candidate(candidates)
+    if labeled is not None:
+        return PipelineOutcome(_scholar_outcome(row=row, candidate=labeled), candidates)
+    oa_outcome = await _oa_outcome(row=row, request_email=request_email)
+    if _oa_has_pdf(oa_outcome):
+        return PipelineOutcome(oa_outcome, candidates)
+    unlabeled = _unlabeled_candidate(candidates)
+    if unlabeled is None:
+        return PipelineOutcome(oa_outcome, candidates)
+    fallback_outcome = await _unlabeled_fallback_outcome(row=row, candidate=unlabeled)
+    if fallback_outcome is not None:
+        return PipelineOutcome(fallback_outcome, candidates)
+    return PipelineOutcome(oa_outcome, candidates)
+
+
+async def _safe_scholar_candidates(pub_url: str | None) -> ScholarPublicationLinkCandidates | None:
+    try:
+        return await fetch_link_candidates_from_scholar_publication_page(pub_url)
+    except Exception as exc:  # pragma: no cover - defensive boundary
+        logger.warning(
+            "publications.pdf_resolution.scholar_candidates_failed",
+            extra={"event": "publications.pdf_resolution.scholar_candidates_failed", "error": str(exc)},
+        )
+        return None
+
+
+def _labeled_candidate(
+    candidates: ScholarPublicationLinkCandidates | None,
+) -> ScholarPublicationLinkCandidate | None:
+    if candidates is None:
+        return None
+    return candidates.labeled_candidate
+
+
+def _unlabeled_candidate(
+    candidates: ScholarPublicationLinkCandidates | None,
+) -> ScholarPublicationLinkCandidate | None:
+    if candidates is None:
+        return None
+    return candidates.fallback_candidate
+
+
+def _scholar_outcome(
+    *,
+    row: PublicationListItem,
+    candidate: ScholarPublicationLinkCandidate,
+) -> OaResolutionOutcome:
+    source = (
+        PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE
+        if candidate.label_present
+        else PDF_SOURCE_SCHOLAR_PUBLICATION_PAGE_UNLABELED
+    )
+    return OaResolutionOutcome(
+        publication_id=row.publication_id,
+        doi=row.doi,
+        pdf_url=candidate.url,
+        failure_reason=None,
+        source=source,
+        used_crossref=False,
+    )
+
+
+async def _oa_outcome(
+    *,
+    row: PublicationListItem,
+    request_email: str | None,
+) -> OaResolutionOutcome | None:
+    outcomes = await resolve_publication_oa_outcomes([row], request_email=request_email)
+    return outcomes.get(row.publication_id)
+
+
+def _oa_has_pdf(outcome: OaResolutionOutcome | None) -> bool:
+    return bool(outcome and outcome.pdf_url)
+
+
+async def _unlabeled_fallback_outcome(
+    *,
+    row: PublicationListItem,
+    candidate: ScholarPublicationLinkCandidate,
+) -> OaResolutionOutcome | None:
+    pdf_url = await _validated_pdf_url(candidate.url)
+    if pdf_url is None:
+        return None
+    return _scholar_outcome(row=row, candidate=ScholarPublicationLinkCandidate(
+        url=pdf_url,
+        confidence_score=candidate.confidence_score,
+        label_present=False,
+        reason=candidate.reason,
+    ))
+
+
+async def _validated_pdf_url(candidate_url: str) -> str | None:
+    if _looks_direct_pdf(candidate_url):
+        return candidate_url
+    timeout_seconds = _discovery_timeout_seconds()
+    async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+        if await pdf_discovery_service._candidate_is_pdf(client, candidate_url=candidate_url):
+            return candidate_url
+        return await pdf_discovery_service.resolve_pdf_from_landing_page(client, page_url=candidate_url)
+
+
+def _looks_direct_pdf(url: str | None) -> bool:
+    if pdf_discovery_service.looks_like_pdf_url(url):
+        return True
+    if not isinstance(url, str):
+        return False
+    path = (urlparse(url).path or "").lower()
+    return PDF_PATH_TOKEN in path
+
+
+def _discovery_timeout_seconds() -> float:
+    return max(float(settings.unpaywall_timeout_seconds), HTTP_TIMEOUT_FLOOR_SECONDS)

app/services/domains/publications/types.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
 
+from app.services.domains.publication_identifiers.types import DisplayIdentifier
+
 
 @dataclass(frozen=True)
 class PublicationListItem:
@@ -24,6 +26,7 @@ class PublicationListItem:
     pdf_attempt_count: int = 0
     pdf_failure_reason: str | None = None
     pdf_failure_detail: str | None = None
+    display_identifier: DisplayIdentifier | None = None
 
 
 @dataclass(frozen=True)