import time import random from playwright.sync_api import Page from playwright.async_api import Page as AsyncPage from .human_like import HumanLikeTyper import asyncio from typing import Union, Optional, List, Dict, Any class HumanTypingWrapper: """ 人类化输入包装器，提供更高级的人类化输入功能 支持同步和异步页面操作 """ def __init__(self, page: Union[Page, AsyncPage], config: Optional[Dict[str, Any]] = None): self.page = page self.is_async = hasattr(page, 'wait_for_timeout') # 检测是否为异步页面 # 初始化配置 self.config = self._init_config(config) # 初始化human_like模块（仅用于同步页面） if not self.is_async: self.human_typer = HumanLikeTyper(page) def _init_config(self, config: Optional[Dict[str, Any]]) -> Dict[str, Any]: """初始化配置参数""" default_config = { # 输入速度设置（字符/秒） 'min_typing_speed': 2, 'max_typing_speed': 10, # 思考停顿设置 'pause_probability': 0.15, # 15%的概率停顿 'min_pause_duration': 0.3, 'max_pause_duration': 2.5, # 错误修正设置 'correction_probability': 0.0, # 禁用错误修正，确保文字准确性 'backspace_probability': 0.0, # 禁用退格重输，确保文字准确性 # 点击前后停顿 'click_delay_before': (0.1, 0.4), 'click_delay_after': (0.2, 0.6), # 输入完成后停顿 'finish_pause_probability': 0.4, # 40%的概率在输入完成后停顿 'finish_pause_duration': (0.3, 1.2), # 分段输入设置（长文本分段输入） 'chunk_input': True, 'max_chunk_length': 50, 'chunk_pause_duration': (0.5, 1.5), # 模拟疲劳效果 'fatigue_effect': True, 'fatigue_threshold': 100, # 输入超过100个字符后开始疲劳 'fatigue_slowdown': 0.3, # 疲劳后速度减慢30% } if config: default_config.update(config) return default_config def _calculate_typing_delay(self, char_index: int = 0) -> float: """计算每个字符之间的延迟时间，考虑疲劳效果""" base_speed = random.uniform( self.config['min_typing_speed'], self.config['max_typing_speed'] ) # 计算疲劳效果 if (self.config['fatigue_effect'] and char_index > self.config['fatigue_threshold']): fatigue_factor = 1 + self.config['fatigue_slowdown'] base_speed /= fatigue_factor delay = 1 / base_speed + random.uniform(-0.05, 0.15) return max(0.01, delay) # 确保延迟不为负数 def _should_pause(self) -> bool: """判断是否应该停顿思考""" return random.random() < self.config['pause_probability'] def _should_correct(self) -> bool: """判断是否应该进行错误修正""" return random.random() < self.config['correction_probability'] def _should_backspace(self) -> bool: """判断是否应该退格重新输入""" return random.random() < self.config['backspace_probability'] def _get_random_pause_duration(self) -> float: """获取随机停顿时长""" return random.uniform( self.config['min_pause_duration'], self.config['max_pause_duration'] ) def _get_wrong_char(self, correct_char: str) -> str: """生成错误字符""" # 键盘相邻字符映射 keyboard_neighbors = { 'a': 'sqw', 'b': 'vghn', 'c': 'xdfv', 'd': 'erfcxs', 'e': 'wsdr', 'f': 'rtgvcd', 'g': 'tyhbvf', 'h': 'yujnbg', 'i': 'ujko', 'j': 'uikmnh', 'k': 'iolmj', 'l': 'opmk', 'm': 'njk', 'n': 'bhjm', 'o': 'iklp', 'p': 'ol', 'q': 'wa', 'r': 'edft', 's': 'awedxz', 't': 'rfgy', 'u': 'yhij', 'v': 'cfgb', 'w': 'qase', 'x': 'zsdc', 'y': 'tghu', 'z': 'asx' } char_lower = correct_char.lower() if char_lower in keyboard_neighbors: neighbors = keyboard_neighbors[char_lower] wrong_char = random.choice(neighbors) # 保持原始大小写 return wrong_char.upper() if correct_char.isupper() else wrong_char else: # 如果不在映射中，返回随机字符 return random.choice('abcdefghijklmnopqrstuvwxyz') async def _sleep(self, duration: float): """统一的睡眠方法，兼容同步和异步""" if self.is_async: await asyncio.sleep(duration) else: time.sleep(duration) async def _type_char(self, char: str, delay: float): """输入单个字符，兼容同步和异步""" if self.is_async: await self.page.keyboard.type(char, delay=delay * 1000) else: self.page.keyboard.type(char, delay=delay * 1000) async def _press_key(self, key: str): """按键操作，兼容同步和异步""" if self.is_async: await self.page.keyboard.press(key) else: self.page.keyboard.press(key) async def _click_element(self, selector: str): """点击元素，兼容同步和异步""" if self.is_async: await self.page.click(selector) else: self.page.click(selector) async def _wait_for_selector(self, selector: str, timeout: int = 30000): """等待选择器，兼容同步和异步""" if self.is_async: await self.page.wait_for_selector(selector, timeout=timeout) else: self.page.wait_for_selector(selector, timeout=timeout) async def type_text_human(self, selector: str, text: str, clear_first: bool = True) -> bool: """ 以人类化方式在指定元素中输入文本 Args: selector: 元素选择器 text: 要输入的文本 clear_first: 是否先清空现有内容 Returns: bool: 是否成功输入 """ try: # 等待元素并点击 await self._wait_for_selector(selector) # 点击前停顿 delay_before = random.uniform(*self.config['click_delay_before']) await self._sleep(delay_before) # 点击元素 await self._click_element(selector) # 点击后停顿 delay_after = random.uniform(*self.config['click_delay_after']) await self._sleep(delay_after) # 清空现有内容 if clear_first: await self._press_key("Control+A") await self._sleep(0.1) await self._press_key("Delete") await self._sleep(0.2) # 分段输入长文本 if self.config['chunk_input'] and len(text) > self.config['max_chunk_length']: await self._type_text_in_chunks(text) else: await self._type_text_continuously(text) # 输入完成后可能停顿 if random.random() < self.config['finish_pause_probability']: pause_duration = random.uniform(*self.config['finish_pause_duration']) await self._sleep(pause_duration) return True except Exception as e: print(f"人类化输入失败: {e}") return False async def _type_text_continuously(self, text: str): """连续输入文本，包含人类化效果""" current_input = "" for i, char in enumerate(text): # 随机停顿思考 if self._should_pause(): pause_duration = self._get_random_pause_duration() await self._sleep(pause_duration) # 随机错误修正 if current_input and self._should_correct(): await self._simulate_correction(char) # 随机退格重新输入 if current_input and self._should_backspace(): await self._simulate_backspace_retype(char) # 计算延迟并输入字符 delay = self._calculate_typing_delay(i) await self._type_char(char, delay) current_input += char # 字符间微小停顿 micro_pause = random.uniform(0.01, 0.08) await self._sleep(micro_pause) async def _type_text_in_chunks(self, text: str): """分段输入长文本""" chunk_size = self.config['max_chunk_length'] chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)] for i, chunk in enumerate(chunks): await self._type_text_continuously(chunk) # 段落间停顿（除了最后一段） if i < len(chunks) - 1: pause_duration = random.uniform(*self.config['chunk_pause_duration']) await self._sleep(pause_duration) async def _simulate_correction(self, next_char: str): """模拟输入错误并修正""" # 删除最后一个字符 await self._press_key("Backspace") await self._sleep(random.uniform(0.1, 0.4)) # 输入错误字符 wrong_char = self._get_wrong_char(next_char) delay = self._calculate_typing_delay() await self._type_char(wrong_char, delay) await self._sleep(random.uniform(0.2, 0.5)) # 删除错误字符 await self._press_key("Backspace") await self._sleep(random.uniform(0.1, 0.3)) async def _simulate_backspace_retype(self, target_char: str): """模拟退格后重新输入""" backspace_count = random.randint(1, min(3, len(target_char))) # 执行退格 for _ in range(backspace_count): await self._press_key("Backspace") await self._sleep(random.uniform(0.1, 0.2)) # 短暂停顿 await self._sleep(random.uniform(0.2, 0.6)) async def click_and_type(self, selector: str, text: str, **kwargs) -> bool: """ 点击元素并输入文本的便捷方法 Args: selector: 元素选择器 text: 要输入的文本 **kwargs: 传递给type_text_human的额外参数 Returns: bool: 是否成功 """ return await self.type_text_human(selector, text, **kwargs) async def human_click(self, selector: str, wait_after: bool = True) -> bool: """ 人类化点击元素 Args: selector: 元素选择器 wait_after: 点击后是否等待 Returns: bool: 是否成功点击 """ try: await self._wait_for_selector(selector) # 点击前停顿 delay_before = random.uniform(*self.config['click_delay_before']) await self._sleep(delay_before) # 点击 await self._click_element(selector) # 点击后停顿 if wait_after: delay_after = random.uniform(*self.config['click_delay_after']) await self._sleep(delay_after) return True except Exception as e: print(f"人类化点击失败: {e}") return False async def human_scroll(self, direction: str = "down", amount: int = 3): """ 人类化滚动页面 Args: direction: 滚动方向 "up" 或 "down" amount: 滚动次数 """ key = "PageDown" if direction == "down" else "PageUp" for i in range(amount): await self._press_key(key) # 滚动间隔 pause = random.uniform(0.3, 0.8) await self._sleep(pause) def update_config(self, new_config: Dict[str, Any]): """更新配置""" self.config.update(new_config) def get_config(self) -> Dict[str, Any]: """获取当前配置""" return self.config.copy() # 便捷的工厂函数 def create_human_typer(page: Union[Page, AsyncPage], config: Optional[Dict[str, Any]] = None) -> HumanTypingWrapper: """ 创建人类化输入包装器的工厂函数 Args: page: Playwright页面对象（同步或异步） config: 可选的配置字典 Returns: HumanTypingWrapper实例 """ return HumanTypingWrapper(page, config)