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

scitex/scholar/browser/__init__.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-05 17:03:46 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/browser/__init__.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from .ScholarBrowserManager import ScholarBrowserManager
+from scitex.browser.interaction import (
+    click_center_async,
+    close_popups_async,
+    PopupHandler,
+)
+from scitex.browser.pdf import (
+    click_download_for_chrome_pdf_viewer_async,
+    detect_chrome_pdf_viewer_async,
+)
+from scitex.browser.debugging import (
+    show_grid_async,
+    browser_logger,
+)
+
+__all__ = [
+    "ScholarBrowserManager",
+    "click_center_async",
+    "click_download_for_chrome_pdf_viewer_async",
+    "close_popups_async",
+    "detect_chrome_pdf_viewer_async",
+    "PopupHandler",
+    "show_grid_async",
+    "browser_logger",
+]
+
+# EOF

scitex/scholar/browser/utils/__init__.py

@@ -0,0 +1,13 @@
+# Scholar-specific utilities (stay here)
+from .wait_redirects import wait_redirects
+from .close_unwanted_pages import close_unwanted_pages
+from .click_and_wait import click_and_wait
+# from .JSLoader import JSLoader
+
+__all__ = [
+    # Scholar-specific
+    # "JSLoader",
+    "wait_redirects",
+    "close_unwanted_pages",
+    "click_and_wait",  # Scholar-specific (uses wait_redirects)
+]

scitex/scholar/browser/utils/click_and_wait.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-13 06:01:49 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/browser/utils/click_and_wait.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/scholar/browser/utils/click_and_wait.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+__FILE__ = __file__
+
+from typing import Dict, Optional
+
+from playwright.async_api import Locator
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def click_and_wait(
+    link: Locator,
+    message: str = "Clicking link...",
+    wait_redirects_options: Optional[Dict] = None,
+    func_name="click_and_wait",
+) -> dict:
+    """
+    Click link with visual feedback and wait for redirect chain to complete.
+
+    This function combines clicking logic with redirect waiting using the
+    standalone wait_redirects function for better modularity.
+
+    Args:
+        link: Playwright locator for the element to click
+        message: Message to display during clicking
+        wait_redirects_options: Options to pass to wait_redirects function
+            - timeout: Maximum wait time in milliseconds (default: 30000)
+            - max_redirects: Maximum number of redirects to follow (default: 10)
+            - show_progress: Show popup messages during redirects (default: False)
+            - track_chain: Whether to track detailed redirect chain (default: True)
+            - wait_for_idle: Whether to wait for network idle (default: True)
+
+    Returns:
+        dict: {
+            'success': bool,
+            'final_url': str,
+            'page': Page,
+            'new_page_opened': bool,
+            'redirect_count': int,
+            'redirect_chain': list,  # if track_chain=True
+            'total_time_ms': float,
+            'timed_out': bool,
+        }
+    """
+    from scitex.browser.debugging import (
+        browser_logger,
+        highlight_element_async,
+    )
+
+    from .wait_redirects import wait_redirects
+
+    page = link.page
+    context = page.context
+
+    # Initial UI feedback
+    await browser_logger.info(page, message, duration_ms=1500)
+    await highlight_element_async(link, 1000)
+
+    initial_url = page.url
+    href = await link.get_attribute("href") or ""
+    text = await link.inner_text() or ""
+    logger.debug(f"{func_name,} Clicking: '{text[:30]}' -> {href[:50]}")
+
+    try:
+        # Handle potential new page opening
+        new_page_opened = False
+        try:
+            async with context.expect_page(timeout=5000) as new_page_info:
+                await link.click()
+                new_page = await new_page_info.value
+                page = new_page
+                new_page_opened = True
+                logger.debug(f"{func_name} New page opened, switching context")
+        except:
+            await link.click()
+
+        # Use standalone wait_redirects function
+        redirect_options = wait_redirects_options or {}
+        redirect_result = await wait_redirects(page, **redirect_options)
+
+        # Combine results
+        result = {
+            "success": redirect_result["success"] or new_page_opened,
+            "final_url": redirect_result["final_url"],
+            "page": page,
+            "new_page_opened": new_page_opened,
+            **redirect_result,  # Include all redirect details
+        }
+
+        # Final feedback
+        if result["success"]:
+            await browser_logger.info(
+                page,
+                f"{func_name}: Complete: {result['final_url'][:40]}... "
+                f"({redirect_result['redirect_count']} redirects)",
+                duration_ms=2000,
+            )
+            logger.debug(
+                f"{func_name}: Navigation: {initial_url} -> {result['final_url']}"
+            )
+        else:
+            logger.info(f"{func_name}: Navigation failed or no change")
+
+        return result
+
+    except Exception as e:
+        logger.error(f"{func_name}: Click and wait failed: {e}")
+        return {
+            "success": False,
+            "final_url": initial_url,
+            "page": page,
+            "error": str(e),
+        }
+
+
+# Convenience function with common redirect options
+async def click_and_wait_with_progress(
+    link: Locator,
+    message: str = "Clicking link...",
+    timeout: int = 30000,
+) -> dict:
+    """
+    Click and wait with progress messages enabled.
+
+    This is a convenience function for the common case of wanting
+    to see redirect progress messages.
+    """
+    return await click_and_wait(
+        link,
+        message,
+        wait_redirects_options={
+            "timeout": timeout,
+            "show_progress": True,
+            "track_chain": True,
+        },
+    )
+
+
+# Convenience function for fast clicking without detailed tracking
+async def click_and_wait_fast(
+    link: Locator,
+    message: str = "Clicking link...",
+    timeout: int = 15000,
+) -> dict:
+    """
+    Click and wait with minimal overhead for faster execution.
+
+    This disables chain tracking and progress messages for speed.
+    """
+    return await click_and_wait(
+        link,
+        message,
+        wait_redirects_options={
+            "timeout": timeout,
+            "show_progress": False,
+            "track_chain": False,
+            "wait_for_idle": False,
+        },
+    )
+
+
+# Usage examples:
+"""
+# 1. Basic click and wait (same as before)
+result = await click_and_wait(link)
+
+# 2. Click and wait with custom redirect options
+result = await click_and_wait(
+    link,
+    wait_redirects_options={
+        "timeout": 15000,
+        "show_progress": True,
+        "track_chain": True
+    }
+)
+
+# 3. Click and wait with progress (convenience function)
+result = await click_and_wait_with_progress(link, "Loading paper...")
+
+# 4. Fast click and wait (minimal overhead)
+result = await click_and_wait_fast(link, timeout=10000)
+
+# 5. Access detailed redirect information
+result = await click_and_wait(link, wait_redirects_options={"track_chain": True})
+if result['success'] and 'redirect_chain' in result:
+    print(f"Redirect chain:")
+    for step in result['redirect_chain']:
+        print(f"  {step['step']}. {step['url']} ({step['status']})")
+"""
+
+# EOF

scitex/scholar/browser/utils/close_unwanted_pages.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-13 11:22:44 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/browser/utils/close_unwanted_pages.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/scholar/browser/utils/close_unwanted_pages.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import asyncio
+
+__FILE__ = __file__
+
+from playwright.async_api import BrowserContext, Page
+
+from scitex.browser.debugging import browser_logger
+
+
+async def close_unwanted_pages(
+    context: BrowserContext,
+    delay_sec=1,
+    max_attempts: int = 20,
+    func_name="close_unwanted_pages",
+    continuous: bool = False,
+):
+    """Close unwanted extension and blank pages while keeping at least one page open.
+
+    Args:
+        context: Browser context to clean up
+        delay_sec: Initial delay before starting cleanup
+        max_attempts: Maximum cleanup attempts (for single-run mode)
+        func_name: Name for logging purposes
+        continuous: If True, run continuously monitoring for new unwanted pages
+    """
+
+    # URL patterns to identify unwanted pages
+    UNWANTED_PAGE_EXPRESSIONS = [
+        "chrome-extension://",
+        "pbapi.xyz",
+        "options.html",
+        # "newtab",
+        # "about:blank",
+        # "chrome://newtab",
+    ]
+
+    await asyncio.sleep(delay_sec)
+
+    attempts = 0
+    while True:
+        if not continuous and attempts >= max_attempts:
+            break
+
+        attempts += 1
+
+        try:
+            # Get current pages first to avoid stale references
+            current_pages = list(context.pages)
+
+            # Get a valid page for browser_logger (prefer non-extension pages)
+            valid_page = None
+            for page in current_pages:
+                if (
+                    "chrome-extension://" not in page.url
+                    and not page.is_closed()
+                ):
+                    valid_page = page
+                    break
+
+            # If no valid page, use the first page
+            if not valid_page and current_pages:
+                valid_page = current_pages[0]
+
+            # Find unwanted pages by checking if any expression matches
+            unwanted_pages = [
+                page
+                for page in current_pages
+                if any(
+                    unwanted_exp in page.url
+                    for unwanted_exp in UNWANTED_PAGE_EXPRESSIONS
+                )
+            ]
+
+            if not unwanted_pages:
+                if valid_page and not continuous:
+                    await browser_logger.debug(
+                        valid_page, f"{func_name}: Extension cleanup completed"
+                    )
+                if not continuous:
+                    break
+                # In continuous mode, wait before checking again
+                await asyncio.sleep(2)
+                continue
+
+            # Log what we're about to close
+            if valid_page and unwanted_pages:
+                await browser_logger.debug(
+                    valid_page,
+                    f"{func_name}: Closing {len(unwanted_pages)} unwanted page(s)",
+                )
+
+            # Ensure context stays alive - create new page BEFORE closing if needed
+            if len(current_pages) == len(unwanted_pages):
+                new_page = await context.new_page()
+                if valid_page:
+                    await browser_logger.debug(
+                        valid_page,
+                        f"{func_name}: Created new page to keep context alive",
+                    )
+                valid_page = new_page  # Use new page for logging
+
+            # Close unwanted pages
+            closed_count = 0
+            for page in unwanted_pages:
+                try:
+                    await page.close()
+                    closed_count += 1
+                except Exception as e:
+                    if valid_page:
+                        await browser_logger.warning(
+                            valid_page, f"{func_name}: Failed to close page"
+                        )
+
+            if closed_count > 0 and valid_page:
+                await browser_logger.debug(
+                    valid_page,
+                    f"{func_name}: Closed {closed_count} page(s) (attempt {attempts + 1})",
+                )
+
+        except Exception as e:
+            if valid_page:
+                await browser_logger.warning(
+                    valid_page,
+                    f"{func_name}: Cleanup attempt {attempt + 1} failed",
+                )
+
+# EOF