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

scitex/browser/automation/CookieHandler.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-11 00:41:46 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/browser/automation/CookieHandler.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/browser/automation/CookieHandler.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+__FILE__ = __file__
+
+import json
+
+from playwright.async_api import Page
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CookieAutoAcceptor:
+    """Automatically handles cookie consent banners on web pages."""
+
+    def __init__(self):
+        self.name = self.__class__.__name__
+        self.cookie_texts = [
+            "Accept all cookies",
+            "Accept All",
+            "Accept cookies",
+            "Accept",
+            "I Accept",
+            "OK",
+            "Continue",
+            "Agree",
+            "Continue without an account",
+            "Don't ask again",
+        ]
+
+        self.selectors = [
+            "[data-testid*='accept']",
+            "[id*='accept']",
+            "[class*='accept']",
+            "button[aria-label*='Accept']",
+            ".cookie-banner button:first-of-type",
+            "#cookie-banner button:first-of-type",
+        ]
+
+    async def inject_auto_acceptor_async(self, context):
+        """Inject auto-acceptor script into browser context."""
+        logger.warning(f"{self.name}: Use get_auto_acceptor_script instead")
+        script = self.get_auto_acceptor_script()
+        await context.add_init_script(script)
+        logger.debug(f"{self.name}: Injected auto-acceptor script")
+
+    def get_auto_acceptor_script(
+        self,
+    ):
+        return f"""
+        (() => {{
+            const cookieTexts = {json.dumps(self.cookie_texts)};
+            const selectors = {json.dumps(self.selectors)};
+
+            function acceptCookies() {{
+                // Try text-based buttons
+                for (const text of cookieTexts) {{
+                    const buttons = Array.from(document.querySelectorAll('button, a'));
+                    const match = buttons.find(btn =>
+                        btn.textContent.trim().toLowerCase() === text.toLowerCase() &&
+                        !btn.hasAttribute('data-scitex-no-auto-click') &&  // SKIP SciTeX buttons!
+                        !btn.closest('[data-scitex-no-auto-click]') &&  // SKIP if inside SciTeX container!
+                        btn.id !== 'stop-automation-btn' &&  // SKIP manual download button by ID!
+                        !btn.id.includes('scitex')  // SKIP any scitex-related button
+                    );
+                    if (match && match.offsetParent !== null) {{
+                        match.click();
+                        console.log('Auto-accepted cookies:', text);
+                        return true;
+                    }}
+                }}
+
+                // Try CSS selectors
+                for (const selector of selectors) {{
+                    try {{
+                        const elements = document.querySelectorAll(selector);
+                        for (const elem of elements) {{
+                            // SKIP SciTeX buttons!
+                            if (elem.hasAttribute('data-scitex-no-auto-click') ||
+                                elem.closest('[data-scitex-no-auto-click]') ||
+                                elem.id === 'stop-automation-btn' ||  // SKIP by ID!
+                                elem.id.includes('scitex')) {{  // SKIP any scitex ID
+                                continue;
+                            }}
+
+                            if (elem.offsetParent !== null) {{
+                                elem.click();
+                                console.log('Auto-accepted cookies:', selector);
+                                return true;
+                            }}
+                        }}
+                    }} catch (e) {{}}
+                }}
+                return false;
+            }}
+
+            // Check periodically
+            const interval = setInterval(() => {{
+                if (acceptCookies()) {{
+                    clearInterval(interval);
+                }}
+            }}, 1000);
+
+            // Stop after 30 seconds
+            setTimeout(() => clearInterval(interval), 30000);
+        }})();
+        """
+
+    async def check_cookie_banner_exists_async(self, page: Page) -> bool:
+        """Check if a cookie banner is still visible."""
+        try:
+            exists = await page.locator(
+                ".cookie-banner, [class*='cookie']"
+            ).first.is_visible()
+            logger.debug(f"{self.name}: Cookie banner exists: {exists}")
+            return exists
+        except:
+            logger.debug(f"{self.name}: Cookie banner not found")
+            return False
+
+
+def main(args):
+    """Demonstrate CookieAutoAcceptor functionality."""
+    import asyncio
+
+    from playwright.async_api import async_playwright
+
+    from ..debugging import browser_logger
+
+    async def demo():
+        acceptor = CookieAutoAcceptor()
+
+        async with async_playwright() as p:
+            logger.info("Starting demo")
+            browser = await p.chromium.launch(headless=False)
+            context = await browser.new_context()
+
+            await context.add_init_script(acceptor.get_auto_acceptor_script())
+
+            page = await context.new_page()
+
+            logger.info("Navigating to https://www.springer.com")
+            await page.goto("https://www.springer.com", timeout=30000)
+
+            logger.debug("Waiting for cookie banner detection")
+            await asyncio.sleep(5)
+
+            banner_exists = await acceptor.check_cookie_banner_exists_async(page)
+
+            logger.success("Auto-acceptor demo complete")
+
+            await browser.close()
+
+    asyncio.run(demo())
+    return 0
+
+
+def parse_args():
+    """Parse command line arguments."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="CookieAutoAcceptor demo")
+    return parser.parse_args()
+
+
+def run_main() -> None:
+    """Initialize scitex framework, run main function, and cleanup."""
+    global CONFIG, CC, sys, plt, rng
+
+    import sys
+
+    import matplotlib.pyplot as plt
+
+    import scitex as stx
+
+    args = parse_args()
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
+        sys,
+        plt,
+        args=args,
+        file=__FILE__,
+        sdir_suffix=None,
+        verbose=False,
+        agg=True,
+    )
+
+    exit_status = main(args)
+
+    stx.session.close(
+        CONFIG,
+        verbose=False,
+        notify=False,
+        message="",
+        exit_status=exit_status,
+    )
+
+
+if __name__ == "__main__":
+    run_main()
+
+# python -m scitex.browser.automation.CookieHandler
+
+# EOF

scitex/browser/automation/__init__.py

@@ -0,0 +1,7 @@
+"""Browser automation utilities."""
+
+from .CookieHandler import CookieAutoAcceptor
+
+__all__ = [
+    "CookieAutoAcceptor",
+]

scitex/browser/collaboration/__init__.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-19 05:20:00 (ywatanabe)"
+# File: ./src/scitex/browser/collaboration/__init__.py
+# ----------------------------------------
+"""
+scitex.browser.collaboration - Interactive browser automation for AI-human teams.
+
+This is a NEW module that does NOT affect existing scitex.browser functionality.
+
+Features:
+- Persistent shared browser sessions
+- Multi-agent coordination
+- AI-human collaboration
+- Authentication handling
+- Content extraction
+
+Version: 0.1.0-alpha (experimental)
+"""
+
+__version__ = "0.1.0-alpha"
+__experimental__ = True
+
+# Import components
+from .shared_session import SharedBrowserSession, SessionConfig
+from .visual_feedback import VisualFeedback
+from .credential_manager import CredentialManager
+
+# Exports
+__all__ = [
+    "SharedBrowserSession",
+    "SessionConfig",
+    "VisualFeedback",
+    "CredentialManager",
+]
+
+# Compatibility check - ensure we don't break existing code
+def _check_compatibility():
+    """Verify existing scitex.browser still works."""
+    try:
+        from scitex.browser import browser_logger
+        from scitex.browser.automation import CookieAutoAcceptor
+        from scitex.browser.interaction import click_center_async
+        return True
+    except ImportError as e:
+        raise RuntimeError(
+            f"❌ Collaboration module broke existing imports: {e}\n"
+            "This should never happen! Please report this bug."
+        )
+
+_check_compatibility()
+
+print("✅ scitex.browser.collaboration loaded (experimental)")
+
+# EOF

scitex/browser/collaboration/auth_helpers.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-19 05:40:00 (ywatanabe)"
+# File: ./src/scitex/browser/collaboration/auth_helpers.py
+# ----------------------------------------
+"""
+Simple authentication helpers for SharedBrowserSession.
+
+Start small - just Django login for now.
+"""
+
+import os
+from typing import Optional
+from playwright.async_api import Page
+
+
+class DjangoAuthHelper:
+    """
+    Simple Django authentication helper.
+
+    Example:
+        auth = DjangoAuthHelper(
+            login_url="http://127.0.0.1:8000/auth/login/",
+            username="your_user",
+            password="your_pass",
+        )
+
+        success = await auth.login(page)
+    """
+
+    def __init__(
+        self,
+        login_url: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        username_field: str = "#id_username",
+        password_field: str = "#id_password",
+        submit_button: str = "button[type='submit']",
+        success_indicator: str = "/core/",  # URL contains this after login
+    ):
+        self.login_url = login_url
+        self.username = username or os.getenv("SCITEX_CLOUD_USERNAME", "")
+        self.password = password or os.getenv("SCITEX_CLOUD_PASSWORD", "")
+        self.username_field = username_field
+        self.password_field = password_field
+        self.submit_button = submit_button
+        self.success_indicator = success_indicator
+
+    async def login(self, page: Page) -> bool:
+        """
+        Perform Django login.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Navigate to login page
+            await page.goto(self.login_url, wait_until="load")
+
+            # Fill username
+            await page.fill(self.username_field, self.username)
+
+            # Fill password
+            await page.fill(self.password_field, self.password)
+
+            # Submit
+            await page.click(self.submit_button)
+
+            # Wait for redirect (success indicator in URL)
+            await page.wait_for_url(f"**{self.success_indicator}**", timeout=5000)
+
+            print(f"✅ Logged in as: {self.username}")
+            return True
+
+        except Exception as e:
+            print(f"❌ Login failed: {e}")
+            return False
+
+    async def is_logged_in(self, page: Page) -> bool:
+        """
+        Check if currently logged in.
+
+        Simple check: not on login page.
+        """
+        current_url = page.url
+        is_logged_in = "login" not in current_url.lower()
+        return is_logged_in
+
+    async def logout(self, page: Page, logout_url: str = "http://127.0.0.1:8000/auth/logout/"):
+        """Logout (navigate to logout URL)."""
+        await page.goto(logout_url)
+
+
+# EOF

scitex/browser/collaboration/collaborative_agent.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-19 06:10:00 (ywatanabe)"
+# File: ./src/scitex/browser/collaboration/collaborative_agent.py
+# ----------------------------------------
+"""
+Collaborative Agent - Watches browser and responds to user actions.
+
+Runs continuously, responds to:
+- User clicks panel buttons
+- User fills panel fields
+- User navigates
+- DOM changes
+
+This is the "watching agent" pattern for true collaboration!
+"""
+
+import asyncio
+import signal
+from typing import Optional, Callable, Dict
+from playwright.async_api import Page
+
+from scitex.browser.debugging import browser_logger
+from .interactive_panel import InteractivePanel
+
+
+class CollaborativeAgent:
+    """
+    Agent that watches browser and responds to user.
+
+    Runs continuously, reacts to user input in real-time.
+
+    Example:
+        agent = CollaborativeAgent(page)
+
+        # Define what to do when user provides email
+        @agent.on_input("email")
+        async def handle_email(email):
+            print(f"Got email: {email}")
+            # Automatically navigate to login
+
+        await agent.run()  # Runs forever, watching
+    """
+
+    def __init__(
+        self,
+        page: Page,
+        panel: InteractivePanel,
+        check_interval: float = 0.5,
+    ):
+        self.page = page
+        self.panel = panel
+        self.check_interval = check_interval
+
+        self.running = False
+        self.handlers: Dict[str, Callable] = {}
+
+        # State
+        self.last_url = None
+        self.last_panel_data = {}
+
+    def on_input(self, key: str):
+        """Decorator to register handler for input."""
+        def decorator(func: Callable):
+            self.handlers[key] = func
+            return func
+        return decorator
+
+    def on_url_change(self, func: Callable):
+        """Decorator to register handler for URL changes."""
+        self.handlers["__url_change__"] = func
+        return func
+
+    async def run(self):
+        """
+        Run agent - watch browser continuously.
+
+        Responds to user actions automatically.
+        """
+        self.running = True
+
+        print("🤖 Collaborative agent started")
+        print("   Watching browser for user actions...")
+        print("   Press Ctrl+C to stop")
+
+        # Signal handling
+        loop = asyncio.get_event_loop()
+
+        def stop_agent(sig, frame):
+            print("\n\n🛑 Stopping agent...")
+            self.running = False
+
+        signal.signal(signal.SIGINT, stop_agent)
+        signal.signal(signal.SIGTERM, stop_agent)
+
+        # Watch loop
+        try:
+            while self.running:
+                await self._check_changes()
+                await asyncio.sleep(self.check_interval)
+
+        except Exception as e:
+            print(f"❌ Agent error: {e}")
+
+        finally:
+            print("✅ Agent stopped")
+
+    async def _check_changes(self):
+        """Check for changes and trigger handlers."""
+
+        # Check URL change
+        current_url = self.page.url
+        if current_url != self.last_url:
+            self.last_url = current_url
+
+            if "__url_change__" in self.handlers:
+                await self.handlers["__url_change__"](current_url)
+
+        # Check panel data changes
+        current_data = await self.page.evaluate("window.scitexPanel?.data || {}")
+
+        for key, value in current_data.items():
+            # New or changed value
+            if key not in self.last_panel_data or self.last_panel_data[key] != value:
+                self.last_panel_data[key] = value
+
+                # Trigger handler if registered
+                if key in self.handlers:
+                    await self.handlers[key](value)
+
+    async def stop(self):
+        """Stop the agent."""
+        self.running = False
+
+
+# EOF

scitex/browser/collaboration/credential_manager.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-19 05:50:00 (ywatanabe)"
+# File: ./src/scitex/browser/collaboration/credential_manager.py
+# ----------------------------------------
+"""
+Flexible credential management for browser automation.
+
+Safe, clear communication with user.
+Multiple input methods: env vars, terminal, browser.
+"""
+
+import os
+import getpass
+from typing import Optional, Dict
+from playwright.async_api import Page
+
+
+class CredentialManager:
+    """
+    Flexible credential retrieval.
+
+    Tries multiple sources in order:
+    1. Explicitly provided credentials
+    2. Environment variables
+    3. Terminal prompt (if terminal available)
+    4. Browser prompt (if browser available)
+
+    Always clearly communicates what it's doing!
+    """
+
+    def __init__(self, verbose: bool = True):
+        self.verbose = verbose
+        self.cache: Dict[str, str] = {}  # Session cache (not persistent)
+
+    async def get_credential(
+        self,
+        name: str,
+        env_var: Optional[str] = None,
+        prompt_text: Optional[str] = None,
+        page: Optional[Page] = None,
+        mask: bool = False,  # For passwords
+    ) -> str:
+        """
+        Get credential from best available source.
+
+        Args:
+            name: Credential name (for caching)
+            env_var: Environment variable to check
+            prompt_text: Text to show in prompt
+            page: Playwright page (for browser prompts)
+            mask: Whether to mask input (for passwords)
+
+        Returns:
+            Credential value
+
+        Example:
+            username = await creds.get_credential(
+                name="username",
+                env_var="SCITEX_CLOUD_USERNAME",
+                prompt_text="Django username",
+                page=page,
+            )
+        """
+        # Check cache first
+        if name in self.cache:
+            if self.verbose:
+                print(f"🔑 Using cached {name}")
+            return self.cache[name]
+
+        # Try environment variable
+        if env_var:
+            value = os.getenv(env_var)
+            if value:
+                if self.verbose:
+                    display_value = "***" if mask else value
+                    print(f"🔑 Using {name} from ${env_var}: {display_value}")
+                self.cache[name] = value
+                return value
+
+        # Try terminal prompt
+        if self._is_terminal_available():
+            value = await self._prompt_terminal(name, prompt_text, mask)
+            if value:
+                self.cache[name] = value
+                return value
+
+        # Try browser prompt
+        if page:
+            value = await self._prompt_browser(page, name, prompt_text)
+            if value:
+                self.cache[name] = value
+                return value
+
+        raise ValueError(f"Could not get credential: {name}")
+
+    def _is_terminal_available(self) -> bool:
+        """Check if we can prompt in terminal."""
+        try:
+            return os.isatty(0)  # stdin is a terminal
+        except:
+            return False
+
+    async def _prompt_terminal(
+        self,
+        name: str,
+        prompt_text: Optional[str],
+        mask: bool,
+    ) -> Optional[str]:
+        """Prompt user in terminal."""
+        prompt_text = prompt_text or name
+
+        print(f"\n🔑 Credential needed: {name}")
+        print(f"   (No environment variable found)")
+
+        if mask:
+            value = getpass.getpass(f"   Enter {prompt_text}: ")
+        else:
+            value = input(f"   Enter {prompt_text}: ")
+
+        return value if value else None
+
+    async def _prompt_browser(
+        self,
+        page: Page,
+        name: str,
+        prompt_text: Optional[str],
+    ) -> Optional[str]:
+        """Prompt user in browser window."""
+        prompt_text = prompt_text or name
+
+        print(f"\n🔑 Asking for {name} in browser...")
+
+        # Wait for page to be ready
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=2000)
+        except:
+            pass  # Continue anyway
+
+        value = await page.evaluate(f"""
+            () => {{
+                const response = prompt('🔑 Credential needed: {prompt_text}\\n\\n(You can also set ${name.upper()} environment variable)');
+                return response;
+            }}
+        """)
+
+        return value if value else None
+
+    async def get_login_credentials(
+        self,
+        page: Optional[Page] = None,
+        username_env: str = "SCITEX_CLOUD_USERNAME",
+        password_env: str = "SCITEX_CLOUD_PASSWORD",
+    ) -> Dict[str, str]:
+        """
+        Get both username and password.
+
+        Convenient helper for login flows.
+
+        Returns:
+            {'username': '...', 'password': '...'}
+        """
+        username = await self.get_credential(
+            name="username",
+            env_var=username_env,
+            prompt_text="Username",
+            page=page,
+            mask=False,
+        )
+
+        password = await self.get_credential(
+            name="password",
+            env_var=password_env,
+            prompt_text="Password",
+            page=page,
+            mask=True,
+        )
+
+        return {"username": username, "password": password}
+
+    def clear_cache(self):
+        """Clear credential cache."""
+        self.cache = {}
+        if self.verbose:
+            print("🔑 Credential cache cleared")
+
+
+# EOF