Initial commit
This commit is contained in:
commit
57fc3525eb
7311 files changed
+1291398
No files matched your search
@@ -0,0 +1,972 @@
|
||||
# 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()
|
||||
Reference in new issue
Block a user