# patch_drissionpage.py - 自动补丁 DrissionPage Listener # 用法:python patch_drissionpage.py # 时机:pip install 之后、项目启动之前 import importlib import inspect import shutil from pathlib import Path from datetime import datetime RECOVERY_GUARD_MARKER = "# CODEX_LISTENER_RECOVERY_GUARD_V2" STREAM_CAPTURE_GUARD_MARKER = "# CODEX_LISTENER_STREAM_CAPTURE_V2" LEGACY_STREAM_CAPTURE_GUARD_MARKER = "# CODEX_LISTENER_STREAM_CAPTURE_V1" RECOVERY_GUARD_SNIPPET = """ # CODEX_LISTENER_RECOVERY_GUARD_V2 try: _orig_start_v2 = Listener.start def _listener_driver_alive_v2(listener): driver = getattr(listener, '_driver', None) return bool(driver and getattr(driver, 'is_running', False)) def _listener_mark_stopped_v2(listener): listener.listening = False if getattr(listener, '_reuse_driver', False): listener._network_enabled = False def _listener_not_listening_v2(listener): _listener_mark_stopped_v2(listener) raise RuntimeError(_S._lang.join(_S._lang.NOT_LISTENING)) def _listener_require_driver_v2(listener): if not listener.listening: raise RuntimeError(_S._lang.join(_S._lang.NOT_LISTENING)) if not _listener_driver_alive_v2(listener): listener._driver = None _listener_not_listening_v2(listener) return listener._driver def _safe_start_v2(self, targets=None, is_regex=None, method=None, res_type=None): if getattr(self, 'listening', False) and not _listener_driver_alive_v2(self): self._driver = None _listener_mark_stopped_v2(self) elif not getattr(self, 'listening', False) and not _listener_driver_alive_v2(self): self._driver = None if getattr(self, '_reuse_driver', False): self._network_enabled = False return _orig_start_v2(self, targets, is_regex, method, res_type) def _safe_pause_v2(self, clear=True): if self.listening: driver = getattr(self, '_driver', None) if driver is not None: for event_name in ( 'Network.requestWillBeSent', 'Network.responseReceived', 'Network.loadingFinished', 'Network.loadingFailed', ): try: driver.set_callback(event_name, None) except Exception: pass self.listening = False if clear: self.clear() def _safe_stop_v2(self): if self.listening: try: _safe_pause_v2(self) except Exception: self.listening = False try: self.clear() except Exception: pass driver = getattr(self, '_driver', None) if self._reuse_driver: if self._network_enabled and driver: try: driver.run('Network.disable') except Exception: pass self._network_enabled = False self._driver = None else: if driver: try: driver.stop() except Exception: pass self._driver = None def _safe_wait_v2(self, count=1, timeout=None, fit_count=True, raise_err=None): _listener_require_driver_v2(self) fail = False if not timeout: while self.listening and self._caught.qsize() < count: _listener_require_driver_v2(self) sleep(.03) fail = self._caught.qsize() < count else: end = perf_counter() + timeout while self.listening: _listener_require_driver_v2(self) if perf_counter() > end: fail = True break if self._caught.qsize() >= count: break sleep(.03) if self._caught.qsize() < count: fail = True if fail: if fit_count or not self._caught.qsize(): if raise_err is True or (_S.raise_when_wait_failed is True and raise_err is None): raise WaitTimeoutError(_S._lang.join(_S._lang.WAITING_FAILED_, _S._lang.DATA_PACKET, timeout)) else: return False else: return [self._caught.get_nowait() for _ in range(self._caught.qsize())] if count == 1: return self._caught.get_nowait() return [self._caught.get_nowait() for _ in range(count)] def _safe_steps_v2(self, count=None, timeout=None, gap=1): if not self.listening: raise RuntimeError(_S._lang.join(_S._lang.NOT_LISTENING)) caught = 0 if timeout is None: while self.listening: _listener_require_driver_v2(self) if self._caught.qsize() >= gap: yield self._caught.get_nowait() if gap == 1 else [self._caught.get_nowait() for _ in range(gap)] if count: caught += gap if caught >= count: return sleep(.03) else: end = perf_counter() + timeout while self.listening and perf_counter() < end: _listener_require_driver_v2(self) if self._caught.qsize() >= gap: yield self._caught.get_nowait() if gap == 1 else [self._caught.get_nowait() for _ in range(gap)] end = perf_counter() + timeout if count: caught += gap if caught >= count: return sleep(.03) return False def _safe_wait_silent_v2(self, timeout=None, targets_only=False, limit=0): _listener_require_driver_v2(self) if timeout is None: while ((not targets_only and self._running_requests > limit) or (targets_only and self._running_targets > limit)): _listener_require_driver_v2(self) sleep(.01) return True end_time = perf_counter() + timeout while perf_counter() < end_time: _listener_require_driver_v2(self) if ((not targets_only and self._running_requests <= limit) or (targets_only and self._running_targets <= limit)): return True sleep(.01) else: return False Listener.start = _safe_start_v2 Listener.pause = _safe_pause_v2 Listener.stop = _safe_stop_v2 Listener.wait = _safe_wait_v2 Listener.steps = _safe_steps_v2 Listener.wait_silent = _safe_wait_silent_v2 except Exception: pass """.lstrip("\n") STREAM_CAPTURE_SNIPPET = r""" # CODEX_LISTENER_STREAM_CAPTURE_V2 try: _codecs_v1 = __import__('codecs') _copy_v1 = __import__('copy') _threading_v1 = __import__('threading') _os_v1 = __import__('os') _orig_listener_set_callback_v1 = Listener._set_callback _orig_listener_pause_v1 = Listener.pause _orig_listener_stop_v1 = Listener.stop _orig_listener_request_will_be_sent_v1 = Listener._requestWillBeSent _orig_listener_response_received_v1 = Listener._response_received _orig_listener_loading_finished_v1 = Listener._loading_finished _orig_listener_loading_failed_v1 = Listener._loading_failed _orig_data_packet_init_v1 = DataPacket.__init__ class _ListenerStreamStateV1(dict): # P0-4: fullText is accumulated as a list of parts and joined only when # read (once per poll) instead of copying the whole body on every chunk. # _uwapi_stream_lock_v2: the CDP event thread appends while monitor # threads read; without the lock a read that merges parts could replace # the list and drop chunks appended in between (reproduced). __slots__ = ('_parts', '_lock') def __init__(self, *args, **kwargs): self._lock = _threading_v1.Lock() dict.__init__(self, *args, **kwargs) base = dict.get(self, 'fullText', '') or '' base = base if isinstance(base, str) else str(base) self._parts = [base] if base else [] dict.__setitem__(self, 'fullText', base) def append_text(self, text): if text: with self._lock: self._parts.append(text) def full_text_length(self): with self._lock: return sum(len(part) for part in self._parts) def _joined(self): with self._lock: parts = self._parts if len(parts) > 1: joined = ''.join(parts) self._parts = [joined] dict.__setitem__(self, 'fullText', joined) return joined current = parts[0] if parts else '' if dict.get(self, 'fullText') is not current: dict.__setitem__(self, 'fullText', current) return current def __getitem__(self, key): if key == 'fullText': return self._joined() return dict.__getitem__(self, key) def get(self, key, default=None): if key == 'fullText': return self._joined() return dict.get(self, key, default) def __setitem__(self, key, value): if key == 'fullText': value = '' if value is None else value with self._lock: self._parts = [value] if value else [] dict.__setitem__(self, key, value) return dict.__setitem__(self, key, value) def setdefault(self, key, default=None): if key == 'fullText': return self._joined() return dict.setdefault(self, key, default) def items(self): self._joined() return dict.items(self) def values(self): self._joined() return dict.values(self) def copy(self): self._joined() return dict(dict.items(self)) def __reduce_ex__(self, protocol): self._joined() return (dict, (dict(dict.items(self)),)) def _new_listener_stream_state_v1(): return _ListenerStreamStateV1({ 'chunks': [], 'chunk_count': 0, 'fullText': '', 'complete': False, 'truncated': False, }) def _data_packet_init_stream_v1(self, tab_id, target): _orig_data_packet_init_v1(self, tab_id, target) self._stream = _new_listener_stream_state_v1() self._stream_enabled = False self._stream_emitted = False self._stream_decoder = _codecs_v1.getincrementaldecoder('utf-8')('ignore') def _listener_stream_dict_v1(packet): stream = getattr(packet, '_stream', None) if not isinstance(stream, dict): stream = _new_listener_stream_state_v1() packet._stream = stream elif not isinstance(stream, _ListenerStreamStateV1): stream = _ListenerStreamStateV1(stream) packet._stream = stream else: # hot path (every chunk): keys were created with the state object; # do not touch fullText here, reading it would force a join. for key, default in (('complete', False), ('truncated', False)): if not dict.__contains__(stream, key): dict.__setitem__(stream, key, default) if not dict.__contains__(stream, 'chunks'): dict.__setitem__(stream, 'chunks', []) if not dict.__contains__(stream, 'chunk_count'): dict.__setitem__(stream, 'chunk_count', len(stream['chunks'])) return stream stream.setdefault('chunks', []) stream.setdefault('chunk_count', len(stream['chunks'])) stream.setdefault('fullText', '') stream.setdefault('complete', False) stream.setdefault('truncated', False) return stream def _listener_stream_int_v1(name, default, minimum, maximum): try: value = int(str(_os_v1.getenv(name, default) or default).strip()) except Exception: value = default return max(minimum, min(maximum, value)) def _listener_stream_debug_enabled_v1(): return str(_os_v1.getenv('DRISSION_STREAM_DEBUG_ENABLED', '') or '').strip().lower() in { '1', 'true', 'yes', 'on' } def _listener_trim_stream_debug_dir_v1(path): max_total = _listener_stream_int_v1( 'DRISSION_STREAM_DEBUG_MAX_TOTAL_BYTES', 50 * 1024 * 1024, 5 * 1024 * 1024, 2 * 1024 * 1024 * 1024, ) try: files = [item for item in path.parent.iterdir() if item.is_file()] files.sort(key=lambda item: item.stat().st_mtime) total = sum(item.stat().st_size for item in files) for item in files: if total <= max_total: break if item == path: continue size = item.stat().st_size item.unlink(missing_ok=True) total -= size except Exception: pass def _listener_rotate_stream_debug_v1(path): max_bytes = _listener_stream_int_v1( 'DRISSION_STREAM_DEBUG_MAX_BYTES', 10 * 1024 * 1024, 1024 * 1024, 100 * 1024 * 1024, ) backups = _listener_stream_int_v1('DRISSION_STREAM_DEBUG_BACKUPS', 4, 1, 20) try: if not path.exists() or path.stat().st_size < max_bytes: return for index in range(backups, 0, -1): source = path.with_name(f'{path.stem}.{index}{path.suffix}') target = path.with_name(f'{path.stem}.{index + 1}{path.suffix}') if index == backups: source.unlink(missing_ok=True) elif source.exists(): source.replace(target) path.replace(path.with_name(f'{path.stem}.1{path.suffix}')) except Exception: pass def _listener_stream_debug_v1(packet, phase, **details): if not _listener_stream_debug_enabled_v1(): return try: import json as _json_v1 from pathlib import Path as _Path_v1 raw_request = getattr(packet, '_raw_request', {}) or {} request = raw_request.get('request', {}) if isinstance(raw_request, dict) else {} raw_response = getattr(packet, '_raw_response', {}) or {} stream = _listener_stream_dict_v1(packet) max_events = _listener_stream_int_v1( 'DRISSION_STREAM_DEBUG_MAX_EVENTS_PER_REQUEST', 8, 2, 100, ) debug_events = int(getattr(packet, '_stream_debug_events', 0) or 0) if debug_events >= max_events: return packet._stream_debug_events = debug_events + 1 payload = { 'captured_at': __import__('time').time(), 'phase': phase, 'request_id': getattr(packet, '_stream_request_id', None), 'url': request.get('url', '') if isinstance(request, dict) else '', 'method': request.get('method', '') if isinstance(request, dict) else '', 'mime_type': raw_response.get('mimeType', '') if isinstance(raw_response, dict) else '', 'stream_complete': bool(stream.get('complete', False)), 'full_text_len': len(str(stream.get('fullText', '') or '')), 'chunks_len': len(stream.get('chunks', [])) if isinstance(stream.get('chunks'), list) else 0, 'chunk_count': int(stream.get('chunk_count', 0) or 0), 'truncated': bool(stream.get('truncated', False)), } payload.update(details) path = _Path_v1('logs') / 'network_parser_debug' / 'drission_stream_events.jsonl' path.parent.mkdir(parents=True, exist_ok=True) _listener_rotate_stream_debug_v1(path) with path.open('a', encoding='utf-8', newline='\n') as handle: handle.write(_json_v1.dumps(payload, ensure_ascii=False) + '\n') _listener_trim_stream_debug_dir_v1(path) except Exception: pass def _listener_stream_text_v1(packet, raw_data): if raw_data in (None, ''): return '' if isinstance(raw_data, (bytes, bytearray)): raw_bytes = bytes(raw_data) elif isinstance(raw_data, str): try: raw_bytes = b64decode(raw_data) except Exception: raw_bytes = raw_data.encode('utf-8', errors='ignore') else: raw_bytes = str(raw_data).encode('utf-8', errors='ignore') decoder = getattr(packet, '_stream_decoder', None) if decoder is None: decoder = _codecs_v1.getincrementaldecoder('utf-8')('ignore') packet._stream_decoder = decoder try: return decoder.decode(raw_bytes) except Exception: try: return raw_bytes.decode('utf-8', errors='ignore') except Exception: return '' def _listener_append_stream_v1(packet, raw_data, source='dataReceived'): text = _listener_stream_text_v1(packet, raw_data) if not text: return '' stream = _listener_stream_dict_v1(packet) stream['chunk_count'] = int(stream.get('chunk_count', 0) or 0) + 1 chunks = stream['chunks'] chunks.append({'data': text, 'source': source}) max_chunks = _listener_stream_int_v1( 'DRISSION_STREAM_CAPTURE_MAX_RECENT_CHUNKS', 32, 1, 1024, ) if len(chunks) > max_chunks: del chunks[:-max_chunks] # fullText is joined lazily; packet._raw_body is set once in finalize # (DataPacket.response caches the body at first access anyway). stream.append_text(text) packet._base64_body = False return text def _listener_emit_stream_packet_v1(listener, packet): if packet and not getattr(packet, '_stream_emitted', False): listener._caught.put(packet) packet._stream_emitted = True def _listener_request_will_be_sent_stream_v1(self, **kwargs): _orig_listener_request_will_be_sent_v1(self, **kwargs) request_id = kwargs.get('requestId') packet = self._request_ids.get(request_id, None) if packet is not None: # CDP event dictionaries can be reused by the driver; retain an immutable # request snapshot so later requests cannot rewrite an active packet. try: packet._raw_request = _copy_v1.deepcopy(packet._raw_request) except Exception: packet._raw_request = dict(packet._raw_request or {}) packet._stream_request_id = request_id def _listener_attach_stream_response_v1(listener, packet, request_id): driver = getattr(listener, '_driver', None) if not packet or getattr(packet, '_stream_enabled', False): return False if not driver or not getattr(driver, 'is_running', False): return False try: result = driver.run('Network.streamResourceContent', requestId=request_id) except Exception: return False packet._stream_enabled = True stream = _listener_stream_dict_v1(packet) buffered = result.get('bufferedData') if isinstance(result, dict) else None if buffered not in (None, ''): _listener_append_stream_v1(packet, buffered, 'bufferedData') stream['complete'] = False _listener_stream_debug_v1(packet, 'stream_attached', buffered_len=len(str(buffered or ''))) _listener_emit_stream_packet_v1(listener, packet) return True def _listener_bind_extra_info_v1(listener, request_id, packet): r = listener._extra_info_ids.get(request_id, None) if not r: return obj = r.get('obj', None) if obj is False: listener._extra_info_ids.pop(request_id, None) return if isinstance(obj, DataPacket): response = r.get('response', None) if response: obj._requestExtraInfo = r.get('request', None) obj._responseExtraInfo = response listener._extra_info_ids.pop(request_id, None) def _listener_finalize_stream_v1(listener, request_id, failed_kwargs=None): packet = listener._request_ids.get(request_id, None) if not packet or not getattr(packet, '_stream_enabled', False): return False if failed_kwargs: packet._raw_fail_info = failed_kwargs packet._resource_type = failed_kwargs.get('type') packet.is_failed = True decoder = getattr(packet, '_stream_decoder', None) if decoder is not None: try: tail = decoder.decode(b'', final=True) except Exception: tail = '' if tail: stream = _listener_stream_dict_v1(packet) _listener_append_stream_v1(packet, tail, 'decoder_tail') stream = _listener_stream_dict_v1(packet) packet._raw_body = stream.get('fullText', '') packet._base64_body = False stream['complete'] = True _listener_bind_extra_info_v1(listener, request_id, packet) listener._request_ids.pop(request_id, None) _listener_emit_stream_packet_v1(listener, packet) listener._running_targets -= 1 return True def _listener_set_callback_stream_v1(self): _orig_listener_set_callback_v1(self) self._driver.set_callback('Network.dataReceived', self._data_received) self._driver.set_callback('Network.eventSourceMessageReceived', self._event_source_message_received) def _listener_pause_stream_v1(self, clear=True): if self.listening: driver = getattr(self, '_driver', None) if driver is not None: for event_name in ( 'Network.requestWillBeSent', 'Network.requestWillBeSentExtraInfo', 'Network.responseReceived', 'Network.responseReceivedExtraInfo', 'Network.loadingFinished', 'Network.loadingFailed', 'Network.dataReceived', 'Network.eventSourceMessageReceived', ): try: driver.set_callback(event_name, None) except Exception: pass self.listening = False if clear: self.clear() def _listener_stop_stream_v1(self): if self.listening: try: _listener_pause_stream_v1(self) except Exception: self.listening = False try: self.clear() except Exception: pass driver = getattr(self, '_driver', None) if self._reuse_driver: if self._network_enabled and driver: try: driver.run('Network.disable') except Exception: pass self._network_enabled = False self._driver = None else: if driver: try: driver.stop() except Exception: pass self._driver = None def _listener_response_received_stream_v1(self, **kwargs): _orig_listener_response_received_v1(self, **kwargs) request_id = kwargs.get('requestId') packet = self._request_ids.get(request_id, None) if packet is not None: try: packet._raw_response = _copy_v1.deepcopy(packet._raw_response) except Exception: packet._raw_response = dict(packet._raw_response or {}) packet._stream_request_id = request_id _listener_attach_stream_response_v1(self, packet, request_id) def _listener_data_received_stream_v1(self, **kwargs): packet = self._request_ids.get(kwargs.get('requestId'), None) if not packet or not getattr(packet, '_stream_enabled', False): return data = kwargs.get('data') appended = _listener_append_stream_v1(packet, data, 'dataReceived') _listener_stream_debug_v1( packet, 'data_received', raw_data_len=len(str(data or '')), decoded_data_len=len(appended), data_length=kwargs.get('dataLength'), encoded_data_length=kwargs.get('encodedDataLength'), ) def _listener_event_source_message_received_stream_v1(self, **kwargs): packet = self._request_ids.get(kwargs.get('requestId'), None) if not packet or not getattr(packet, '_stream_enabled', False): return event_name = str(kwargs.get('eventName') or '').strip() data = kwargs.get('data') if data in (None, ''): return payload = f"event: {event_name}\ndata: {data}\n\n" if event_name else f"data: {data}\n\n" appended = _listener_append_stream_v1(packet, payload, 'eventSourceMessageReceived') _listener_stream_debug_v1( packet, 'event_source_message_received', event_name=event_name, raw_data_len=len(str(data)), decoded_data_len=len(appended), ) def _listener_loading_finished_stream_v1(self, **kwargs): request_id = kwargs.get('requestId') packet = self._request_ids.get(request_id, None) if packet and getattr(packet, '_stream_enabled', False): self._running_requests -= 1 _listener_stream_debug_v1(packet, 'loading_finished') if _listener_finalize_stream_v1(self, request_id): return _orig_listener_loading_finished_v1(self, **kwargs) def _listener_loading_failed_stream_v1(self, **kwargs): request_id = kwargs.get('requestId') packet = self._request_ids.get(request_id, None) if packet and getattr(packet, '_stream_enabled', False): self._running_requests -= 1 _listener_stream_debug_v1(packet, 'loading_failed', error_text=str(kwargs.get('errorText') or '')) if _listener_finalize_stream_v1(self, request_id, failed_kwargs=kwargs): return _orig_listener_loading_failed_v1(self, **kwargs) def _response_stream_property_v1(self): return getattr(self._data_packet, '_stream', None) DataPacket.__init__ = _data_packet_init_stream_v1 Listener._set_callback = _listener_set_callback_stream_v1 Listener.pause = _listener_pause_stream_v1 Listener.stop = _listener_stop_stream_v1 Listener._requestWillBeSent = _listener_request_will_be_sent_stream_v1 Listener._response_received = _listener_response_received_stream_v1 Listener._data_received = _listener_data_received_stream_v1 Listener._event_source_message_received = _listener_event_source_message_received_stream_v1 Listener._loading_finished = _listener_loading_finished_stream_v1 Listener._loading_failed = _listener_loading_failed_stream_v1 Response.stream = property(_response_stream_property_v1) Response._stream = property(_response_stream_property_v1) except Exception: pass """.lstrip("\n") def find_listener_file(): """定位 DrissionPage Listener 源码文件""" try: from DrissionPage._units.listener import Listener return Path(inspect.getfile(Listener)) except ImportError: print("❌ DrissionPage 未安装") return None def has_base_patch(content): """检查基础复用补丁是否存在""" return '_reuse_driver' in content and '_network_enabled' in content def has_recovery_patch(content): """检查恢复补丁是否存在""" return RECOVERY_GUARD_MARKER in content def has_stream_capture_patch(content): """检查流式抓包补丁是否存在且包含当前增量事件能力。""" if STREAM_CAPTURE_GUARD_MARKER not in content: return False # V1 只监听 Network.dataReceived。旧安装会因此漏掉部分 SSE 事件, # 而新版片段还必须带有终态/分块诊断,不能仅凭 marker 判定已更新。 return all( required in content for required in ( "Network.eventSourceMessageReceived", "def _listener_stream_debug_v1", "DRISSION_STREAM_DEBUG_ENABLED", "DRISSION_STREAM_CAPTURE_MAX_RECENT_CHUNKS", "class _ListenerStreamStateV1(dict)", "stream.append_text(text)", "_uwapi_stream_lock_v2", ) ) and "DRISSION_STREAM_CAPTURE_MAX_CHARS" not in content def check_already_patched(content): """检查是否已经打过完整补丁""" return ( has_base_patch(content) and has_recovery_patch(content) and has_stream_capture_patch(content) ) def ensure_recovery_patch(content): """确保 V2 恢复补丁存在""" if has_recovery_patch(content): return content, False if not content.endswith('\n'): content += '\n' return content + '\n' + RECOVERY_GUARD_SNIPPET, True def ensure_stream_capture_patch(content): """确保当前流式抓包补丁存在,升级时替换旧补丁而非重复包装。""" if has_stream_capture_patch(content): return content, False if ( STREAM_CAPTURE_GUARD_MARKER in content or LEGACY_STREAM_CAPTURE_GUARD_MARKER in content ): # 流捕获片段始终由本脚本追加在文件末尾。旧版本也使用 V1 marker, # 必须先裁掉旧片段;直接再追加会覆盖其全局原函数引用并产生递归。 markers = [ marker for marker in ( STREAM_CAPTURE_GUARD_MARKER, LEGACY_STREAM_CAPTURE_GUARD_MARKER, ) if marker in content ] first_marker = min(markers, key=content.index) content = content.split(first_marker, 1)[0].rstrip() if not content.endswith('\n'): content += '\n' return content + '\n' + STREAM_CAPTURE_SNIPPET, True def apply_patch(filepath): """应用补丁""" content = filepath.read_text(encoding='utf-8') if check_already_patched(content): print("✅ 已经打过补丁,无需重复操作") return True base_patched = has_base_patch(content) # 备份原文件 backup = filepath.with_suffix('.py.bak') if not backup.exists(): shutil.copy2(filepath, backup) print(f"📦 已备份原文件: {backup}") if not base_patched: # ===== 补丁 1:__init__ 添加标记 ===== old_init_end = ( "self._res_type = True" ) new_init_end = ( "self._res_type = True\n" "\n" " # 复用模式:使用 tab 主连接而非创建独立连接\n" " self._reuse_driver = False\n" " self._network_enabled = False" ) if old_init_end not in content: print("❌ 无法定位 __init__ 补丁点") return False content = content.replace(old_init_end, new_init_end, 1) # ===== 补丁 2:start() 支持复用 ===== old_start = ( " self._driver = Driver(self._target_id, self._address)\n" " self._driver.session_id = self._driver.run('Target.attachToTarget', targetId=self._target_id, flatten=True)['sessionId']\n" " self._driver.run('Network.enable')\n" "\n" " self._set_callback()\n" " self.listening = True" ) new_start = ( " if self._reuse_driver:\n" " self._driver = self._owner.driver\n" " if not self._network_enabled:\n" " self._driver.run('Network.enable')\n" " self._network_enabled = True\n" " else:\n" " self._driver = Driver(self._target_id, self._address)\n" " self._driver.session_id = self._driver.run('Target.attachToTarget', targetId=self._target_id, flatten=True)['sessionId']\n" " self._driver.run('Network.enable')\n" "\n" " self._set_callback()\n" " self.listening = True" ) if old_start not in content: print("❌ 无法定位 start() 补丁点") return False content = content.replace(old_start, new_start, 1) # ===== 补丁 3:stop() 复用模式不关闭连接 ===== old_stop = ( " def stop(self):\n" " if self.listening:\n" " self.pause()\n" " self.clear()\n" " self._driver.stop()\n" " self._driver = None" ) new_stop = ( " def stop(self):\n" " if self.listening:\n" " self.pause()\n" " self.clear()\n" "\n" " if self._reuse_driver:\n" " if self._network_enabled and self._driver:\n" " try:\n" " self._driver.run('Network.disable')\n" " except Exception:\n" " pass\n" " self._network_enabled = False\n" " self._driver = None\n" " else:\n" " if self._driver:\n" " self._driver.stop()\n" " self._driver = None" ) if old_stop not in content: print("❌ 无法定位 stop() 补丁点") return False content = content.replace(old_stop, new_stop, 1) # ===== 补丁 4:_to_target() 兼容复用模式 ===== old_to_target = ( " def _to_target(self, target_id, address, owner):\n" " self._target_id = target_id\n" " self._address = address\n" " self._owner = owner\n" " if self._driver:\n" " self._driver.stop()\n" " if self.listening:\n" " self._driver = Driver(self._target_id, self._address)\n" " self._driver.session_id = self._driver.run('Target.attachToTarget',\n" " targetId=target_id, flatten=True)['sessionId']\n" " self._driver.run('Network.enable')\n" " self._set_callback()" ) new_to_target = ( " def _to_target(self, target_id, address, owner):\n" " self._target_id = target_id\n" " self._address = address\n" " self._owner = owner\n" " if self._driver and not self._reuse_driver:\n" " self._driver.stop()\n" " if self.listening:\n" " if self._reuse_driver:\n" " if self._network_enabled and self._driver:\n" " try:\n" " self._driver.run('Network.disable')\n" " except Exception:\n" " pass\n" " self._driver = self._owner.driver\n" " if not self._network_enabled:\n" " self._driver.run('Network.enable')\n" " self._network_enabled = True\n" " else:\n" " self._driver = Driver(self._target_id, self._address)\n" " self._driver.session_id = self._driver.run('Target.attachToTarget',\n" " targetId=target_id, flatten=True)['sessionId']\n" " self._driver.run('Network.enable')\n" " self._set_callback()" ) if old_to_target not in content: print("⚠️ 无法定位 _to_target() 补丁点(非关键,跳过)") else: content = content.replace(old_to_target, new_to_target, 1) else: print("ℹ️ 检测到基础复用补丁已存在,跳过基础段") content, recovery_added = ensure_recovery_patch(content) if recovery_added: print("🩹 已追加监听恢复补丁 (V2)") content, stream_capture_added = ensure_stream_capture_patch(content) if stream_capture_added: print("🌊 已追加增量流捕获补丁 (V2)") try: compile(content, str(filepath), 'exec') except SyntaxError as exc: print(f"❌ 生成的补丁源码语法无效,已取消写入: {exc}") return False # 写入修改后的文件 filepath.write_text(content, encoding='utf-8') print(f"✅ 补丁已应用: {filepath}") print(f" 备份位置: {backup}") return True def restore(filepath): """恢复原文件""" backup = filepath.with_suffix('.py.bak') if backup.exists(): shutil.copy2(backup, filepath) print(f"✅ 已恢复原文件: {filepath}") return True else: print("❌ 未找到备份文件") return False def main(): import sys filepath = find_listener_file() if not filepath: return print(f"📍 Listener 源码: {filepath}") if len(sys.argv) > 1 and sys.argv[1] == '--restore': restore(filepath) return if apply_patch(filepath): print("\n🎉 补丁完成!") print(" 恢复命令: python patch_drissionpage.py --restore") else: print("\n❌ 补丁失败,请将以上输出发给开发者") if __name__ == '__main__': main()