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

scitex/scholar/auth/sso/OpenAthensSSOAutomator.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-10 07:16:32 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/auth/library/_OpenAthensSSOAutomator.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/scholar/auth/library/_OpenAthensSSOAutomator.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+__FILE__ = __file__
+
+"""OpenAthens page automation for institutional email entry and selection."""
+
+import asyncio
+from typing import Optional
+
+from playwright.async_api import BrowserContext, Page
+
+from scitex.browser.interaction import click_with_fallbacks_async
+from scitex.scholar.config import ScholarConfig
+
+from .BaseSSOAutomator import BaseSSOAutomator
+
+
+class OpenAthensSSOAutomator(BaseSSOAutomator):
+    """Automator for the initial OpenAthens page (my.openathens.net)."""
+
+    def __init__(
+        self,
+        openathens_email: Optional[str] = None,
+        config: Optional[ScholarConfig] = None,
+        **kwargs,
+    ):
+        """Initialize OpenAthens page automator.
+
+        Args:
+            openathens_email: Institutional email for OpenAthens
+            config: ScholarConfig instance
+            **kwargs: Additional arguments
+        """
+        if config is None:
+            config = ScholarConfig()
+
+        # Resolve email from config
+        self.openathens_email = config.resolve(
+            "openathens_email", openathens_email, default=""
+        )
+
+        super().__init__(**kwargs)
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def get_institution_name(self) -> str:
+        """Get human-readable name."""
+        return "OpenAthens"
+
+    def get_institution_id(self) -> str:
+        """Get machine-readable ID."""
+        return "openathens"
+
+    def is_sso_page(self, url: str) -> bool:
+        """Check if URL is OpenAthens login page."""
+        openathens_patterns = [
+            "my.openathens.net",
+            "openathens.net/login",
+            "openathens.net/?passiveLogin",
+        ]
+        return any(pattern in url.lower() for pattern in openathens_patterns)
+
+    async def perform_login_async(self, page: Page) -> bool:
+        """Perform OpenAthens email entry and institution selection."""
+        try:
+            self.logger.info(
+                f"{self.name}: Starting OpenAthens page automation"
+            )
+
+            if not self.openathens_email:
+                self.logger.error(
+                    f"{self.name}: No OpenAthens email configured"
+                )
+                return False
+
+            # Step 1: Enter institutional email
+            success = await self._enter_institutional_email_async(page)
+            if not success:
+                return False
+
+            # Step 2: Wait for institution selection to appear and select it
+            success = await self._select_institution_async(page)
+            if not success:
+                return False
+
+            # Step 3: Wait for redirect to institution SSO
+            success = await self._wait_for_institution_redirect_async(page)
+
+            return success
+
+        except Exception as e:
+            self.logger.error(
+                f"{self.name}: OpenAthens page automation failed: {e}"
+            )
+            await self._take_debug_screenshot_async(page)
+            return False
+
+    async def _enter_institutional_email_async(self, page) -> bool:
+        """Enter institutional email in OpenAthens form."""
+        try:
+            self.logger.info(
+                f"{self.name}: Entering institutional email: {self.openathens_email}"
+            )
+
+            # The correct selector from Puppeteer testing
+            email_selector = "#type-ahead"
+
+            # Wait for and fill the email field
+            try:
+                await page.wait_for_selector(email_selector, timeout=10000)
+                await page.fill(email_selector, self.openathens_email)
+                self.logger.info(
+                    f"{self.name}: Successfully filled OpenAthens email field"
+                )
+
+                # Press Enter to trigger the search/autocomplete
+                await page.press(email_selector, "Enter")
+                self.logger.info(
+                    f"{self.name}: Pressed Enter to trigger institution search"
+                )
+
+                # Wait for institution dropdown to appear
+                await page.wait_for_timeout(2000)
+                return True
+
+            except Exception as e:
+                self.logger.error(
+                    f"{self.name}: Failed to fill email field: {e}"
+                )
+                return False
+
+        except Exception as e:
+            self.logger.error(f"{self.name}: Failed to enter email: {e}")
+            return False
+
+    async def _submit_email_form_async(self, page: Page) -> bool:
+        """Submit email form or trigger next step."""
+        try:
+            # Try pressing Enter first
+            await page.keyboard.press("Enter")
+            await page.wait_for_timeout(1000)
+
+            # Try clicking submit/continue buttons
+            submit_selectors = [
+                "button[type='submit']",
+                "input[type='submit']",
+                "button:has-text('Continue')",
+                "button:has-text('Next')",
+                "button:has-text('Submit')",
+                "button:has-text('Go')",
+                ".submit-button",
+                ".continue-button",
+            ]
+
+            for selector in submit_selectors:
+                try:
+                    element = await page.wait_for_selector(
+                        selector, timeout=2000
+                    )
+                    if element:
+                        success = await click_with_fallbacks_async(
+                            page, selector
+                        )
+                        if success:
+                            self.logger.info(
+                                f"{self.name}: Successfully clicked submit using: {selector}"
+                            )
+                            await page.wait_for_timeout(1000)
+                            return True
+                except TimeoutError:
+                    continue
+
+            self.logger.info(
+                f"{self.name}: No explicit submit button found, assuming form submitted automatically"
+            )
+            return True
+
+        except Exception as e:
+            self.logger.error(f"{self.name}: Failed to submit email form: {e}")
+            return False
+
+    async def _select_institution_async(self, page) -> bool:
+        """Select institution from the list that appears (generic for any institution)."""
+        try:
+            self.logger.info(
+                f"{self.name}: Waiting for institution selection to appear..."
+            )
+
+            institution_selector = ".wayfinder-item"
+            await page.wait_for_selector(institution_selector, timeout=10000)
+            self.logger.info("Found institution dropdown options")
+
+            institution_elements = await page.query_selector_all(
+                institution_selector
+            )
+
+            if len(institution_elements) == 1:
+                # Get text BEFORE clicking
+                institution_text = await institution_elements[0].text_content()
+                await institution_elements[0].click()
+                self.logger.info(
+                    f"{self.name}: Selected institution: {institution_text.strip()}"
+                )
+            elif len(institution_elements) > 1:
+                selected = await self._select_best_institution_match(
+                    page, institution_elements
+                )
+                if not selected:
+                    # Get text BEFORE clicking
+                    institution_text = await institution_elements[
+                        0
+                    ].text_content()
+                    await institution_elements[0].click()
+                    self.logger.info(
+                        f"{self.name}: Selected first available institution: {institution_text.strip()}"
+                    )
+            else:
+                self.logger.error(f"{self.name}: No institution options found")
+                return False
+
+            await page.wait_for_timeout(2000)
+            return True
+
+        except Exception as e:
+            self.logger.error(
+                f"{self.name}: Failed to select institution: {e}"
+            )
+            return False
+
+    async def _select_best_institution_match(
+        self, page, institution_elements
+    ) -> bool:
+        """Try to select the best matching institution based on email domain."""
+        try:
+            email_domain = (
+                self.openathens_email.split("@")[1].lower()
+                if "@" in self.openathens_email
+                else ""
+            )
+
+            # Domain-specific matching logic
+            domain_keywords = {
+                "unimelb.edu.au": ["melbourne", "unimelb"],
+                "stanford.edu": ["stanford"],
+                "mit.edu": ["mit", "massachusetts"],
+                "harvard.edu": ["harvard"],
+                "oxford.ac.uk": ["oxford"],
+                "cambridge.ac.uk": ["cambridge"],
+                # Add more mappings as needed
+            }
+
+            if email_domain in domain_keywords:
+                keywords = domain_keywords[email_domain]
+
+                for element in institution_elements:
+                    text = await element.text_content()
+                    text_lower = text.lower()
+
+                    if any(keyword in text_lower for keyword in keywords):
+                        await element.click()
+                        self.logger.info(
+                            f"{self.name}: Selected matched institution: {text.strip()}"
+                        )
+                        return True
+
+            # Generic fallback - look for university in the name
+            if "university" in email_domain or "edu" in email_domain:
+                for element in institution_elements:
+                    text = await element.text_content()
+                    if "university" in text.lower():
+                        await element.click()
+                        self.logger.info(
+                            f"{self.name}: Selected university institution: {text.strip()}"
+                        )
+                        return True
+
+            return False
+
+        except Exception as e:
+            self.logger.error(f"{self.name}: Failed to match institution: {e}")
+            return False
+
+    async def _wait_for_institution_redirect_async(self, page) -> bool:
+        """Wait for redirect to institution SSO page."""
+        try:
+            self.logger.info(
+                f"{self.name}: Waiting for redirect to institution SSO..."
+            )
+
+            # Wait for URL to change away from OpenAthens
+            for i in range(30):  # Wait up to 30 seconds
+                current_url = page.url
+
+                if not self.is_sso_page(current_url):
+                    self.logger.info(
+                        f"{self.name}: Redirected to institution SSO: {current_url[:50]}..."
+                    )
+                    return True
+
+                await page.wait_for_timeout(1000)
+
+            self.logger.error(
+                f"{self.name}: Timeout waiting for institution redirect"
+            )
+            return False
+
+        except Exception as e:
+            self.logger.error(f"{self.name}: Failed waiting for redirect: {e}")
+            return False
+
+    async def _take_debug_screenshot_async(self, page: Page):
+        """Take debug screenshot."""
+        try:
+            import time
+            from pathlib import Path
+
+            screenshot_path = (
+                Path.home()
+                / ".scitex"
+                / "scholar"
+                / f"openathens_debug_{int(time.time())}.png"
+            )
+            screenshot_path.parent.mkdir(parents=True, exist_ok=True)
+            await page.screenshot(path=str(screenshot_path))
+            self.logger.debug(
+                f"{self.name}: Debug screenshot: {screenshot_path}"
+            )
+        except Exception as e:
+            self.logger.debug(f"{self.name}: Screenshot failed: {e}")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    def main():
+        """Test OpenAthens page automator."""
+        from playwright.async_api import async_playwright
+
+        async def test_automator():
+            automator = OpenAthensSSOAutomator()
+
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=False)
+                page = await browser.new_page()
+
+                try:
+                    await page.goto(
+                        "https://my.openathens.net/?passiveLogin=false"
+                    )
+                    success = await automator.perform_login_async(page)
+                    print(f"OpenAthens automation success: {success}")
+
+                    await page.wait_for_timeout(10000)
+                except Exception as e:
+                    print(f"Error: {e}")
+                finally:
+                    await browser.close()
+
+        asyncio.run(test_automator())
+
+    main()
+
+# python -m scitex.scholar.auth.sso_automation._OpenAthensSSOAutomator
+
+# EOF

scitex/scholar/auth/sso/SSOAutomator.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-23 11:25:43 (ywatanabe)"
+# File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/scholar/auth/sso_automation/_SSOAutomator.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""Factory for creating SSO automators."""
+
+from typing import Dict, Optional
+
+from scitex import logging
+from scitex.scholar.config import ScholarConfig
+
+from .BaseSSOAutomator import BaseSSOAutomator
+
+logger = logging.getLogger(__name__)
+
+
+class SSOAutomator:
+    """Factory for creating institution-specific SSO automators."""
+
+    # Email domain mappings
+    EMAIL_DOMAIN_MAP = {
+        "@unimelb.edu.au": "UniversityOfMelbourne",
+        "@student.unimelb.edu.au": "UniversityOfMelbourne",
+    }
+
+    # URL pattern mappings
+    URL_PATTERN_MAP = {
+        "unimelb": "UniversityOfMelbourne",
+        "melbourne.edu.au": "UniversityOfMelbourne",
+        "exlibrisgroup.com/sfxlcl41": "UniversityOfMelbourne",
+    }
+
+    # Institution name mappings
+    INSTITUTION_NAME_MAP = {
+        "unimelb": "UniversityOfMelbourne",
+        "university of melbourne": "UniversityOfMelbourne",
+        "melbourne": "UniversityOfMelbourne",
+        "melbourne university": "UniversityOfMelbourne",
+    }
+
+    # Automator class mappings
+    AUTOMATOR_CLASS_MAP = {
+        "UniversityOfMelbourne": "UniversityOfMelbourneSSOAutomator.UniversityOfMelbourneSSOAutomator",
+    }
+
+    def __new__(cls, institution=None, email=None, url=None, **kwargs):
+        if institution:
+            return cls.create_by_name(institution, **kwargs)
+        elif email:
+            return cls.create_from_email(email, **kwargs)
+        elif url:
+            return cls.create_from_url(url, **kwargs)
+        else:
+            return None
+
+    @classmethod
+    def create_from_email(
+        cls, email: str, **kwargs
+    ) -> Optional[BaseSSOAutomator]:
+        """Create SSO automator based on email domain."""
+        if not email:
+            return None
+
+        email_lower = email.lower()
+
+        for domain, automator_name in cls.EMAIL_DOMAIN_MAP.items():
+            if email_lower.endswith(domain):
+                return cls._create_automator(automator_name, **kwargs)
+
+        logger.debug(f"No SSO automator found for email: {email}")
+        return None
+
+    @classmethod
+    def create_from_url(cls, url: str, **kwargs) -> Optional[BaseSSOAutomator]:
+        """Auto-detect institution from URL and create appropriate automator."""
+        url_lower = url.lower()
+
+        for pattern, automator_name in cls.URL_PATTERN_MAP.items():
+            if pattern in url_lower:
+                logger.info(
+                    f"Detected {automator_name.replace('Of', ' of ')} from URL"
+                )
+                return cls._create_automator(automator_name, **kwargs)
+
+        logger.debug(f"No SSO automator found for URL: {url}")
+        return None
+
+    @classmethod
+    def create_by_name(
+        cls, institution_name: str, **kwargs
+    ) -> Optional[BaseSSOAutomator]:
+        """Create SSO automator by institution name."""
+        name_lower = institution_name.lower()
+
+        for key, automator_name in cls.INSTITUTION_NAME_MAP.items():
+            if key in name_lower:
+                return cls._create_automator(automator_name, **kwargs)
+
+        logger.warning(
+            f"No SSO automator found for institution: {institution_name}"
+        )
+        return None
+
+    @classmethod
+    def _create_automator(
+        cls, automator_name: str, **kwargs
+    ) -> Optional[BaseSSOAutomator]:
+        """Create automator instance by name."""
+        if automator_name not in cls.AUTOMATOR_CLASS_MAP:
+            logger.error(f"Unknown automator: {automator_name}")
+            return None
+
+        try:
+            module_path, class_name = cls.AUTOMATOR_CLASS_MAP[
+                automator_name
+            ].rsplit(".", 1)
+            from importlib import import_module
+
+            module = import_module(f".{module_path}", package=__package__)
+            automator_class = getattr(module, class_name)
+            return automator_class(**kwargs)
+        except ImportError as e:
+            logger.error(f"Failed to import automator {automator_name}: {e}")
+            return None
+
+    @classmethod
+    def list_supported_institutions(cls) -> Dict[str, str]:
+        """Get list of supported institutions."""
+        return {
+            "unimelb": "University of Melbourne",
+        }
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    def main():
+        """Test UniMelb SSO automator."""
+        from playwright.async_api import async_playwright
+
+        from scitex.scholar.auth.sso.SSOAutomator import SSOAutomator
+
+        automator = SSOAutomator(email=os.getenv("SCITEX_SCHOLAR_SSO_EMAIL"))
+
+        async def test_automator():
+            # automator = UniversityOfMelbourneSSOAutomator()
+            automator = SSOAutomator(
+                email=os.getenv("SCITEX_SCHOLAR_SSO_EMAIL")
+            )
+
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=False)
+                page = await browser.new_page()
+
+                try:
+                    await page.goto("https://sso.unimelb.edu.au/")
+                    success = await automator.perform_login_async(page)
+                    print(f"Login success: {success}")
+
+                    await page.wait_for_timeout(5000)
+                except Exception as e:
+                    print(f"Error: {e}")
+                finally:
+                    await browser.close()
+
+        asyncio.run(test_automator())
+
+    main()
+
+
+# python -m scitex.scholar.auth.sso_automation._SSOAutomator
+
+# EOF