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

scitex/scholar/auth/providers/ShibbolethAuthenticator.py

@@ -36,6 +36,7 @@ logger = logging.getLogger(__name__)
 
 class ShibbolethError(ScholarError):
     """Raised when Shibboleth authentication fails."""
+
     pass
 
 
@@ -101,9 +102,11 @@ class ShibbolethAuthenticator(BaseAuthenticator):
             cache_dir or Path.home() / ".scitex" / "scholar" / "shibboleth_sessions"
         )
         self.cache_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # Session file path
-        self.session_file = self.cache_dir / f"session_{self._get_session_async_key()}.json"
+        self.session_file = (
+            self.cache_dir / f"session_{self._get_session_async_key()}.json"
+        )
 
         # Session management
         self._cookies: Dict[str, str] = {}
@@ -119,7 +122,7 @@ class ShibbolethAuthenticator(BaseAuthenticator):
             "https://ds.aai.switch.ch",  # Swiss federation
             "https://discovery.shibboleth.net",  # Generic discovery
         ]
-        
+
         # Common IdP login patterns
         self.idp_patterns = {
             "username_field": [
@@ -144,7 +147,7 @@ class ShibbolethAuthenticator(BaseAuthenticator):
                 "button:has-text('Sign in')",
             ],
         }
-        
+
         # Load existing session
         self._load_session()
 
@@ -163,7 +166,7 @@ class ShibbolethAuthenticator(BaseAuthenticator):
             try:
                 with open(self.session_file, "r") as f:
                     data = json.load(f)
-                    
+
                 # Check if session is expired
                 expiry_str = data.get("expiry")
                 if expiry_str:
@@ -238,45 +241,47 @@ class ShibbolethAuthenticator(BaseAuthenticator):
 
         # Get resource URL to access (triggers Shibboleth flow)
         resource_url = kwargs.get("resource_url", "https://www.nature.com/siteindex")
-        
-        logger.info(f"Authenticating with Shibboleth for {self.institution or 'institution'}")
+
+        logger.info(
+            f"Authenticating with Shibboleth for {self.institution or 'institution'}"
+        )
 
         async with async_playwright() as p:
             browser = await p.chromium.launch(
                 headless=not self.debug_mode,
-                args=['--disable-blink-features=AutomationControlled']
+                args=["--disable-blink-features=AutomationControlled"],
             )
-            
+
             try:
                 context = await browser.new_context(
-                    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                    user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
                 )
                 page = await context.new_page()
-                
+
                 # Step 1: Access protected resource
                 await page.goto(resource_url, wait_until="networkidle")
-                
+
                 # Step 2: Look for institutional login option
                 login_found = await self._find_institutional_login_async(page)
-                
+
                 if login_found:
                     # Click institutional login
                     await login_found.click()
                     await page.wait_for_load_state("networkidle")
-                
+
                 # Step 3: Handle WAYF/Discovery Service
                 wayf_handled = await self._handle_wayf_selection_async(page)
-                
+
                 if not wayf_handled and not self.idp_url:
                     raise ShibbolethError("Could not find institution selection page")
-                
+
                 # Step 4: Handle IdP login
                 if self.idp_url and page.url.startswith(self.idp_url):
                     await self._handle_idp_login_async(page)
                 else:
                     # Try to detect and handle IdP automatically
                     await self._handle_idp_login_async(page)
-                
+
                 # Step 5: Wait for redirect back to resource
                 try:
                     await page.wait_for_function(
@@ -285,35 +290,35 @@ class ShibbolethAuthenticator(BaseAuthenticator):
                                    !window.location.href.includes('wayf') &&
                                    !window.location.href.includes('discovery');
                         }}""",
-                        timeout=30000
+                        timeout=30000,
                     )
                 except:
                     # Continue anyway - might still be authenticate_async
                     pass
-                
+
                 # Extract cookies and SAML attributes
                 cookies = await context.cookies()
-                
+
                 # Try to extract SAML attributes from page or headers
                 self._saml_attributes = await self._extract_saml_attributes_async(page)
-                
+
                 # Convert cookies
                 self._cookies = {c["name"]: c["value"] for c in cookies}
                 self._full_cookies = cookies
-                
+
                 # Set session expiry (typically 8-12 hours for Shibboleth)
                 self._session_expiry = datetime.now() + timedelta(hours=8)
-                
+
                 # Save session
                 self._save_session_async()
-                
+
                 logger.info(f"{self.name}: Shibboleth authentication successful")
                 return {
                     "cookies": self._cookies,
                     "full_cookies": self._full_cookies,
                     "saml_attributes": self._saml_attributes,
                 }
-                
+
             except Exception as e:
                 logger.error(f"Shibboleth authentication failed: {e}")
                 raise ShibbolethError(f"Authentication failed: {str(e)}")
@@ -333,13 +338,13 @@ class ShibbolethAuthenticator(BaseAuthenticator):
             "a[href*='wayf']",
             "a[href*='idp']",
         ]
-        
+
         for selector in selectors:
             element = await page.query_selector(selector)
             if element and await element.is_visible():
                 logger.debug(f"Found institutional login: {selector}")
                 return element
-                
+
         return None
 
     async def _handle_wayf_selection_async(self, page: Page) -> bool:
@@ -348,15 +353,16 @@ class ShibbolethAuthenticator(BaseAuthenticator):
         wayf_indicators = ["wayf", "discovery", "ds.", "where are you from"]
         current_url = page.url.lower()
         page_content = await page.content()
-        
-        is_wayf = any(ind in current_url for ind in wayf_indicators) or \
-                  any(ind in page_content.lower() for ind in wayf_indicators)
-        
+
+        is_wayf = any(ind in current_url for ind in wayf_indicators) or any(
+            ind in page_content.lower() for ind in wayf_indicators
+        )
+
         if not is_wayf:
             return False
-            
+
         logger.info(f"{self.name}: Detected WAYF/Discovery Service page")
-        
+
         # Try to find institution selector
         if self.institution:
             # Search for institution in dropdown/list
@@ -365,43 +371,48 @@ class ShibbolethAuthenticator(BaseAuthenticator):
                 f"a:has-text('{self.institution}')",
                 f"li:has-text('{self.institution}')",
             ]
-            
+
             for selector in selectors:
                 element = await page.query_selector(selector)
                 if element:
                     # If it's an option, select it
                     if await element.evaluate("el => el.tagName") == "OPTION":
                         select = await element.evaluate_handle("el => el.parentElement")
-                        await select.select_option(value=await element.get_attribute("value"))
+                        await select.select_option(
+                            value=await element.get_attribute("value")
+                        )
                         # Find and click submit button
-                        submit = await page.query_selector("button[type='submit'], input[type='submit']")
+                        submit = await page.query_selector(
+                            "button[type='submit'], input[type='submit']"
+                        )
                         if submit:
                             await submit.click()
                     else:
                         # Direct click
                         await element.click()
-                    
+
                     await page.wait_for_load_state("networkidle")
                     return True
-                    
+
         # If automated selection fails, might need manual intervention
         if self.debug_mode:
             logger.info(f"{self.name}: Please select your institution manually")
             await asyncio.sleep(30)  # Give time for manual selection
-            
+
         return False
 
     async def _handle_idp_login_async(self, page: Page) -> None:
         """Handle login at the Identity Provider."""
         logger.info(f"{self.name}: Handling IdP login page")
-        
+
         # Get credentials
         if not self.username:
             self.username = input("Shibboleth username: ")
         if not self.password:
             import getpass
+
             self.password = getpass.getpass("Shibboleth password: ")
-        
+
         # Try each username field pattern
         username_filled = False
         for selector in self.idp_patterns["username_field"]:
@@ -410,10 +421,10 @@ class ShibbolethAuthenticator(BaseAuthenticator):
                 await field.fill(self.username)
                 username_filled = True
                 break
-                
+
         if not username_filled:
             raise ShibbolethError("Could not find username field")
-            
+
         # Try each password field pattern
         password_filled = False
         for selector in self.idp_patterns["password_field"]:
@@ -422,24 +433,24 @@ class ShibbolethAuthenticator(BaseAuthenticator):
                 await field.fill(self.password)
                 password_filled = True
                 break
-                
+
         if not password_filled:
             raise ShibbolethError("Could not find password field")
-            
+
         # Try each submit button pattern
         for selector in self.idp_patterns["submit_button"]:
             button = await page.query_selector(selector)
             if button and await button.is_visible():
                 await button.click()
                 break
-        
+
         # Wait for authentication to complete
         await page.wait_for_load_state("networkidle")
 
     async def _extract_saml_attributes_async(self, page: Page) -> Dict[str, Any]:
         """Try to extract SAML attributes from the page."""
         attributes = {}
-        
+
         try:
             # Some SPs expose attributes in meta tags
             meta_tags = await page.query_selector_all("meta[name^='shib-']")
@@ -449,20 +460,20 @@ class ShibbolethAuthenticator(BaseAuthenticator):
                 if name and content:
                     attr_name = name.replace("shib-", "")
                     attributes[attr_name] = content
-                    
+
             # Check for common attribute patterns in page
             if not attributes:
                 # Try to find email/eppn
-                email_pattern = r'[\w._%+-]+@[\w.-]+\.[a-zA-Z]{2,}'
+                email_pattern = r"[\w._%+-]+@[\w.-]+\.[a-zA-Z]{2,}"
                 page_text = await page.text_content()
                 if page_text:
                     emails = re.findall(email_pattern, page_text)
                     if emails and self.username in emails[0]:
                         attributes["eppn"] = emails[0]
-                        
+
         except Exception as e:
             logger.debug(f"Could not extract SAML attributes: {e}")
-            
+
         return attributes
 
     async def is_authenticate_async(self, verify_live: bool = False) -> bool:
@@ -478,48 +489,48 @@ class ShibbolethAuthenticator(BaseAuthenticator):
         # Check if we have session data
         if not self._cookies or not self._session_expiry:
             return False
-            
+
         # Check if session is expired
         if datetime.now() > self._session_expiry:
             logger.info(f"{self.name}: Shibboleth session expired")
             return False
-            
+
         # If requested, verify session is still valid
         if verify_live:
             try:
                 async with async_playwright() as p:
                     browser = await p.chromium.launch(headless=True)
                     context = await browser.new_context()
-                    
+
                     # Add cookies
                     await context.add_cookies(self._full_cookies)
-                    
+
                     page = await context.new_page()
-                    
+
                     # Try to access a protected resource
                     test_url = "https://www.nature.com/nature"
                     response = await page.goto(test_url, wait_until="networkidle")
-                    
+
                     # Check if we're redirected to login
                     is_valid = not any(
-                        ind in page.url.lower() 
+                        ind in page.url.lower()
                         for ind in ["login", "wayf", "idp", "shibboleth"]
                     )
-                    
+
                     await browser.close()
-                    
+
                     if not is_valid:
                         logger.info(f"{self.name}: Shibboleth session no longer valid")
                         self._cookies = {}
                         self._full_cookies = []
                         self._session_expiry = None
-                        
+
                     return is_valid
-                    
+
             except Exception as e:
                 logger.warn(f"Failed to verify session: {e}")
                 return False
-                
+
         return True
 
     async def get_auth_headers_async(self) -> Dict[str, str]:
@@ -561,17 +572,17 @@ class ShibbolethAuthenticator(BaseAuthenticator):
         self._full_cookies = []
         self._session_expiry = None
         self._saml_attributes = {}
-        
+
         # Remove session file
         if self.session_file.exists():
             self.session_file.unlink()
-            
+
         logger.info(f"{self.name}: Logged out from Shibboleth")
 
     async def get_session_info_async(self) -> Dict[str, Any]:
         """Get information about current session."""
         is_authenticate_async = await self.is_authenticate_async()
-        
+
         return {
             "authenticate_async": is_authenticate_async,
             "provider": "Shibboleth",
@@ -580,7 +591,9 @@ class ShibbolethAuthenticator(BaseAuthenticator):
             "idp_url": self.idp_url,
             "entity_id": self.entity_id,
             "saml_attributes": self._saml_attributes,
-            "session_expiry": self._session_expiry.isoformat() if self._session_expiry else None,
+            "session_expiry": self._session_expiry.isoformat()
+            if self._session_expiry
+            else None,
             "cookies_count": len(self._cookies),
         }
 
@@ -671,16 +684,17 @@ class ShibbolethAuthenticator(BaseAuthenticator):
         p = await async_playwright().start()
         browser = await p.chromium.launch(
             headless=not self.debug_mode,
-            args=['--disable-blink-features=AutomationControlled']
+            args=["--disable-blink-features=AutomationControlled"],
         )
-        
+
         context = await browser.new_context(
-            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
         )
-        
+
         # Add authentication cookies
         await context.add_cookies(self._full_cookies)
-        
+
         return browser, context
 
-# EOF
+
+# EOF

scitex/scholar/auth/session/AuthCacheManager.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/utils/AuthCacheManager.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/utils/AuthCacheManager.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -61,13 +60,13 @@ class AuthCacheManager:
             os.chmod(self.cache_dir, 0o700)
         except OSError:
             # Permission denied in WSL or other systems where chmod may not work
-            logger.debug(f"{self.name}: Could not set directory permissions: {self.cache_dir}")
+            logger.debug(
+                f"{self.name}: Could not set directory permissions: {self.cache_dir}"
+            )
 
         self.email = email
 
-    async def save_session_async(
-        self, session_manager: SessionManager
-    ) -> bool:
+    async def save_session_async(self, session_manager: SessionManager) -> bool:
         """Save session data to cache file."""
         try:
             cache_data = self._create_cache_data(session_manager)
@@ -77,23 +76,17 @@ class AuthCacheManager:
 
             # Set secure permissions
             os.chmod(self.cache_json, 0o600)
-            logger.info(
-                f"{self.name}: Session saved to: {self.cache_json}"
-            )
+            logger.info(f"{self.name}: Session saved to: {self.cache_json}")
             return True
 
         except Exception as e:
             logger.error(f"{self.name}: Failed to save session cache: {e}")
             return False
 
-    async def load_session_async(
-        self, session_manager: SessionManager
-    ) -> bool:
+    async def load_session_async(self, session_manager: SessionManager) -> bool:
         """Load session data from cache file."""
         if not Path(self.cache_json).exists():
-            logger.debug(
-                f"{self.name}: No session cache found at {self.cache_json}"
-            )
+            logger.debug(f"{self.name}: No session cache found at {self.cache_json}")
             return False
 
         try:
@@ -121,9 +114,7 @@ class AuthCacheManager:
         try:
             if self.cache_json.exists():
                 self.cache_json.unlink()
-                logger.info(
-                    f"{self.name}: Cleared cache file: {self.cache_json}"
-                )
+                logger.info(f"{self.name}: Cleared cache file: {self.cache_json}")
             return True
         except Exception as e:
             logger.error(f"{self.name}: Failed to clear cache: {e}")
@@ -137,9 +128,7 @@ class AuthCacheManager:
         """Get lock file path."""
         return self.cache_json_lock
 
-    def _create_cache_data(
-        self, session_manager: SessionManager
-    ) -> Dict[str, Any]:
+    def _create_cache_data(self, session_manager: SessionManager) -> Dict[str, Any]:
         """Create cache data dictionary from session manager."""
         expiry = session_manager.get_session_async_expiry()
         return {
@@ -193,4 +182,5 @@ class AuthCacheManager:
 
         session_manager.set_session_data(cookies, full_cookies, expiry)
 
+
 # EOF

scitex/scholar/auth/session/SessionManager.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/auth/library/_SessionManager.py"
-)
+
+__FILE__ = "./src/scitex/scholar/auth/library/_SessionManager.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -98,9 +97,7 @@ class SessionManager:
             "has_cookies": bool(self._cookies),
             "cookie_count": len(self._cookies),
             "expiry": (
-                self._session_expiry.isoformat()
-                if self._session_expiry
-                else None
+                self._session_expiry.isoformat() if self._session_expiry else None
             ),
             "expired": self.is_session_expired(),
             "time_remaining": self._get_time_remaining(),
@@ -156,4 +153,5 @@ class SessionManager:
             "expiry": self._session_expiry,
         }
 
+
 # EOF

scitex/scholar/auth/sso/BaseSSOAutomator.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -92,9 +93,7 @@ class BaseSSOAutomator(ABC):
         )
 
         # Session management
-        self._session_dir = (
-            Path.home() / ".scitex" / "scholar" / "sso_sessions"
-        )
+        self._session_dir = Path.home() / ".scitex" / "scholar" / "sso_sessions"
         self._session_dir.mkdir(parents=True, exist_ok=True)
 
         self.logger = logger
@@ -135,9 +134,7 @@ class BaseSSOAutomator(ABC):
             if not self.is_sso_page(current_url):
                 return True
 
-            self.logger.info(
-                f"Detected {self.get_institution_name()} SSO page"
-            )
+            self.logger.info(f"Detected {self.get_institution_name()} SSO page")
 
             # Try to restore session first
             if self.use_persistent_session:
@@ -250,9 +247,7 @@ class BaseSSOAutomator(ABC):
             if success:
                 self.logger.info(f"User notification sent: {event_type}")
             else:
-                self.logger.warning(
-                    f"Failed to send user notification: {event_type}"
-                )
+                self.logger.warning(f"Failed to send user notification: {event_type}")
 
         except Exception as e:
             self.logger.warning(f"Failed to send user notification: {str(e)}")
@@ -287,16 +282,14 @@ Action Required:
 System: SciTeX Scholar Module
 Institution: {institution}
 Status: Awaiting 2FA approval
-Timeout: {kwargs.get('timeout', 'Unknown')} seconds
+Timeout: {kwargs.get("timeout", "Unknown")} seconds
 
 This is an automated notification from the SciTeX Scholar authentication system.
             """.strip()
             priority = "high"
 
         elif event_type == "authentication_success":
-            subject = (
-                f"SciTeX Scholar: Authentication Successful - {institution}"
-            )
+            subject = f"SciTeX Scholar: Authentication Successful - {institution}"
             message = f"""
 {institution} SSO Authentication Complete
 
@@ -304,8 +297,8 @@ Your authentication has been completed successfully.
 
 Details:
 - Institution: {institution}
-- Session expires: {kwargs.get('expires_at', 'Unknown')}
-- Cookies saved: {kwargs.get('cookie_count', 'Unknown')}
+- Session expires: {kwargs.get("expires_at", "Unknown")}
+- Cookies saved: {kwargs.get("cookie_count", "Unknown")}
 
 System: SciTeX Scholar Module
 Status: Authenticated
@@ -323,7 +316,7 @@ Authentication was not completed successfully.
 
 Details:
 - Institution: {institution}
-- Error: {kwargs.get('error', 'Unknown error')}
+- Error: {kwargs.get("error", "Unknown error")}
 - Retry available: Yes
 
 System: SciTeX Scholar Module
@@ -342,8 +335,8 @@ Your authentication session has expired and will need to be renewed.
 
 Details:
 - Institution: {institution}
-- Expired at: {kwargs.get('expired_at', 'Unknown')}
-- Auto-renewal: {kwargs.get('auto_renewal', 'Disabled')}
+- Expired at: {kwargs.get("expired_at", "Unknown")}
+- Auto-renewal: {kwargs.get("auto_renewal", "Disabled")}
 
 System: SciTeX Scholar Module
 Status: Session expired
@@ -358,7 +351,7 @@ Authentication will be required for the next access.
             message = f"""
 {institution} SSO Notification
 
-Event: {event_type.replace('_', ' ').title()}
+Event: {event_type.replace("_", " ").title()}
 Institution: {institution}
 Context: {kwargs}
 
@@ -370,4 +363,5 @@ This is an automated notification from the SciTeX Scholar authentication system.
 
         return subject, message, priority
 
+
 # EOF