nonebot-plugin-zhihu-parser 0.1.0__py3-none-any.whl

nonebot_plugin_zhihu_parser/__init__.py

@@ -0,0 +1,331 @@
+import re
+from nonebot import on_message, on_command, get_bots
+from nonebot.permission import SUPERUSER
+from nonebot.adapters.onebot.v11 import Message, MessageSegment, MessageEvent, Bot, GroupMessageEvent, PrivateMessageEvent
+from nonebot.log import logger
+from nonebot import get_driver
+from nonebot.rule import Rule
+from nonebot.typing import T_State
+
+from nonebot.plugin import PluginMetadata
+from nonebot_plugin_zhihu_parser.config import PluginConfig
+from .core.parsers.zhihu.parser import ZhihuParser
+from .core.download import Downloader
+from .core.render import Renderer
+from .core.debounce import Debouncer
+from .core.clean import CacheCleaner
+from .core.exception import ParseException
+
+# 洗血专用依赖
+from nonebot import require
+require("nonebot_plugin_apscheduler")
+from nonebot_plugin_apscheduler import scheduler
+from nonebot import on_command
+from .core.parsers.zhihu.refresher import do_refresh_token
+from .core.parsers.zhihu.maintenance import (
+    RefreshMonitor, format_refresh_result, refresh_alert_targets, refresh_job_options,
+)
+
+global_config = get_driver().config
+# 从 .env 读取配置，如果没有则提供默认值（分批阈值默认10，防抖默认86400秒）
+ZHIHU_BATCH_SIZE = getattr(global_config, "zhihu_batch_size", 10)
+ZHIHU_DEBOUNCE_TIME = getattr(global_config, "zhihu_debounce_time", 86400)
+ZHIHU_CACHE_MAX_AGE = getattr(global_config, "zhihu_cache_max_age", 86400 * 7)
+ZHIHU_MAX_IMAGES = getattr(global_config, "zhihu_max_images", 50)
+
+cfg = PluginConfig()
+refresh_monitor = RefreshMonitor(
+    cfg.data_dir / "zhihu_refresh_state.json",
+    refresh_alert_targets(global_config),
+    do_refresh_token,
+    lambda: [bot for bot in get_bots().values() if isinstance(bot, Bot)],
+)
+zhihu_parser = None
+zhihu_renderer = None
+# 将配置好的防抖时间传给防抖器
+zhihu_debouncer = Debouncer(ttl_seconds=ZHIHU_DEBOUNCE_TIME)
+
+__plugin_meta__ = PluginMetadata(
+    name="知乎解析",
+    description="解析知乎问题、回答、专栏文章与想法链接，生成预览卡片并转发图文内容",
+    usage="直接发送知乎链接即可自动解析；引用含知乎链接的消息回复「解析」可重新解析；管理员发送「知乎保活」可手动刷新登录信息",
+    type="application",
+    homepage="https://github.com/devil233-ui/nonebot-plugin-zhihu-parser",
+    supported_adapters={"~onebot.v11"},
+)
+
+@get_driver().on_startup
+async def init_parser():
+    global zhihu_parser, zhihu_renderer
+    downloader = Downloader(cfg)
+    zhihu_parser = ZhihuParser(cfg, downloader)
+    Renderer.load_resources()
+    zhihu_renderer = Renderer(cfg)
+    max_age = int(ZHIHU_CACHE_MAX_AGE)
+    zhihu_cleaner = CacheCleaner(temp_dir=cfg.cache_dir, max_age_seconds=max_age)
+    zhihu_cleaner.start()
+    
+    days = max_age / 86400
+    logger.info(f"知乎解析插件：{days:g}天缓存自动清理任务已挂载启动！")
+    
+    scheduler.add_job(
+        auto_refresh_zhihu_cookie,
+        **refresh_job_options(
+            scheduler.timezone,
+            getattr(global_config, "zhihu_refresh_jitter_seconds", 900),
+        ),
+    )
+
+
+async def auto_refresh_zhihu_cookie():
+    logger.info("[知乎保活] 开始自动保活")
+    result = await refresh_monitor.run(cfg)
+    if result.ok:
+        logger.info(format_refresh_result(result))
+    else:
+        logger.warning(format_refresh_result(result))
+
+
+@get_driver().on_bot_connect
+async def resume_refresh_alerts(bot):
+    if isinstance(bot, Bot):
+        await refresh_monitor.notify_pending()
+
+def check_zhihu_url():
+    async def _check(bot: Bot, event: MessageEvent, state: T_State) -> bool:
+        raw_msg = str(event.get_message()).replace("\\/", "/")
+        pat = re.compile(r"(https?://(?:www\.)?zhihu\.com/[^\s\"\'\\]+|https?://zhuanlan\.zhihu\.com/[^\s\"\'\\]+)")
+        
+        # 1. 正常情况：直接检测消息里有没有知乎链接
+        match = pat.search(raw_msg)
+        if match:
+            state['zhihu_match'] = match
+            state['zhihu_raw'] = raw_msg
+            return True
+            
+        # 2. 引用解析情况：检查是不是发了“解析”并且带了引用(reply)
+        # 兼容这几个词：解析、提取、解析知乎
+        if raw_msg.strip() in ["解析", "提取", "解析知乎"] and event.reply:
+            # 提取被引用原消息（哪怕是小程序 JSON 卡片，这里也会变成字符串）
+            reply_msg = str(event.reply.message).replace("\\/", "/")
+            reply_match = pat.search(reply_msg)
+            if reply_match:
+                # 狸猫换太子：把引用里的链接和文本存进 state，骗过后面的程序
+                state['zhihu_match'] = reply_match
+                state['zhihu_raw'] = reply_msg 
+                return True
+                
+        return False
+    return Rule(_check)
+
+zhihu_matcher = on_message(rule=check_zhihu_url(), priority=10, block=False)
+
+# 【新增】手动强制换血指令，方便你随时补充存活期
+refresh_cmd = on_command(
+    "刷新知乎ck", aliases={"知乎保活", "知乎刷新"},
+    permission=SUPERUSER, priority=5, block=True,
+)
+
+@refresh_cmd.handle()
+async def force_refresh(bot: Bot, event: MessageEvent):
+    await refresh_cmd.send("正在刷新知乎登录信息，请稍候。")
+    result = await refresh_monitor.run(cfg)
+    await refresh_cmd.send(format_refresh_result(result))
+
+@zhihu_matcher.handle()
+async def handle_zhihu(bot: Bot, event: MessageEvent, state: T_State):
+    if not zhihu_parser or not zhihu_renderer:
+        logger.warning("知乎解析器仍在初始化中，请稍后再试")
+        return
+        
+    await zhihu_matcher.send("识别到知乎链接，开始解析")
+    
+    text = state['zhihu_raw']
+    base_match = state['zhihu_match']
+    
+    # 原始提取的 URL
+    raw_url = base_match.group(0).replace("&", "&")
+    # [新增清洗] 暴力剔除 URL 尾部可能因为引用而粘连的中文和特殊标点
+    import re
+    url = re.sub(r'[\u4e00-\u9fa5\u3000-\u303f\uff00-\uffef\]\}）】”"。，！？]+$', '', raw_url)
+    
+    text = text.replace("&", "&")
+    session_id = event.get_session_id()
+    
+    if zhihu_debouncer.hit_url(session_id, url):
+        logger.info(f"[{session_id}] 链接 {url} 在防抖时间内，已跳过重复解析")
+        await zhihu_matcher.send("24小时内有人水果了，端下去罢")
+        return
+        
+    handlers = getattr(zhihu_parser, "_handlers", {})
+    final_keyword = None
+    final_match_obj = None
+
+    for kw, func in handlers.items():
+        pat = getattr(func, "__parser_pattern__", None)
+        if pat:
+            if isinstance(pat, str): pat = re.compile(pat)
+            match = pat.search(text)
+            if match:
+                final_keyword = kw
+                final_match_obj = match
+                break
+
+    if not final_match_obj:
+        KNOWN_PATTERNS = [
+            ("/answer/", re.compile(r"zhihu\.com/question/(?P<question_id>\d+)/answer/(?P<answer_id>\d+)")),
+            ("www.zhihu.com/question/", re.compile(r"zhihu\.com/question/(?P<question_id>\d+)")),
+            ("zhuanlan.zhihu.com/p/", re.compile(r"zhuanlan\.zhihu\.com/p/(?P<article_id>\d+)")),
+            ("www.zhihu.com/pin/", re.compile(r"zhihu\.com/pin/(?P<pin_id>\d+)")),
+        ]
+        for exact_kw, pat in KNOWN_PATTERNS:
+            match = pat.search(text)
+            if match and exact_kw in handlers:
+                final_keyword = exact_kw
+                final_match_obj = match
+                break
+                
+    if not final_keyword or not final_match_obj:
+        return
+
+    logger.warning(f"🔍 [X光机] 开始解析！命中规则: {final_keyword}, 提取参数: {final_match_obj.group(0)}")
+
+    try:
+        parse_res = await zhihu_parser.parse(final_keyword, final_match_obj)
+        if not parse_res: return
+            
+        # A. 发送预览卡片
+        card_path = await zhihu_renderer.render_card(parse_res)
+        if card_path and card_path.exists():
+            await zhihu_matcher.send(MessageSegment.image(card_path))
+
+        # B. 分批次合并转发逻辑
+        bot_id = int(bot.self_id)
+        img_counter = 0
+        batch_num = 1
+        current_combined_msg = Message()
+        total_img_counter = 0
+        limit_reached = False
+        
+        # 初始添加标题
+        if getattr(parse_res, "title", None):
+            current_combined_msg += MessageSegment.text(f"【{parse_res.title}】\n\n")
+
+        async def send_current_batch(msg: Message, is_last: bool = False):
+            if not msg: return
+            prefix = f"(第{batch_num}部分) " if not (batch_num == 1 and is_last) else ""
+            node = [MessageSegment.node_custom(user_id=bot_id, nickname=f"知乎解析 {prefix}", content=msg)]
+            try:
+                if isinstance(event, GroupMessageEvent):
+                    await bot.call_api("send_group_forward_msg", group_id=event.group_id, messages=node)
+                else:
+                    await bot.call_api("send_private_forward_msg", user_id=event.user_id, messages=node)
+            except Exception as e:
+                logger.error(f"发送第 {batch_num} 部分转发失败: {e}")
+                
+                # [恢复] 降级单发机制：因为现在有总量限制，可以放心拆包单发了
+                await zhihu_matcher.send(f"⚠️ 第 {batch_num} 部分触发风控拦截，正在自动拆分单独发送...")
+                
+                # [新增] 专门处理长文本折叠的内部助手函数
+                async def safe_send_text(text_msg: Message):
+                    t_str = str(text_msg).strip()
+                    if not t_str: return
+                    
+                    # 纯文字装进合并转发里“折叠”起来
+                    if len(t_str): 
+                        t_node = [MessageSegment.node_custom(user_id=bot_id, nickname="风控部分纯文字折叠", content=Message(t_str))]
+                        try:
+                            if isinstance(event, GroupMessageEvent):
+                                await bot.call_api("send_group_forward_msg", group_id=event.group_id, messages=t_node)
+                            else:
+                                await bot.call_api("send_private_forward_msg", user_id=event.user_id, messages=t_node)
+                        except Exception:
+                            # 终极兜底：万一纯文本转发都失败，截断只发前500字
+                            await zhihu_matcher.send(t_str[:500] + "\n...[字数过多已截断]")
+                    else:
+                        # 不满 150 字的短句（比如图注、小标题）直接发，不影响阅读连贯性
+                        await zhihu_matcher.send(text_msg)
+
+                fallback_msg = Message()
+                for seg in msg:
+                    if seg.type == 'text':
+                        fallback_msg += seg
+                    else:
+                        # 先发送之前攒着的文字（带折叠判定）
+                        try: await safe_send_text(fallback_msg)
+                        except Exception: pass
+                        fallback_msg = Message()
+                        
+                        # 单发媒体
+                        try: await zhihu_matcher.send(Message(seg))
+                        except Exception as sub_e: 
+                            logger.error(f"单发媒体失败（严重风控死锁）: {sub_e}")
+                            await zhihu_matcher.send("🚫 [一张图片/视频因触发腾讯极其严格的审核被无情抹杀]")
+                            
+                # 收尾剩余文字
+                try: await safe_send_text(fallback_msg)
+                except Exception: pass
+
+        # 遍历正文内容
+        if hasattr(parse_res, "contents") and parse_res.contents:
+            for content in parse_res.contents:
+                # 1. 处理文字
+                if hasattr(content, "text") and content.text:
+                    current_combined_msg += MessageSegment.text(str(content.text) + "\n")
+                
+                # 2. 处理图片/媒体（增加精准异常捕获）
+                if hasattr(content, "get_path"):
+                    try:
+                        file_path = await content.get_path()
+                        if file_path and getattr(file_path, "exists", lambda: False)():
+                            # 换完后上一行是：
+                            ext = file_path.suffix.lower()
+                            if ext in [".jpg", ".jpeg", ".png", ".gif", ".webp"]:
+                                current_combined_msg += MessageSegment.image(file_path)
+                                current_combined_msg += MessageSegment.text("\n")
+                                img_counter += 1
+                                total_img_counter += 1  # [新增] 累加总数
+                            elif ext in [".mp4", ".mov", ".avi"]:
+                                current_combined_msg += MessageSegment.video(file_path)
+                                current_combined_msg += MessageSegment.text("\n")
+                                img_counter += 2 
+                                total_img_counter += 2  # [新增] 累加总数
+                    except RuntimeError:
+                        pass
+                    except Exception as e:
+                        logger.debug(f"读取媒体失败: {e}")
+
+                # [修改] 达到单批次阈值 或 达到总量限制 时触发发包
+                if img_counter >= ZHIHU_BATCH_SIZE or total_img_counter >= ZHIHU_MAX_IMAGES:
+                    await send_current_batch(current_combined_msg)
+                    current_combined_msg = Message() 
+                    img_counter = 0
+                    batch_num += 1
+                    
+                # [新增] 总量阻断：超过设定总量直接掐断循环
+                if total_img_counter >= ZHIHU_MAX_IMAGES:
+                    limit_reached = True
+                    break
+
+        # [修改] 如果没有被提前阻断，才发送收尾段落
+        if current_combined_msg and not limit_reached:
+            await send_current_batch(current_combined_msg, is_last=True)
+            
+        # [新增] 触发了截断则发送文案提示
+        if limit_reached:
+            await zhihu_matcher.send("不刷屏了，剩下的请点击原链接跳转阅读")
+
+    except ParseException as e:
+        err_msg = str(e)
+        logger.warning(f"知乎抓取被阻断: {err_msg}")
+        if e.__cause__:
+            logger.error(f"💥 [X光机] 底层致命报错: {e.__cause__}")
+        
+        # 触发回滚！把毒数据从防抖池踢出去
+        zhihu_debouncer.rollback_url(session_id, url)
+        
+        await zhihu_matcher.send(f"⚠️ 解析失败: {err_msg}")
+            
+    except Exception as e:
+        logger.exception("解析知乎链接时发生严重错误")
+        zhihu_debouncer.rollback_url(session_id, url)

nonebot_plugin_zhihu_parser/config.py

@@ -0,0 +1,84 @@
+import json
+from pathlib import Path
+from nonebot.log import logger
+from nonebot import get_driver
+
+class ParserItem(dict):
+    """兼容原代码的替身类，允许通过 .属性名 访问字典键值"""
+    def __getattr__(self, item):
+        if item not in self:
+            # 遇到 enable 系列开关默认返回 True
+            if isinstance(item, str) and "enable" in item:
+                return True
+            return ParserItem()
+        return self.get(item)
+
+    def __getitem__(self, item):
+        if item not in self:
+            if isinstance(item, str) and "enable" in item:
+                return True
+            return ParserItem()
+        return super().__getitem__(item)
+        
+    def __bool__(self):
+        return True
+
+class PluginConfig:
+    def __init__(self):
+        # --- 严格执行用户定义的路径规范 ---
+        self.data_dir = Path.cwd() / "data" / "nonebot_plugin_zhihu_parser"
+        self.config_dir = Path.cwd() / "config" / "nonebot_plugin_zhihu_parser"
+        self.temp_dir = Path.cwd() / "cache" / "nonebot_plugin_zhihu_parser"
+        
+        self.cache_dir = self.temp_dir
+
+        # 确保所有目录存在
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.temp_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 补上 Downloader 等组件需要的属性
+        self.source_max_size = 50
+        self.download_retry_times = 5
+        self.common_timeout = 60
+        self.download_timeout = 60
+        self.max_duration = 3600
+        
+        # --- Cookie 文件管理 (位于 config 目录) ---
+        self.cookie_file = self.config_dir / "zhihu_cookies.txt"
+        if not self.cookie_file.exists():
+            self.cookie_file.write_text("", encoding="utf-8")
+            logger.info(f"[知乎解析] 已在 config 目录下创建 CK 文件: {self.cookie_file}")
+            
+        local_cookie = self.cookie_file.read_text(encoding="utf-8").strip()
+        
+        # 读取 .env.dev 配置作为备选
+        nb_config = get_driver().config
+        env_cookie = getattr(nb_config, "zhihu_cookie", "").strip()
+        
+        # 优先级：config 目录下的 txt 文件 > .env.dev
+        final_cookie = local_cookie if local_cookie else env_cookie
+
+        # 构造 parser.zhihu 结构，供底层解析器通过 self.mycfg 调用
+        self.parser = ParserItem({
+            "zhihu": ParserItem({
+                "cookie": final_cookie
+            })
+        })
+        
+        # 基础配置项字典
+        self.settings = {
+            "proxy": getattr(nb_config, "zhihu_proxy", None),
+            "zhihu_cookie": final_cookie,
+        }
+        
+    def get(self, key, default=None):
+        return self.settings.get(key, default)
+
+    def get_config(self, key: str, default=None):
+        return self.settings.get(key, default)
+
+    def __getattr__(self, item):
+        if item in self.settings:
+            return self.settings[item]
+        return ParserItem()

nonebot_plugin_zhihu_parser/core/clean.py

@@ -0,0 +1,35 @@
+import time
+import asyncio
+from pathlib import Path
+from nonebot.log import logger
+
+class CacheCleaner:
+    def __init__(self, temp_dir: str | Path, max_age_seconds: int = 86400*7):
+        """默认清理 一周 前的缓存文件"""
+        self.temp_dir = Path(temp_dir)
+        self.max_age = max_age_seconds
+        self.temp_dir.mkdir(parents=True, exist_ok=True)
+        self._running = False
+
+    def start(self):
+        if not self._running:
+            self._running = True
+            asyncio.create_task(self._cleanup_loop())
+
+    async def _cleanup_loop(self):
+        while self._running:
+            try:
+                now = time.time()
+                count = 0
+                # 遍历目录清理过期文件
+                for file_path in self.temp_dir.glob('*'):
+                    if file_path.is_file() and now - file_path.stat().st_mtime > self.max_age:
+                        file_path.unlink(missing_ok=True)
+                        count += 1
+                if count > 0:
+                    logger.info(f"[知乎解析] 后台清理了 {count} 个过期缓存文件")
+            except Exception as e:
+                logger.error(f"[知乎解析] 缓存清理异常: {e}")
+            
+            # 每 12 小时执行一次检查
+            await asyncio.sleep(43200)

nonebot_plugin_zhihu_parser/core/constants.py

@@ -0,0 +1,24 @@
+
+from typing import Final
+
+COMMON_HEADER: Final[dict[str, str]] = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/55.0.2883.87 UBrowser/6.2.4098.3 Safari/537.36"
+    )
+}
+
+IOS_HEADER: Final[dict[str, str]] = {
+    "User-Agent": (
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) "
+        "Version/16.6 Mobile/15E148 Safari/604.1 Edg/132.0.0.0"
+    )
+}
+
+ANDROID_HEADER: Final[dict[str, str]] = {
+    "User-Agent": (
+        "Mozilla/5.0 (Linux; Android 15; SM-G998B) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/132.0.0.0 Mobile Safari/537.36 Edg/132.0.0.0"
+    )
+}
+