scitex 2.16.0__py3-none-any.whl → 2.16.2__py3-none-any.whl

scitex/scholar/url_finder/.tmp/open_url/_OpenURLResolver.py

@@ -0,0 +1,1160 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-06 16:55:39 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/open_url/_OpenURLResolver.py
+# ----------------------------------------
+from __future__ import annotations
+
+import os
+
+__FILE__ = (
+    "./src/scitex/scholar/open_url/_OpenURLResolver.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import asyncio
+import random
+import time
+from typing import List, Union
+
+from scitex import logging
+
+"""OpenURL resolver for finding full-text access through institutional libraries."""
+
+from typing import Any, Dict, Optional
+from urllib.parse import urlencode
+
+from playwright.async_api import Page
+
+from scitex.scholar.browser import BrowserManager
+from scitex.scholar.config import ScholarConfig
+
+from ...errors import ScholarError
+from ._ResolverLinkFinder import ResolverLinkFinder
+
+logger = logging.getLogger(__name__)
+
+
+class OpenURLResolver:
+    """Resolves DOIs/metadata to full-text URLs via institutional OpenURL resolver.
+
+    OpenURL is a standardized format for encoding bibliographic information
+    that libraries use to link to full-text resources."""
+
+    AUTH_PATTERNS = [
+        "openathens.net",
+        "shibauth",
+        "saml",
+        "institutionlogin",
+        "iam.atypon.com",
+        "auth.elsevier.com",
+        "go.gale.com/ps/headerQuickSearch",
+    ]
+
+    PUBLISHER_DOMAINS = [
+        "sciencedirect.com",
+        "nature.com",
+        "springer.com",
+        "wiley.com",
+        "onlinelibrary.wiley.com",
+        "acs.org",
+        "tandfonline.com",
+        "sagepub.com",
+        "academic.oup.com",
+        "science.org",
+        "pnas.org",
+        "bmj.com",
+        "cell.com",
+    ]
+
+    def __init__(
+        self,
+        auth_manager,
+        resolver_url: Optional[str] = None,
+        browser_mode: str = "stealth",
+        config: Optional[ScholarConfig] = None,
+    ):
+        """Initialize OpenURL resolver.
+
+        Args:
+            auth_manager: Authentication manager for institutional access
+            resolver_url: Base URL of institutional OpenURL resolver
+                         (Details can be seen at https://www.zotero.org/openurl_resolvers)
+            browser_mode: Browser mode ("stealth" or "interactive")
+            config: ScholarConfig instance (creates new if None)
+        """
+        self.auth_manager = auth_manager
+
+        # Initialize config
+        if config is None:
+            config = ScholarConfig()
+        self.config = config
+
+        # Resolve resolver URL from config
+        self.resolver_url = self.config.resolve(
+            "openurl_resolver_url", resolver_url, None, str
+        )
+
+        # Create BrowserManager with simplified configuration
+        self.browser = BrowserManager(
+            auth_manager=auth_manager,
+            browser_mode=browser_mode,
+            config=self.config,
+        )
+
+        self.timeout = 30
+        self._link_finder = ResolverLinkFinder()
+
+        # Screenshot capture setup (optional, controlled by config)
+        self.capture_screenshots = self.config.resolve(
+            "capture_screenshots", None, False, bool
+        )
+        if self.capture_screenshots:
+            from datetime import datetime
+
+            self.screenshot_dir = (
+                self.config.paths.get_screenshots_dir() / "openurl"
+            )
+            self.screenshot_dir.mkdir(parents=True, exist_ok=True)
+            self.session_timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    async def _capture_checkpoint_screenshot_async(
+        self, page, stage: str, doi: str = ""
+    ) -> Optional[str]:
+        """Capture screenshot at checkpoint for debugging."""
+        if not self.capture_screenshots:
+            return None
+
+        try:
+            from datetime import datetime
+
+            timestamp = datetime.now().strftime("%H%M%S")
+            doi_safe = (
+                doi.replace("/", "-").replace(".", "_") if doi else "unknown"
+            )
+            screenshot_name = f"openurl_{stage}_{doi_safe}_{timestamp}.png"
+            screenshot_path = self.screenshot_dir / screenshot_name
+
+            await page.screenshot(path=str(screenshot_path), full_page=True)
+            logger.info(
+                f"📸 Screenshot captured: {stage} -> {screenshot_name}"
+            )
+            return str(screenshot_path)
+        except Exception as e:
+            logger.warning(f"📸 Screenshot capture failed at {stage}: {e}")
+            return None
+
+    def build_openurl(
+        self,
+        title: str = "",
+        authors: Optional[list] = None,
+        journal: str = "",
+        year: Optional[int] = None,
+        volume: Optional[int] = None,
+        issue: Optional[int] = None,
+        pages: str = "",
+        doi: str = "",
+        pmid: str = "",
+    ) -> str:
+        """Build OpenURL query string from paper metadata."""
+        params = {
+            "ctx_ver": "Z39.88-2004",
+            "rft_val_fmt": "info:ofi/fmt:kev:mtx:journal",
+            "rft.genre": "article",
+        }
+
+        if title:
+            params["rft.atitle"] = title
+        if journal:
+            params["rft.jtitle"] = journal
+        if year:
+            params["rft.date"] = str(year)
+        if volume:
+            params["rft.volume"] = str(volume)
+        if issue:
+            params["rft.issue"] = str(issue)
+        if pages:
+            if "-" in str(pages):
+                spage, epage = pages.split("-", 1)
+                params["rft.spage"] = spage.strip()
+                params["rft.epage"] = epage.strip()
+            else:
+                params["rft.spage"] = str(pages)
+        if doi:
+            params["rft.doi"] = doi
+        if pmid:
+            params["rft.pmid"] = str(pmid)
+
+        if authors:
+            first_author = authors[0]
+            if "," in first_author:
+                last, first = first_author.split(",", 1)
+                params["rft.aulast"] = last.strip()
+                params["rft.aufirst"] = first.strip()
+                params["rft.au"] = first_author
+
+        query_string = urlencode(params, safe=":/")
+        return f"{self.resolver_url}?{query_string}"
+
+    def _is_publisher_url(self, url: str, doi: str = "") -> bool:
+        """Check if URL is from expected publisher domain."""
+        if not url:
+            return False
+        if any(pattern in url.lower() for pattern in self.AUTH_PATTERNS):
+            return False
+        if any(domain in url.lower() for domain in self.PUBLISHER_DOMAINS):
+            return True
+        else:
+            return False
+
+    async def _follow_saml_redirect_async(self, page, saml_url, doi=""):
+        """Follow SAML/SSO redirect chain until publisher URL is reached."""
+        logger.info(f"Following SAML redirect chain starting from: {saml_url}")
+
+        if self._is_publisher_url(saml_url, doi):
+            return saml_url
+
+        await page.goto(
+            saml_url,
+            wait_until="domcontentloaded",
+            timeout=15000,  # Increased from 1.5-3s to 15s
+        )
+        last_url = ""
+
+        for attempt in range(8):
+            current_url = page.url
+            logger.debug(f"SAML redirect attempt {attempt + 1}: {current_url}")
+
+            if self._is_publisher_url(current_url, doi):
+                logger.info(
+                    f"Successfully navigated to publisher URL: {current_url}"
+                )
+                return current_url
+
+            # If URL hasn't changed in 2 attempts, we're stuck
+            if current_url == last_url and attempt > 1:
+                logger.warning(f"SAML redirect stuck at: {current_url}")
+                return current_url
+
+            last_url = current_url
+
+            # Only try form submission first few attempts
+            if attempt < 3:
+                try:
+                    forms = await page.query_selector_all("form")
+                    for form in forms:
+                        if await form.is_visible():
+                            logger.debug("Submitting visible form...")
+                            await form.evaluate("form => form.submit()")
+                            await page.wait_for_load_state(
+                                "domcontentloaded", timeout=10000
+                            )
+                            break
+                except:
+                    pass
+
+            await page.wait_for_timeout(1000)
+
+        final_url = page.url
+        logger.info(f"SAML redirect completed at: {final_url}")
+        return final_url
+
+    async def _find_and_click_publisher_go_button_async(self, page, doi=""):
+        """Find and click the appropriate publisher GO button on the OpenURL resolver page.
+
+        This method implements our proven GO button detection and clicking logic
+        that successfully worked for Science.org and Nature.com access.
+        """
+        try:
+            logger.info("Looking for publisher GO buttons on resolver page...")
+
+            # Get all GO buttons with context information
+            go_buttons = await page.evaluate(
+                """() => {
+                const goButtons = Array.from(document.querySelectorAll('input[value="Go"], button[value="Go"], input[value="GO"], button[value="GO"]'));
+                return goButtons.map((btn, index) => {
+                    const parentRow = btn.closest('tr') || btn.parentElement;
+                    const rowText = parentRow ? parentRow.textContent.trim() : '';
+
+                    // Check for publisher indicators in the row text
+                    const isScience = rowText.toLowerCase().includes('american association') ||
+                                    rowText.toLowerCase().includes('aaas') ||
+                                    rowText.toLowerCase().includes('science');
+                    const isNature = rowText.toLowerCase().includes('nature') ||
+                                   rowText.toLowerCase().includes('springer');
+                    const isWiley = rowText.toLowerCase().includes('wiley');
+                    const isElsevier = rowText.toLowerCase().includes('elsevier') ||
+                                     rowText.toLowerCase().includes('sciencedirect');
+
+                    return {
+                        index: index,
+                        globalIndex: Array.from(document.querySelectorAll('input, button, a, [onclick]')).indexOf(btn),
+                        value: btn.value,
+                        rowText: rowText,
+                        isScience: isScience,
+                        isNature: isNature,
+                        isWiley: isWiley,
+                        isElsevier: isElsevier,
+                        isPublisher: isScience || isNature || isWiley || isElsevier
+                    };
+                });
+            }"""
+            )
+
+            if not go_buttons:
+                logger.warning("No GO buttons found on resolver page")
+                return {"success": False, "reason": "no_go_buttons"}
+
+            logger.info(f"Found {len(go_buttons)} GO buttons")
+            for btn in go_buttons:
+                logger.debug(
+                    f"GO button {btn['index']}: {btn['rowText'][:50]}... (Publisher: {btn['isPublisher']})"
+                )
+
+            # Find the most appropriate publisher button
+            target_button = None
+
+            # Priority order: Science > Nature > Other publishers
+            for btn in go_buttons:
+                if btn["isScience"]:
+                    target_button = btn
+                    logger.info(
+                        f"Selected Science/AAAS GO button: {btn['rowText'][:50]}..."
+                    )
+                    break
+                elif btn["isNature"]:
+                    target_button = btn
+                    logger.info(
+                        f"Selected Nature GO button: {btn['rowText'][:50]}..."
+                    )
+                    break
+                elif btn["isPublisher"]:
+                    target_button = btn
+                    logger.info(
+                        f"Selected publisher GO button: {btn['rowText'][:50]}..."
+                    )
+                    break
+
+            # Fallback: if no publisher buttons, try the first few GO buttons (might be direct access)
+            if not target_button and go_buttons:
+                target_button = go_buttons[0]
+                logger.info(
+                    f"Using fallback GO button: {target_button['rowText'][:50]}..."
+                )
+
+            if not target_button:
+                logger.warning("No suitable GO button found")
+                return {"success": False, "reason": "no_suitable_button"}
+
+            # Click the selected GO button and handle popup
+            logger.info("Clicking GO button and waiting for popup...")
+
+            try:
+                # Set up popup listener before clicking
+                popup_promise = page.wait_for_event("popup", timeout=30000)
+
+                # Click the button using its global index for reliability
+                click_result = await page.evaluate(
+                    f"""() => {{
+                    const allElements = Array.from(document.querySelectorAll('input, button, a, [onclick]'));
+                    const targetButton = allElements[{target_button['globalIndex']}];
+                    if (targetButton && (targetButton.value === 'Go' || targetButton.value === 'GO')) {{
+                        console.log('Clicking GO button:', targetButton);
+                        targetButton.click();
+                        return 'clicked';
+                    }}
+                    return 'not-found';
+                }}"""
+                )
+
+                if click_result != "clicked":
+                    logger.warning("Failed to click GO button")
+                    return {"success": False, "reason": "click_failed"}
+
+                # Wait for popup
+                popup = await popup_promise
+                logger.info("Publisher popup opened successfully")
+
+                # Wait for popup to load
+                await popup.wait_for_load_state(
+                    "domcontentloaded", timeout=30000
+                )
+                await popup.wait_for_timeout(5000)  # Allow time for redirects
+
+                final_url = popup.url
+                popup_title = await popup.title()
+
+                logger.info(f"Successfully accessed: {popup_title}")
+                logger.info(f"Final URL: {final_url}")
+
+                # Verify we reached a publisher URL
+                if self._is_publisher_url(final_url, doi):
+                    logger.success(
+                        f"Successfully reached publisher: {final_url}"
+                    )
+
+                    result = {
+                        "final_url": final_url,
+                        "resolver_url": page.url,
+                        "access_type": "publisher_go_button",
+                        "success": True,
+                        "publisher_detected": True,
+                        "popup_page": popup,  # Keep popup open for potential PDF download
+                    }
+
+                    # Don't close popup immediately - let caller decide
+                    # await popup.close()
+                    return result
+                else:
+                    logger.info(f"Reached non-publisher URL: {final_url}")
+
+                    result = {
+                        "final_url": final_url,
+                        "resolver_url": page.url,
+                        "access_type": "go_button_redirect",
+                        "success": True,
+                        "publisher_detected": False,
+                        "popup_page": popup,  # Keep popup open for potential PDF download
+                    }
+
+                    # Don't close popup immediately - let caller decide
+                    # await popup.close()
+                    return result
+
+            except Exception as popup_error:
+                logger.warning(f"Popup handling failed: {popup_error}")
+                return {
+                    "success": False,
+                    "reason": f"popup_error: {popup_error}",
+                }
+
+        except Exception as e:
+            logger.error(f"GO button detection failed: {e}")
+            return {"success": False, "reason": f"detection_error: {e}"}
+
+    async def _download_pdf_async_from_publisher_page(
+        self, popup, filename, download_dir="downloads"
+    ):
+        """Download PDF from publisher page after successful GO button access.
+
+        This method implements our proven PDF download logic that works
+        with various publisher sites including Science.org and Nature.com.
+        """
+        from pathlib import Path
+
+        try:
+            download_path = Path(download_dir)
+            download_path.mkdir(exist_ok=True)
+
+            logger.info("Looking for PDF download links on publisher page...")
+
+            # Find PDF download links
+            pdf_links = await popup.evaluate(
+                """() => {
+                const allLinks = Array.from(document.querySelectorAll('a, button, input'));
+                return allLinks.filter(el =>
+                    el.textContent.toLowerCase().includes('pdf') ||
+                    el.textContent.toLowerCase().includes('download') ||
+                    el.href?.includes('pdf') ||
+                    el.getAttribute('data-track-action')?.includes('pdf')
+                ).map(el => ({
+                    tag: el.tagName,
+                    text: el.textContent.trim(),
+                    href: el.href || el.value || 'no-href',
+                    className: el.className,
+                    id: el.id,
+                    trackAction: el.getAttribute('data-track-action') || 'none'
+                }));
+            }"""
+            )
+
+            if not pdf_links:
+                logger.warning("No PDF links found on publisher page")
+                return {"success": False, "reason": "no_pdf_links"}
+
+            logger.info(f"Found {len(pdf_links)} potential PDF links")
+            for i, link in enumerate(pdf_links):
+                logger.debug(
+                    f"PDF link {i}: {link['text'][:30]}... | {link['href'][:50]}..."
+                )
+
+            # Find the best PDF download link
+            main_pdf_link = None
+
+            # Priority order: direct download > PDF with download > PDF view
+            for link in pdf_links:
+                if "download pdf" in link["text"].lower():
+                    main_pdf_link = link
+                    break
+                elif link["href"] != "no-href" and link["href"].endswith(
+                    ".pdf"
+                ):
+                    main_pdf_link = link
+                    break
+                elif (
+                    "pdf" in link["text"].lower()
+                    and "view" not in link["text"].lower()
+                ):
+                    main_pdf_link = link
+                    break
+
+            if not main_pdf_link:
+                main_pdf_link = pdf_links[
+                    0
+                ]  # Fallback to first PDF-related link
+
+            logger.info(f"Selected PDF link: {main_pdf_link['text'][:40]}...")
+
+            # Set up download path
+            file_path = download_path / filename
+
+            # Configure download headers
+            await popup.set_extra_http_headers(
+                {"Accept": "application/pdf,application/octet-stream,*/*"}
+            )
+
+            # Try download methods
+            pdf_download = False
+
+            # Method 1: Direct URL navigation
+            if (
+                main_pdf_link["href"] != "no-href"
+                and "pdf" in main_pdf_link["href"].lower()
+            ):
+                try:
+                    logger.info("Attempting direct PDF URL download...")
+                    download_promise = popup.wait_for_event(
+                        "download", timeout=30000
+                    )
+                    await popup.goto(main_pdf_link["href"])
+
+                    download = await download_promise
+                    await download.save_as(str(file_path))
+
+                    if file_path.exists():
+                        size_mb = file_path.stat().st_size / (1024 * 1024)
+                        logger.success(
+                            f"PDF download successfully: {filename} ({size_mb:.1f} MB)"
+                        )
+                        pdf_download = True
+
+                except Exception as e:
+                    logger.debug(f"Direct download failed: {e}")
+
+            # Method 2: Click-based download
+            if not pdf_download:
+                try:
+                    logger.info("Attempting click-based PDF download...")
+                    download_promise = popup.wait_for_event(
+                        "download", timeout=30000
+                    )
+
+                    # Click the first PDF link
+                    await popup.evaluate(
+                        """() => {
+                        const allLinks = Array.from(document.querySelectorAll('a, button, input'));
+                        const pdfLinks = allLinks.filter(el =>
+                            el.textContent.toLowerCase().includes('pdf') ||
+                            el.textContent.toLowerCase().includes('download') ||
+                            el.href?.includes('pdf')
+                        );
+                        if (pdfLinks.length > 0) {
+                            pdfLinks[0].click();
+                            return 'clicked';
+                        }
+                        return 'no-link';
+                    }"""
+                    )
+
+                    download = await download_promise
+                    await download.save_as(str(file_path))
+
+                    if file_path.exists():
+                        size_mb = file_path.stat().st_size / (1024 * 1024)
+                        logger.success(
+                            f"PDF download successfully: {filename} ({size_mb:.1f} MB)"
+                        )
+                        pdf_download = True
+
+                except Exception as e:
+                    logger.debug(f"Click-based download failed: {e}")
+
+            if pdf_download:
+                return {
+                    "success": True,
+                    "filename": filename,
+                    "path": str(file_path),
+                    "size_mb": (
+                        file_path.stat().st_size / (1024 * 1024)
+                        if file_path.exists()
+                        else 0
+                    ),
+                }
+            else:
+                logger.warning("All PDF download methods failed")
+                # Take screenshot for debugging
+                screenshot_path = (
+                    download_path
+                    / f"pdf_download_failed_{filename.replace('.pdf', '.png')}"
+                )
+                await popup.screenshot(
+                    path=str(screenshot_path), full_page=True
+                )
+                logger.info(
+                    f"Screenshot saved for debugging: {screenshot_path}"
+                )
+
+                return {
+                    "success": False,
+                    "reason": "download_failed",
+                    "screenshot": str(screenshot_path),
+                    "available_links": [link["text"] for link in pdf_links],
+                }
+
+        except Exception as e:
+            logger.error(f"PDF download failed: {e}")
+            return {"success": False, "reason": f"error: {e}"}
+
+    async def resolve_and_download_pdf_async(
+        self,
+        title: str = "",
+        authors: Optional[list] = None,
+        journal: str = "",
+        year: Optional[int] = None,
+        volume: Optional[int] = None,
+        issue: Optional[int] = None,
+        pages: str = "",
+        doi: str = "",
+        pmid: str = "",
+        filename: str = None,
+        download_dir: str = "downloads",
+    ) -> Dict[str, Any]:
+        """Resolve paper access and download PDF in one operation.
+
+        This method combines our GO button resolution with PDF download
+        to provide a complete paper acquisition workflow.
+        """
+        if not filename:
+            # Generate filename from metadata
+            first_author = (
+                authors[0].split(",")[0].strip() if authors else "Unknown"
+            )
+            filename = f"{first_author}-{year}-{journal.replace(' ', '')}-{title[:30].replace(' ', '_')}.pdf"
+            # Clean filename
+            filename = "".join(
+                c for c in filename if c.isalnum() or c in ".-_"
+            ).strip()
+
+        logger.info(f"Starting resolve and download for: {filename}")
+
+        # Create fresh context for this operation
+        browser, context = await self.browser.get_authenticated_browser_and_context_async()
+        page = await context.new_page()
+
+        try:
+            # Build OpenURL
+            openurl = self.build_openurl(
+                title, authors, journal, year, volume, issue, pages, doi, pmid
+            )
+            logger.info(f"Resolving and downloading via OpenURL: {openurl}")
+
+            # Navigate to OpenURL resolver
+            await page.goto(
+                openurl, wait_until="domcontentloaded", timeout=30000
+            )
+            await page.wait_for_timeout(2000)
+
+            # Try GO button method
+            go_button_result = (
+                await self._find_and_click_publisher_go_button_async(page, doi)
+            )
+
+            if (
+                go_button_result["success"]
+                and "popup_page" in go_button_result
+            ):
+                popup = go_button_result["popup_page"]
+
+                logger.info(
+                    "Successfully accessed publisher page, attempting PDF download..."
+                )
+
+                # Try to download PDF
+                download_result = (
+                    await self._download_pdf_async_from_publisher_page(
+                        popup, filename, download_dir
+                    )
+                )
+
+                # Close popup
+                try:
+                    await popup.close()
+                except:
+                    pass
+
+                # Combine results
+                final_result = {
+                    **go_button_result,
+                    "pdf_download": download_result,
+                    "filename": filename,
+                }
+
+                # Remove popup reference
+                if "popup_page" in final_result:
+                    del final_result["popup_page"]
+
+                if download_result["success"]:
+                    logger.success(f"Successfully download PDF: {filename}")
+                else:
+                    logger.warning(
+                        f"Paper accessed but PDF download failed: {download_result.get('reason', 'unknown')}"
+                    )
+
+                return final_result
+
+            else:
+                logger.warning("Could not access publisher page via GO button")
+                return {
+                    "success": False,
+                    "reason": "go_button_failed",
+                    "go_button_result": go_button_result,
+                    "filename": filename,
+                }
+
+        except Exception as e:
+            logger.error(f"Resolve and download failed: {e}")
+            return {
+                "success": False,
+                "reason": f"error: {e}",
+                "filename": filename,
+            }
+        finally:
+            await context.close()
+
+    async def _resolve_single_async(
+        self,
+        title: str = "",
+        authors: Optional[list] = None,
+        journal: str = "",
+        year: Optional[int] = None,
+        volume: Optional[int] = None,
+        issue: Optional[int] = None,
+        pages: str = "",
+        doi: str = "",
+        pmid: str = "",
+    ) -> Optional[Dict[str, Any]]:
+
+        # Note: Removed self.__init__ call that was creating second BrowserManager
+        # This was causing configuration inconsistency - the resolver is already initialized
+
+        if not doi:
+            logger.warning("DOI is required for reliable resolution")
+
+        # Create fresh context for each resolution
+        browser, context = await self.browser.get_authenticated_browser_and_context_async()
+        page = await context.new_page()
+
+        openurl = self.build_openurl(
+            title, authors, journal, year, volume, issue, pages, doi, pmid
+        )
+        logger.info(f"Resolving via OpenURL: {openurl}")
+
+        try:
+            logger.info("Navigating to OpenURL resolver...")
+
+            # Clear any existing navigation state
+            await page.wait_for_timeout(1000)
+
+            await page.goto(
+                openurl, wait_until="domcontentloaded", timeout=30000
+            )
+
+            # Checkpoint 1: After loading OpenURL resolver page
+            await self._capture_checkpoint_screenshot_async(
+                page, "01_openurl_loaded", doi
+            )
+
+            # Apply stealth behaviors if using standard browser
+            if hasattr(self.browser, "stealth_manager"):
+                await self.browser.stealth_manager.human_delay_async()
+                await self.browser.stealth_manager.human_mouse_move_async(page)
+                await self.browser.stealth_manager.human_scroll_async(page)
+
+            await page.wait_for_timeout(2000)
+
+            # Checkpoint 2: After stealth behaviors applied
+            await self._capture_checkpoint_screenshot_async(
+                page, "02_stealth_applied", doi
+            )
+
+            current_url = page.url
+            if self._is_publisher_url(current_url, doi):
+                logger.info(
+                    f"Resolver redirected directly to publisher: {current_url}"
+                )
+                return {
+                    "final_url": current_url,
+                    "resolver_url": openurl,
+                    "access_type": "direct_redirect",
+                    "success": True,
+                }
+
+            content = await page.content()
+            if any(
+                phrase in content
+                for phrase in [
+                    "No online text available",
+                    "No full text available",
+                    "No electronic access",
+                ]
+            ):
+                logger.warn("Resolver indicates no access available")
+                return {
+                    "final_url": None,
+                    "resolver_url": current_url,
+                    "access_type": "no_access",
+                    "success": False,
+                }
+
+            logger.info("Looking for full-text link on resolver page...")
+
+            # First try our GO button method
+            go_button_result = (
+                await self._find_and_click_publisher_go_button_async(page, doi)
+            )
+            if go_button_result["success"]:
+                # Clean up popup if it exists
+                if "popup_page" in go_button_result:
+                    popup = go_button_result["popup_page"]
+                    try:
+                        await popup.close()
+                    except:
+                        pass
+                    # Remove popup reference from result
+                    del go_button_result["popup_page"]
+                return go_button_result
+
+            # Fallback to original link finder method
+            link_result = await self._link_finder.find_link_async(page, doi)
+
+            if not link_result["success"]:
+                logger.warning(
+                    "Could not find full-text link on resolver page"
+                )
+                return {
+                    "final_url": None,
+                    "resolver_url": current_url,
+                    "access_type": "link_not_found",
+                    "success": False,
+                }
+
+            link_url = link_result["url"]
+
+            if link_url.startswith("javascript:"):
+                logger.info("Handling JavaScript link...")
+                try:
+                    async with page.expect_popup(timeout=30000) as popup_info:
+                        await page.evaluate(
+                            link_url.replace("javascript:", "")
+                        )
+
+                    popup = await popup_info.value
+                    await popup.wait_for_load_state(
+                        "domcontentloaded", timeout=30000
+                    )
+                    final_url = popup.url
+
+                    if any(
+                        domain in final_url
+                        for domain in ["openathens.net", "saml", "shibauth"]
+                    ):
+                        final_url = await self._follow_saml_redirect_async(
+                            popup, final_url, doi
+                        )
+
+                    logger.info(f"Successfully resolved to popup: {final_url}")
+                    await popup.close()
+
+                    return {
+                        "final_url": final_url,
+                        "resolver_url": openurl,
+                        "access_type": "institutional",
+                        "success": True,
+                    }
+
+                except Exception as popup_error:
+                    logger.warning(f"Popup handling failed: {popup_error}")
+                    return {
+                        "final_url": None,
+                        "resolver_url": openurl,
+                        "access_type": "popup_error",
+                        "success": False,
+                    }
+            else:
+                try:
+                    new_page_promise = None
+
+                    def handle_page_async(new_page):
+                        nonlocal new_page_promise
+                        new_page_promise = new_page
+                        logger.info(f"New page detected: {new_page.url}")
+
+                    context.on("page", handle_page_async)
+
+                    await page.goto(
+                        link_url, wait_until="domcontentloaded", timeout=30000
+                    )
+                    await page.wait_for_timeout(3000)
+
+                    if new_page_promise:
+                        target_page = new_page_promise
+                        await target_page.wait_for_load_state(
+                            "domcontentloaded", timeout=30000
+                        )
+                        final_url = target_page.url
+                        logger.info(f"Using new window: {final_url}")
+                        await target_page.close()
+                    else:
+                        final_url = page.url
+
+                    if any(
+                        domain in final_url.lower()
+                        for domain in [
+                            "openathens.net",
+                            "saml",
+                            "shibauth",
+                            "institutionlogin",
+                        ]
+                    ):
+                        final_url = await self._follow_saml_redirect_async(
+                            page, final_url, doi
+                        )
+
+                    return {
+                        "final_url": final_url,
+                        "resolver_url": openurl,
+                        "access_type": "institutional",
+                        "success": True,
+                    }
+
+                except Exception as nav_error:
+                    logger.error(f"Navigation failed: {nav_error}")
+                    return {
+                        "final_url": None,
+                        "resolver_url": openurl,
+                        "access_type": "navigation_error",
+                        "success": False,
+                    }
+
+        except Exception as e:
+            logger.error(f"OpenURL resolution failed: {e}")
+            return {
+                "final_url": None,
+                "resolver_url": openurl,
+                "access_type": "error",
+                "success": False,
+            }
+        finally:
+            await context.close()
+            # await page.close()
+
+    def _resolve_single(self, **kwargs) -> str:
+        """Synchronous wrapper for _resolve_single_async."""
+        import asyncio
+
+        try:
+            # Try to get existing loop
+            loop = asyncio.get_running_loop()
+            # If we're in Jupyter/IPython, use nest_asyncio
+            import nest_asyncio
+
+            nest_asyncio.apply()
+            result = asyncio.run(self._resolve_single_async(**kwargs))
+        except RuntimeError:
+            # No running loop, create new one
+            result = asyncio.run(self._resolve_single_async(**kwargs))
+
+        self._validate_final_url(kwargs.get("doi", ""), result)
+        return result.get("resolved_url") if result else None
+
+    async def _resolve_parallel_async(
+        self, dois: Union[str, List[str]], concurrency: int = 2
+    ) -> List[Optional[Dict[str, Any]]]:
+        """Resolves a list of DOIs in parallel with controlled concurrency.
+
+        Args:
+            dois: A list of DOI strings to resolve.
+            concurrency: Maximum number of concurrent tasks (default: 2)
+
+        Returns:
+            A list of result dictionaries, in the same order as the input DOIs.
+        """
+        if not dois:
+            return []
+
+        is_single = False
+        if isinstance(dois, str):
+            dois = [dois]
+            is_single = True
+
+        logger.info(
+            f"--- Starting parallel resolution for {len(dois)} DOIs (concurrency: {concurrency}) ---"
+        )
+
+        # Create semaphore to limit concurrency
+        semaphore = asyncio.Semaphore(concurrency)
+
+        async def worker_async(doi):
+            async with semaphore:
+                # Add random delay between requests to appear more human
+                await asyncio.sleep(random.uniform(0.5, 2.0))
+                return await self._resolve_single_async(doi=doi)
+
+        # Create tasks using the worker_async function
+        tasks = [worker_async(doi) for doi in dois]
+        results = await asyncio.gather(*tasks)
+
+        logger.info("--- Parallel resolution finished ---")
+        return results[0] if is_single else results
+
+    def resolve(
+        self, dois: Union[str, List[str]], concurrency: int = 5
+    ) -> Union[str, List[str]]:
+        """Synchronous wrapper for _resolve_parallel_async."""
+        try:
+            loop = asyncio.get_running_loop()
+            import nest_asyncio
+
+            nest_asyncio.apply()
+            results = asyncio.run(
+                self._resolve_parallel_async(dois, concurrency)
+            )
+        except RuntimeError:
+            results = asyncio.run(
+                self._resolve_parallel_async(dois, concurrency)
+            )
+
+        # Validate results
+        dois_list = [dois] if isinstance(dois, str) else dois
+        results_list = [results] if not isinstance(results, list) else results
+        for doi, result in zip(dois_list, results_list):
+            self._validate_final_url(doi, result)
+
+        return results
+
+    def _validate_final_url(self, doi, result):
+        if result and result.get("success"):
+            final_url = result.get("final_url", "")
+
+            # Check if we reached a publisher URL
+            if self._is_publisher_url(final_url, doi=doi):
+                logger.success(f"{doi}: {final_url}")
+                result["resolved_url"] = final_url
+                return True
+
+            # Also accept Elsevier linking hub as success
+            elif "linkinghub.elsevier.com" in final_url:
+                logger.success(f"{doi}: {final_url} (Elsevier linking hub)")
+                result["resolved_url"] = final_url
+                return True
+
+            # If we have a URL but it's not a publisher, still mark as partial success
+            elif (
+                final_url
+                and "chrome-error" not in final_url
+                and "openathens" not in final_url.lower()
+            ):
+                logger.info(f"{doi}: Reached {final_url}")
+                result["resolved_url"] = final_url
+                return True
+
+        # Only mark as failed if no URL or error/auth page
+        final_url = result.get("final_url") if result else "N/A"
+        logger.fail(f"{doi}: Failed - {final_url}")
+        if result:
+            result["resolved_url"] = None
+        return False
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if hasattr(self.browser, "cleanup_authenticate_async_context"):
+            await self.browser.cleanup_authenticate_async_context()
+
+
+async def try_openurl_resolver_async(
+    title: str = "",
+    authors: Optional[list] = None,
+    journal: str = "",
+    year: Optional[int] = None,
+    volume: Optional[int] = None,
+    issue: Optional[int] = None,
+    pages: str = "",
+    doi: str = "",
+    pmid: str = "",
+    resolver_url: Optional[str] = None,
+    auth_manager=None,
+) -> Optional[str]:
+    """Try to find full-text URL via OpenURL resolver."""
+    async with OpenURLResolver(auth_manager, resolver_url) as resolver:
+        result = await resolver._resolve_single_async(
+            title, authors, journal, year, volume, issue, pages, doi, pmid
+        )
+        if result and result.get("success") and result.get("final_url"):
+            return result["final_url"]
+    return None
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        """Test the resolver with different articles."""
+        # from scitex import logging
+        # logging.basicConfig(level=logging.DEBUG)
+        from scitex.scholar.auth import AuthenticationManager
+
+        auth_manager = AuthenticationManager()
+        # resolver_url = "https://unimelb.hosted.exlibrisgroup.com/sfxlcl41"
+
+        async with OpenURLResolver(auth_manager) as resolver:
+            print("\n=== Test 1: Article with access ===")
+            result = await resolver._resolve_single_async(
+                doi="10.1002/hipo.22488",
+                # title="Hippocampal sharp wave-ripple: A cognitive biomarker for episodic memory and planning",
+                # authors=["Buzsáki, György"],
+                # journal="Hippocampus",
+                # year=2015,
+                # volume=25,
+                # issue=10,
+                # pages="1073-1188",
+            )
+            print(f"Result: {result}")
+
+            print("\n=== Test 2: Article without access ===")
+            result = await resolver._resolve_single_async(
+                doi="10.1038/s41593-025-01990-7",
+                title="Addressing artifactual bias in large, automated MRI analyses of brain development",
+                journal="Nature Neuroscience",
+                year=2025,
+            )
+            print(f"Result: {result}")
+
+            time.sleep(600)
+
+    asyncio.run(main())
+
+# python -m scitex.scholar.open_url._OpenURLResolver
+
+# Is it a resolver url?
+# https://unimelb.hosted.exlibrisgroup.com/sfxlcl41?ctx_ver=Z39.88-2004&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.doi=10.1002/hipo.22488
+
+# EOF
+# https://unimelb.hosted.exlibrisgroup.com/sfxlcl41?ctx_ver=Z39.88-2004&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.doi=10.1038/s41593-025-01990-7
+
+# https://unimelb.hosted.exlibrisgroup.com/sfxlcl41?ctx_ver=Z39.88-2004&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.doi=10.1002/hipo.22488
+# https://unimelb.hosted.exlibrisgroup.com/sfxlcl41?ctx_ver=Z39.88-2004&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.doi=10.1038/s41593-025-02020-2
+
+# EOF