entari-plugin-hyw 4.0.0rc17__py3-none-any.whl → 4.0.0rc19__py3-none-any.whl

entari_plugin_hyw/filters.py

@@ -1,83 +0,0 @@
-"""
-Filter syntax parsing utilities.
-"""
-
-import re
-from typing import List, Tuple, Optional
-
-
-def parse_filter_syntax(query: str, max_count: int = 3):
-    """
-    Parse enhanced filter syntax supporting:
-    - Chinese/English colons (: ：) and commas (, ，)
-    - Multiple filters: "mcmod=2, github=1 : xxx" 
-    - Index lists: "1, 2, 3 : xxx"
-    - Max total selections
-    
-    Returns:
-        (filters, search_query, error_msg)
-        filters: list of (filter_type, filter_value, count) tuples
-                 filter_type: 'index' or 'link'
-                 count: how many to get (default 1)
-        search_query: the actual search query
-        error_msg: error message if exceeded max
-    """
-    if not query:
-        return [], query, None
-    
-    # Skip filter parsing if query contains URL (has :// pattern)
-    if re.search(r'https?://', query):
-        return [], query.strip(), None
-    
-    # Normalize Chinese punctuation to English
-    normalized = query.replace('：', ':').replace('，', ',').replace('、', ',')
-    
-    # Handle escaped colons: \: or /: -> placeholder
-    normalized = re.sub(r'[/\\]:', '\x00COLON\x00', normalized)
-    
-    # Split by colon - last part is the search query
-    parts = normalized.split(':')
-    if len(parts) < 2:
-        # No colon found, restore escaped colons and return as-is
-        return [], query.replace('\\:', ':').replace('/:', ':'), None
-    
-    # Everything after the last colon is the search query
-    search_query = parts[-1].strip().replace('\x00COLON\x00', ':')
-    
-    # Everything before is the filter specification
-    filter_spec = ':'.join(parts[:-1]).strip().replace('\x00COLON\x00', ':')
-    
-    if not filter_spec or not search_query:
-        return [], query.replace('\\:', ':').replace('/:', ':'), None
-    
-    # Parse filter specifications (comma-separated)
-    filter_items = [f.strip() for f in filter_spec.split(',') if f.strip()]
-    
-    filters = []
-    for item in filter_items:
-        # Check for "filter=count" pattern (e.g., "mcmod=2")
-        eq_match = re.match(r'^(\w+)\s*=\s*(\d+)$', item)
-        if eq_match:
-            filter_name = eq_match.group(1).lower()
-            count = int(eq_match.group(2))
-            filters.append(('link', filter_name, count))
-        elif item.isdigit():
-            # Pure index
-            filters.append(('index', int(item), 1))
-        else:
-            # Filter name without count (default count=1)
-            filters.append(('link', item.lower(), 1))
-    
-    # Calculate total count
-    total = sum(f[2] for f in filters)
-    if total > max_count:
-        return [], search_query, f"最多选择{max_count}个结果 (当前选择了{total}个)"
-    
-    # Append filter names to search query
-    # Extract filter names (only 'link' type, skip 'index' type)
-    filter_names = [f[1] for f in filters if f[0] == 'link']
-    if filter_names:
-        # Append filter names to search query: "search_query filter1 filter2"
-        search_query = f"{search_query} {' '.join(filter_names)}"
-    
-    return filters, search_query, None

entari_plugin_hyw/history.py

@@ -1,251 +0,0 @@
-import random
-import string
-from typing import Dict, List, Any, Optional
-
-class HistoryManager:
-    def __init__(self):
-        self._history: Dict[str, List[Dict[str, Any]]] = {}
-        self._metadata: Dict[str, Dict[str, Any]] = {}
-        self._mapping: Dict[str, str] = {}
-        self._context_latest: Dict[str, str] = {}
-        
-        # New: Short code management
-        self._short_codes: Dict[str, str] = {} # code -> key
-        self._key_to_code: Dict[str, str] = {} # key -> code
-        self._context_history: Dict[str, List[str]] = {} # context_id -> list of keys
-
-    def is_bot_message(self, message_id: str) -> bool:
-        """Check if the message ID belongs to a bot message"""
-        return message_id in self._history
-
-    def generate_short_code(self) -> str:
-        """Generate a unique 4-digit hex code"""
-        while True:
-            code = ''.join(random.choices(string.hexdigits.lower(), k=4))
-            if code not in self._short_codes:
-                return code
-
-    def get_conversation_id(self, message_id: str) -> Optional[str]:
-        return self._mapping.get(message_id)
-        
-    def get_key_by_code(self, code: str) -> Optional[str]:
-        return self._short_codes.get(code.lower())
-        
-    def get_code_by_key(self, key: str) -> Optional[str]:
-        return self._key_to_code.get(key)
-
-    def get_history(self, key: str) -> List[Dict[str, Any]]:
-        return self._history.get(key, [])
-
-    def get_metadata(self, key: str) -> Dict[str, Any]:
-        return self._metadata.get(key, {})
-        
-    def get_latest_from_context(self, context_id: str) -> Optional[str]:
-        return self._context_latest.get(context_id)
-        
-    def list_by_context(self, context_id: str, limit: int = 10) -> List[str]:
-        """Return list of keys for a context, most recent first"""
-        keys = self._context_history.get(context_id, [])
-        return keys[-limit:][::-1]
-
-    def remember(self, message_id: Optional[str], history: List[Dict[str, Any]], related_ids: List[str], metadata: Optional[Dict[str, Any]] = None, context_id: Optional[str] = None, code: Optional[str] = None):
-        if not message_id:
-            return
-            
-        key = message_id
-        self._history[key] = history
-        if metadata:
-            self._metadata[key] = metadata
-            
-        self._mapping[key] = key
-        for rid in related_ids:
-            if rid:
-                self._mapping[rid] = key
-                
-        # Generate or use provided short code
-        if key not in self._key_to_code:
-            if not code:
-                code = self.generate_short_code()
-            self._short_codes[code] = key
-            self._key_to_code[key] = code
-            
-        if context_id:
-            self._context_latest[context_id] = key
-            if context_id not in self._context_history:
-                self._context_history[context_id] = []
-            self._context_history[context_id].append(key)
-
-    def save_to_disk(self, key: str, save_root: str = "data/conversations", image_path: Optional[str] = None, web_results: Optional[List[Dict]] = None, vision_trace: Optional[Dict] = None, instruct_traces: Optional[List[Dict]] = None):
-        """Save conversation history to specific folder structure"""
-        import os
-        import time
-        import re
-        import shutil
-        import json
-        
-        if key not in self._history and not web_results:
-            return
-
-        try:
-            # Extract user's first message (question) for folder name
-            user_question = "unknown_query"
-            if key in self._history:
-                for msg in self._history[key]:
-                    if msg.get("role") == "user":
-                        content = msg.get("content", "")
-                        if isinstance(content, list):
-                            for item in content:
-                                if isinstance(item, dict) and item.get("type") == "text":
-                                    user_question = item.get("text", "")
-                                    break
-                        else:
-                            user_question = str(content)
-                        break
-            
-            # Use raw query from first web result if available and no history (for pure search debug)
-            if user_question == "unknown_query" and web_results and len(web_results) > 0:
-                 q = web_results[0].get("query", "")
-                 if q: user_question = q
-
-            # Clean and truncate question
-            question_part = re.sub(r'[\\/:*?"<>|\n\r\t]', '', user_question)[:20].strip()
-            if not question_part:
-                question_part = "conversation"
-            
-            # Create folder: YYYYMMDD_HHMMSS_question
-            time_str = time.strftime("%Y%m%d_%H%M%S", time.localtime())
-            folder_name = f"{time_str}_{question_part}"
-            
-            # Auto-resolve relative paths to absolute if needed
-            if not os.path.isabs(save_root):
-                 # Try to save next to the project root (assuming we are in src/...)
-                 # But safer to just use CWD
-                 save_root = os.path.abspath(save_root)
-            
-            folder_path = os.path.join(save_root, folder_name)
-            
-            os.makedirs(folder_path, exist_ok=True)
-            
-            meta = self._metadata.get(key, {})
-
-            # 1. Save Context/Trace
-            trace_md = meta.get("trace_markdown")
-            if trace_md:
-                with open(os.path.join(folder_path, "context_trace.md"), "w", encoding="utf-8") as f:
-                    f.write(trace_md)
-            
-            # 2. Save Web Results (Search & Pages)
-            if web_results:
-                pages_dir = os.path.join(folder_path, "pages")
-                os.makedirs(pages_dir, exist_ok=True)
-                
-                search_buffer = []  # Buffer for unfetched search results
-                
-                for i, item in enumerate(web_results):
-                    item_type = item.get("_type", "unknown")
-                    title = item.get("title", "Untitled")
-                    url = item.get("url", "")
-                    content = item.get("content", "")
-                    item_id = item.get("_id", i + 1)
-                    
-                    if not content:
-                        continue
-                    
-                    if item_type == "search":
-                        # Collect search snippets for consolidated file
-                        search_buffer.append(f"## [{item_id}] {title}\n- **URL**: {url}\n\n{content}\n")
-                    
-                    elif item_type in ["page", "search_raw_page"]:
-                        # Save fetched pages/raw search pages individually
-                        clean_title = re.sub(r'[\\/:*?"<>|\n\r\t]', '', title)[:30].strip() or "page"
-                        filename = f"{item_id:02d}_{item_type}_{clean_title}.md"
-                        
-                        # Save screenshot if available
-                        screenshot_b64 = item.get("screenshot_b64")
-                        image_ref = ""
-                        if screenshot_b64:
-                            try:
-                                import base64
-                                img_filename = f"{item_id:02d}_{item_type}_{clean_title}.jpg"
-                                img_path = os.path.join(pages_dir, img_filename)
-                                with open(img_path, "wb") as f:
-                                    f.write(base64.b64decode(screenshot_b64))
-                                image_ref = f"\n### Screenshot\n![Screenshot]({img_filename})\n"
-                            except Exception as e:
-                                print(f"Failed to save screenshot for {title}: {e}")
-                        
-                        page_md = f"# [{item_id}] {title}\n\n"
-                        page_md += f"- **Type**: {item_type}\n"
-                        page_md += f"- **URL**: {url}\n\n"
-                        if image_ref:
-                            page_md += f"{image_ref}\n"
-                        page_md += f"---\n\n{content}\n"
-                        
-                        with open(os.path.join(pages_dir, filename), "w", encoding="utf-8") as f:
-                            f.write(page_md)
-                
-                # Save consolidated search results
-                if search_buffer:
-                    with open(os.path.join(folder_path, "search_results.md"), "w", encoding="utf-8") as f:
-                        f.write(f"# Search Results\n\nGenerated at {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n" + "\n---\n\n".join(search_buffer))
-                
-            # 3. Save Final Response (MD)
-            final_content = ""
-            # Find last assistant message
-            for msg in reversed(self._history[key]):
-                if msg.get("role") == "assistant":
-                    content = msg.get("content", "")
-                    if isinstance(content, str):
-                        final_content = content
-                    break
-            
-            if final_content:
-                with open(os.path.join(folder_path, "final_response.md"), "w", encoding="utf-8") as f:
-                    f.write(final_content)
-
-            # Save Output Image (Final Card)
-            if image_path and os.path.exists(image_path):
-                try:
-                    dest_img_path = os.path.join(folder_path, "output_card.jpg")
-                    shutil.copy2(image_path, dest_img_path)
-                except Exception as e:
-                    print(f"Failed to copy output image: {e}")
-
-            # 4. Save Vision Log (if vision stage was used)
-            if vision_trace and not vision_trace.get("skipped"):
-                vision_md = "# Vision Stage Log\n\n"
-                vision_md += f"- **Model**: {vision_trace.get('model', 'unknown')}\n"
-                vision_md += f"- **Time**: {vision_trace.get('time', 0):.2f}s\n"
-                vision_md += f"- **Images Count**: {vision_trace.get('images_count', 0)}\n"
-                vision_md += f"- **Input Tokens**: {vision_trace.get('usage', {}).get('input_tokens', 0)}\n"
-                vision_md += f"- **Output Tokens**: {vision_trace.get('usage', {}).get('output_tokens', 0)}\n\n"
-                vision_md += "## Vision Description Output\n\n"
-                vision_md += f"```\n{vision_trace.get('output', '')}\n```\n"
-                
-                with open(os.path.join(folder_path, "vision_log.md"), "w", encoding="utf-8") as f:
-                    f.write(vision_md)
-            
-            # 5. Save Instruct Log (all instruct rounds)
-            if instruct_traces:
-                instruct_md = "# Instruct Stage Log\n\n"
-                for i, trace in enumerate(instruct_traces):
-                    stage_name = trace.get("stage_name", f"Round {i+1}")
-                    instruct_md += f"## {stage_name}\n\n"
-                    instruct_md += f"- **Model**: {trace.get('model', 'unknown')}\n"
-                    instruct_md += f"- **Time**: {trace.get('time', 0):.2f}s\n"
-                    instruct_md += f"- **Tool Calls**: {trace.get('tool_calls', 0)}\n"
-                    instruct_md += f"- **Input Tokens**: {trace.get('usage', {}).get('input_tokens', 0)}\n"
-                    instruct_md += f"- **Output Tokens**: {trace.get('usage', {}).get('output_tokens', 0)}\n\n"
-                    
-                    output = trace.get("output", "")
-                    if output:
-                        instruct_md += "### Reasoning Output\n\n"
-                        instruct_md += f"```\n{output}\n```\n\n"
-                    
-                    instruct_md += "---\n\n"
-                
-                with open(os.path.join(folder_path, "instruct_log.md"), "w", encoding="utf-8") as f:
-                    f.write(instruct_md)
-                
-        except Exception as e:
-            print(f"Failed to save conversation: {e}")

entari_plugin_hyw/misc.py

@@ -1,214 +0,0 @@
-import json
-import base64
-import httpx
-import re
-import time
-from typing import Dict, Any, List, Optional
-from loguru import logger
-from arclet.entari import MessageChain, Image
-from typing import Tuple
-import asyncio
-from satori.exception import ActionFailed
-
-def process_onebot_json(data: Dict[str, Any]) -> str:
-    """Process OneBot JSON elements"""
-    try:
-        if "data" in data:
-            json_str = data["data"]
-            if isinstance(json_str, str):
-                json_str = json_str.replace(""", '"').replace(",", ",")
-                content = json.loads(json_str)
-                if "meta" in content and "detail_1" in content["meta"]:
-                    detail = content["meta"]["detail_1"]
-                    if "desc" in detail and "qqdocurl" in detail:
-                        return f"[Shared Document] {detail['desc']}: {detail['qqdocurl']}"
-    except Exception as e:
-        logger.warning(f"Failed to process JSON element: {e}")
-    return ""
-
-
-async def download_image(url: str) -> bytes:
-    """下载图片"""
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            resp = await client.get(url)
-            if resp.status_code == 200:
-                return resp.content
-            else:
-                raise ActionFailed(f"下载图片失败，状态码: {resp.status_code}")
-    except Exception as e:
-        raise ActionFailed(f"下载图片失败: {url}, 错误: {str(e)}")
-
-async def process_images(mc: MessageChain, vision_model: Optional[str] = None) -> Tuple[List[str], Optional[str]]:
-    # If vision model is explicitly set to "off", skip image processing
-    if vision_model == "off":
-        return [], None
-        
-    has_images = bool(mc.get(Image))
-    images = []
-    if has_images:
-        urls = mc[Image].map(lambda x: x.src)
-        tasks = [download_image(url) for url in urls]
-        raw_images = await asyncio.gather(*tasks)
-        import base64
-        images = [base64.b64encode(img).decode('utf-8') for img in raw_images]
-    
-    return images, None
-
-
-def resolve_model_name(name: str, models_config: List[Dict[str, Any]]) -> Tuple[Optional[str], Optional[str]]:
-    """
-    Resolve a user input model name to the full API model name from config.
-    Supports partial matching if unique.
-    """
-    if not name:
-        return None, "No model name provided"
-        
-    name = name.lower()
-    
-    # 1. Exact match (name or id or shortname)
-    for m in models_config:
-        if m.get("name") == name or m.get("id") == name:
-            return m.get("name"), None
-            
-    # 2. Key/Shortcut match
-    # Assuming the config might have keys like 'gpt4' mapping to full name
-    # But usually models list is [{'name': '...', 'provider': '...'}, ...]
-    
-    # Check if 'name' matches any model 'name' partially?
-    # Or just return the name itself if it looks like a valid model ID (contains / or -)
-    if "/" in name or "-" in name or "." in name:
-        return name, None
-        
-    # If not found in config specific list, and doesn't look like an ID, maybe return error
-    # But let's look for partial match in config names
-    matches = [m["name"] for m in models_config if name in m.get("name", "").lower()]
-    if len(matches) == 1:
-        return matches[0], None
-    elif len(matches) > 1:
-        return None, f"Model name '{name}' is ambiguous. Matches: {', '.join(matches[:3])}..."
-        
-    # Default: assume it's a valid ID passed directly
-    return name, None
-
-
-# Hardcoded markdown for refuse answer
-REFUSE_ANSWER_MARKDOWN = """
-<summary>
-Instruct 专家分配此任务流程失败，请尝试提出其他问题~
-</summary>
-"""
-
-
-async def render_refuse_answer(
-    renderer,
-    output_path: str,
-    reason: str = "Instruct 专家分配此任务流程失败，请尝试提出其他问题~",
-    theme_color: str = "#ef4444",
-    tab_id: str = None,
-) -> bool:
-    """
-    Render a refuse-to-answer image using the provided reason.
-    
-    Args:
-        renderer: ContentRenderer instance
-        output_path: Path to save the output image
-        reason: The refusal reason to display
-        theme_color: Theme color for the card
-        tab_id: Optional tab ID for reusing a prepared browser tab
-        
-    Returns:
-        True if render succeeded, False otherwise
-    """
-    markdown = f"""
-# 任务中止
-
-> {reason}
-"""
-    return await renderer.render(
-        markdown_content=markdown,
-        output_path=output_path,
-        stats={},
-        references=[],
-        page_references=[],
-        image_references=[],
-        stages_used=[],
-        image_timeout=1000,
-        theme_color=theme_color,
-        tab_id=tab_id,
-    )
-
-
-IMAGE_UNSUPPORTED_MARKDOWN = """
-<summary>
-当前模型不支持图片输入，请使用支持视觉能力的模型或仅发送文本。
-</summary>
-"""
-
-async def render_image_unsupported(
-    renderer,
-    output_path: str,
-    theme_color: str = "#ef4444",
-    tab_id: str = None
-) -> bool:
-    """
-    Render a card indicating that the model does not support image input.
-    """
-    markdown = f"""
-# 图片输入不支持
-
-> 当前选择的模型不支持图片输入。
-> 请切换到支持视觉的模型，或仅发送文本内容。
-"""
-    return await renderer.render(
-        markdown_content=markdown,
-        output_path=output_path,
-        stats={},
-        references=[],
-        page_references=[],
-        image_references=[],
-        stages_used=[],
-        image_timeout=1000,
-        theme_color=theme_color,
-        tab_id=tab_id
-    )
-
-
-def parse_color(color: str) -> str:
-    """Parse color string to hex format."""
-    if not color:
-        return "#ef4444"
-    color = str(color).strip()
-    if color.startswith('#') and len(color) in [4, 7]:
-        return color
-    if re.match(r'^[0-9a-fA-F]{6}$', color):
-        return f'#{color}'
-    rgb_match = re.match(r'^\(?(\d+)[,\s]+(\d+)[,\s]+(\d+)\)?$', color)
-    if rgb_match:
-        r, g, b = (max(0, min(255, int(x))) for x in rgb_match.groups())
-        return f'#{r:02x}{g:02x}{b:02x}'
-    return "#ef4444"
-
-
-class RecentEventDeduper:
-    """Deduplicates recent events based on a key with TTL."""
-    
-    def __init__(self, ttl_seconds: float = 30.0, max_size: int = 2048):
-        self.ttl_seconds = ttl_seconds
-        self.max_size = max_size
-        self._seen: Dict[str, float] = {}
-
-    def seen_recently(self, key: str) -> bool:
-        now = time.time()
-        if len(self._seen) > self.max_size:
-            self._prune(now)
-        ts = self._seen.get(key)
-        if ts is None or now - ts > self.ttl_seconds:
-            self._seen[key] = now
-            return False
-        return True
-
-    def _prune(self, now: float):
-        expired = [k for k, ts in self._seen.items() if now - ts > self.ttl_seconds]
-        for k in expired:
-            self._seen.pop(k, None)