Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+52
View File
@@ -0,0 +1,52 @@
"""R2-1:浏览器驱动层。业务代码经由这里访问浏览器,逐步替代对 DrissionPage 的直接调用。"""
from app.core.driver.base import ElementHandle, TabDriver
from app.core.driver.drission import (
DrissionActions,
DrissionBrowserDriver,
DrissionElement,
DrissionListener,
DrissionTabDriver,
as_element,
browser_driver,
driver_for_tab,
unwrap,
)
from app.core.driver.errors import (
ContextLost,
DriverDisconnected,
DriverError,
DriverTimeout,
ScriptError,
classify_driver_error,
translate_error,
translated_errors,
)
from app.core.driver.fake import FakeElement, FakeTabDriver
from app.core.driver.locators import split_locator, to_locator
__all__ = [
"ContextLost",
"DriverDisconnected",
"DriverError",
"DriverTimeout",
"DrissionActions",
"DrissionBrowserDriver",
"DrissionElement",
"DrissionListener",
"DrissionTabDriver",
"ElementHandle",
"FakeElement",
"FakeTabDriver",
"ScriptError",
"TabDriver",
"as_element",
"browser_driver",
"classify_driver_error",
"driver_for_tab",
"split_locator",
"to_locator",
"translate_error",
"translated_errors",
"unwrap",
]
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+64
View File
@@ -0,0 +1,64 @@
"""R2-1:浏览器驱动接口。
业务代码通过这里定义的接口访问浏览器,不再直接调用 DrissionPage。目前的实现:
- ``drission.DrissionTabDriver``:包装现有 DrissionPage 标签页对象,只转发调用、翻译异常;
- ``fake.FakeTabDriver``:内存假驱动,供单测使用,不需要真实浏览器。
迁移计划见 docs/architecture/browser-driver-and-process-model.md。网络监听(listen)
在第 5 步迁移时再加入接口,这里只包含已经实现的部分。
"""
from __future__ import annotations
from typing import Any, List, Optional, Protocol, runtime_checkable
@runtime_checkable
class ElementHandle(Protocol):
@property
def tag(self) -> str: ...
@property
def text(self) -> str: ...
def attr(self, name: str) -> Optional[str]: ...
def click(self, *, by_js: bool = False) -> None: ...
def input(self, text: str, *, clear: bool = False) -> None: ...
def run_js(self, script: str, *args: Any) -> Any: ...
@runtime_checkable
class TabDriver(Protocol):
@property
def tab_id(self) -> str: ...
@property
def url(self) -> str: ...
@property
def title(self) -> str: ...
@property
def raw(self) -> Any:
"""底层对象(迁移期间的逃生口:尚未迁移的代码仍可拿到原始 DrissionPage 标签页)。"""
def run_js(self, script: str, *args: Any, timeout: Optional[float] = None, as_expr: bool = False) -> Any: ...
def run_cdp(self, method: str, **params: Any) -> Any: ...
def find(self, locator: str, timeout: Optional[float] = None) -> Optional[ElementHandle]:
"""timeout 为 None 时沿用驱动的默认等待。"""
def find_all(self, locator: str, timeout: Optional[float] = None) -> List[ElementHandle]: ...
def navigate(self, url: str, timeout: Optional[float] = None) -> bool: ...
def reload(self, ignore_cache: bool = False) -> None: ...
def screenshot(self, full_page: bool = False) -> bytes: ...
def insert_text(self, text: str) -> None:
"""在当前焦点处插入文本(CDP Input.insertText,不模拟逐键输入)。"""
+458
View File
@@ -0,0 +1,458 @@
"""R2-1:基于 DrissionPage 的驱动实现——只做转发与异常翻译,不改变任何行为。
包装对象:
- ``DrissionTabDriver``:标签页(run_js / run_cdp / find / find_all / navigate / reload / screenshot /
insert_text,以及 ``listener`` 网络监听、``actions`` 键鼠动作链);
- ``DrissionElement``:元素。过渡期内未包装的属性经 ``__getattr__`` 转发给原元素;
- ``DrissionBrowserDriver``:浏览器级 CDP(``browser._run_cdp``)。
兼容性约定:
- 定位器按 DrissionPage 原生语法**原样传递**(不带前缀的字符串在 DrissionPage 中表示按文本模糊匹配);
配置里的选择器(默认是 CSS)请先用 ``to_locator()`` 规范化;
- 超时、as_expr 等可选参数只在调用方显式给出时才转发,默认行为与直接调用 DrissionPage 完全一致,
也兼容签名较窄的测试替身;
- 作为参数传入 run_js / run_cdp / 动作链的包装元素会自动换回原元素(DrissionPage 只认原始元素)。
"""
from __future__ import annotations
import weakref
from typing import Any, List, Optional
from app.core.driver.errors import translated_errors
def unwrap(value: Any) -> Any:
"""包装对象 -> 原始 DrissionPage 对象;其他值原样返回。"""
if isinstance(value, (DrissionElement, DrissionTabDriver, DrissionBrowserDriver)):
return value.raw
return value
def _unwrap_args(args: tuple, kwargs: dict) -> tuple:
return tuple(unwrap(a) for a in args), {k: unwrap(v) for k, v in kwargs.items()}
def _optional_kwargs(**values: Any) -> dict:
"""只保留调用方显式给出(非 None / 非 False)的可选参数。"""
return {k: v for k, v in values.items() if v is not None and v is not False}
class DrissionElement:
__slots__ = ("_ele",)
def __init__(self, ele: Any):
object.__setattr__(self, "_ele", ele)
# ---- 标识
@property
def raw(self) -> Any:
return self._ele
def __bool__(self) -> bool:
return bool(self._ele)
def __eq__(self, other: Any) -> bool:
return self._ele == unwrap(other)
def __hash__(self) -> int:
return hash(self._ele)
def __repr__(self) -> str:
return f"DrissionElement({self._ele!r})"
# ---- 接口内的方法
@property
def tag(self) -> str:
with translated_errors():
return str(getattr(self._ele, "tag", "") or "")
@property
def text(self) -> str:
with translated_errors():
return str(getattr(self._ele, "text", "") or "")
def attr(self, name: str) -> Optional[str]:
with translated_errors():
value = self._ele.attr(name)
return None if value is None else str(value)
@property
def click(self) -> "_Clicker":
"""与 DrissionPage 一致:既可直接调用 ele.click(...),也可 ele.click.left() / .at(x, y) 等。"""
return _Clicker(self._ele.click)
def input(self, *args: Any, **kwargs: Any) -> Any:
with translated_errors():
return self._ele.input(*args, **kwargs)
def run_js(self, script: str, *args: Any, timeout: Optional[float] = None, as_expr: bool = False) -> Any:
args, _ = _unwrap_args(args, {})
with translated_errors():
return self._ele.run_js(script, *args, **_optional_kwargs(as_expr=as_expr, timeout=timeout))
def find(self, locator: str, timeout: Optional[float] = None) -> Optional["DrissionElement"]:
with translated_errors():
ele = self._ele.ele(locator, **_optional_kwargs(timeout=timeout))
return DrissionElement(ele) if ele else None
def find_all(self, locator: str, timeout: Optional[float] = None) -> List["DrissionElement"]:
with translated_errors():
elements = self._ele.eles(locator, **_optional_kwargs(timeout=timeout))
if not isinstance(elements, list):
elements = [elements] if elements else []
return [DrissionElement(e) for e in elements if e]
def is_displayed(self) -> bool:
with translated_errors():
return bool(self._ele.states.is_displayed)
def is_alive(self) -> bool:
with translated_errors():
return bool(self._ele.states.is_alive)
# ---- 过渡期:其余 DrissionPage 元素属性原样转发(rect、states、parent()、shadow_root 等)
def __getattr__(self, name: str) -> Any:
return getattr(object.__getattribute__(self, "_ele"), name)
class _Clicker:
"""DrissionPage 点击器的代理:调用时翻译异常、拆包参数;其余方法(left/at/for_new_tab…)同样处理。"""
__slots__ = ("_clicker",)
def __init__(self, clicker: Any):
self._clicker = clicker
def __call__(self, *args: Any, **kwargs: Any) -> Any:
args, kwargs = _unwrap_args(args, kwargs)
with translated_errors():
return self._clicker(*args, **kwargs)
def __getattr__(self, name: str) -> Any:
target = getattr(object.__getattribute__(self, "_clicker"), name)
if not callable(target):
return target
def call(*args: Any, **kwargs: Any) -> Any:
args, kwargs = _unwrap_args(args, kwargs)
with translated_errors():
return target(*args, **kwargs)
return call
def as_element(obj: Any) -> Any:
"""把 DrissionPage 元素包装成 DrissionElement;已经是包装对象或假值(NoneElement、None)则原样返回。"""
if obj is None or isinstance(obj, DrissionElement) or not obj:
return obj
if hasattr(obj, "matches") and hasattr(obj, "inputs"): # FakeElement
return obj
return DrissionElement(obj)
class DrissionListener:
"""网络监听(tab.listen)的包装。返回的数据包仍是 DrissionPage 的 DataPacket(鸭子类型约定:
url / method / resourceType / request / response / is_failed 等属性),更换驱动时需要产出同形对象。"""
__slots__ = ("_listen",)
def __init__(self, listen: Any):
self._listen = listen
@property
def raw(self) -> Any:
return self._listen
@property
def listening(self) -> bool:
return bool(getattr(self._listen, "listening", False))
@property
def reuse_driver(self) -> bool:
return bool(getattr(self._listen, "_reuse_driver", False))
@reuse_driver.setter
def reuse_driver(self, value: bool) -> None:
# DrissionPage 的私有开关:复用标签页已有的 CDP 连接,避免为监听单独建连接
try:
setattr(self._listen, "_reuse_driver", bool(value))
except Exception:
pass
@property
def _reuse_driver(self) -> bool:
"""兼容直接访问私有名称的历史调用或误写。"""
return self.reuse_driver
@_reuse_driver.setter
def _reuse_driver(self, value: bool) -> None:
self.reuse_driver = value
def start(self, *args: Any, **kwargs: Any) -> Any:
with translated_errors():
return self._listen.start(*args, **kwargs)
def wait(self, *args: Any, **kwargs: Any) -> Any:
with translated_errors():
return self._listen.wait(*args, **kwargs)
def steps(self, *args: Any, **kwargs: Any) -> Any:
with translated_errors():
return self._listen.steps(*args, **kwargs)
def stop(self) -> Any:
with translated_errors():
return self._listen.stop()
def pause(self, *args: Any, **kwargs: Any) -> Any:
with translated_errors():
return self._listen.pause(*args, **kwargs)
def resume(self) -> Any:
with translated_errors():
return self._listen.resume()
def clear(self) -> Any:
with translated_errors():
return self._listen.clear()
# ---- 以下四个方法原样迁自 network_monitor:它们依赖 DrissionPage Listener 的内部状态,属于驱动实现细节
def is_active(self) -> bool:
"""监听处于活动状态:listening 为真且独立 Driver 连接仍在运行。"""
try:
driver = getattr(self._listen, "_driver", None)
return bool(getattr(self._listen, "listening", False) and driver is not None
and getattr(driver, "is_running", False))
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
return False
def force_reset(self) -> None:
"""stop() 失败时强制复位内部状态(listening / _network_enabled / _driver),再清空缓存。"""
listen = self._listen
try:
setattr(listen, "listening", False)
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
pass
try:
if hasattr(listen, "_network_enabled"):
setattr(listen, "_network_enabled", False)
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
pass
try:
if hasattr(listen, "_driver"):
setattr(listen, "_driver", None)
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
pass
try:
clear = getattr(listen, "clear", None)
if callable(clear):
clear()
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
pass
def safe_stop(self) -> None:
"""停止监听(会移除 Network.* 回调并关闭独立的 Driver 连接);失败则强制复位。"""
listen = self._listen
try:
if getattr(listen, "listening", False):
listen.stop()
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
self.force_reset()
return
try:
clear = getattr(listen, "clear", None)
if callable(clear):
clear()
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
pass
def counters(self) -> dict:
"""内部计数:进行中的目标数、请求数,以及已捕获待取的数据包数。"""
listen = self._listen
try:
running_targets = int(getattr(listen, "_running_targets", 0) or 0)
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
running_targets = 0
try:
running_requests = int(getattr(listen, "_running_requests", 0) or 0)
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
running_requests = 0
queued_packets = 0
try:
caught = getattr(listen, "_caught", None)
if caught is not None and hasattr(caught, "qsize"):
queued_packets = int(caught.qsize() or 0)
except Exception: # broad-except: DrissionPage 内部状态的尽力而为操作(原样迁自 network_monitor)
queued_packets = 0
return {
"running_targets": max(0, running_targets),
"running_requests": max(0, running_requests),
"queued_packets": max(0, queued_packets),
}
def __getattr__(self, name: str) -> Any: # 过渡期:其余属性原样转发
return getattr(object.__getattribute__(self, "_listen"), name)
class DrissionActions:
"""键鼠动作链(tab.actions)的包装:元素参数自动拆包,链式调用返回包装对象本身。"""
__slots__ = ("_actions",)
def __init__(self, actions: Any):
self._actions = actions
@property
def raw(self) -> Any:
return self._actions
def __getattr__(self, name: str) -> Any:
target = getattr(object.__getattribute__(self, "_actions"), name)
if not callable(target):
return target
def call(*args: Any, **kwargs: Any) -> Any:
args, kwargs = _unwrap_args(args, kwargs)
with translated_errors():
result = target(*args, **kwargs)
return self if result is self._actions else result
return call
class DrissionTabDriver:
"""包装一个 DrissionPage 标签页(ChromiumTab / ChromiumPage)。"""
__slots__ = ("_tab", "__weakref__")
def __init__(self, tab: Any):
self._tab = tab
@property
def raw(self) -> Any:
return self._tab
@property
def tab_id(self) -> str:
return str(getattr(self._tab, "tab_id", "") or "")
@property
def url(self) -> str:
with translated_errors():
return str(getattr(self._tab, "url", "") or "")
@property
def title(self) -> str:
with translated_errors():
return str(getattr(self._tab, "title", "") or "")
def run_js(self, script: str, *args: Any, timeout: Optional[float] = None, as_expr: bool = False) -> Any:
# 只传与默认值不同的关键字参数:对 DrissionPage 完全等价,也兼容签名为 run_js(script, *args) 的测试替身
args, _ = _unwrap_args(args, {})
with translated_errors():
return self._tab.run_js(script, *args, **_optional_kwargs(as_expr=as_expr, timeout=timeout))
def run_cdp(self, method: str, **params: Any) -> Any:
_, params = _unwrap_args((), params)
with translated_errors():
return self._tab.run_cdp(method, **params)
def find(self, locator: str, timeout: Optional[float] = None) -> Optional[DrissionElement]:
"""不传 timeout 时沿用 DrissionPage 的默认等待(与直接调用 tab.ele 一致)。"""
with translated_errors():
ele = self._tab.ele(locator, **_optional_kwargs(timeout=timeout))
# DrissionPage 找不到元素时返回假值的 NoneElement,而不是抛异常
return DrissionElement(ele) if ele else None
def find_all(self, locator: str, timeout: Optional[float] = None) -> List[DrissionElement]:
with translated_errors():
elements = self._tab.eles(locator, **_optional_kwargs(timeout=timeout))
if not isinstance(elements, list):
elements = [elements] if elements else []
return [DrissionElement(ele) for ele in elements if ele]
def navigate(self, url: str, timeout: Optional[float] = None) -> bool:
with translated_errors():
return bool(self._tab.get(url, **_optional_kwargs(timeout=timeout)))
def reload(self, ignore_cache: bool = False) -> None:
with translated_errors():
self._tab.refresh(ignore_cache=ignore_cache)
def screenshot(self, full_page: bool = False) -> bytes:
with translated_errors():
return self._tab.get_screenshot(as_bytes="png", full_page=full_page)
def insert_text(self, text: str) -> None:
with translated_errors():
self._tab.run_cdp("Input.insertText", text=str(text))
@property
def listener(self) -> DrissionListener:
return DrissionListener(self._tab.listen)
@property
def listener_or_none(self) -> Optional[DrissionListener]:
"""标签页没有 listen 属性(例如某些测试替身)时返回 None,而不是抛异常。"""
listen = getattr(self._tab, "listen", None)
return DrissionListener(listen) if listen is not None else None
@property
def actions(self) -> DrissionActions:
return DrissionActions(self._tab.actions)
class DrissionBrowserDriver:
"""浏览器级操作(browser._run_cdp:Target.*、Browser.* 等不属于某个标签页的 CDP 命令)。"""
__slots__ = ("_browser", "__weakref__")
def __init__(self, browser: Any):
self._browser = browser
@property
def raw(self) -> Any:
return self._browser
def run_cdp(self, method: str, **params: Any) -> Any:
_, params = _unwrap_args((), params)
with translated_errors():
return self._browser._run_cdp(method, **params)
_WRAPPERS: "weakref.WeakKeyDictionary[Any, DrissionTabDriver]" = weakref.WeakKeyDictionary()
_BROWSER_WRAPPERS: "weakref.WeakKeyDictionary[Any, DrissionBrowserDriver]" = weakref.WeakKeyDictionary()
def driver_for_tab(tab: Any):
"""返回标签页对应的驱动;已经是驱动对象则原样返回。同一个标签页对象复用同一个包装。"""
if tab is None:
raise ValueError("tab 不能为空")
if hasattr(tab, "raw") and hasattr(tab, "find_all") and hasattr(tab, "insert_text"):
return tab
try:
driver = _WRAPPERS.get(tab)
if driver is None:
driver = DrissionTabDriver(tab)
_WRAPPERS[tab] = driver
return driver
except TypeError: # 不支持弱引用的对象(例如某些测试替身):每次新建包装,开销很小
return DrissionTabDriver(tab)
def browser_driver(browser: Any):
"""返回浏览器对象(DrissionPage Chromium)对应的浏览器级驱动。"""
if browser is None:
raise ValueError("browser 不能为空")
if isinstance(browser, DrissionBrowserDriver) or (hasattr(browser, "raw") and hasattr(browser, "run_cdp")
and not hasattr(browser, "_run_cdp")):
return browser
try:
driver = _BROWSER_WRAPPERS.get(browser)
if driver is None:
driver = DrissionBrowserDriver(browser)
_BROWSER_WRAPPERS[browser] = driver
return driver
except TypeError:
return DrissionBrowserDriver(browser)
+63
View File
@@ -0,0 +1,63 @@
"""R2-1:访问 DrissionPage 内部对象的唯一入口。
业务代码和 DrissionPage 专用的补丁模块(``app/core/cdp_hygiene.py``)需要用到 DrissionPage 的内部类或函数时,
一律从这里取,不再直接 ``import DrissionPage``。更换驱动时,这些依赖都集中在驱动包里,一目了然。
所有导入都是延迟的:只有真正用到时才加载 DrissionPage。
"""
from __future__ import annotations
from typing import Any, Tuple
def connect_existing_browser(address: str) -> Any:
"""连接一个已经在运行、开启了远程调试端口的浏览器(不会自行启动新浏览器)。"""
from DrissionPage import Chromium, ChromiumOptions
opts = ChromiumOptions()
opts.set_address(address)
opts.existing_only()
return Chromium(addr_or_opts=opts)
def chromium_element_module() -> Any:
"""DrissionPage 元素模块(cdp_hygiene 在这里替换 run_js 的结果解析)。"""
from DrissionPage._elements import chromium_element
return chromium_element
def driver_class() -> Any:
"""DrissionPage 的底层 CDP 连接类(cdp_hygiene 在这里限制 Network.enable 的缓冲区)。"""
from DrissionPage._base.driver import Driver
return Driver
def is_real_page(obj: Any) -> bool:
"""是否为真实的 DrissionPage 页面/标签页对象(测试替身返回 False)。"""
try:
from DrissionPage._pages.chromium_base import ChromiumBase
return isinstance(obj, ChromiumBase)
except Exception: # broad-except: 判断失败一律视为非真实页面
return False
def forget_tab_object(tab: Any) -> None:
"""从 DrissionPage 的标签页对象缓存中移除该对象,下次按 tab_id 获取时会重新创建(用于回收坏掉的会话)。"""
try:
from DrissionPage._pages.chromium_tab import ChromiumTab
tab_id = getattr(tab, "tab_id", None) or getattr(tab, "_target_id", None)
if tab_id and ChromiumTab._TABS.get(tab_id) is tab:
ChromiumTab._TABS.pop(tab_id, None)
except Exception: # broad-except: 清理缓存是尽力而为,失败不影响回收流程
pass
def get_loc(locator: str) -> Tuple[str, str]:
"""把 DrissionPage 定位语法解析为 (by, query),by 为 'css selector' 或 'xpath'。"""
from DrissionPage._functions.locator import get_loc as _get_loc
return _get_loc(locator)
+129
View File
@@ -0,0 +1,129 @@
"""R2-1:驱动层统一异常。
各处代码以前靠匹配 DrissionPage 异常的类型或消息文本来判断“页面在刷新”“上下文丢了”“连接断了”,
规则分散在 tab_pool(执行上下文)、page_lifecycle(页面刷新)、command_engine(断连)三处。
这里把它们合并成一个分类器,驱动实现抛出的都是下面这几种异常。
**翻译后的异常消息与原异常完全相同**(原异常保存在 ``__cause__`` 和 ``original`` 上),
所以迁移期间仍按字符串判断的旧代码不受影响。
"""
from __future__ import annotations
import contextlib
from typing import Iterator, Optional, Type
class DriverError(Exception):
"""驱动层错误的基类。"""
def __init__(self, message: str = "", original: Optional[BaseException] = None):
super().__init__(message)
self.original = original
class DriverDisconnected(DriverError):
"""与浏览器或标签页的连接已断开(标签页关闭、WebSocket 断开、浏览器退出)。"""
class ContextLost(DriverError):
"""页面执行上下文已失效:页面正在刷新、导航,或脚本所在的 frame 被销毁。通常稍后重试即可。"""
class DriverTimeout(DriverError, TimeoutError):
"""等待超时(元素、页面加载、脚本执行)。"""
class ScriptError(DriverError):
"""页面内脚本执行出错(JavaScript 异常、非法定位器等)。"""
_CONTEXT_LOST_MARKERS = (
"cannot find context with specified id",
"cannot find default execution context",
"execution context was destroyed",
"execution context is not available",
"context was destroyed",
"inspected target navigated or closed",
# page_lifecycle.is_page_refresh_error 的判定
"页面被刷新",
"page was refreshed",
"page is refreshing",
"page refreshed",
"try waiting for page refresh",
)
_DISCONNECTED_MARKERS = (
"连接已断开",
"connection disconnected",
"target closed",
"session closed",
"no target with given id",
"browser has disconnected",
)
def _drission_error_types():
try:
from DrissionPage import errors
except ImportError: # pragma: no cover - DrissionPage 为必装依赖
return {}
return {
"context": tuple(getattr(errors, n) for n in ("ContextLostError",) if hasattr(errors, n)),
"disconnected": tuple(
getattr(errors, n) for n in ("PageDisconnectedError", "BrowserConnectError", "TargetNotFoundError")
if hasattr(errors, n)
),
"timeout": tuple(getattr(errors, n) for n in ("WaitTimeoutError",) if hasattr(errors, n)),
"script": tuple(getattr(errors, n) for n in ("JavaScriptError", "LocatorError") if hasattr(errors, n)),
}
def classify_driver_error(error: BaseException) -> Type[DriverError]:
"""判断一个底层异常属于哪一类驱动错误(不修改异常本身)。"""
if isinstance(error, DriverError):
return type(error)
types = _drission_error_types()
text = str(error or "").lower()
if isinstance(error, types.get("context", ())) or any(m in text for m in _CONTEXT_LOST_MARKERS):
return ContextLost
if isinstance(error, types.get("disconnected", ())) or any(m in text for m in _DISCONNECTED_MARKERS) or (
"websocket" in text and "closed" in text
):
return DriverDisconnected
if isinstance(error, types.get("timeout", ())) or isinstance(error, TimeoutError):
return DriverTimeout
if isinstance(error, types.get("script", ())):
return ScriptError
return DriverError
def translate_error(error: BaseException) -> DriverError:
if isinstance(error, DriverError):
return error
return classify_driver_error(error)(str(error), original=error)
def _is_drission_error(error: BaseException) -> bool:
try:
from DrissionPage.errors import BaseError
except ImportError: # pragma: no cover
return False
return isinstance(error, BaseError)
@contextlib.contextmanager
def translated_errors() -> Iterator[None]:
"""只把 DrissionPage 自己的异常翻译成驱动异常;其他异常原样抛出。
Python 内置异常(TypeError、OSError、KeyError……)保持原样,调用方已有的 ``except TypeError`` 之类
的兼容逻辑因此不受影响——例如 network_monitor 先试 ``start(pattern, res_type=True)``,
旧版 DrissionPage 不认识该参数时抛 TypeError,再退回 ``start(pattern)``。
"""
try:
yield
except DriverError:
raise
except Exception as exc: # broad-except: 先判断类型,非 DrissionPage 异常原样重新抛出
if not _is_drission_error(exc):
raise
raise translate_error(exc) from exc
+153
View File
@@ -0,0 +1,153 @@
"""R2-1:内存假驱动——不需要浏览器,供单测替代真实标签页。
支持的定位器(经 ``to_locator`` 规范化后):``css:tag``、``css:#id``、``css:.class``、
``css:tag#id.class[attr="v"]`` 这类单个复合选择器(不支持后代、逗号分组、伪类),
以及 ``tag:名称``、``@属性=值``。其他写法抛 ScriptError,行为与真实浏览器遇到非法选择器一致。
"""
from __future__ import annotations
import re
from typing import Any, Callable, Dict, List, Optional
from app.core.driver.errors import DriverError, ScriptError
from app.core.driver.locators import split_locator
_COMPOUND = re.compile(r"^(?P<tag>[a-zA-Z][\w-]*)?(?P<rest>(?:#[\w-]+|\.[\w-]+|\[[^\]]+\])*)$")
_ATTR = re.compile(r"""\[\s*([\w-]+)\s*(?:=\s*["']?([^"'\]]*)["']?)?\s*\]""")
class FakeElement:
def __init__(self, tag: str, text: str = "", **attrs: Any):
self.tag = tag.lower()
self.text = text
# class_ 之类规避 Python 关键字的写法:先去掉末尾下划线,再把下划线换成连字符(data_test -> data-test)
self.attrs = {k.rstrip("_").replace("_", "-"): str(v) for k, v in attrs.items()}
self.clicks = 0
self.inputs: List[str] = []
def attr(self, name: str) -> Optional[str]:
return self.attrs.get(name)
def click(self, *, by_js: bool = False) -> None:
self.clicks += 1
def input(self, text: str, *, clear: bool = False) -> None:
if clear:
self.inputs.clear()
self.inputs.append(text)
def run_js(self, script: str, *args: Any) -> Any:
return None
def matches(self, locator: str) -> bool:
kind, expr = split_locator(locator)
if kind == "tag":
return self.tag == expr.strip().lower()
if kind == "attr":
name, _, value = expr.partition("=")
return self.attrs.get(name.strip()) == value.strip() if value else name.strip() in self.attrs
if kind != "css":
raise ScriptError(f"FakeTabDriver 不支持的定位器: {locator}")
match = _COMPOUND.match(expr.strip())
if not match or not expr.strip():
raise ScriptError(f"FakeTabDriver 不支持的 CSS 选择器: {expr}")
if match.group("tag") and match.group("tag").lower() != self.tag:
return False
rest = match.group("rest")
for element_id in re.findall(r"#([\w-]+)", rest):
if self.attrs.get("id") != element_id:
return False
classes = set((self.attrs.get("class") or "").split())
if not set(re.findall(r"\.([\w-]+)", rest)) <= classes:
return False
for name, value in _ATTR.findall(rest):
if name not in self.attrs or (value and self.attrs[name] != value):
return False
return True
class FakeTabDriver:
def __init__(
self,
elements: Optional[List[FakeElement]] = None,
*,
url: str = "about:blank",
title: str = "",
tab_id: str = "fake-tab",
js: Optional[Callable[[str, tuple], Any]] = None,
cdp: Optional[Callable[[str, Dict[str, Any]], Any]] = None,
):
self.elements = list(elements or [])
self._url = url
self._title = title
self._tab_id = tab_id
self._js = js
self._cdp = cdp
self.js_calls: List[tuple] = []
self.cdp_calls: List[tuple] = []
self.navigations: List[str] = []
self.reloads = 0
self.inserted_text: List[str] = []
self._next_error: Optional[DriverError] = None
# 让下一次调用抛出指定的驱动异常,用于测试错误处理路径
def fail_next(self, error: DriverError) -> None:
self._next_error = error
def _maybe_fail(self) -> None:
if self._next_error is not None:
error, self._next_error = self._next_error, None
raise error
@property
def raw(self) -> Any:
return self
@property
def tab_id(self) -> str:
return self._tab_id
@property
def url(self) -> str:
return self._url
@property
def title(self) -> str:
return self._title
def run_js(self, script: str, *args: Any, timeout: Optional[float] = None, as_expr: bool = False) -> Any:
self._maybe_fail()
self.js_calls.append((script, args))
return self._js(script, args) if self._js else None
def run_cdp(self, method: str, **params: Any) -> Any:
self._maybe_fail()
self.cdp_calls.append((method, params))
return self._cdp(method, params) if self._cdp else {}
def find(self, locator: str, timeout: Optional[float] = None) -> Optional[FakeElement]:
matches = self.find_all(locator, timeout)
return matches[0] if matches else None
def find_all(self, locator: str, timeout: Optional[float] = None) -> List[FakeElement]:
self._maybe_fail()
return [element for element in self.elements if element.matches(locator)]
def navigate(self, url: str, timeout: Optional[float] = None) -> bool:
self._maybe_fail()
self.navigations.append(url)
self._url = url
return True
def reload(self, ignore_cache: bool = False) -> None:
self._maybe_fail()
self.reloads += 1
def screenshot(self, full_page: bool = False) -> bytes:
self._maybe_fail()
return b"\x89PNG\r\n\x1a\nFAKE"
def insert_text(self, text: str) -> None:
self._maybe_fail()
self.inserted_text.append(str(text))
+35
View File
@@ -0,0 +1,35 @@
"""R2-1:定位语法的统一规则(ElementFinder、健康巡检和各驱动共用)。
- 带 DrissionPage 前缀的原样使用:``css:``、``xpath:``、``tag:``、``@属性=值``、含 ``@@`` 的组合语法;
- 以 ``/`` 或 ``(`` 开头的按 XPath 处理(工作流执行器对这类选择器走 document.evaluate);
- 其余按 CSS 处理。
"""
from __future__ import annotations
DRISSION_PREFIXES = ("tag:", "@", "xpath:", "css:")
def to_locator(selector: str) -> str:
selector = str(selector or "").strip()
if selector.startswith(DRISSION_PREFIXES) or "@@" in selector:
return selector
if selector.startswith(("/", "(")):
return f"xpath:{selector}"
return f"css:{selector}"
def split_locator(locator: str) -> tuple:
"""把规范化后的定位器拆成 (类型, 表达式),类型为 css / xpath / tag / attr / drission。"""
locator = to_locator(locator)
if locator.startswith("css:"):
return "css", locator[4:]
if locator.startswith("xpath:"):
return "xpath", locator[6:]
if "@@" in locator:
return "drission", locator
if locator.startswith("tag:"):
return "tag", locator[4:]
if locator.startswith("@"):
return "attr", locator[1:]
return "drission", locator