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

973 lines
38 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.
# 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()