scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/scholar/auth/sso/OpenAthensSSOAutomator.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/library/_OpenAthensSSOAutomator.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/library/_OpenAthensSSOAutomator.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -76,14 +75,10 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
     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"
-            )
+            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"
-                )
+                self.logger.error(f"{self.name}: No OpenAthens email configured")
                 return False
 
             # Step 1: Enter institutional email
@@ -102,9 +97,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
             return success
 
         except Exception as e:
-            self.logger.error(
-                f"{self.name}: OpenAthens page automation failed: {e}"
-            )
+            self.logger.error(f"{self.name}: OpenAthens page automation failed: {e}")
             await self._take_debug_screenshot_async(page)
             return False
 
@@ -137,9 +130,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
                 return True
 
             except Exception as e:
-                self.logger.error(
-                    f"{self.name}: Failed to fill email field: {e}"
-                )
+                self.logger.error(f"{self.name}: Failed to fill email field: {e}")
                 return False
 
         except Exception as e:
@@ -167,13 +158,9 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
 
             for selector in submit_selectors:
                 try:
-                    element = await page.wait_for_selector(
-                        selector, timeout=2000
-                    )
+                    element = await page.wait_for_selector(selector, timeout=2000)
                     if element:
-                        success = await click_with_fallbacks_async(
-                            page, selector
-                        )
+                        success = await click_with_fallbacks_async(page, selector)
                         if success:
                             self.logger.info(
                                 f"{self.name}: Successfully clicked submit using: {selector}"
@@ -203,9 +190,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
             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
-            )
+            institution_elements = await page.query_selector_all(institution_selector)
 
             if len(institution_elements) == 1:
                 # Get text BEFORE clicking
@@ -220,9 +205,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
                 )
                 if not selected:
                     # Get text BEFORE clicking
-                    institution_text = await institution_elements[
-                        0
-                    ].text_content()
+                    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()}"
@@ -235,14 +218,10 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
             return True
 
         except Exception as e:
-            self.logger.error(
-                f"{self.name}: Failed to select institution: {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:
+    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 = (
@@ -296,9 +275,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
     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..."
-            )
+            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
@@ -312,9 +289,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
 
                 await page.wait_for_timeout(1000)
 
-            self.logger.error(
-                f"{self.name}: Timeout waiting for institution redirect"
-            )
+            self.logger.error(f"{self.name}: Timeout waiting for institution redirect")
             return False
 
         except Exception as e:
@@ -335,9 +310,7 @@ class OpenAthensSSOAutomator(BaseSSOAutomator):
             )
             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}"
-            )
+            self.logger.debug(f"{self.name}: Debug screenshot: {screenshot_path}")
         except Exception as e:
             self.logger.debug(f"{self.name}: Screenshot failed: {e}")
 
@@ -357,9 +330,7 @@ if __name__ == "__main__":
                 page = await browser.new_page()
 
                 try:
-                    await page.goto(
-                        "https://my.openathens.net/?passiveLogin=false"
-                    )
+                    await page.goto("https://my.openathens.net/?passiveLogin=false")
                     success = await automator.perform_login_async(page)
                     print(f"OpenAthens automation success: {success}")
 

scitex/scholar/auth/sso/SSOAutomator.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -61,9 +62,7 @@ class SSOAutomator:
             return None
 
     @classmethod
-    def create_from_email(
-        cls, email: str, **kwargs
-    ) -> Optional[BaseSSOAutomator]:
+    def create_from_email(cls, email: str, **kwargs) -> Optional[BaseSSOAutomator]:
         """Create SSO automator based on email domain."""
         if not email:
             return None
@@ -84,9 +83,7 @@ class SSOAutomator:
 
         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"
-                )
+                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}")
@@ -103,9 +100,7 @@ class SSOAutomator:
             if key in name_lower:
                 return cls._create_automator(automator_name, **kwargs)
 
-        logger.warning(
-            f"No SSO automator found for institution: {institution_name}"
-        )
+        logger.warning(f"No SSO automator found for institution: {institution_name}")
         return None
 
     @classmethod
@@ -118,9 +113,9 @@ class SSOAutomator:
             return None
 
         try:
-            module_path, class_name = cls.AUTOMATOR_CLASS_MAP[
-                automator_name
-            ].rsplit(".", 1)
+            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__)
@@ -151,9 +146,7 @@ if __name__ == "__main__":
 
         async def test_automator():
             # automator = UniversityOfMelbourneSSOAutomator()
-            automator = SSOAutomator(
-                email=os.getenv("SCITEX_SCHOLAR_SSO_EMAIL")
-            )
+            automator = SSOAutomator(email=os.getenv("SCITEX_SCHOLAR_SSO_EMAIL"))
 
             async with async_playwright() as p:
                 browser = await p.chromium.launch(headless=False)

scitex/scholar/auth/sso/UniversityOfMelbourneSSOAutomator.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -16,7 +17,10 @@ from typing import Optional
 from playwright.async_api import Page, TimeoutError
 
 # from scitex.scholar.browser import BrowserUtils
-from scitex.browser.interaction import click_with_fallbacks_async, fill_with_fallbacks_async
+from scitex.browser.interaction import (
+    click_with_fallbacks_async,
+    fill_with_fallbacks_async,
+)
 from scitex.scholar.config import ScholarConfig
 
 from .BaseSSOAutomator import BaseSSOAutomator
@@ -76,9 +80,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
             username_success = await self._handle_username_step_async(page)
             if not username_success:
                 # Try generic login as fallback
-                self.logger.info(
-                    "Trying generic login form detection as fallback"
-                )
+                self.logger.info("Trying generic login form detection as fallback")
                 username_success = await self._handle_generic_login_async(page)
                 if not username_success:
                     return False
@@ -189,9 +191,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
                 self.logger.info("Filled generic username field")
 
             # Find any password field
-            password_elements = await page.query_selector_all(
-                'input[type="password"]'
-            )
+            password_elements = await page.query_selector_all('input[type="password"]')
             if password_elements:
                 await page.evaluate(
                     '(args) => { args.element.value = args.value; args.element.dispatchEvent(new Event("input", { bubbles: true })); }',
@@ -219,9 +219,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
         """Handle Duo 2FA using proven working patterns."""
         try:
             # Quick check for Duo auth elements
-            duo_elements = await page.query_selector_all(
-                ".authenticator-verify-list"
-            )
+            duo_elements = await page.query_selector_all(".authenticator-verify-list")
 
             if not duo_elements:
                 try:
@@ -240,9 +238,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
 
             if push_buttons:
                 await push_buttons[0].click()
-                self.logger.info(
-                    "Push notification requested - check your device"
-                )
+                self.logger.info("Push notification requested - check your device")
 
                 # Send notification to user - USER INTERVENTION REQUIRED
                 await self.notify_user_async(
@@ -260,9 +256,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
                 )
                 if auth_buttons:
                     await auth_buttons[0].click()
-                    self.logger.info(
-                        "Alternative authentication method selected"
-                    )
+                    self.logger.info("Alternative authentication method selected")
 
                     # Send notification for alternative auth - USER INTERVENTION REQUIRED
                     await self.notify_user_async(
@@ -290,9 +284,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
                 try:
                     # Check if moved away from SSO
                     if not self.is_sso_page(page.url):
-                        self.logger.info(
-                            "Login successful - redirected away from SSO"
-                        )
+                        self.logger.info("Login successful - redirected away from SSO")
                         return True
 
                     # Check for success indicators only if context is still valid
@@ -300,9 +292,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
                         'input[name="prompt"], .chat-interface, .dashboard, .main-content'
                     )
                     if success_elements:
-                        self.logger.info(
-                            "Login successful - found success elements"
-                        )
+                        self.logger.info("Login successful - found success elements")
                         return True
 
                 except Exception as context_error:
@@ -316,7 +306,7 @@ class UniversityOfMelbourneSSOAutomator(BaseSSOAutomator):
                             return True
 
                 if ii > 0 and ii % 10 == 0:
-                    self.logger.info(f"Still waiting... ({60-ii}s remaining)")
+                    self.logger.info(f"Still waiting... ({60 - ii}s remaining)")
 
             return False
 

scitex/scholar/browser/ScholarBrowserManager.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/browser/ScholarBrowserManager.py"
-)
+
+__FILE__ = "./src/scitex/scholar/browser/ScholarBrowserManager.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -124,9 +123,7 @@ class ScholarBrowserManager(BrowserMixin):
         )
 
         # Stealth
-        self.stealth_manager = StealthManager(
-            self.viewport_size, self.spoof_dimension
-        )
+        self.stealth_manager = StealthManager(self.viewport_size, self.spoof_dimension)
 
         # Cookie
         self.cookie_acceptor = CookieAutoAcceptor()
@@ -183,9 +180,7 @@ class ScholarBrowserManager(BrowserMixin):
                 f"{self.name}: Using persistent context with profile and extensions"
             )
         else:
-            logger.warning(
-                f"{self.name}: Falling back to regular context creation"
-            )
+            logger.warning(f"{self.name}: Falling back to regular context creation")
 
             auth_options = await self.auth_manager.get_auth_options()
             context_options.update(auth_options)
@@ -199,18 +194,14 @@ class ScholarBrowserManager(BrowserMixin):
     ) -> BrowserContext:
         """Creates a new browser context with stealth options and invisible mode applied."""
         stealth_options = self.stealth_manager.get_stealth_options()
-        context = await browser.new_context(
-            {**stealth_options, **context_options}
-        )
+        context = await browser.new_context({**stealth_options, **context_options})
 
         # Apply stealth script
         await context.add_init_script(self.stealth_manager.get_init_script())
         await context.add_init_script(
             self.stealth_manager.get_dimension_spoofing_script()
         )
-        await context.add_init_script(
-            self.cookie_acceptor.get_auto_acceptor_script()
-        )
+        await context.add_init_script(self.cookie_acceptor.get_auto_acceptor_script())
         return context
 
     # ########################################
@@ -277,9 +268,7 @@ class ScholarBrowserManager(BrowserMixin):
                     )
 
         if removed_locks > 0:
-            logger.debug(
-                f"{self.name}: Cleaned up {removed_locks} Chrome lock files"
-            )
+            logger.debug(f"{self.name}: Cleaned up {removed_locks} Chrome lock files")
             # Wait a moment for the system to release file handles
             time.sleep(1)
 
@@ -302,13 +291,19 @@ class ScholarBrowserManager(BrowserMixin):
 
         # This show_asyncs a small screen with 4 extensions show_asyncn
         persistent_context_launch_options["headless"] = False
-        self._persistent_context = await self._persistent_playwright.chromium.launch_persistent_context(
-            **persistent_context_launch_options
+        self._persistent_context = (
+            await self._persistent_playwright.chromium.launch_persistent_context(
+                **persistent_context_launch_options
+            )
         )
         # First cleanup run (immediate, non-continuous)
-        await close_unwanted_pages(self._persistent_context, delay_sec=1, continuous=False)
+        await close_unwanted_pages(
+            self._persistent_context, delay_sec=1, continuous=False
+        )
         # Background continuous monitoring task
-        asyncio.create_task(close_unwanted_pages(self._persistent_context, delay_sec=5, continuous=True))
+        asyncio.create_task(
+            close_unwanted_pages(self._persistent_context, delay_sec=5, continuous=True)
+        )
         # await self._close_unwanted_extension_pages_async()
         # asyncio.create_task(self._close_unwanted_extension_pages_async())
         await self._apply_stealth_scripts_to_persistent_context_async()
@@ -325,14 +320,10 @@ class ScholarBrowserManager(BrowserMixin):
                 timeout=5,
             )
             if result.returncode == 0:
-                logger.debug(
-                    f"{self.name}: Xvfb display :{self.display} is running"
-                )
+                logger.debug(f"{self.name}: Xvfb display :{self.display} is running")
                 return True
             else:
-                logger.debug(
-                    f"{self.name}: Starting Xvfb display :{self.display}"
-                )
+                logger.debug(f"{self.name}: Starting Xvfb display :{self.display}")
                 # Kill any existing Xvfb on this display first
                 subprocess.run(
                     ["pkill", "-f", f"Xvfb.*:{self.display}"],
@@ -437,9 +428,7 @@ class ScholarBrowserManager(BrowserMixin):
             "headless": self.headless,
             "args": launch_args,
             "accept_downloads": True,  # Enable download handling
-            "downloads_path": str(
-                downloads_path
-            ),  # Set custom download directory
+            "downloads_path": str(downloads_path),  # Set custom download directory
             "proxy": proxy_config,
             "viewport": {
                 "width": self.viewport_size[0],
@@ -472,9 +461,7 @@ class ScholarBrowserManager(BrowserMixin):
 
         try:
             # Check if we have authentication
-            if await self.auth_manager.is_authenticate_async(
-                verify_live=False
-            ):
+            if await self.auth_manager.is_authenticate_async(verify_live=False):
                 cookies = await self.auth_manager.get_auth_cookies_async()
                 if cookies:
                     await self._persistent_context.add_cookies(cookies)
@@ -482,17 +469,11 @@ class ScholarBrowserManager(BrowserMixin):
                         f"{self.name}: Loaded {len(cookies)} authentication cookies into persistent browser context"
                     )
                 else:
-                    logger.debug(
-                        f"{self.name}: No cookies available from auth manager"
-                    )
+                    logger.debug(f"{self.name}: No cookies available from auth manager")
             else:
-                logger.debug(
-                    f"{self.name}: Not authenticated, skipping cookie loading"
-                )
+                logger.debug(f"{self.name}: Not authenticated, skipping cookie loading")
         except Exception as e:
-            logger.warning(
-                f"{self.name}: Failed to load authentication cookies: {e}"
-            )
+            logger.warning(f"{self.name}: Failed to load authentication cookies: {e}")
 
     async def take_screenshot_async(
         self,
@@ -558,9 +539,7 @@ class ScholarBrowserManager(BrowserMixin):
                         )
                 except Exception as e:
                     if verbose:
-                        logger.debug(
-                            f"{self.name}: Screenshot {step} failed: {e}"
-                        )
+                        logger.debug(f"{self.name}: Screenshot {step} failed: {e}")
 
                 await asyncio.sleep(interval_seconds)
                 elapsed += interval_seconds
@@ -599,10 +578,7 @@ class ScholarBrowserManager(BrowserMixin):
                 await self._persistent_context.close()
                 logger.debug(f"{self.name}: Closed persistent browser context")
 
-            if (
-                self._persistent_browser
-                and self._persistent_browser.is_connected()
-            ):
+            if self._persistent_browser and self._persistent_browser.is_connected():
                 await self._persistent_browser.close()
                 logger.debug(f"{self.name}: Closed persistent browser")
 
@@ -631,9 +607,10 @@ if __name__ == "__main__":
             auth_manager=ScholarAuthManager(),
         )
 
-        browser, context = (
-            await browser_manager.get_authenticated_browser_and_context_async()
-        )
+        (
+            browser,
+            context,
+        ) = await browser_manager.get_authenticated_browser_and_context_async()
         page = await context.new_page()
 
         # Test sites configuration
@@ -686,9 +663,7 @@ if __name__ == "__main__":
 
     import argparse
 
-    parser = argparse.ArgumentParser(
-        description="ScholarBrowserManager testing"
-    )
+    parser = argparse.ArgumentParser(description="ScholarBrowserManager testing")
     parser.add_argument(
         "--stealth",
         action="store_true",

scitex/scholar/browser/__init__.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------

scitex/scholar/browser/utils/click_and_wait.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/browser/utils/click_and_wait.py"
-)
+
+__FILE__ = "./src/scitex/scholar/browser/utils/click_and_wait.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -73,7 +72,7 @@ async def click_and_wait(
     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]}")
+    logger.debug(f"{(func_name,)} Clicking: '{text[:30]}' -> {href[:50]}")
 
     try:
         # Handle potential new page opening

scitex/scholar/browser/utils/close_unwanted_pages.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/browser/utils/close_unwanted_pages.py"
-)
+
+__FILE__ = "./src/scitex/scholar/browser/utils/close_unwanted_pages.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -63,10 +62,7 @@ async def close_unwanted_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()
-                ):
+                if "chrome-extension://" not in page.url and not page.is_closed():
                     valid_page = page
                     break
 
@@ -137,4 +133,5 @@ async def close_unwanted_pages(
                     f"{func_name}: Cleanup attempt {attempt + 1} failed",
                 )
 
+
 # EOF