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

scitex/scholar/.legacy/storage/__init__.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -15,4 +16,4 @@ from ._EnhancedStorageManager import EnhancedStorageManager
 
 __all__ = ["EnhancedStorageManager"]
 
-# EOF
+# EOF

scitex/scholar/__init__.py

@@ -35,11 +35,9 @@ __all__ = [
     "ScholarURLFinder",
     "ScholarAuthManager",
     "ScholarBrowserManager",
-
     "Paper",
     "Papers",
     "Scholar",
-
     "utils",
 ]
 

scitex/scholar/__main__.py

@@ -255,9 +255,7 @@ async def run_parallel_pipeline(args):
         project=args.project,
     )
 
-    logger.success(
-        f"Parallel pipeline completed: {len(papers)} papers processed"
-    )
+    logger.success(f"Parallel pipeline completed: {len(papers)} papers processed")
     return 0
 
 

scitex/scholar/auth/ScholarAuthManager.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/ScholarAuthManager.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/ScholarAuthManager.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -45,15 +44,9 @@ class ScholarAuthManager:
 
     def __init__(
         self,
-        email_openathens: Optional[str] = os.getenv(
-            "SCITEX_SCHOLAR_OPENATHENS_EMAIL"
-        ),
-        email_ezproxy: Optional[str] = os.getenv(
-            "SCITEX_SCHOLAR_EZPROXY_EMAIL"
-        ),
-        email_shibboleth: Optional[str] = os.getenv(
-            "SCITEX_SCHOLAR_SHIBBOLETH_EMAIL"
-        ),
+        email_openathens: Optional[str] = os.getenv("SCITEX_SCHOLAR_OPENATHENS_EMAIL"),
+        email_ezproxy: Optional[str] = os.getenv("SCITEX_SCHOLAR_EZPROXY_EMAIL"),
+        email_shibboleth: Optional[str] = os.getenv("SCITEX_SCHOLAR_SHIBBOLETH_EMAIL"),
         config: Optional[ScholarConfig] = None,
     ):
         """Initialize the authentication manager.
@@ -102,9 +95,7 @@ class ScholarAuthManager:
         if await self.is_authenticate_async(verify_live=verify_live):
             return True
 
-        if await self.authenticate_async(
-            provider_name=provider_name, **kwargs
-        ):
+        if await self.authenticate_async(provider_name=provider_name, **kwargs):
             return True
 
         raise AuthenticationError("Authentication not ensured")
@@ -133,9 +124,7 @@ class ScholarAuthManager:
         """Authenticate with specified or active provider."""
         if provider_name:
             if provider_name not in self.providers:
-                raise AuthenticationError(
-                    f"Provider '{provider_name}' not found"
-                )
+                raise AuthenticationError(f"Provider '{provider_name}' not found")
             provider = self.providers[provider_name]
         elif self.active_provider:
             provider = self.providers[self.active_provider]
@@ -146,9 +135,7 @@ class ScholarAuthManager:
         if self.auth_session and provider_name:
             self.active_provider = provider_name
 
-        logger.info(
-            f"{self.name}: Authentication succeeded by {provider_name}."
-        )
+        logger.info(f"{self.name}: Authentication succeeded by {provider_name}.")
 
         return self.auth_session
 
@@ -228,9 +215,7 @@ class ScholarAuthManager:
         )
         return filtered_cookies
 
-    def _register_provider(
-        self, name: str, provider: BaseAuthenticator
-    ) -> None:
+    def _register_provider(self, name: str, provider: BaseAuthenticator) -> None:
         """Register an authentication provider with email context."""
         if not isinstance(provider, BaseAuthenticator):
             raise TypeError(
@@ -239,9 +224,7 @@ class ScholarAuthManager:
         self.providers[name] = provider
         if not self.active_provider:
             self.active_provider = name
-        logger.debug(
-            f"{self.name}: Registered authentication provider: {name}"
-        )
+        logger.debug(f"{self.name}: Registered authentication provider: {name}")
 
     def set_active_provider(self, name: str) -> None:
         """Set the active authentication provider."""
@@ -251,18 +234,14 @@ class ScholarAuthManager:
                 f"Available providers: {list(self.providers.keys())}"
             )
         self.active_provider = name
-        logger.debug(
-            f"{self.name}: Set active authentication provider: {name}"
-        )
+        logger.debug(f"{self.name}: Set active authentication provider: {name}")
 
     def get_active_provider(self) -> Optional[BaseAuthenticator]:
         """Get the currently active provider."""
         if self.active_provider:
             return self.providers.get(self.active_provider)
         else:
-            raise ValueError(
-                f"Active provider not found. Please set active provider"
-            )
+            raise ValueError(f"Active provider not found. Please set active provider")
 
     async def logout_async(self) -> None:
         """Log out from all providers."""
@@ -271,9 +250,7 @@ class ScholarAuthManager:
                 await provider.logout_async()
                 logger.info(f"{self.name}: Logged out from {provider}")
             except Exception as e:
-                logger.warning(
-                    f"{self.name}: Error logging out from {provider}: {e}"
-                )
+                logger.warning(f"{self.name}: Error logging out from {provider}: {e}")
 
         self.active_provider = None
         self.auth_session = None

scitex/scholar/auth/core/AuthenticationGateway.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/core/AuthenticationGateway.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/core/AuthenticationGateway.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -158,9 +157,7 @@ class AuthenticationGateway:
                     f"{self.name}: Direct navigation failed, trying OpenURL: {e}"
                 )
                 try:
-                    publisher_url = await resolver.resolve_doi(
-                        url_context.doi, page
-                    )
+                    publisher_url = await resolver.resolve_doi(url_context.doi, page)
                     url_context.url = publisher_url
                 except Exception as openurl_error:
                     logger.warning(
@@ -204,22 +201,16 @@ class AuthenticationGateway:
         try:
             publisher_url = await resolver.resolve_doi(url_context.doi, page)
             url_context.url = publisher_url
-            logger.debug(
-                f"{self.name}: Resolved {url_context.doi} → {publisher_url}"
-            )
+            logger.debug(f"{self.name}: Resolved {url_context.doi} → {publisher_url}")
         except Exception as e:
-            logger.warning(
-                f"{self.name}: Failed to resolve DOI {url_context.doi}: {e}"
-            )
+            logger.warning(f"{self.name}: Failed to resolve DOI {url_context.doi}: {e}")
             url_context.url = openurl  # Fallback to OpenURL
         finally:
             await page.close()
 
         return url_context
 
-    def _check_auth_requirements_from_doi(
-        self, url_context: URLContext
-    ) -> URLContext:
+    def _check_auth_requirements_from_doi(self, url_context: URLContext) -> URLContext:
         """
         Determine if DOI requires authentication based on DOI prefix patterns.
 
@@ -334,9 +325,7 @@ class AuthenticationGateway:
         gateway_url = url_context.auth_gateway_url
 
         if not gateway_url:
-            logger.warning(
-                f"{self.name}: No gateway URL available for authentication"
-            )
+            logger.warning(f"{self.name}: No gateway URL available for authentication")
             return None
 
         # Check cache - avoid redundant visits
@@ -417,9 +406,7 @@ async def main_async():
     # Initialize components
     config = ScholarConfig()
     auth_manager = ScholarAuthManager(config=config)
-    browser_manager = ScholarBrowserManager(
-        auth_manager=auth_manager, config=config
-    )
+    browser_manager = ScholarBrowserManager(auth_manager=auth_manager, config=config)
 
     # Initialize gateway
     gateway = AuthenticationGateway(
@@ -436,20 +423,19 @@ async def main_async():
     ]
 
     # Get authenticated browser context
-    browser, context = (
-        await browser_manager.get_authenticated_browser_and_context_async()
-    )
+    (
+        browser,
+        context,
+    ) = await browser_manager.get_authenticated_browser_and_context_async()
 
     try:
         for doi in test_dois:
-            logger.info(f"\n{'='*60}")
+            logger.info(f"\n{'=' * 60}")
             logger.info(f"Testing DOI: {doi}")
-            logger.info(f"{'='*60}")
+            logger.info(f"{'=' * 60}")
 
             # Prepare authentication (this is the key operation)
-            url_context = await gateway.prepare_context_async(
-                doi=doi, context=context
-            )
+            url_context = await gateway.prepare_context_async(doi=doi, context=context)
 
             # Show results
             logger.info(f"Publisher URL: {url_context.url}")

scitex/scholar/auth/core/BrowserAuthenticator.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/core/BrowserAuthenticator.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/core/BrowserAuthenticator.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -70,9 +69,7 @@ class BrowserAuthenticator(BrowserMixin):
             context_options["viewport"] = {"width": 1, "height": 1}
 
         context = await browser.new_context(**context_options)
-        await context.add_init_script(
-            self.cookie_acceptor.get_auto_acceptor_script()
-        )
+        await context.add_init_script(self.cookie_acceptor.get_auto_acceptor_script())
         # await self.cookie_acceptor.inject_auto_acceptor_async(context)
         page = await context.new_page()
 
@@ -111,17 +108,13 @@ class BrowserAuthenticator(BrowserMixin):
             # Track SSO navigation
             if self._is_sso_page(current_url):
                 seen_sso_page = True
-                logger.debug(
-                    f"{self.name}: Detected SSO/login page: {current_url}"
-                )
+                logger.debug(f"{self.name}: Detected SSO/login page: {current_url}")
 
             # Handle different authentication flows based on current URL
             automation_attempted = False
 
             # Priority 1: OpenAthens page automation (if on OpenAthens and not yet automated)
-            if not openathens_automated and self._is_openathens_page(
-                current_url
-            ):
+            if not openathens_automated and self._is_openathens_page(current_url):
                 logger.debug(
                     f"{self.name}: OpenAthens page detected - attempting automation"
                 )
@@ -135,8 +128,8 @@ class BrowserAuthenticator(BrowserMixin):
                     openathens_automator = OpenAthensSSOAutomator()
 
                     if openathens_automator.is_sso_page(current_url):
-                        oa_success = await openathens_automator.handle_sso_redirect_async(
-                            page
+                        oa_success = (
+                            await openathens_automator.handle_sso_redirect_async(page)
                         )
                         if oa_success:
                             logger.info(
@@ -148,23 +141,17 @@ class BrowserAuthenticator(BrowserMixin):
                                 f"{self.name}: OpenAthens page automation failed"
                             )
                 except Exception as e:
-                    logger.warning(
-                        f"{self.name}: OpenAthens automation failed: {e}"
-                    )
+                    logger.warning(f"{self.name}: OpenAthens automation failed: {e}")
 
             # Priority 2: Institution-specific SSO automation (if available and on SSO page)
-            elif self.sso_automator and self.sso_automator.is_sso_page(
-                current_url
-            ):
+            elif self.sso_automator and self.sso_automator.is_sso_page(current_url):
                 institution_name = self.sso_automator.get_institution_name()
                 logger.info(
                     f"{self.name}: {institution_name} SSO detected - attempting automation"
                 )
                 automation_attempted = True
 
-                sso_success = (
-                    await self.sso_automator.handle_sso_redirect_async(page)
-                )
+                sso_success = await self.sso_automator.handle_sso_redirect_async(page)
                 if sso_success:
                     logger.info(
                         f"{self.name}: {institution_name} SSO automation completed"
@@ -182,21 +169,15 @@ class BrowserAuthenticator(BrowserMixin):
                 automation_attempted = True
 
                 try:
-                    generic_success = (
-                        await self._attempt_generic_sso_automation(page)
-                    )
+                    generic_success = await self._attempt_generic_sso_automation(page)
                     if generic_success:
-                        logger.info(
-                            f"{self.name}: Generic SSO automation completed"
-                        )
+                        logger.info(f"{self.name}: Generic SSO automation completed")
                     else:
                         logger.info(
                             f"{self.name}: Generic SSO automation not applicable"
                         )
                 except Exception as e:
-                    logger.debug(
-                        f"{self.name}: Generic SSO automation failed: {e}"
-                    )
+                    logger.debug(f"{self.name}: Generic SSO automation failed: {e}")
 
             # If automation was attempted but we're still on the same page,
             # it likely failed and requires manual intervention
@@ -214,9 +195,7 @@ class BrowserAuthenticator(BrowserMixin):
                     logger.info(
                         f"{self.name}: Login successful detected at URL: {current_url}"
                     )
-                    logger.info(
-                        f"{self.name}: Login detected! Capturing session..."
-                    )
+                    logger.info(f"{self.name}: Login detected! Capturing session...")
                     return True
 
             # Show progress
@@ -265,9 +244,7 @@ class BrowserAuthenticator(BrowserMixin):
                 )
 
                 current_url = page.url
-                is_authenticate_async = self._check_authenticate_async_page(
-                    current_url
-                )
+                is_authenticate_async = self._check_authenticate_async_page(current_url)
 
                 await browser.close()
 
@@ -283,9 +260,7 @@ class BrowserAuthenticator(BrowserMixin):
                 return is_authenticate_async
 
         except Exception as e:
-            logger.error(
-                f"{self.name}: Authentication verification failed: {e}"
-            )
+            logger.error(f"{self.name}: Authentication verification failed: {e}")
             return False
         finally:
             # Restore original mode setting
@@ -310,15 +285,11 @@ class BrowserAuthenticator(BrowserMixin):
         """Perform reliable click using shared utility."""
         return await click_with_fallbacks_async(page, selector)
 
-    async def reliable_fill_async(
-        self, page: Page, selector: str, value: str
-    ) -> bool:
+    async def reliable_fill_async(self, page: Page, selector: str, value: str) -> bool:
         """Perform reliable form fill using shared utility."""
         return await fill_with_fallbacks_async(page, selector, value)
 
-    def display_login_instructions(
-        self, email: Optional[str], timeout: int
-    ) -> None:
+    def display_login_instructions(self, email: Optional[str], timeout: int) -> None:
         """Display login instructions to user using proper logging.
 
         Args:
@@ -332,9 +303,7 @@ class BrowserAuthenticator(BrowserMixin):
         logger.info(f"{self.name}: Please complete the login process:")
         logger.info(f"{self.name}: 1. Enter your institutional email")
         logger.info(f"{self.name}: 2. Click your institution when it appears")
-        logger.info(
-            f"{self.name}: 3. Complete login on your institution's page"
-        )
+        logger.info(f"{self.name}: 3. Complete login on your institution's page")
         logger.info(
             f"{self.name}: 4. You'll be redirected back to OpenAthens when done"
         )
@@ -353,14 +322,9 @@ class BrowserAuthenticator(BrowserMixin):
 
     def _is_openathens_page(self, url: str) -> bool:
         """Check if URL is OpenAthens page."""
-        return (
-            "my.openathens.net" in url.lower()
-            or "openathens.net" in url.lower()
-        )
+        return "my.openathens.net" in url.lower() or "openathens.net" in url.lower()
 
-    def _check_success_indicators(
-        self, url: str, indicators: List[str]
-    ) -> bool:
+    def _check_success_indicators(self, url: str, indicators: List[str]) -> bool:
         """Check if URL matches any success indicators."""
         return any(indicator in url for indicator in indicators)
 
@@ -383,4 +347,5 @@ class BrowserAuthenticator(BrowserMixin):
         # Check for authenticate_async patterns
         return any(pattern in url for pattern in authenticate_async_patterns)
 
+
 # EOF

scitex/scholar/auth/core/StrategyResolver.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/core/StrategyResolver.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/core/StrategyResolver.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -106,9 +105,7 @@ class AuthenticationStrategyResolver:
 
         # Get email from config if not provided
         if not openathens_email:
-            openathens_email = self.config.resolve(
-                "openathens_email", None, None, str
-            )
+            openathens_email = self.config.resolve("openathens_email", None, None, str)
 
         if not openathens_email:
             logger.warning(
@@ -155,18 +152,14 @@ class AuthenticationStrategyResolver:
         """Resolve strategy for known institution."""
 
         institution_name = institution_config["name"]
-        sso_automator_available = (
-            institution_config.get("sso_automator") is not None
-        )
+        sso_automator_available = institution_config.get("sso_automator") is not None
 
         logger.info(
             f"{self.name}: Resolving strategy for known institution: {institution_name}"
         )
 
         # Determine primary method based on preferences and capabilities
-        if prefer_openathens and institution_config.get(
-            "openathens_supported", False
-        ):
+        if prefer_openathens and institution_config.get("openathens_supported", False):
             if institution_config.get("openathens_redirects_to_sso", False):
                 # OpenAthens → SSO flow
                 method = AuthenticationMethod.OPENATHENS_TO_SSO
@@ -188,9 +181,7 @@ class AuthenticationStrategyResolver:
         else:
             # Direct SSO
             method = AuthenticationMethod.DIRECT_SSO
-            primary_url = institution_config.get(
-                "direct_sso_url", target_url or ""
-            )
+            primary_url = institution_config.get("direct_sso_url", target_url or "")
             confidence = 0.8 if sso_automator_available else 0.5
             fallback_methods = (
                 [
@@ -232,9 +223,7 @@ class AuthenticationStrategyResolver:
             fallback_methods = [AuthenticationMethod.MANUAL]
         else:
             method = AuthenticationMethod.MANUAL
-            primary_url = (
-                target_url or "https://my.openathens.net/?passiveLogin=false"
-            )
+            primary_url = target_url or "https://my.openathens.net/?passiveLogin=false"
             confidence = 0.3
             fallback_methods = []
 
@@ -269,9 +258,7 @@ class AuthenticationStrategyResolver:
             "openathens_redirects_to_sso": openathens_redirects_to_sso,
             "sso_automator": sso_automator,
         }
-        logger.info(
-            f"{self.name}: Added institution configuration: {name} ({domain})"
-        )
+        logger.info(f"{self.name}: Added institution configuration: {name} ({domain})")
 
 
 if __name__ == "__main__":
@@ -281,17 +268,13 @@ if __name__ == "__main__":
         resolver = AuthenticationStrategyResolver()
 
         # Test known institution
-        strategy = resolver.resolve_strategy(
-            openathens_email="test@unimelb.edu.au"
-        )
+        strategy = resolver.resolve_strategy(openathens_email="test@unimelb.edu.au")
         print(
             f"UniMelb Strategy: {strategy.method.value}, URL: {strategy.primary_url}, Confidence: {strategy.confidence}"
         )
 
         # Test unknown institution
-        strategy = resolver.resolve_strategy(
-            openathens_email="test@unknown.edu"
-        )
+        strategy = resolver.resolve_strategy(openathens_email="test@unknown.edu")
         print(
             f"Unknown Strategy: {strategy.method.value}, URL: {strategy.primary_url}, Confidence: {strategy.confidence}"
         )

scitex/scholar/auth/core/__init__.py

@@ -2,7 +2,11 @@
 
 from .AuthenticationGateway import AuthenticationGateway, URLContext
 from .BrowserAuthenticator import BrowserAuthenticator
-from .StrategyResolver import AuthenticationStrategyResolver, AuthenticationStrategy, AuthenticationMethod
+from .StrategyResolver import (
+    AuthenticationStrategyResolver,
+    AuthenticationStrategy,
+    AuthenticationMethod,
+)
 
 __all__ = [
     "AuthenticationGateway",

scitex/scholar/auth/gateway/_OpenURLLinkFinder.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/gateway/_OpenURLLinkFinder.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/gateway/_OpenURLLinkFinder.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -47,9 +46,7 @@ class OpenURLLinkFinder:
             for pattern in openurl_available_from_patterns:
                 publisher = pattern[len("Available from ") :]
                 try:
-                    link_element = page.locator(
-                        f'a:has-text("{publisher}")'
-                    ).first
+                    link_element = page.locator(f'a:has-text("{publisher}")').first
                     if await link_element.count() > 0:
                         href = await link_element.get_attribute("href")
                         if href not in seen_hrefs:
@@ -63,23 +60,17 @@ class OpenURLLinkFinder:
                             )
                             seen_hrefs.add(href)
                 except Exception as e:
-                    logger.debug(
-                        f"{self.name}: Could not find {publisher}: {e}"
-                    )
+                    logger.debug(f"{self.name}: Could not find {publisher}: {e}")
 
             if found_links:
-                publishers = [
-                    found_link.get("publisher") for found_link in found_links
-                ]
+                publishers = [found_link.get("publisher") for found_link in found_links]
                 logger.info(
                     f"{self.name}: Found {len(publishers)} link elements for: {', '.join(publishers)}"
                 )
                 return found_links
 
         except Exception as e:
-            logger.fail(
-                f"{self.name}: Did not find any urls from {page.url}: {e}"
-            )
+            logger.fail(f"{self.name}: Did not find any urls from {page.url}: {e}")
             return []
 
 
@@ -98,18 +89,17 @@ if __name__ == "__main__":
             browser_mode="interactive",
             chrome_profile_name="system",
         )
-        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()
         url = "https://unimelb.hosted.exlibrisgroup.com/sfxlcl41?doi=10.1126/science.aao0702"
         await page.goto(url, wait_until="networkidle", timeout=30_000)
         await page.wait_for_timeout(3000)
 
         finder = OpenURLLinkFinder()
-        links = await finder.find_link_elements(
-            page, "10.1126/science.aao0702"
-        )
+        links = await finder.find_link_elements(page, "10.1126/science.aao0702")
 
         result = await click_and_wait(links[0].get("link_element"))