scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/browser/pdf/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# SciTeX Browser PDF Utilities
+# ----------------------------------------
+
+from .detect_chrome_pdf_viewer import detect_chrome_pdf_viewer_async
+from .click_download_for_chrome_pdf_viewer import click_download_for_chrome_pdf_viewer_async
+
+__all__ = [
+    "detect_chrome_pdf_viewer_async",
+    "click_download_for_chrome_pdf_viewer_async",
+]
+
+# EOF

scitex/browser/pdf/click_download_for_chrome_pdf_viewer.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-10 03:24:13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/browser/pdf/click_download_for_chrome_pdf_viewer.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/browser/pdf/click_download_for_chrome_pdf_viewer.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from pathlib import Path
+
+__FILE__ = __file__
+
+"""
+Functionalities:
+  - Clicks download button in Chrome PDF viewer and saves PDF file
+  - Locates download button at top-right corner of PDF viewer
+  - Verifies successful download with file size check
+  - Demonstrates PDF download when run standalone
+
+Dependencies:
+  - packages:
+    - playwright
+
+IO:
+  - input-files:
+    - None
+  - output-files:
+    - User-specified PDF output path
+"""
+
+"""Imports"""
+import argparse
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+from ..debugging import browser_logger
+
+"""Functions & Classes"""
+async def click_download_for_chrome_pdf_viewer_async(
+    page,
+    output_path: Path | str,
+    verbose: bool = False,
+    func_name="click_download_for_chrome_pdf_viewer_async",
+) -> bool:
+    """
+    Click download button in Chrome PDF viewer and save the PDF file.
+
+    This function locates the download button in Chrome's built-in PDF viewer
+    (typically at top-right corner) and triggers the download, then saves the
+    file to the specified path.
+
+    Args:
+        page: Playwright page object showing a PDF in Chrome's PDF viewer
+        output_path: Path where the PDF file should be saved
+        verbose: Enable visual feedback via popup system (default False)
+
+    Returns:
+        bool: True if download succeeded and file is valid (>1KB), False otherwise
+
+    Example:
+        >>> await click_download_for_chrome_pdf_viewer_async(
+        ...     page, "paper.pdf", verbose=True
+        ... )
+        True
+
+    Note:
+        - Expects Chrome PDF viewer to be already loaded on the page
+        - Download button position is at approximately (95%, 3%) of viewport
+        - Waits up to 120 seconds for download to start
+        - Waits 10 seconds for download to complete after starting
+    """
+    try:
+        output_path = Path(output_path)
+
+        # Ensure .pdf extension
+        if not str(output_path).endswith(".pdf"):
+            output_path = Path(str(output_path) + ".pdf")
+
+        viewport = page.viewport_size
+        viewport_width = viewport["width"]
+        viewport_height = viewport["height"]
+
+        # Download button is typically at top-right corner (95%, 3%)
+        download_button_x = int(viewport_width * 0.95)
+        download_button_y = int(viewport_height * 0.03)
+
+        if verbose:
+            await browser_logger.debug(
+                page,
+                f"{func_name}: Clicking PDF download button...",
+            )
+
+        # Click download button and wait for download to start
+        async with page.expect_download(timeout=120_000) as download_info:
+            await page.mouse.click(download_button_x, download_button_y)
+
+        download = await download_info.value
+
+        # Monitor download progress with real-time updates
+        if verbose:
+            await browser_logger.info(
+                page,
+                f"{func_name}: Download started, monitoring progress...",
+            )
+
+        # Wait for download to complete and get final path
+        download_path = await download.path()
+
+        # Show download completion
+        if download_path:
+            temp_size = Path(download_path).stat().st_size if Path(download_path).exists() else 0
+            size_mb = temp_size / (1024 * 1024)
+            if verbose:
+                await browser_logger.success(
+                    page,
+                    f"{func_name}: Download complete! Size: {size_mb:.2f} MB",
+                )
+
+        await page.wait_for_timeout(2_000)  # Brief pause to show completion message
+
+        if download_path:
+            # Save download to specified path
+            await download.save_as(output_path)
+
+            # Verify download succeeded
+            if output_path.exists() and output_path.stat().st_size > 1024:
+                file_size_mb = output_path.stat().st_size / 1e6
+                logger.success(
+                    f"Downloaded PDF: {output_path} ({file_size_mb:.1f} MB)"
+                )
+                return True
+
+        return False
+
+    except Exception as e:
+        logger.error(f"Chrome PDF viewer download failed: {e}")
+        return False
+
+
+def main(args):
+    logger.debug(
+        "Chrome PDF download utility - use click_download_for_chrome_pdf_viewer_async() in your code"
+    )
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments."""
+    import scitex as stx
+
+    parser = argparse.ArgumentParser(
+        description="Chrome PDF viewer download utility"
+    )
+    args = parser.parse_args()
+    return args
+
+
+def run_main() -> None:
+    """Initialize scitex framework, run main function, and cleanup."""
+    global CONFIG, CC, sys, plt, rng
+
+    import sys
+
+    import matplotlib.pyplot as plt
+
+    import scitex as stx
+
+    args = parse_args()
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
+        sys,
+        plt,
+        args=args,
+        file=__FILE__,
+        sdir_suffix=None,
+        verbose=False,
+        agg=True,
+    )
+
+    exit_status = main(args)
+
+    stx.session.close(
+        CONFIG,
+        verbose=False,
+        notify=False,
+        message="",
+        exit_status=exit_status,
+    )
+
+
+if __name__ == "__main__":
+    run_main()
+
+# EOF

scitex/browser/pdf/detect_chrome_pdf_viewer.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-11 03:47:51 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/browser/pdf/detect_chrome_pdf_viewer.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/browser/pdf/detect_chrome_pdf_viewer.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+__FILE__ = __file__
+from scitex import logging
+
+from ..debugging import browser_logger
+
+logger = logging.getLogger(__name__)
+
+
+async def detect_chrome_pdf_viewer_async(
+    page, verbose: bool = False, func_name="detect_chrome_pdf_viewer_async"
+):
+    """
+    Detect if Chrome PDF viewer is present on the page.
+
+    Universal utility for detecting PDF viewer across any browser automation workflow.
+
+    NOTE: Caller should wait for networkidle BEFORE calling this function.
+    This function does NOT wait for networkidle to avoid redundant waits.
+
+    Args:
+        page: Playwright page object
+        verbose: Enable visual feedback via popup system (default False)
+
+    Returns:
+        bool: True if PDF viewer detected, False otherwise
+    """
+
+    if verbose:
+        await browser_logger.debug(
+            page, f"{func_name}: Detecting Chrome PDF Viewer..."
+        )
+
+    # Try multiple detection methods
+    detected = await page.evaluate(
+        """
+    () => {
+        // Method 1: Standard PDF embed/iframe/object
+        const embedPDF = document.querySelector('embed[type="application/pdf"]');
+        const iframePDF = document.querySelector('iframe[src*=".pdf"]');
+        const objectPDF = document.querySelector('object[type="application/pdf"]');
+
+        // Method 2: Chrome's built-in PDF viewer
+        const chromeViewer = window.PDFViewerApplication;
+
+        // Method 3: Common PDF viewer attributes
+        const pdfViewerDiv = document.querySelector('[data-testid="pdf-viewer"]');
+
+        // Method 4: Check if there's a PDF plugin
+        const pdfPlugin = navigator.mimeTypes['application/pdf'];
+
+        // Method 5: Check for IEEE-specific PDF viewer elements
+        const ieeePDFViewer = document.querySelector('#pdfViewer') ||
+                              document.querySelector('.pdf-viewer') ||
+                              document.querySelector('[id*="pdf"]') ||
+                              document.querySelector('[class*="pdf-viewer"]');
+
+        // Method 6: Check if main frame contains PDF content
+        const contentType = document.contentType || document.mimeType;
+        const isPDFContent = contentType === 'application/pdf';
+
+        console.log('PDF Detection Results:', {
+            embedPDF: !!embedPDF,
+            iframePDF: !!iframePDF,
+            objectPDF: !!objectPDF,
+            chromeViewer: !!chromeViewer,
+            pdfViewerDiv: !!pdfViewerDiv,
+            pdfPlugin: !!pdfPlugin,
+            ieeePDFViewer: !!ieeePDFViewer,
+            isPDFContent: isPDFContent
+        });
+
+        return !!(
+            embedPDF || iframePDF || objectPDF ||
+            chromeViewer || pdfViewerDiv || pdfPlugin ||
+            ieeePDFViewer || isPDFContent
+        );
+    }
+    """
+    )
+
+    if detected:
+        if verbose:
+            await browser_logger.success(
+                page, f"{func_name}: ✓ PDF viewer elements found!"
+            )
+        return True
+    else:
+        if verbose:
+            await browser_logger.debug(
+                page, f"{func_name}: ✗ No PDF viewer elements found"
+            )
+        return False
+
+
+def main(args):
+    """Demonstrate detect_chrome_pdf_viewer functionality."""
+    import asyncio
+
+    from playwright.async_api import async_playwright
+
+    from ..debugging import browser_logger
+
+    async def demo():
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=False)
+            page = await browser.new_page()
+
+            await browser_logger.debug(
+                page, "PDF Detection: Starting demo", verbose=True
+            )
+
+            # Navigate to a PDF file
+            test_pdf_url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
+            await page.goto(test_pdf_url, timeout=30000)
+
+            await browser_logger.debug(
+                page, "Waiting for page to load...", verbose=True
+            )
+
+            await page.wait_for_load_state("networkidle", timeout=10000)
+
+            # Detect PDF viewer
+            detected = await detect_chrome_pdf_viewer_async(page, verbose=True)
+
+            if detected:
+                logger.success("PDF viewer detected successfully")
+            else:
+                logger.debug("No PDF viewer detected (this may be expected)")
+
+            await browser_logger.debug(page, "✓ Demo complete", verbose=True)
+
+            await asyncio.sleep(2)
+            await browser.close()
+
+    asyncio.run(demo())
+    return 0
+
+
+def parse_args():
+    """Parse command line arguments."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="PDF viewer detection demo")
+    return parser.parse_args()
+
+
+def run_main() -> None:
+    """Initialize scitex framework, run main function, and cleanup."""
+    global CONFIG, CC, sys, plt, rng
+
+    import sys
+
+    import matplotlib.pyplot as plt
+
+    import scitex as stx
+
+    args = parse_args()
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
+        sys,
+        plt,
+        args=args,
+        file=__FILE__,
+        sdir_suffix=None,
+        verbose=False,
+        agg=True,
+    )
+
+    exit_status = main(args)
+
+    stx.session.close(
+        CONFIG,
+        verbose=False,
+        notify=False,
+        message="",
+        exit_status=exit_status,
+    )
+
+
+if __name__ == "__main__":
+    run_main()
+
+# python -m scitex.browser.pdf.detect_chrome_pdf_viewer
+
+# EOF