""" flow_engine.py - 极简声明式注解流引擎 (基于 DrissionPage 原生 API) """ import time from typing import Optional, Callable, Dict, Any, Type from vs_types import BizLogicError def on(url: Optional[str] = None, title: Optional[str] = None, text: Optional[str] = None, ele: Optional[str] = None, not_ele: Optional[str] = None, predicate: Optional[Callable[['BaseFlow'], bool]] = None, priority: int = 100): """主匹配注解:页面满足条件时触发对应动作方法(支持同一方法堆叠多个注解,形成 OR 关系)""" def decorator(func: Callable): rule_spec = { "url": url, "title": title, "text": text, "ele": ele, "not_ele": not_ele, "predicate": predicate, "priority": priority, "is_done": getattr(func, "_is_done", False), "fatal_msg": getattr(func, "_fatal_msg", None), "exception_cls": getattr(func, "_exception_cls", BizLogicError) } rules = getattr(func, "_flow_rules", None) if rules is None: rules = [] func._flow_rules = rules rules.append(rule_spec) func._flow_rule = rule_spec return func return decorator def done(func: Callable): """终态注解:执行完后退出并标记成功""" func._is_done = True for r in getattr(func, "_flow_rules", []): r["is_done"] = True return func def fatal(error_msg: str, exception_cls: Type[Exception] = BizLogicError): """致命错误注解:命中时抛出异常终止流程""" def decorator(func: Callable): func._fatal_msg = error_msg func._exception_cls = exception_cls for r in getattr(func, "_flow_rules", []): r["fatal_msg"] = error_msg r["exception_cls"] = exception_cls return func return decorator def guard(url: Optional[str] = None, title: Optional[str] = None, text: Optional[str] = None, ele: Optional[str] = None, not_ele: Optional[str] = None, predicate: Optional[Callable[['BaseFlow'], bool]] = None, priority: int = 10): """高优先级异常守卫注解""" return on(url=url, title=title, text=text, ele=ele, not_ele=not_ele, predicate=predicate, priority=priority) class BaseFlow: """ 轻量注解状态机驱动引擎 """ def __init__(self, page, config: Optional[Dict[str, Any]] = None, context: Optional[Dict[str, Any]] = None, interval: float = 1.0, logger: Optional[Callable[[str], None]] = None, cf_bypasser=None, max_stuck_cycles: Optional[int] = 30): self.page = page self.config = config or {} self.context = context if context is not None else {} self.result = None self.interval = interval self.cf_bypasser = cf_bypasser self._logger = logger self.last_url = "" self.stuck_count = 0 self.max_stuck_cycles = max_stuck_cycles # 收集注解方法并按 priority 升序排序 self._rules = [] for attr_name in dir(self): try: method = getattr(self, attr_name) if callable(method): for r in getattr(method, "_flow_rules", []): rule = r.copy() rule["is_done"] = getattr(method, "_is_done", rule.get("is_done", False)) rule["fatal_msg"] = getattr(method, "_fatal_msg", rule.get("fatal_msg", None)) rule["exception_cls"] = getattr(method, "_exception_cls", rule.get("exception_cls", BizLogicError)) rule["method"] = method rule["name"] = attr_name self._rules.append(rule) except Exception: continue self._rules.sort(key=lambda r: r["priority"]) def log(self, msg: str, level: str = "info"): if self._logger is not None: log_fn = getattr(self._logger, level.lower(), getattr(self._logger, "info", None)) if callable(log_fn): log_fn(f"[{self.__class__.__name__}] {msg}") elif callable(self._logger): self._logger(f"[{self.__class__.__name__}] {msg}") else: print(f"[{self.__class__.__name__}] [{level.upper()}] {msg}") else: print(f"[{self.__class__.__name__}] [{level.upper()}] {msg}") def _matches(self, rule: Dict[str, Any]) -> bool: """根据 URL、Title、Text、Ele 及自定义 Predicate 判定是否命中规则""" # 防呆机制:如果没有任何匹配条件,直接视为不匹配,防止无条件空转造成死循环 if not any([ rule.get("url"), rule.get("title"), rule.get("text"), rule.get("ele"), rule.get("not_ele"), rule.get("predicate"), ]): return False curr_url = getattr(self.page, "url", "") or "" curr_title = getattr(self.page, "title", "") or "" if rule["url"] and rule["url"] not in curr_url: return False if rule["title"] and rule["title"].lower() not in curr_title.lower(): return False if rule["text"]: try: curr_html = getattr(self.page, "html", "") or "" if rule["text"] not in curr_html: return False except Exception: return False if rule["ele"]: try: if not self.page.ele(rule["ele"], timeout=0.2): return False except Exception: return False if rule["not_ele"]: try: if self.page.ele(rule["not_ele"], timeout=0.2): return False except Exception: pass if rule.get("predicate"): try: if not rule["predicate"](self): return False except Exception as e: self.log(f"[WARN] 规则 @{rule.get('name', 'unknown')} 的 predicate 执行异常: {e}", level="warning") return False return True def run(self, max_steps: Optional[int] = None, timeout: Optional[float] = None, max_stuck_cycles: Optional[int] = None) -> Any: """ 执行扫描调度循环,支持步数与超时时间双重限制 :param max_steps: 最大循环步数限制,为 None 时表示不限制步数 :param timeout: 最大执行超时时间(秒),为 None 时表示不限制时间 :param max_stuck_cycles: 页面停滞自愈刷新周期,若提供则覆盖实例配置,为 None 则关闭停滞刷新 """ if max_stuck_cycles is not None: self.max_stuck_cycles = max_stuck_cycles start_time = time.time() step = 0 # 构建展示信息 limits_desc = [] if max_steps is not None: limits_desc.append(f"max_steps={max_steps}") if timeout is not None: limits_desc.append(f"timeout={timeout}s") limits_str = f" (限制: {', '.join(limits_desc)})" if limits_desc else " (无限制模式)" self.log(f"🚀 启动流程状态机,加载了 {len(self._rules)} 条规则{limits_str}") while True: step += 1 elapsed = time.time() - start_time # 1. 检查步数限制 if max_steps is not None and step > max_steps: raise BizLogicError( f"流程步数耗尽(已执行 {step - 1} 步 / 上限 {max_steps} 步,耗时 {elapsed:.1f}s),最后停留在: {getattr(self.page, 'url', '')}" ) # 2. 检查超时限制 if timeout is not None and elapsed > timeout: raise BizLogicError( f"流程执行超时(已耗时 {elapsed:.1f}s / 上限 {timeout:.1f}s,已执行 {step - 1} 步),最后停留在: {getattr(self.page, 'url', '')}" ) # 格式化步骤标识前缀 if max_steps is not None and timeout is not None: step_prefix = f"[{step}/{max_steps} | {elapsed:.1f}s/{timeout:.1f}s]" elif max_steps is not None: step_prefix = f"[{step}/{max_steps} | {elapsed:.1f}s]" elif timeout is not None: step_prefix = f"[Step {step} | {elapsed:.1f}s/{timeout:.1f}s]" else: step_prefix = f"[Step {step} | {elapsed:.1f}s]" try: self.page.wait.doc_loaded(timeout=5) except Exception: pass time.sleep(self.interval) curr_url = getattr(self.page, "url", "") # 停滞检测与刷新自愈(若启用) if self.max_stuck_cycles is not None and self.max_stuck_cycles > 0: if curr_url and curr_url == self.last_url: self.stuck_count += 1 if self.stuck_count >= self.max_stuck_cycles: self.log(f"{step_prefix} [WARN] 页面停滞达 {self.stuck_count} 周期,执行刷新自愈...", level="warning") try: self.page.refresh() self.page.wait.load_start(timeout=5) except Exception as e: self.log(f"[ERROR] 刷新页面失败: {e}", level="error") self.stuck_count = 0 continue else: self.last_url, self.stuck_count = curr_url, 0 # 按优先级匹配规则 matched_rule = None for rule in self._rules: if self._matches(rule): matched_rule = rule self.log(f"{step_prefix} 🎯 命中规则: @{rule['name']} (priority={rule['priority']})") if rule["fatal_msg"]: self.log(f"💥 触发致命错误中断: {rule['fatal_msg']}", level="error") exc_cls = rule.get("exception_cls", BizLogicError) raise exc_cls(rule["fatal_msg"]) rule["method"]() if rule["is_done"]: self.log(f"✨ 目标达成,流程完成!(耗时 {time.time() - start_time:.1f}s,共执行 {step} 步)") return self.result if self.result is not None else True break if not matched_rule: self.log(f"{step_prefix} ⏳ 未匹配到注解规则 (URL: {curr_url}),等待下一周期...")