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

scitex/browser/collaboration/visual_feedback.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-19 05:42:00 (ywatanabe)"
+# File: ./src/scitex/browser/collaboration/visual_feedback.py
+# ----------------------------------------
+"""
+Visual feedback for collaborative browser sessions.
+
+Shows who's controlling the browser and what they're doing.
+"""
+
+from playwright.async_api import Page
+from typing import Optional
+
+
+class VisualFeedback:
+    """
+    Simple visual feedback overlay on browser.
+
+    Shows:
+    - Who's in control
+    - What action is being performed
+    - Status messages
+    """
+
+    def __init__(self, page: Page):
+        self.page = page
+        self.initialized = False
+
+    async def initialize(self):
+        """Initialize visual feedback overlay."""
+        if self.initialized:
+            return
+
+        await self.page.add_init_script("""
+            () => {
+                // Create feedback container
+                const container = document.createElement('div');
+                container.id = 'scitex-feedback-container';
+                container.style.cssText = `
+                    position: fixed;
+                    top: 10px;
+                    right: 10px;
+                    z-index: 2147483647;
+                    font-family: system-ui, -apple-system, sans-serif;
+                    pointer-events: none;
+                `;
+                document.body?.appendChild(container) || window.addEventListener('load', () => {
+                    document.body.appendChild(container);
+                });
+
+                // Make globally accessible
+                window.scitexFeedback = {
+                    show: function(message, type = 'info', duration = 3000) {
+                        const colors = {
+                            'info': '#2196F3',
+                            'success': '#4CAF50',
+                            'warning': '#FF9800',
+                            'error': '#F44336',
+                            'agent': '#9C27B0',
+                            'human': '#00BCD4',
+                        };
+
+                        const badge = document.createElement('div');
+                        badge.style.cssText = `
+                            background: ${colors[type] || colors.info};
+                            color: white;
+                            padding: 10px 16px;
+                            border-radius: 8px;
+                            margin-bottom: 8px;
+                            box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+                            animation: slideIn 0.3s ease-out;
+                            font-size: 13px;
+                            max-width: 300px;
+                        `;
+                        badge.textContent = message;
+
+                        const container = document.getElementById('scitex-feedback-container');
+                        if (container) {
+                            container.appendChild(badge);
+
+                            if (duration > 0) {
+                                setTimeout(() => {
+                                    badge.style.animation = 'slideOut 0.3s ease-in';
+                                    setTimeout(() => badge.remove(), 300);
+                                }, duration);
+                            }
+                        }
+                    },
+
+                    showParticipant: function(name, type = 'agent') {
+                        const indicator = document.createElement('div');
+                        indicator.id = `scitex-participant-${name}`;
+                        indicator.style.cssText = `
+                            background: ${type === 'agent' ? '#9C27B0' : '#00BCD4'};
+                            color: white;
+                            padding: 6px 12px;
+                            border-radius: 16px;
+                            margin-bottom: 6px;
+                            font-size: 12px;
+                            font-weight: 500;
+                        `;
+                        indicator.textContent = `${type === 'agent' ? '🤖' : '👤'} ${name}`;
+
+                        const container = document.getElementById('scitex-feedback-container');
+                        if (container) {
+                            container.appendChild(indicator);
+                        }
+                    },
+
+                    clear: function() {
+                        const container = document.getElementById('scitex-feedback-container');
+                        if (container) {
+                            container.innerHTML = '';
+                        }
+                    }
+                };
+
+                // Add animations
+                const style = document.createElement('style');
+                style.textContent = `
+                    @keyframes slideIn {
+                        from {
+                            transform: translateX(400px);
+                            opacity: 0;
+                        }
+                        to {
+                            transform: translateX(0);
+                            opacity: 1;
+                        }
+                    }
+                    @keyframes slideOut {
+                        from {
+                            transform: translateX(0);
+                            opacity: 1;
+                        }
+                        to {
+                            transform: translateX(400px);
+                            opacity: 0;
+                        }
+                    }
+                `;
+                document.head?.appendChild(style) || window.addEventListener('load', () => {
+                    document.head.appendChild(style);
+                });
+            }
+        """)
+
+        self.initialized = True
+
+    async def show_message(
+        self,
+        message: str,
+        type: str = "info",  # info, success, warning, error, agent, human
+        duration: int = 3000,
+    ):
+        """Show feedback message."""
+        await self.page.evaluate(
+            f"window.scitexFeedback?.show('{message}', '{type}', {duration})"
+        )
+
+    async def show_participant(self, name: str, type: str = "agent"):
+        """Show participant indicator."""
+        await self.page.evaluate(
+            f"window.scitexFeedback?.showParticipant('{name}', '{type}')"
+        )
+
+    async def show_action(self, participant_name: str, action: str):
+        """Show what participant is doing."""
+        await self.show_message(
+            f"{participant_name} is {action}...",
+            type="agent" if "agent" in participant_name.lower() else "human",
+            duration=2000,
+        )
+
+    async def clear(self):
+        """Clear all feedback."""
+        await self.page.evaluate("window.scitexFeedback?.clear()")
+
+
+# EOF

scitex/browser/core/BrowserMixin.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-07 20:04:42 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/browser/local/_BrowserMixin.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import aiohttp
+from playwright.async_api import Browser, async_playwright
+
+from scitex.browser.automation import CookieAutoAcceptor
+
+
+class BrowserMixin:
+    """Mixin for local browser-based strategies with common functionality.
+
+    Browser Modes:
+    - interactive: For human interaction (authentication, debugging) - 1280x720 viewport
+    - stealth: For automated operations (scraping, downloading) - 1x1 viewport
+
+    Note: Always runs browser in visible system mode (never truly headless)
+    but uses viewport sizing to control interaction vs stealth behavior.
+    """
+
+    _shared_browser = None
+    _shared_playwright = None
+
+    def __init__(self, mode):
+        """Initialize browser mixin.
+
+        Args:
+            mode: Browser mode - 'interactive' or 'stealth'
+        """
+        assert mode in ["interactive", "stealth"]
+
+        self.cookie_acceptor = CookieAutoAcceptor()
+        self.mode = mode
+        self.contexts = []
+        self.pages = []
+
+    @classmethod
+    async def get_shared_browser_async(cls) -> Browser:
+        """Get or create shared browser instance (deprecated - use get_browser_async)."""
+        if (
+            cls._shared_browser is None
+            or cls._shared_browser.is_connected() is False
+        ):
+            if cls._shared_playwright is None:
+                cls._shared_playwright = await async_playwright().start()
+            cls._shared_browser = await cls._shared_playwright.chromium.launch(
+                headless=True,
+                args=["--no-sandbox", "--disable-dev-shm-usage"],
+            )
+        return cls._shared_browser
+
+    @classmethod
+    async def cleanup_shared_browser_async(cls):
+        """Clean up shared browser instance (call on app shutdown)."""
+        if cls._shared_browser:
+            await cls._shared_browser.close()
+            cls._shared_browser = None
+        if cls._shared_playwright:
+            await cls._shared_playwright.stop()
+            cls._shared_playwright = None
+
+    async def get_browser_async(self) -> Browser:
+        """Get or create a local browser instance with the current mode setting."""
+        if (
+            self._shared_browser is None
+            or self._shared_browser.is_connected() is False
+        ):
+            if self._shared_playwright is None:
+                self._shared_playwright = await async_playwright().start()
+
+            # Enhanced stealth launch arguments
+            stealth_args = [
+                "--no-sandbox",
+                "--disable-dev-shm-usage",
+                "--disable-blink-features=AutomationControlled",
+                "--disable-web-security",
+                "--disable-features=VizDisplayCompositor",
+                "--disable-background-networking",
+                "--disable-sync",
+                "--disable-translate",
+                "--disable-default-apps",
+                "--enable-extensions",  # Enable extensions support
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--disable-background-timer-throttling",
+                "--disable-backgrounding-occluded-windows",
+                "--disable-renderer-backgrounding",
+                "--disable-field-trial-config",
+                "--disable-client-side-phishing-detection",
+                "--disable-component-update",
+                "--disable-plugins-discovery",
+                "--disable-hang-monitor",
+                "--disable-prompt-on-repost",
+                "--disable-domain-reliability",
+                "--disable-infobars",
+                "--disable-notifications",
+                "--disable-popup-blocking",
+                "--window-size=1920,1080",
+            ]
+
+            # Always run in visible mode (never headless)
+            # This is safer for bot detection while providing flexibility via viewport sizing
+            self._shared_browser = (
+                await self._shared_playwright.chromium.launch(
+                    headless=False,
+                    args=stealth_args,
+                )
+            )
+        return self._shared_browser
+
+    async def new_page(self, url=None):
+        """Create new page/tab and optionally navigate to URL."""
+        browser = await self.get_browser_async()
+        context = await browser.new_context()
+        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()
+        self.contexts.append(context)
+        self.pages.append(page)
+        if url:
+            await page.goto(url, wait_until="domcontentloaded", timeout=30000)
+        return page
+
+    async def close_page(self, page_index):
+        """Close specific page/tab by index."""
+        if 0 <= page_index < len(self.pages):
+            await self.contexts[page_index].close()
+            self.contexts.pop(page_index)
+            self.pages.pop(page_index)
+
+    async def close_all_pages(self):
+        """Close all pages/tabs."""
+        for context in self.contexts:
+            await context.close()
+        self.contexts.clear()
+        self.pages.clear()
+
+    async def create_browser_context_async(
+        self, playwright_instance, **context_options
+    ):
+        """Create browser context with cookie auto-acceptance."""
+        # Use headless mode for stealth, visible for interactive
+        is_headless = self.mode == "stealth"
+        browser = await playwright_instance.chromium.launch(
+            headless=is_headless
+        )
+
+        # # Smart viewport sizing based on mode
+        # if "viewport" not in context_options:
+        #     if self.mode == "stealth":
+        #         # For stealth mode: use minimal viewport to avoid detection
+        #         context_options["viewport"] = {"width": 1, "height": 1}
+        #     else:  # interactive mode
+        #         # For interactive mode: use human-friendly size
+        #         context_options["viewport"] = {"width": 1280, "height": 720}
+
+        context = await browser.new_context(**context_options)
+        await context.add_init_script(
+            self.cookie_acceptor.get_auto_acceptor_script()
+        )
+        # await self.cookie_acceptor.inject_auto_acceptor_async(context)
+        return browser, context
+
+    async def get_session_async(
+        self, timeout: int = 30
+    ) -> aiohttp.ClientSession:
+        """Get or create basic aiohttp session."""
+        if (
+            not hasattr(self, "_session")
+            or self._session is None
+            or self._session.closed
+        ):
+            connector = aiohttp.TCPConnector()
+            client_timeout = aiohttp.ClientTimeout(total=timeout)
+            self._session = aiohttp.ClientSession(
+                connector=connector, timeout=client_timeout
+            )
+        return self._session
+
+    async def close_session(self):
+        """Close the aiohttp session."""
+        if (
+            hasattr(self, "_session")
+            and self._session
+            and not self._session.closed
+        ):
+            await self._session.close()
+            self._session = None
+
+    async def accept_cookies_async(self, page_index=0, wait_seconds=2):
+        """Manually accept cookies on specific page."""
+        if 0 <= page_index < len(self.pages):
+            return await self.cookie_acceptor.accept_cookies_async(
+                self.pages[page_index], wait_seconds
+            )
+        return False
+
+    def interactive(self):
+        """Set browser to interactive mode (human-friendly viewport)."""
+        if self.mode == "interactive":
+            return self
+        self.mode = "interactive"
+        self._shared_browser = None
+        return self
+
+    def stealth(self):
+        """Set browser to stealth mode (minimal viewport for bot detection avoidance)."""
+        if self.mode == "stealth":
+            return self
+        self.mode = "stealth"
+        self._shared_browser = None
+        return self
+
+    async def show_async(self):
+        """Switch browser to interactive mode and recreate all existing pages at current URLs."""
+        if self.mode == "interactive":
+            return self
+        self.mode = "interactive"
+        await self._restart_contexts_async()
+        return self
+
+    async def hide_async(self):
+        """Switch browser to stealth mode and recreate all existing pages at current URLs."""
+        if self.mode == "stealth":
+            return self
+        self.mode = "stealth"
+        await self._restart_contexts_async()
+        return self
+
+    async def _restart_contexts_async(self):
+        page_urls = [page.url for page in self.pages]
+        await self.close_all_pages()
+        self._shared_browser = None
+        for url in page_urls:
+            await self.new_page(url)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close_all_pages()
+        await self.close_session()
+
+
+def main(args):
+    """Demonstrate BrowserMixin functionality."""
+    import asyncio
+    from scitex.browser.core import BrowserMixin
+
+    class DemoBrowser(BrowserMixin):
+        async def scrape_async(self, url):
+            page = await self.new_page(url)
+            return await page.content()
+
+    async def demo():
+        browser = DemoBrowser(mode="interactive")
+
+        # Scrape a page
+        content = await browser.scrape_async("https://example.com")
+        print(f"✓ Fetched {len(content)} bytes")
+        print(f"✓ Open tabs: {len(browser.pages)}")
+
+        # Close
+        await browser.close_all_pages()
+        print("✓ Demo complete")
+
+    asyncio.run(demo())
+    return 0
+
+
+def parse_args():
+    """Parse command line arguments."""
+    import argparse
+    parser = argparse.ArgumentParser(description="BrowserMixin 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.core.BrowserMixin
+
+# EOF