entari-plugin-hyw 4.0.0rc6__py3-none-any.whl → 4.0.0rc8__py3-none-any.whl

entari_plugin_hyw/browser/__init__.py

@@ -1,10 +0,0 @@
-from .manager import get_shared_browser_manager, close_shared_browser
-from .service import get_screenshot_service, close_screenshot_service, prestart_browser
-
-__all__ = [
-    "get_shared_browser_manager",
-    "close_shared_browser",
-    "get_screenshot_service",
-    "close_screenshot_service",
-    "prestart_browser",
-]

entari_plugin_hyw/browser/engines/bing.py

@@ -1,95 +0,0 @@
-
-import urllib.parse
-import re
-from typing import List, Dict, Any
-from loguru import logger
-from .base import SearchEngine
-
-class BingEngine(SearchEngine):
-    """
-    Search engine implementation for Bing.
-    """
-    
-    def build_url(self, query: str, limit: int = 10) -> str:
-        encoded_query = urllib.parse.quote(query)
-        base = "https://www.bing.com/search"
-        return f"{base}?form=&q={encoded_query}"
-
-    def parse(self, content: str) -> List[Dict[str, Any]]:
-        results = []
-        # Split by b_algo to isolate results
-        chunks = content.split('class="b_algo"')
-        
-        # Helper to decode Bing URLs roughly
-        def decode_bing_url(u):
-            if "bing.com/ck/a?" not in u: return u
-            try:
-                # Url is usually like ...&u=a1<base64>&...
-                # We look for &u=...
-                import base64
-                match = re.search(r'[?&]u=a1([^&]+)', u)
-                if match:
-                    # Bing uses a modified base64 (url safe) and adds 'a1' prefix
-                    # We stripped 'a1' in regex match group
-                    b64 = match.group(1)
-                    # padding
-                    b64 += '=' * (-len(b64) % 4)
-                    # url safe
-                    b64 = b64.replace('-', '+').replace('_', '/')
-                    decoded = base64.b64decode(b64).decode('utf-8')
-                    return decoded
-            except Exception:
-                pass
-            return u
-
-        seen_urls = set()
-
-        for chunk in chunks[1:]:
-            # Exact regexes for title and snippet within the chunk
-            # Title: <h2><a href="...">...</a></h2>
-            link_match = re.search(r'<h2[^>]*>.*?<a[^>]+href=["\'](http[^"\']+)["\'][^>]*>(.*?)</a>', chunk, re.IGNORECASE | re.DOTALL)
-            if not link_match:
-                # Fallback: pure a tag
-                link_match = re.search(r'<a[^>]+href=["\'](http[^"\']+)["\'][^>]*>(.*?)</a>', chunk, re.IGNORECASE | re.DOTALL)
-            
-            if link_match:
-                raw_url = link_match.group(1)
-                title_html = link_match.group(2)
-                title = re.sub(r'<[^>]+>', '', title_html).strip()
-                
-                url = decode_bing_url(raw_url)
-                
-                if url in seen_urls: continue
-                seen_urls.add(url)
-
-                # Snippet: class="b_caption" ... <p> ... </p> or just div text
-                snippet = ""
-                caption_match = re.search(r'class="b_caption"[^>]*>(.*?)</div>', chunk, re.IGNORECASE | re.DOTALL)
-                if caption_match:
-                    snippet_html = caption_match.group(1)
-                    snippet = re.sub(r'<[^>]+>', ' ', snippet_html).strip()
-                else:
-                    # Fallback snippet
-                    start = link_match.end()
-                    snippet = re.sub(r'<[^>]+>', ' ', chunk[start:start+600]).strip()
-                
-                snippet = re.sub(r'\s+', ' ', snippet).strip()
-                
-                # Image extraction (basic)
-                images = []
-                img_matches = re.findall(r'<img[^>]+src=["\'](http[^"\']+)["\']', chunk)
-                for img_url in img_matches:
-                    if not any(x in img_url for x in ['favicon', 'icon', 'tracking', 'pixel']):
-                         images.append(img_url)
-
-                if url and title:
-                    results.append({
-                        "title": title,
-                        "url": url,
-                        "domain": urllib.parse.urlparse(url).hostname or "",
-                        "content": snippet[:5000],
-                        "images": images[:3]
-                    })
-
-        logger.info(f"BingEngine parsed {len(results)} results.")
-        return results

entari_plugin_hyw/browser/service.py

@@ -1,304 +0,0 @@
-"""
-Browser Service (DrissionPage)
-
-Provides page fetching and screenshot capabilities using DrissionPage.
-"""
-
-import asyncio
-import base64
-from concurrent.futures import ThreadPoolExecutor
-from typing import Optional, Dict, Any, List
-from loguru import logger
-import trafilatura
-
-class ScreenshotService:
-    """
-    Browser Service using DrissionPage.
-    """
-    
-    def __init__(self, headless: bool = True, auto_start: bool = True):
-        self.headless = headless
-        self._manager = None
-        self._executor = ThreadPoolExecutor(max_workers=10)
-        
-        if auto_start:
-            self._ensure_ready()
-    
-    def _ensure_ready(self):
-        """Ensure shared browser is ready."""
-        from .manager import get_shared_browser_manager
-        self._manager = get_shared_browser_manager(headless=self.headless)
-
-    async def fetch_page(self, url: str, timeout: float = 20.0, include_screenshot: bool = True) -> Dict[str, Any]:
-        """
-        Fetch page content (and optionally screenshot).
-        Runs in a thread executor to avoid blocking the async loop.
-        """
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            self._executor,
-            self._fetch_page_sync,
-            url,
-            timeout,
-            include_screenshot
-        )
-
-    def _fetch_page_sync(self, url: str, timeout: float, include_screenshot: bool) -> Dict[str, Any]:
-        """Synchronous fetch logic."""
-        if not url:
-            return {"content": "Error: missing url", "title": "Error", "url": ""}
-        
-        tab = None
-        try:
-            self._ensure_ready()
-            page = self._manager.page
-            if not page:
-                return {"content": "Error: Browser not available", "title": "Error", "url": url}
-            
-            # New Tab
-            tab = page.new_tab(url)
-            
-            # Wait logic
-            is_search_page = any(s in url.lower() for s in ['search', 'bing.com', 'duckduckgo', 'google.com/search', 'searx'])
-            if is_search_page:
-                # Quick check for results
-                result_selectors = ['#results', '#b_results', '#search', '#links', '.result']
-                for selector in result_selectors:
-                    if tab.ele(selector, timeout=1):
-                        break
-            else:
-                # 1. Wait for document to settle (Fast Dynamic Wait)
-                try:
-                    tab.wait.doc_loaded(timeout=5)
-                    # Brief check for loading overlays (fast skip if none)
-                    tab.run_js("""
-                        (async () => {
-                            const isVisible = (el) => !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
-                            for (let i = 0; i < 15; i++) {
-                                const indicators = Array.from(document.querySelectorAll('*')).filter(el => {
-                                    try {
-                                        const text = (el.textContent || '').toLowerCase();
-                                        const id = (el.id || '').toLowerCase();
-                                        const cls = (el.getAttribute('class') || '').toLowerCase();
-                                        return (text.includes('loading') || id.includes('loading') || cls.includes('loading')) && isVisible(el);
-                                    } catch(e) { return false; }
-                                });
-                                if (indicators.length === 0) break;
-                                await new Promise(r => setTimeout(r, 100));
-                            }
-                        })()
-                    """, as_expr=True)
-                except: pass
-
-            html = tab.html
-            title = tab.title
-            final_url = tab.url
-            
-            raw_screenshot_b64 = None
-            if include_screenshot:
-                try:
-                    # Scrollbar Hiding Best Effort
-                    from .manager import SharedBrowserManager
-                    SharedBrowserManager.hide_scrollbars(tab)
-                    
-                    # Inject CSS
-                    tab.run_js("""
-                        const style = document.createElement('style');
-                        style.textContent = `
-                            ::-webkit-scrollbar { display: none !important; }
-                            html, body { -ms-overflow-style: none !important; scrollbar-width: none !important; }
-                        `;
-                        document.head.appendChild(style);
-                        document.documentElement.style.overflow = 'hidden';
-                        document.body.style.overflow = 'hidden';
-                    """)
-                    
-                    raw_screenshot_b64 = tab.get_screenshot(as_base64='jpg', full_page=False)
-                except Exception as e:
-                    logger.warning(f"ScreenshotService: Failed to capture screenshot: {e}")
-
-            # Extract content
-            content = trafilatura.extract(
-                html, include_links=True, include_images=True, include_comments=False, 
-                include_tables=True, favor_precision=False, output_format="markdown"
-            ) or ""
-
-            # 2. Extract Images via Parallelized JS (Gallery)
-            # Strategy: For search pages, use Canvas to grab already loaded images (Instant)
-            # For other pages, use fetch (more robust for lazy load)
-            images_b64 = []
-            try:
-                js_code = """
-                    (async () => {
-                        const blocklist = ['logo', 'icon', 'avatar', 'ad', 'pixel', 'tracker', 'button', 'menu', 'nav'];
-                        const candidates = Array.from(document.querySelectorAll('img'));
-                        const validImages = [];
-                        
-                        // Helper: Get base64 from loaded image via Canvas
-                        const getBase64 = (img) => {
-                            try {
-                                const canvas = document.createElement('canvas');
-                                canvas.width = img.naturalWidth;
-                                canvas.height = img.naturalHeight;
-                                const ctx = canvas.getContext('2d');
-                                ctx.drawImage(img, 0, 0);
-                                return canvas.toDataURL('image/jpeg').split(',')[1];
-                            } catch(e) { return null; }
-                        };
-
-                        for (const img of candidates) {
-                            if (validImages.length >= 8) break;
-                            
-                            if (img.naturalWidth < 100 || img.naturalHeight < 80) continue;
-                            
-                            const alt = (img.alt || '').toLowerCase();
-                            const cls = (typeof img.className === 'string' ? img.className : '').toLowerCase();
-                            const src = (img.src || '').toLowerCase();
-                            
-                            if (blocklist.some(b => alt.includes(b) || cls.includes(b) || src.includes(b))) continue;
-                            
-                            // 1. Try Canvas (Instant for loaded images)
-                            if (img.complete && img.naturalHeight > 0) {
-                                const b64 = getBase64(img);
-                                if (b64) {
-                                    validImages.push(b64);
-                                    continue;
-                                }
-                            }
-                            
-                            // 2. Fallback to fetch (only for non-search pages to avoid delay)
-                            // We skip fetch for search pages to ensure speed
-                            if (!window.location.href.includes('google') && !window.location.href.includes('search')) {
-                                try {
-                                    const controller = new AbortController();
-                                    const id = setTimeout(() => controller.abort(), 2000);
-                                    const resp = await fetch(img.src, { signal: controller.signal });
-                                    clearTimeout(id);
-                                    const blob = await resp.blob();
-                                    const b64 = await new Promise(resolve => {
-                                        const reader = new FileReader();
-                                        reader.onloadend = () => resolve(reader.result.split(',')[1]);
-                                        reader.onerror = () => resolve(null);
-                                        reader.readAsDataURL(blob);
-                                    });
-                                    if (b64) validImages.push(b64);
-                                } catch(e) {}
-                            }
-                        }
-                        return validImages;
-                    })()
-                """
-                images_b64 = tab.run_js(js_code, as_expr=True) or []
-                
-                if images_b64:
-                    logger.info(f"ScreenshotService: Extracted {len(images_b64)} images for {url}")
-                
-            except Exception as e:
-                logger.warning(f"ScreenshotService: Image extraction failed: {e}")
-
-            return {
-                "content": content,
-                "html": html,
-                "title": title,
-                "url": final_url,
-                "raw_screenshot_b64": raw_screenshot_b64,
-                "images": images_b64
-            }
-
-        except Exception as e:
-            logger.error(f"ScreenshotService: Failed to fetch {url}: {e}")
-            return {"content": f"Error: fetch failed ({e})", "title": "Error", "url": url}
-        finally:
-            if tab:
-                try: tab.close()
-                except: pass
-
-    async def fetch_pages_batch(self, urls: List[str], timeout: float = 20.0, include_screenshot: bool = True) -> List[Dict[str, Any]]:
-        """Fetch multiple pages concurrently."""
-        if not urls: return []
-        logger.info(f"ScreenshotService: Batch fetching {len(urls)} URLs (screenshots={include_screenshot})")
-        tasks = [self.fetch_page(url, timeout, include_screenshot) for url in urls]
-        return await asyncio.gather(*tasks, return_exceptions=True)
-
-    async def screenshot_url(self, url: str, wait_load: bool = True, timeout: float = 15.0, full_page: bool = False, quality: int = 80) -> Optional[str]:
-        """Screenshot URL (Async wrapper for sync)."""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            self._executor,
-            self._screenshot_sync,
-            url, wait_load, timeout, full_page, quality
-        )
-
-    def _screenshot_sync(self, url: str, wait_load: bool, timeout: float, full_page: bool, quality: int) -> Optional[str]:
-        """Synchronous screenshot."""
-        if not url: return None
-        tab = None
-        try:
-            self._ensure_ready()
-            page = self._manager.page
-            if not page: return None
-            
-            tab = page.new_tab(url)
-            try:
-                if wait_load:
-                    tab.wait.load_complete(timeout=timeout)
-                else:
-                    tab.wait.doc_loaded(timeout=timeout)
-            except: pass
-            
-            # Wait for main element
-            if tab.ele("#main-container"):
-                pass 
-            
-            # Scrollbar Hiding
-            from .manager import SharedBrowserManager
-            SharedBrowserManager.hide_scrollbars(tab)
-            tab.run_js("""
-                const style = document.createElement('style');
-                style.textContent = `
-                    ::-webkit-scrollbar { display: none !important; }
-                    html, body { -ms-overflow-style: none !important; scrollbar-width: none !important; }
-                `;
-                document.head.appendChild(style);
-                document.documentElement.style.overflow = 'hidden';
-                document.body.style.overflow = 'hidden';
-            """)
-            
-            ele = tab.ele("#main-container")
-            if ele:
-                return ele.get_screenshot(as_base64='jpg', quality=quality)
-            else:
-                return tab.get_screenshot(as_base64='jpg', full_page=full_page, quality=quality)
-                
-        except Exception as e:
-            logger.error(f"ScreenshotService: Screenshot URL failed: {e}")
-            return None
-        finally:
-            if tab:
-                try: tab.close()
-                except: pass
-
-    async def close(self):
-        self._executor.shutdown(wait=False)
-        logger.info("ScreenshotService: Closed.")
-
-    async def close_async(self):
-        await self.close()
-
-# Singleton
-_screenshot_service: Optional[ScreenshotService] = None
-
-def get_screenshot_service(headless: bool = True) -> ScreenshotService:
-    global _screenshot_service
-    if _screenshot_service is None:
-        _screenshot_service = ScreenshotService(headless=headless, auto_start=True)
-    return _screenshot_service
-
-async def close_screenshot_service():
-    global _screenshot_service
-    if _screenshot_service:
-        await _screenshot_service.close()
-        _screenshot_service = None
-
-def prestart_browser(headless: bool = True):
-    get_screenshot_service(headless=headless)

entari_plugin_hyw/card-ui/.gitignore

@@ -1,24 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
-
-node_modules
-dist
-dist-ssr
-*.local
-
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?

entari_plugin_hyw/card-ui/README.md

@@ -1,5 +0,0 @@
-# Vue 3 + TypeScript + Vite
-
-This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
-
-Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).

entari_plugin_hyw/card-ui/index.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>Card Renderer</title>
-  <script>window.RENDER_DATA = {}</script>
-</head>
-
-<body>
-  <div id="app"></div>
-  <script type="module" src="/src/main.ts"></script>
-</body>
-
-</html>