Files
universal-web-api/app/utils/human_mouse.py
T
2026-11-02 22:54:14 +08:00

606 lines
20 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
app/utils/human_mouse.py - 人类化鼠标行为模拟
职责:
- 平滑鼠标移动(多中间点 + 噪声 + 弧度)
- 空闲微漂移(等待期间的无意识手部抖动)
- 自然化滚轮滚动(多步小增量)
- 精确 CDP 点击(含 pressure 修复 + 按压微移)
所有函数通过 CDP Input.dispatchMouseEvent 直接操作,
不注入任何 JS,不触发页面脚本。
v5.10 改进:
- 移除 _dispatch_mouse_move 中的 tab.actions 降级(触发 CF)
- cdp_precise_click 按压期间增加微移事件(消灭事件沙漠)
- human_scroll 改用 CDP Input.dispatchMouseEvent(mouseWheel)
- idle_drift 频率更不规则(偶尔静止、偶尔连续微动)
"""
import time
import math
import random
from typing import Tuple, Optional, Callable
from app.core.config import logger
from app.core.driver import driver_for_tab
# ================= CDP 鼠标事件派发 =================
def _dispatch_mouse_move(tab, x: int, y: int, buttons: int = 0) -> bool:
"""
通过 CDP 派发 mouseMoved 事件(绝对视口坐标)
不注入 JS,不触发页面脚本的 Runtime.evaluate。
不降级到 tab.actions(会触发 CF 检测)。
Args:
tab: DrissionPage 标签页
x, y: 视口坐标
buttons: 按钮位掩码(0=无按钮,1=左键按住)
Returns:
是否成功
"""
try:
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mouseMoved',
x=int(x),
y=int(y),
button='none',
buttons=buttons,
modifiers=0,
pointerType='mouse'
)
return True
except Exception as e:
# 🔴 不降级到 tab.actions.move_to()(测试7证明 actions 系列触发 CF)
logger.warning(f"[MOUSE_CDP] mouseMoved 派发失败: {e}")
return False
# ================= 平滑鼠标移动 =================
def smooth_move_mouse(
tab,
from_pos: Tuple[int, int],
to_pos: Tuple[int, int],
duration: float = None,
noise_scale: float = None,
check_cancelled: Callable[[], bool] = None
) -> Tuple[int, int]:
"""
人类化平滑鼠标移动
使用二次贝塞尔插值 + 高斯噪声 + 非对称 ease-out 缓动,
并叠加轻微高频 tremor,模拟“快速接近 + 末端瞄准”。
Args:
tab: DrissionPage 标签页
from_pos: 起始坐标 (x, y)
to_pos: 目标坐标 (x, y)
duration: 移动总时长(秒),None 则自动计算
noise_scale: 噪声幅度(像素),None 则按距离自动
check_cancelled: 取消检查函数
Returns:
最终鼠标坐标 (x, y)
"""
x0, y0 = from_pos
x1, y1 = to_pos
dx = x1 - x0
dy = y1 - y0
dist = math.hypot(dx, dy)
# Very small corrections can still be a single event; 5-15px gets a tiny
# no-delay glide so short movements do not look like coordinate snaps.
if dist < 5:
_dispatch_mouse_move(tab, x1, y1)
return (x1, y1)
if dist < 15:
glide_steps = random.randint(1, 2)
for i in range(1, glide_steps + 1):
if check_cancelled and check_cancelled():
return (x0, y0)
raw_t = i / (glide_steps + 1)
t = 1 - (1 - raw_t) ** 2
jitter = math.sin(raw_t * math.pi)
fx = int(round(x0 + dx * t + random.gauss(0, 0.35) * jitter))
fy = int(round(y0 + dy * t + random.gauss(0, 0.35) * jitter))
_dispatch_mouse_move(tab, fx, fy)
_dispatch_mouse_move(tab, x1, y1)
return (x1, y1)
# 自动计算移动时长:保持连贯,不额外拖慢
if duration is None:
duration = 0.09 + 0.09 * math.log2(1 + dist / 60)
duration *= random.uniform(0.9, 1.08)
duration = max(0.08, min(duration, 0.5))
# 步数:短时高采样,让移动更快但仍平滑
sample_rate = random.uniform(24, 36)
steps = max(6, min(28, int(duration * sample_rate)))
step_interval = duration / steps
# 噪声幅度:与距离成正比,上限 12px
if noise_scale is None:
noise_scale = min(dist * 0.03, 12.0)
# 贝塞尔控制点:在路径中垂线方向偏移,产生弧度
perp_x = -dy / dist if dist > 0 else 0
perp_y = dx / dist if dist > 0 else 0
arc_offset = random.gauss(0, dist * 0.06)
ctrl_x = (x0 + x1) / 2 + perp_x * arc_offset
ctrl_y = (y0 + y1) / 2 + perp_y * arc_offset
start_time = time.perf_counter()
tremor_hz = random.uniform(8.0, 12.0)
tremor_amp_x = random.uniform(0.2, 0.8)
tremor_amp_y = random.uniform(0.2, 0.8)
tremor_phase = random.uniform(0, math.pi * 2)
tremor_phase2 = random.uniform(0, math.pi * 2)
# 逐步移动
for i in range(1, steps + 1):
if check_cancelled and check_cancelled():
return (x0, y0)
# 非对称缓动:前段更快接近,后段更长时间微调
raw_t = i / steps
t = 1 - (1 - raw_t) ** 3
# 二次贝塞尔插值
bx = (1 - t) ** 2 * x0 + 2 * (1 - t) * t * ctrl_x + t ** 2 * x1
by = (1 - t) ** 2 * y0 + 2 * (1 - t) * t * ctrl_y + t ** 2 * y1
# 高斯噪声(中段最大,首尾趋零)
envelope = math.sin(raw_t * math.pi)
nx = random.gauss(0, noise_scale * envelope)
ny = random.gauss(0, noise_scale * envelope)
# 高频低幅手部颤抖(tremor)
tremor_theta = tremor_phase + raw_t * duration * tremor_hz * 2 * math.pi
tremor_x = (
math.sin(tremor_theta)
+ 0.35 * math.sin(2.3 * tremor_theta + tremor_phase2)
) * tremor_amp_x * 0.75
tremor_y = (
math.cos(tremor_theta)
+ 0.35 * math.sin(1.9 * tremor_theta + tremor_phase2 + 0.8)
) * tremor_amp_y * 0.75
fx = int(round(bx + nx + tremor_x))
fy = int(round(by + ny + tremor_y))
_dispatch_mouse_move(tab, fx, fy)
# 步间延迟(带微随机)
target_time = start_time + (step_interval * i)
remaining = target_time - time.perf_counter()
if remaining > 0:
time.sleep(remaining * random.uniform(0.7, 1.0))
# 最终精确到达目标
_dispatch_mouse_move(tab, x1, y1)
# Slightly vary the overshoot chance so long-run samples do not sit on one
# sharp probability edge.
if dist > 100 and random.random() < random.uniform(0.12, 0.28):
angle = math.atan2(dy, dx)
overshoot_dist = random.uniform(3, 8)
ox = int(x1 + math.cos(angle) * overshoot_dist)
oy = int(y1 + math.sin(angle) * overshoot_dist)
_dispatch_mouse_move(tab, ox, oy)
time.sleep(random.uniform(0.02, 0.06))
_dispatch_mouse_move(tab, x1, y1)
return (x1, y1)
# ================= 空闲微漂移 =================
def idle_drift(
tab,
duration: float,
center_pos: Tuple[int, int],
check_cancelled: Callable[[], bool] = None,
drift_radius: float = 3.0,
freq_hz: float = 1.5
) -> Tuple[int, int]:
"""
空闲时的无意识手部微抖动
模拟人类在"等待/阅读/思考"时鼠标的微小漂移。
使用偏向中心的布朗运动,不会越漂越远。
v5.10:频率更不规则,偶尔静止较长时间,偶尔连续快速微动。
Args:
tab: DrissionPage 标签页
duration: 漂移持续时间(秒)
center_pos: 中心坐标
check_cancelled: 取消检查函数
drift_radius: 最大漂移半径(像素)
freq_hz: 基准移动频率(Hz),实际频率会大幅波动
Returns:
最终鼠标坐标
"""
cx, cy = center_pos
cur_x, cur_y = float(cx), float(cy)
base_interval = 1.0 / freq_hz
deadline = time.perf_counter() + max(0.0, float(duration or 0.0))
while time.perf_counter() < deadline:
if check_cancelled and check_cancelled():
break
# 不规则间隔:30% 概率短间隔(连续微动),70% 概率长间隔(静止)
if random.random() < 0.3:
# 连续微动模式:快速连续 2-4 次小移动
burst_count = random.randint(2, 4)
for _ in range(burst_count):
if time.perf_counter() >= deadline:
break
if check_cancelled and check_cancelled():
break
burst_sleep = random.uniform(0.08, 0.25)
burst_sleep = min(burst_sleep, max(0.0, deadline - time.perf_counter()))
if burst_sleep <= 0:
break
time.sleep(burst_sleep)
# 微小移动(0.3-1.5px)
angle = random.uniform(0, 2 * math.pi)
step = random.uniform(0.3, 1.5)
cur_x += math.cos(angle) * step
cur_y += math.sin(angle) * step
# 回弹力
dist_from_center = math.hypot(cur_x - cx, cur_y - cy)
if dist_from_center > drift_radius * 0.6:
pull = 0.3
cur_x += (cx - cur_x) * pull
cur_y += (cy - cur_y) * pull
_dispatch_mouse_move(tab, int(cur_x), int(cur_y))
else:
# 静止模式:较长时间不动
sleep_time = base_interval * random.uniform(0.8, 2.5)
sleep_time = min(sleep_time, max(0.0, deadline - time.perf_counter()))
if sleep_time <= 0:
break
time.sleep(sleep_time)
# 单次微移(0.5-2px)
angle = random.uniform(0, 2 * math.pi)
step = random.uniform(0.5, 2.0)
cur_x += math.cos(angle) * step
cur_y += math.sin(angle) * step
# 回弹力
dist_from_center = math.hypot(cur_x - cx, cur_y - cy)
if dist_from_center > drift_radius * 0.6:
pull = 0.3
cur_x += (cx - cur_x) * pull
cur_y += (cy - cur_y) * pull
_dispatch_mouse_move(tab, int(cur_x), int(cur_y))
return (int(cur_x), int(cur_y))
# ================= 自然化滚轮滚动 =================
def human_scroll(
tab,
total_dy: int,
mouse_x: int = None,
mouse_y: int = None,
check_cancelled: Callable[[], bool] = None
):
"""
模拟人类滚轮滚动(多步小增量,CDP 直接派发)
v5.10:改用 CDP Input.dispatchMouseEvent(mouseWheel) 替代 tab.actions.scroll(),
避免 actions 系列的参数组装差异。
真实鼠标滚轮每格约 100-120px(标准 deltaY=100),间隔 20-80ms。
Args:
tab: DrissionPage 标签页
total_dy: 总滚动量(像素,正=向下,负=向上)
mouse_x: 鼠标 X 坐标(滚动时鼠标位置),None 则默认视口中心
mouse_y: 鼠标 Y 坐标,None 则默认视口中心
check_cancelled: 取消检查函数
"""
if total_dy == 0:
return
# 默认鼠标在视口中心
if mouse_x is None:
mouse_x = 600
if mouse_y is None:
mouse_y = 400
direction = 1 if total_dy > 0 else -1
remaining = abs(total_dy)
while remaining > 0:
if check_cancelled and check_cancelled():
return
# 每步 80-120px(匹配标准鼠标滚轮一格)
step = min(remaining, random.randint(80, 120))
try:
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mouseWheel',
x=int(mouse_x),
y=int(mouse_y),
deltaX=0,
deltaY=step * direction,
button='none',
buttons=0,
pointerType='mouse'
)
except Exception as e:
logger.debug(f"[SCROLL_CDP] mouseWheel 派发失败: {e}")
# 降级到 actions(滚动触发 CF 的风险低于点击)
try:
driver_for_tab(tab).actions.scroll(0, step * direction)
except Exception:
break
remaining -= step
if remaining > 0:
time.sleep(random.uniform(0.02, 0.08))
def human_scroll_path(
tab,
from_pos: Tuple[int, int],
to_pos: Tuple[int, int],
check_cancelled: Callable[[], bool] = None
) -> Tuple[int, int]:
"""
沿坐标路径执行人类化滚轮滚动。
轨迹本身使用平滑鼠标移动,滚动量取 from/to 的坐标差,
以多段 wheel 事件逐步逼近目标,适合隐身模式下的坐标滑动。
"""
x0, y0 = int(from_pos[0]), int(from_pos[1])
x1, y1 = int(to_pos[0]), int(to_pos[1])
total_dx = x1 - x0
total_dy = y1 - y0
if total_dx == 0 and total_dy == 0:
_dispatch_mouse_move(tab, x0, y0)
return (x0, y0)
travel = math.hypot(total_dx, total_dy)
steps = max(4, min(14, int(travel / 55) + random.randint(1, 3)))
prev_scroll_x = 0
prev_scroll_y = 0
_dispatch_mouse_move(tab, x0, y0)
start_time = time.perf_counter()
duration = max(0.12, min(0.6, 0.14 + travel / 1200.0 + random.uniform(0.01, 0.06)))
step_interval = duration / steps
for i in range(1, steps + 1):
if check_cancelled and check_cancelled():
return (x0, y0)
raw_t = i / steps
t = 0.5 - 0.5 * math.cos(raw_t * math.pi)
cur_x = int(round(x0 + total_dx * t + random.gauss(0, 1.4) * math.sin(raw_t * math.pi)))
cur_y = int(round(y0 + total_dy * t + random.gauss(0, 1.8) * math.sin(raw_t * math.pi)))
_dispatch_mouse_move(tab, cur_x, cur_y)
target_scroll_x = int(round(total_dx * t))
target_scroll_y = int(round(total_dy * t))
delta_x = target_scroll_x - prev_scroll_x
delta_y = target_scroll_y - prev_scroll_y
if delta_x or delta_y:
try:
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mouseWheel',
x=cur_x,
y=cur_y,
deltaX=delta_x,
deltaY=delta_y,
button='none',
buttons=0,
pointerType='mouse'
)
prev_scroll_x += delta_x
prev_scroll_y += delta_y
except Exception as e:
logger.debug(f"[SCROLL_CDP] path mouseWheel 派发失败: {e}")
break
target_time = start_time + step_interval * i
remaining = target_time - time.perf_counter()
if remaining > 0:
time.sleep(remaining * random.uniform(0.82, 1.0))
# 收尾,确保滚动量累计完整
rest_dx = total_dx - prev_scroll_x
rest_dy = total_dy - prev_scroll_y
if rest_dx or rest_dy:
try:
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mouseWheel',
x=x1,
y=y1,
deltaX=rest_dx,
deltaY=rest_dy,
button='none',
buttons=0,
pointerType='mouse'
)
except Exception as e:
logger.debug(f"[SCROLL_CDP] path 收尾滚动失败: {e}")
_dispatch_mouse_move(tab, x1, y1)
return (x1, y1)
# ================= 精确 CDP 点击 =================
def cdp_precise_click(
tab,
x: int,
y: int,
hold_duration: float = None,
check_cancelled: Callable[[], bool] = None
) -> bool:
"""
通过 CDP 派发完整的鼠标点击事件序列
v5.10 改进:
- mousePressed 设置 force=0.5(PointerEvent.pressure=0.5,匹配真实鼠标)
- mouseReleased 设置 force=0(释放时 pressure 归零)
- 按压期间插入 1-2 个 mouseMoved(buttons=1) 微移事件(消灭事件沙漠)
- 点击前派发一次 mouseMoved 到精确坐标(匹配真实硬件行为)
完整事件序列(匹配真实硬件):
1. mouseMoved(buttons=0) — 鼠标到达位置
2. mousePressed(force=0.5) — 按下
3. mouseMoved(buttons=1) × 1-2 — 按压期间手指微移
4. mouseReleased(force=0) — 释放
Args:
tab: DrissionPage 标签页
x, y: 视口坐标
hold_duration: 按压时长(秒),None 则随机 60-140ms
check_cancelled: 取消检查函数
Returns:
是否成功
"""
if check_cancelled and check_cancelled():
return False
x, y = int(x), int(y)
if hold_duration is None:
hold_duration = random.uniform(0.04, 0.09)
try:
# 1. 点击前确认鼠标位置(真实硬件在按下前一帧必有 mouseMoved)
_dispatch_mouse_move(tab, x, y, buttons=0)
time.sleep(random.uniform(0.005, 0.015)) # 1 帧间隔
if check_cancelled and check_cancelled():
return False
# 2. mousePressed(force=0.5 → pressure=0.5)
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mousePressed',
x=x,
y=y,
button='left',
buttons=1,
clickCount=1,
force=0.5,
pointerType='mouse'
)
# 3. 按压期间微移(模拟手指按压导致鼠标轻微位移)
# 真实硬件在 pressed→released 之间通常有 1-3 个 mouseMoved(buttons=1)
micro_move_count = random.randint(1, 2)
micro_interval = hold_duration / (micro_move_count + 1)
press_x, press_y = x, y
for _ in range(micro_move_count):
if check_cancelled and check_cancelled():
# 取消时仍需释放按钮
_release_mouse(tab, press_x, press_y)
return False
time.sleep(micro_interval * random.uniform(0.7, 1.3))
# 微小位移:1-2px(手指按压力导致)
press_x = x + random.randint(-2, 2)
press_y = y + random.randint(-1, 1)
_dispatch_mouse_move(tab, press_x, press_y, buttons=1)
# 剩余按压时间
remaining_hold = hold_duration - micro_interval * micro_move_count
if remaining_hold > 0:
time.sleep(max(0.01, remaining_hold * random.uniform(0.6, 1.0)))
if check_cancelled and check_cancelled():
_release_mouse(tab, press_x, press_y)
return False
# 4. mouseReleased(在最终微移位置释放,而非精确回到原点)
# 释放坐标允许和按下坐标有 1-2px 偏差(真实行为)
release_x = x + random.randint(-1, 1)
release_y = y + random.randint(-1, 1)
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mouseReleased',
x=release_x,
y=release_y,
button='left',
buttons=0,
clickCount=1,
force=0,
pointerType='mouse'
)
return True
except Exception as e:
logger.warning(f"[CDP_CLICK] 精确点击失败: {e}")
return False
def _release_mouse(tab, x: int, y: int):
"""安全释放鼠标按钮(防止状态泄漏)"""
try:
driver_for_tab(tab).run_cdp(
'Input.dispatchMouseEvent',
_timeout=0,
type='mouseReleased',
x=int(x),
y=int(y),
button='left',
buttons=0,
clickCount=1,
force=0,
pointerType='mouse'
)
except Exception:
pass
__all__ = ['smooth_move_mouse', 'idle_drift', 'human_scroll', 'cdp_precise_click']