claude/wonderful-brattain-d1cfe0 #4

Merged
zzz merged 16 commits from claude/wonderful-brattain-d1cfe0 into main 2026-05-21 09:58:35 +08:00
28 changed files with 580 additions and 6503 deletions

No files matched your search

+187
View File
@@ -0,0 +1,187 @@
"""文件 IO 与截图镜像辅助函数。
从 douyin/core/underlying_operations.py 顶部抽离的模块级函数,
为多个模块提供共用的安全文件替换和截图镜像能力。
外部 import 路径已通过 underlying_operations 重新导出,保持向后兼容。
"""
from __future__ import annotations
import logging
import os
import time as time_module
from typing import Optional
# 外部完整版 fudai 逻辑所在的工作树路径,用于镜像 screenshot 给那边使用。
# 仅在显式设置 EXTERNAL_DOUYIN_FUDAI_DIR 时启用。
_EXTERNAL_DOUYIN_FUDAI_DIR = os.environ.get("EXTERNAL_DOUYIN_FUDAI_DIR", "").strip()
_EXTERNAL_AXF_SCREENSHOT = (
os.path.join(_EXTERNAL_DOUYIN_FUDAI_DIR, "pic", "screenshot.png")
if _EXTERNAL_DOUYIN_FUDAI_DIR
else ""
)
def _verify_png_integrity(path: str) -> bool:
"""验证 PNG 文件头尾完整性,防止读取半写文件"""
try:
with open(path, "rb") as f:
header = f.read(8)
if len(header) < 8 or header[:4] != b"\x89PNG":
return False
f.seek(-12, 2) # IEND chunk 至少 12 字节
tail = f.read(12)
return b"IEND" in tail
except Exception:
return False
def _safe_replace_file(tmp_file: str, out_file: str, max_retries: int = 2) -> bool:
"""安全地替换文件,处理 Windows 文件锁定问题。
优先 os.replace 原子替换;失败时回退到 shutil.copy2,避免长时间等待。
对 PNG 文件会先校验完整性,避免发布半写文件。
Args:
tmp_file: 临时文件路径
out_file: 目标文件路径
max_retries: 最大重试次数(已优化为 2 次)
Returns:
True if successful, False otherwise
"""
import shutil
if not os.path.exists(tmp_file):
return False
# PNG 完整性校验
if tmp_file.lower().endswith(".png"):
if not _verify_png_integrity(tmp_file):
logging.debug("PNG 文件不完整,跳过替换: %s", tmp_file)
return False
# 方法 1:原子替换
try:
os.replace(tmp_file, out_file)
return True
except (OSError, PermissionError):
pass
# 方法 2:shutil.copy2(保留元数据)
try:
shutil.copy2(tmp_file, out_file)
try:
os.remove(tmp_file)
except Exception:
pass
return True
except Exception:
pass
# 方法 3:手动复制(最后手段)
try:
with open(tmp_file, "rb") as src, open(out_file, "wb") as dst:
while True:
chunk = src.read(1048576) # 1MB chunks
if not chunk:
break
dst.write(chunk)
try:
os.remove(tmp_file)
except Exception:
pass
return True
except Exception:
return False
def _ensure_parent_dir(path: str) -> None:
"""确保 path 的父目录存在。"""
try:
parent = os.path.dirname(path)
if parent:
os.makedirs(parent, exist_ok=True)
except Exception:
logging.exception("无法创建父目录: %s", path)
def _mirror_screenshot_to_external(src_file: str) -> None:
"""将当前项目下的 screenshot.png 同步一份到外部 axf 目录,便于完整版代码复用。
若外部目录/路径不存在或复制失败,会静默忽略,不影响主流程。
可通过环境变量 DISABLE_SCREENSHOT_MIRROR=1 禁用此功能以提升性能。
"""
if os.environ.get("DISABLE_SCREENSHOT_MIRROR", "0") == "1":
return
mirror_start = time_module.time()
try:
external_path = _EXTERNAL_AXF_SCREENSHOT
if not external_path:
return
external_dir = os.path.dirname(external_path)
if not external_dir:
return
external_base = os.environ.get("EXTERNAL_DOUYIN_FUDAI_DIR", "")
is_network_path = False
if external_base:
if external_base.startswith("\\\\") or external_base.startswith("//"):
is_network_path = True
logging.warning(
"[截图] 检测到网络路径,镜像可能较慢: %s", external_base
)
elif ":" in external_base and len(external_base) > 3:
logging.debug("[截图] 镜像目标路径: %s", external_path)
os.makedirs(external_dir, exist_ok=True)
if not os.path.exists(src_file):
return
tmp = external_path + ".tmp"
import shutil
copy_start = time_module.time()
shutil.copyfile(src_file, tmp)
copy_dur = (time_module.time() - copy_start) * 1000.0
if copy_dur > 50.0 or is_network_path:
logging.info(
"[截图] 镜像复制耗时(ms)=%.1f src=%s dst=%s (网络路径=%s)",
copy_dur,
src_file,
tmp,
is_network_path,
)
replace_start = time_module.time()
_safe_replace_file(tmp, external_path)
replace_dur = (time_module.time() - replace_start) * 1000.0
if replace_dur > 50.0 or is_network_path:
logging.info(
"[截图] 镜像文件替换耗时(ms)=%.1f (网络路径=%s)",
replace_dur,
is_network_path,
)
mirror_total_dur = (time_module.time() - mirror_start) * 1000.0
if mirror_total_dur > 100.0 or is_network_path:
logging.info(
"[截图] 镜像总耗时(ms)=%.1f path=%s (网络路径=%s)",
mirror_total_dur,
external_path,
is_network_path,
)
except Exception:
# 任何错误都不应该影响截图主流程
pass
__all__ = [
"_verify_png_integrity",
"_safe_replace_file",
"_ensure_parent_dir",
"_mirror_screenshot_to_external",
"_EXTERNAL_DOUYIN_FUDAI_DIR",
"_EXTERNAL_AXF_SCREENSHOT",
]
+8 -174
View File
@@ -40,183 +40,17 @@ except Exception:
_RESAMPLE = Image
# 外部完整版 fudai 逻辑所在的工作树路径,用于镜像 screenshot 给那边使用。
# 仅在显式设置 EXTERNAL_DOUYIN_FUDAI_DIR 时启用,避免绑定某台机器的旧路径。
_EXTERNAL_DOUYIN_FUDAI_DIR = os.environ.get("EXTERNAL_DOUYIN_FUDAI_DIR", "").strip()
_EXTERNAL_AXF_SCREENSHOT = (
os.path.join(_EXTERNAL_DOUYIN_FUDAI_DIR, "pic", "screenshot.png")
if _EXTERNAL_DOUYIN_FUDAI_DIR
else ""
# 这些常量与文件 IO 辅助函数已抽离到 io_utils.py,此处仅为向后兼容重新导出。
from douyin.core.io_utils import (
_EXTERNAL_DOUYIN_FUDAI_DIR,
_EXTERNAL_AXF_SCREENSHOT,
_verify_png_integrity,
_safe_replace_file,
_ensure_parent_dir,
_mirror_screenshot_to_external,
)
def _verify_png_integrity(path: str) -> bool:
"""验证 PNG 文件头尾完整性,防止读取半写文件"""
try:
with open(path, 'rb') as f:
header = f.read(8)
if len(header) < 8 or header[:4] != b'\x89PNG':
return False
f.seek(-12, 2) # IEND chunk 至少 12 字节
tail = f.read(12)
return b'IEND' in tail
except Exception:
return False
def _safe_replace_file(tmp_file: str, out_file: str, max_retries: int = 2) -> bool:
"""安全地替换文件,处理Windows文件锁定问题。
根本优化:优先使用直接复制而不是替换,避免文件锁定问题。
如果文件被占用,直接复制内容而不是等待释放。
对于 PNG 文件,会先验证完整性再替换。
Args:
tmp_file: 临时文件路径
out_file: 目标文件路径
max_retries: 最大重试次数(已优化为2次)
Returns:
True if successful, False otherwise
"""
import shutil
if not os.path.exists(tmp_file):
return False
# 对于 PNG 文件,先验证完整性
if tmp_file.lower().endswith('.png'):
if not _verify_png_integrity(tmp_file):
logging.debug("PNG 文件不完整,跳过替换: %s", tmp_file)
return False
# 根本优化:优先尝试原子替换(最快),如果失败则直接复制(避免等待)
try:
# 方法1: 直接使用 os.replace (原子操作,最快)
os.replace(tmp_file, out_file)
return True
except (OSError, PermissionError):
# 如果原子替换失败(文件被占用),直接使用复制方法(避免等待)
# 这样可以避免文件锁定导致的长时间等待
pass
# 方法2: 直接复制文件内容(避免文件锁定问题)
# 这是最可靠的方法,即使文件被占用也能成功
try:
# 使用 shutil.copy2 保留元数据,但速度更快
shutil.copy2(tmp_file, out_file)
# 复制成功后删除临时文件
try:
os.remove(tmp_file)
except Exception:
pass
return True
except Exception:
# 如果 shutil.copy2 也失败,使用手动复制(最后手段)
try:
with open(tmp_file, "rb") as src, open(out_file, "wb") as dst:
# 使用更大的块大小提高复制速度(1MB)
while True:
chunk = src.read(1048576) # 1MB chunks
if not chunk:
break
dst.write(chunk)
# 复制成功后删除临时文件
try:
os.remove(tmp_file)
except Exception:
pass
return True
except Exception:
return False
def _ensure_parent_dir(path: str) -> None:
"""Ensure the parent directory for `path` exists."""
try:
parent = os.path.dirname(path)
if parent:
os.makedirs(parent, exist_ok=True)
except Exception:
# 不应因目录创建失败阻塞主流程,记录以便排查
logging.exception("无法创建父目录: %s", path)
def _mirror_screenshot_to_external(src_file: str) -> None:
"""将当前项目下的 screenshot.png 同步一份到外部 axf 目录,便于完整版代码复用。
若外部目录/路径不存在或复制失败,会静默忽略,不影响主流程。
可通过环境变量 DISABLE_SCREENSHOT_MIRROR=1 禁用此功能以提升性能。
"""
# 检查环境变量:是否禁用镜像功能(用于性能测试)
if os.environ.get("DISABLE_SCREENSHOT_MIRROR", "0") == "1":
return
mirror_start = time_module.time()
try:
external_path = _EXTERNAL_AXF_SCREENSHOT
if not external_path:
return
external_dir = os.path.dirname(external_path)
if not external_dir:
return
# 检查外部路径是否是网络路径或可能较慢的路径
external_base = os.environ.get("EXTERNAL_DOUYIN_FUDAI_DIR", "")
is_network_path = False
if external_base:
# 检查是否是网络路径(UNC路径或网络驱动器)
if external_base.startswith("\\\\") or external_base.startswith("//"):
is_network_path = True
logging.warning(
"[截图] 检测到网络路径,镜像可能较慢: %s", external_base
)
# 检查是否是远程挂载点(简单启发式:包含常见网络挂载标识)
elif ":" in external_base and len(external_base) > 3:
# 可能是网络驱动器,但无法确定,记录路径供诊断
logging.debug("[截图] 镜像目标路径: %s", external_path)
os.makedirs(external_dir, exist_ok=True)
if not os.path.exists(src_file):
return
tmp = external_path + ".tmp"
import shutil
copy_start = time_module.time()
shutil.copyfile(src_file, tmp)
copy_dur = (time_module.time() - copy_start) * 1000.0
if copy_dur > 50.0 or is_network_path:
logging.info(
"[截图] 镜像复制耗时(ms)=%.1f src=%s dst=%s (网络路径=%s)",
copy_dur,
src_file,
tmp,
is_network_path,
)
replace_start = time_module.time()
_safe_replace_file(tmp, external_path)
replace_dur = (time_module.time() - replace_start) * 1000.0
if replace_dur > 50.0 or is_network_path:
logging.info(
"[截图] 镜像文件替换耗时(ms)=%.1f (网络路径=%s)",
replace_dur,
is_network_path,
)
mirror_total_dur = (time_module.time() - mirror_start) * 1000.0
if mirror_total_dur > 100.0 or is_network_path:
logging.info(
"[截图] 镜像总耗时(ms)=%.1f path=%s (网络路径=%s)",
mirror_total_dur,
external_path,
is_network_path,
)
except Exception:
# 任何错误都不应该影响截图主流程
pass
class underlying_operations:
"""底层操作类"""
@@ -14,7 +14,7 @@ import time
from PIL import Image
from douyin.fudai.douyin_fudai_core import get_fudai_contain
from .fudai_detail_validator import validate_fudai_detail
from douyin.fudai.core.fudai_detail_validator import validate_fudai_detail
def read_fudai_detail_once(analyser: Any) -> Tuple[str, Tuple, dict]:
File diff suppressed because it is too large. Load diff
+23
View File
@@ -5,10 +5,33 @@
from __future__ import annotations
import re
import time
from typing import Any, Tuple
def _is_short_countdown_text(time_text: str) -> bool:
"""检查倒计时文本是否表示剩余时间很短(应跳过)"""
if not time_text:
return False
time_text = time_text.strip()
# 匹配 00:00, 00:01, 00:02 等,表示剩余时间 <= 2秒
if re.match(r"^00:0[0-2]$", time_text):
return True
# 匹配 0:00, 0:01, 0:02 等(有时没有前导零)
if re.match(r"^0:0[0-2]$", time_text):
return True
# 匹配 "00秒", "01秒", "02秒" 等
if re.match(r"^0[0-2]秒$", time_text):
return True
return False
def check_contain(analyser, contains: str = "") -> bool:
"""检查福袋内容是否命中"黑名单"关键词(只保留黑名单逻辑,不再使用白名单)。
File diff suppressed because it is too large. Load diff
+6 -6
View File
@@ -16,29 +16,29 @@ Exports:
"""
# 从各子模块导入所有公共API
from fudai_detail_modules.fudai_detail_operations import (
from douyin.fudai.core.fudai_detail_operations import (
close_fudai_detail,
ensure_fudai_detail_open,
)
from fudai_detail_modules.fudai_detail_room_title import (
from douyin.fudai.core.fudai_detail_room_title import (
read_live_room_title_core,
)
from fudai_detail_modules.fudai_detail_reader import (
from douyin.fudai.core.fudai_detail_orchestrator import (
read_fudai_detail_once,
read_fudai_detail_with_retries,
)
from fudai_detail_modules.fudai_detail_validator import (
from douyin.fudai.core.fudai_detail_validator import (
validate_fudai_detail,
)
from fudai_detail_modules.fudai_detail_utils import (
from douyin.fudai.core.fudai_detail_utils import (
is_abnormal_time_value,
)
from fudai_detail_modules.fudai_detail_coupon_detection import (
from douyin.fudai.core.fudai_detail_coupon_detection import (
is_wrong_coupon_popup,
)
+1 -1
View File
@@ -14,7 +14,7 @@ from __future__ import annotations
import time
import subprocess
from typing import Any
from douyin.logging.action_tracker import track_action
from douyin.logging.action_logger import track_action
from douyin.handlers import douyin_swipe_ops
+4 -10
View File
@@ -25,17 +25,11 @@ from .log_formatter import (
# 性能追踪模块
from .performance_tracker import PerformanceTracker
# 错误日志模块
from .error_logger import ErrorLogger
# 错误与调试日志(合并到 internal_loggers)
from .internal_loggers import ErrorLogger, DebugLogger, _get_debug_logger
# 调试日志模块
from .debug_logger import DebugLogger, _get_debug_logger
# 行为日志模块
from .action_logger import ActionLogger
# 操作追踪装饰器
from .action_tracker import track_action
# 行为日志模块(含 track_action 装饰器)
from .action_logger import ActionLogger, track_action
# 日志包装器
from .douyin_logging_wrapper import LoggingWrapper
+34 -1
View File
@@ -107,4 +107,37 @@ class ActionLogger:
def log_step(self, name: str, elapsed: Optional[float] = None) -> None:
self.log_operation("Step", name, elapsed=elapsed)
__all__ = ["ActionLogger"]
# ============================================================
# track_action 装饰器(合并自 action_tracker.py)
# ============================================================
from functools import wraps as _wraps # noqa: E402
_action_logger_singleton = ActionLogger()
def track_action(name: str = ""):
"""函数装饰器:自动记录函数耗时与操作信息。"""
def decorator(func):
@_wraps(func)
def wrapper(*args, **kwargs):
timer = _perf.start_timer(name or func.__name__)
t0 = time.time()
try:
return func(*args, **kwargs)
finally:
elapsed = _perf.end_timer(timer)
if elapsed is None:
elapsed = time.time() - t0
_action_logger_singleton.log_step(
name or func.__name__, elapsed=elapsed
)
return wrapper
return decorator
__all__ = ["ActionLogger", "track_action"]
-28
View File
@@ -1,28 +0,0 @@
"""操作追踪装饰器:自动记录函数耗时与操作信息"""
from __future__ import annotations
import time
from functools import wraps
from .performance_tracker import PerformanceTracker
from .action_logger import ActionLogger
_perf = PerformanceTracker()
_logger = ActionLogger()
def track_action(name: str = ""):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
timer = _perf.start_timer(name or func.__name__)
t0 = time.time()
try:
result = func(*args, **kwargs)
return result
finally:
elapsed = _perf.end_timer(timer)
elapsed = elapsed if elapsed is not None else time.time() - t0
_logger.log_step(name or func.__name__, elapsed=elapsed)
return wrapper
return decorator
__all__ = ["track_action"]
-98
View File
@@ -1,98 +0,0 @@
"""调试日志记录器:在运行时输出详细信息,遇到错误时调用错误日志记录器。"""
from __future__ import annotations
import time
import traceback
import logging
import os
from typing import Any, Dict, Optional
import threading
from .log_formatter import format_debug_log
from .performance_tracker import PerformanceTracker
from .error_logger import ErrorLogger
_perf = PerformanceTracker()
_err = ErrorLogger()
# 初始化文件日志记录器
_debug_logger = logging.getLogger("debug_logger")
if not _debug_logger.handlers:
_debug_logger.setLevel(logging.DEBUG)
# 添加控制台处理器
_console_handler = logging.StreamHandler()
_debug_logger.addHandler(_console_handler)
# 添加文件处理器,写入到 debug.log
try:
# 获取日志目录
log_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "logs")
os.makedirs(log_dir, exist_ok=True)
debug_log_path = os.path.join(log_dir, "debug.log")
# 创建轮转文件处理器
from logging.handlers import RotatingFileHandler
_file_handler = RotatingFileHandler(
debug_log_path,
maxBytes=10*1024*1024, # 10MB
backupCount=5,
encoding='utf-8'
)
_file_handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
_debug_logger.addHandler(_file_handler)
except Exception:
# 如果文件处理器创建失败,至少保留控制台输出
pass
class DebugLogger:
def __init__(self, enabled: bool = True) -> None:
self.enabled = enabled
def log_function_entry(self, func_name: str, *args: Any, **kwargs: Any) -> None:
if not self.enabled:
return
params = {"args": args, "kwargs": kwargs}
line = format_debug_log(f"FunctionEntry: {func_name}", level="DEBUG", **params)
_debug_logger.debug(line)
def log_function_exit(self, func_name: str, retval: Any, elapsed: float) -> None:
if not self.enabled:
return
line = format_debug_log(f"FunctionExit: {func_name}", level="DEBUG", elapsed_seconds=elapsed, return_value=retval)
_debug_logger.debug(line)
def log_variable(self, name: str, value: Any) -> None:
if not self.enabled:
return
line = format_debug_log(f"VariableSnapshot: {name}=", level="DEBUG", value=value)
_debug_logger.debug(line)
def log_call_stack(self) -> None:
if not self.enabled:
return
stack = traceback.format_stack()
line = format_debug_log("CallStack", level="DEBUG", stack="".join(stack))
_debug_logger.debug(line)
def log_exception(self, exc: BaseException, context: Optional[Dict[str, Any]] = None) -> None:
if not self.enabled:
return
tb = traceback.format_exc()
line = format_debug_log("Exception", level="ERROR", exception=type(exc).__name__, traceback=tb, context=context or {})
_debug_logger.error(line)
_err.log_exception(exc, context=context)
def log_step(self, name: str, start_time: float, end_time: Optional[float] = None) -> None:
if not self.enabled:
return
t = (end_time if end_time is not None else time.time()) - start_time
line = format_debug_log("StepTiming", level="DEBUG", step=name, elapsed_seconds=t)
_debug_logger.debug(line)
_perf.get_elapsed(name) # update internal stats if used
def _get_debug_logger() -> DebugLogger:
return DebugLogger(True)
__all__ = ["DebugLogger", "_get_debug_logger"]
-297
View File
@@ -1,297 +0,0 @@
"""
增强的日志系统配置模块
====================
功能:
1. 标准 Python logging 模块集成
2. 日志级别管理(DEBUG, INFO, WARNING, ERROR, CRITICAL)
3. 日志轮转(按大小和时间)
4. 清晰的日志格式(时间戳、级别、模块、函数、行号)
5. 异常堆栈完整记录
6. 根据环境动态调整日志级别
"""
from __future__ import annotations
import logging
import logging.handlers
import os
import sys
import json
from typing import Optional, Dict, Any
from douyin.core import path_config
# 日志配置默认值
DEFAULT_LOG_LEVEL = "INFO"
DEFAULT_LOG_FILE = "logs/unified.log"
DEFAULT_MAX_BYTES = 10 * 1024 * 1024 # 10MB
DEFAULT_BACKUP_COUNT = 5
DEFAULT_WHEN = "midnight" # 每天午夜轮转
DEFAULT_INTERVAL = 1 # 每1天轮转一次
def get_log_config() -> Dict[str, Any]:
"""从 config.json 读取日志配置"""
try:
config_path = path_config.get_config_path()
if os.path.exists(config_path):
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
return config.get("logging", {})
except Exception:
pass
return {}
def get_log_level() -> str:
"""获取日志级别(从配置或环境变量)"""
# 优先检查环境变量(开发调试时使用)
env_level = os.environ.get("DOUYIN_LOG_LEVEL", "").upper()
if env_level in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"):
return env_level
# 从配置文件读取
log_config = get_log_config()
level = log_config.get("level", DEFAULT_LOG_LEVEL).upper()
if level in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"):
return level
return DEFAULT_LOG_LEVEL
def get_log_file_path() -> str:
"""获取日志文件路径"""
log_config = get_log_config()
path = log_config.get("file_path", DEFAULT_LOG_FILE)
if not os.path.isabs(path):
path = os.path.join(path_config.PROJECT_ROOT, path)
return path
def get_rotation_config() -> Dict[str, Any]:
"""获取日志轮转配置"""
log_config = get_log_config()
rotation = log_config.get("rotation", {})
return {
"enabled": rotation.get("enabled", True),
"max_bytes": rotation.get("max_bytes", DEFAULT_MAX_BYTES),
"backup_count": rotation.get("backup_count", DEFAULT_BACKUP_COUNT),
"when": rotation.get("when", DEFAULT_WHEN),
"interval": rotation.get("interval", DEFAULT_INTERVAL),
}
def setup_logging(
logger_name: str = "douyin",
log_file: Optional[str] = None,
log_level: Optional[str] = None,
enable_console: bool = True,
enable_file: bool = True,
) -> logging.Logger:
"""
配置并返回一个增强的 logger 实例
参数:
logger_name: logger 名称
log_file: 日志文件路径(None 则从配置读取)
log_level: 日志级别(None 则从配置读取)
enable_console: 是否启用控制台输出
enable_file: 是否启用文件输出
返回:
配置好的 logger 实例
"""
logger = logging.getLogger(logger_name)
# 避免重复配置
if logger.handlers:
return logger
# 设置日志级别
if log_level is None:
log_level = get_log_level()
level = getattr(logging, log_level.upper(), logging.INFO)
logger.setLevel(level)
# 日志格式:时间戳 - [级别] - 模块名:函数名:行号 - 消息
detailed_format = (
"%(asctime)s - [%(levelname)s] - %(name)s:%(funcName)s:%(lineno)d - %(message)s"
)
formatter = logging.Formatter(detailed_format, datefmt="%Y-%m-%d %H:%M:%S")
# 控制台处理器
if enable_console:
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(level)
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
# 文件处理器(带轮转)
if enable_file:
if log_file is None:
log_file = get_log_file_path()
# 确保日志目录存在
log_dir = os.path.dirname(log_file)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
rotation_config = get_rotation_config()
if rotation_config.get("enabled", True):
# 使用 TimedRotatingFileHandler(按时间轮转)
try:
file_handler = logging.handlers.TimedRotatingFileHandler(
log_file,
when=rotation_config.get("when", DEFAULT_WHEN),
interval=rotation_config.get("interval", DEFAULT_INTERVAL),
backupCount=rotation_config.get(
"backup_count", DEFAULT_BACKUP_COUNT
),
encoding="utf-8-sig", # 使用 BOM 避免 Windows 乱码
errors="replace",
)
except Exception:
# 如果时间轮转失败,回退到大小轮转
try:
file_handler = logging.handlers.RotatingFileHandler(
log_file,
maxBytes=rotation_config.get("max_bytes", DEFAULT_MAX_BYTES),
backupCount=rotation_config.get(
"backup_count", DEFAULT_BACKUP_COUNT
),
encoding="utf-8-sig",
errors="replace",
)
except Exception:
# 如果都失败,使用普通 FileHandler
file_handler = logging.FileHandler(
log_file,
encoding="utf-8-sig",
errors="replace",
)
else:
# 不使用轮转,直接使用 FileHandler
file_handler = logging.FileHandler(
log_file,
encoding="utf-8-sig",
errors="replace",
)
file_handler.setLevel(level)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logger
def get_logger(name: str = "douyin") -> logging.Logger:
"""获取或创建 logger 实例(单例模式)"""
logger = logging.getLogger(name)
if not logger.handlers:
# 如果还没有配置,进行初始化
setup_logging(name)
return logger
class LogContext:
"""日志上下文管理器,用于记录函数调用、参数、返回值、耗时等"""
def __init__(
self,
logger: logging.Logger,
func_name: str,
level: int = logging.DEBUG,
log_args: bool = True,
log_result: bool = True,
log_duration: bool = True,
):
self.logger = logger
self.func_name = func_name
self.level = level
self.log_args = log_args
self.log_result = log_result
self.log_duration = log_duration
self.start_time: Optional[float] = None
self.args: tuple = ()
self.kwargs: dict = {}
def __enter__(self):
import time
self.start_time = time.time()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
import time
duration = time.time() - self.start_time if self.start_time else 0
# 记录函数调用信息
if self.log_args and (self.args or self.kwargs):
args_str = ", ".join([repr(a) for a in self.args])
kwargs_str = ", ".join([f"{k}={repr(v)}" for k, v in self.kwargs.items()])
params_str = ", ".join(filter(None, [args_str, kwargs_str]))
self.logger.log(self.level, f"[函数调用] {self.func_name}({params_str})")
# 记录异常
if exc_type is not None:
self.logger.exception(
f"[函数异常] {self.func_name} 发生异常: {exc_type.__name__}",
exc_info=(exc_type, exc_val, exc_tb),
)
# 记录耗时
elif self.log_duration:
self.logger.log(
self.level, f"[函数完成] {self.func_name} 耗时: {duration:.3f}秒"
)
return False # 不抑制异常
def log_function_call(
logger: logging.Logger,
func_name: str,
args: tuple = (),
kwargs: Optional[dict] = None,
result: Any = None,
duration: Optional[float] = None,
level: int = logging.DEBUG,
):
"""记录函数调用的详细信息"""
if kwargs is None:
kwargs = {}
parts = [f"[函数调用] {func_name}"]
# 参数
if args or kwargs:
args_str = ", ".join([repr(a) for a in args])
kwargs_str = ", ".join([f"{k}={repr(v)}" for k, v in kwargs.items()])
params_str = ", ".join(filter(None, [args_str, kwargs_str]))
parts.append(f"参数: {params_str}")
# 返回值
if result is not None:
parts.append(f"返回值: {repr(result)}")
# 耗时
if duration is not None:
parts.append(f"耗时: {duration:.3f}秒")
logger.log(level, " | ".join(parts))
# 全局 logger 实例(延迟初始化)
_global_logger: Optional[logging.Logger] = None
def get_global_logger() -> logging.Logger:
"""获取全局 logger 实例"""
global _global_logger
if _global_logger is None:
_global_logger = setup_logging("douyin")
return _global_logger
+3 -4
View File
@@ -51,8 +51,7 @@ except ImportError:
# 导入所有日志模块
try:
from .error_logger import ErrorLogger # type: ignore[assignment]
from .debug_logger import DebugLogger # type: ignore[assignment]
from .internal_loggers import ErrorLogger, DebugLogger # type: ignore[assignment]
from .action_logger import ActionLogger # type: ignore[assignment]
from .performance_tracker import PerformanceTracker # type: ignore[assignment]
@@ -1017,9 +1016,9 @@ class LoggingWrapper:
analyser._std_logger = get_unified_logger("douyin.fudai")
except ImportError:
try:
from douyin.logging import douyin_logger
from douyin.logging import douyin_logging
analyser._std_logger = douyin_logger.get_logger("douyin")
analyser._std_logger = douyin_logging.get_logger("douyin")
except Exception:
analyser._std_logger = logging.getLogger("douyin.fudai")
-62
View File
@@ -1,62 +0,0 @@
"""错误日志记录模块:记录详细错误、上下文与推荐恢复建议"""
from __future__ import annotations
import logging
import traceback
import os
from typing import Any, Dict, Optional
from douyin.core import path_config
logger = None
def _init_logger():
global logger
if logger is not None:
return
log_path = path_config.get_error_log_path() if hasattr(path_config, "get_error_log_path") else os.path.join(path_config.get_logs_dir(), "error.log")
os.makedirs(os.path.dirname(log_path), exist_ok=True)
import logging.handlers
logger = logging.getLogger("error_logger")
if not logger.handlers:
handler = logging.handlers.RotatingFileHandler(log_path, maxBytes=5*1024*1024, backupCount=5, encoding="utf-8")
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
class ErrorLogger:
def __init__(self) -> None:
_init_logger()
def log_exception(self, exc: BaseException, context: Optional[Dict[str, Any]] = None, level: str = "ERROR") -> None:
if not logger:
_init_logger()
if logger is None:
# 如果仍然无法初始化 logger,则退回到标准输出,避免抛出异常
print(f"[ErrorLogger] {type(exc).__name__}: {exc}")
return
tb = traceback.format_exc()
ctx = ", ".join(f"{k}={v}" for k, v in (context or {}).items()) if context else ""
msg = f"Exception: {type(exc).__name__}: {exc}"
if ctx:
msg += f" | context: {ctx}"
if tb:
msg += f"\nTraceback:\n{tb}"
logger.log(getattr(logging, level, logging.ERROR), msg)
def log_error(self, msg: str, context: Optional[Dict[str, Any]] = None, level: str = "ERROR") -> None:
if not logger:
_init_logger()
if logger is None:
print(f"[ErrorLogger] {msg}")
return
full = msg
if context:
full += " | " + ", ".join(f"{k}={v}" for k, v in context.items())
logger.log(getattr(logging, level, logging.ERROR), full)
def log_warning(self, msg: str, context: Optional[Dict[str, Any]] = None) -> None:
self.log_error(msg, context=context, level="WARNING")
def capture_error_context(self, **ctx) -> Dict[str, Any]:
return dict(ctx)
def log_error_with_context(self, exc: BaseException, context: Optional[Dict[str, Any]] = None, level: str = "ERROR") -> None:
self.log_exception(exc, context=context, level=level)
__all__ = ["ErrorLogger"]
+228
View File
@@ -0,0 +1,228 @@
"""内部日志器:DebugLogger 和 ErrorLogger 合并到同一个文件。
这两个类只被 douyin_logging_wrapper 内部使用,外部不应直接引用。
为减少模块数量,合并为单文件。
"""
from __future__ import annotations
import logging
import logging.handlers
import os
import time
import traceback
from typing import Any, Dict, Optional
from douyin.core import path_config
from .log_formatter import format_debug_log
from .performance_tracker import PerformanceTracker
# ============================================================
# ErrorLogger
# ============================================================
_error_module_logger: Optional[logging.Logger] = None
def _init_error_logger() -> None:
"""惰性初始化错误日志器,写入 logs/error.log"""
global _error_module_logger
if _error_module_logger is not None:
return
log_path = (
path_config.get_error_log_path()
if hasattr(path_config, "get_error_log_path")
else os.path.join(path_config.get_logs_dir(), "error.log")
)
os.makedirs(os.path.dirname(log_path), exist_ok=True)
_error_module_logger = logging.getLogger("error_logger")
if not _error_module_logger.handlers:
handler = logging.handlers.RotatingFileHandler(
log_path, maxBytes=5 * 1024 * 1024, backupCount=5, encoding="utf-8"
)
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
_error_module_logger.addHandler(handler)
_error_module_logger.setLevel(logging.INFO)
class ErrorLogger:
def __init__(self) -> None:
_init_error_logger()
def log_exception(
self,
exc: BaseException,
context: Optional[Dict[str, Any]] = None,
level: str = "ERROR",
) -> None:
if not _error_module_logger:
_init_error_logger()
if _error_module_logger is None:
print(f"[ErrorLogger] {type(exc).__name__}: {exc}")
return
tb = traceback.format_exc()
ctx = (
", ".join(f"{k}={v}" for k, v in (context or {}).items())
if context
else ""
)
msg = f"Exception: {type(exc).__name__}: {exc}"
if ctx:
msg += f" | context: {ctx}"
if tb:
msg += f"\nTraceback:\n{tb}"
_error_module_logger.log(getattr(logging, level, logging.ERROR), msg)
def log_error(
self,
msg: str,
context: Optional[Dict[str, Any]] = None,
level: str = "ERROR",
) -> None:
if not _error_module_logger:
_init_error_logger()
if _error_module_logger is None:
print(f"[ErrorLogger] {msg}")
return
full = msg
if context:
full += " | " + ", ".join(f"{k}={v}" for k, v in context.items())
_error_module_logger.log(getattr(logging, level, logging.ERROR), full)
def log_warning(
self, msg: str, context: Optional[Dict[str, Any]] = None
) -> None:
self.log_error(msg, context=context, level="WARNING")
def capture_error_context(self, **ctx) -> Dict[str, Any]:
return dict(ctx)
def log_error_with_context(
self,
exc: BaseException,
context: Optional[Dict[str, Any]] = None,
level: str = "ERROR",
) -> None:
self.log_exception(exc, context=context, level=level)
# ============================================================
# DebugLogger
# ============================================================
_debug_module_logger = logging.getLogger("debug_logger")
if not _debug_module_logger.handlers:
_debug_module_logger.setLevel(logging.DEBUG)
_debug_module_logger.addHandler(logging.StreamHandler())
try:
log_dir = os.path.join(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
),
"logs",
)
os.makedirs(log_dir, exist_ok=True)
_debug_log_path = os.path.join(log_dir, "debug.log")
_file_handler = logging.handlers.RotatingFileHandler(
_debug_log_path,
maxBytes=10 * 1024 * 1024,
backupCount=5,
encoding="utf-8",
)
_file_handler.setFormatter(logging.Formatter("%(asctime)s - %(message)s"))
_debug_module_logger.addHandler(_file_handler)
except Exception:
# 文件处理器创建失败时退回到控制台输出
pass
_perf = PerformanceTracker()
_err = ErrorLogger()
class DebugLogger:
def __init__(self, enabled: bool = True) -> None:
self.enabled = enabled
def log_function_entry(
self, func_name: str, *args: Any, **kwargs: Any
) -> None:
if not self.enabled:
return
line = format_debug_log(
f"FunctionEntry: {func_name}",
level="DEBUG",
args=args,
kwargs=kwargs,
)
_debug_module_logger.debug(line)
def log_function_exit(
self, func_name: str, retval: Any, elapsed: float
) -> None:
if not self.enabled:
return
line = format_debug_log(
f"FunctionExit: {func_name}",
level="DEBUG",
elapsed_seconds=elapsed,
return_value=retval,
)
_debug_module_logger.debug(line)
def log_variable(self, name: str, value: Any) -> None:
if not self.enabled:
return
line = format_debug_log(
f"VariableSnapshot: {name}=", level="DEBUG", value=value
)
_debug_module_logger.debug(line)
def log_call_stack(self) -> None:
if not self.enabled:
return
stack = traceback.format_stack()
line = format_debug_log(
"CallStack", level="DEBUG", stack="".join(stack)
)
_debug_module_logger.debug(line)
def log_exception(
self, exc: BaseException, context: Optional[Dict[str, Any]] = None
) -> None:
if not self.enabled:
return
tb = traceback.format_exc()
line = format_debug_log(
"Exception",
level="ERROR",
exception=type(exc).__name__,
traceback=tb,
context=context or {},
)
_debug_module_logger.error(line)
_err.log_exception(exc, context=context)
def log_step(
self,
name: str,
start_time: float,
end_time: Optional[float] = None,
) -> None:
if not self.enabled:
return
t = (end_time if end_time is not None else time.time()) - start_time
line = format_debug_log(
"StepTiming", level="DEBUG", step=name, elapsed_seconds=t
)
_debug_module_logger.debug(line)
_perf.get_elapsed(name)
def _get_debug_logger() -> DebugLogger:
return DebugLogger(True)
__all__ = ["ErrorLogger", "DebugLogger", "_get_debug_logger"]
-1
View File
@@ -3,7 +3,6 @@
集中化以前散落在多个文件的重复实现:
- douyin/fudai/douyin_fudai_core.py: _parse_mm_ss
- douyin/fudai/core/fudai_detail_reader.py: _parse_mm_ss
- fudai_detail_modules/fudai_detail_reader.py: _parse_mm_ss
注意:normalize_countdown_text 仍在 douyin/utils/douyin_utils.py 中,
那里逻辑更复杂(包含 OCR 字符纠正等),不在此处重复。
-47
View File
@@ -1,47 +0,0 @@
# 福袋详情模块目录
本目录包含 `douyin_fudai_detail.py` 的模块化子模块。
## 文件结构
- `fudai_detail_room_title.py` - 直播间标题处理模块
- `fudai_detail_operations.py` - 福袋详情页操作模块(打开/关闭)
- `fudai_detail_coupon_detection.py` - 优惠券弹窗检测模块
- `fudai_detail_reader.py` - 福袋详情读取模块
- `fudai_detail_validator.py` - 数据验证模块
- `fudai_detail_utils.py` - 工具函数模块
- `__init__.py` - 包初始化文件
## 使用方式
所有功能通过主模块 `douyin_fudai_detail` 导出,使用方式保持不变:
```python
import douyin_fudai_detail
# 使用导出的函数
douyin_fudai_detail.close_fudai_detail(analyser)
douyin_fudai_detail.read_fudai_detail_once(analyser)
# ... 等等
```
## 模块说明
### fudai_detail_room_title.py
处理直播间标题的OCR识别、噪音过滤、规范化等功能。
### fudai_detail_operations.py
处理福袋详情页的打开和关闭操作。
### fudai_detail_coupon_detection.py
检测当前弹窗是否为优惠券弹窗,而非真正的福袋详情页。
### fudai_detail_reader.py
执行福袋详情的OCR识别和读取,包括单次读取和重试读取。
### fudai_detail_validator.py
验证福袋详情数据的合理性,检测识别错误。
### fudai_detail_utils.py
提供通用的工具函数。
-8
View File
@@ -1,8 +0,0 @@
"""
福袋详情模块包
==============
包含所有福袋详情相关的子模块。
"""
__all__ = []
+7 -60
View File
@@ -60,70 +60,17 @@ warnings.filterwarnings("ignore", message=".*accelerator.*", category=UserWarnin
def format_gui_log_line(line: str) -> str:
"""
将完整日志行转换为GUI显示用的精简版本。
"""将完整日志行转换为 GUI 显示用的精简版本。
使用新的日志格式化模块进行美化和格式化处理。
实际实现位于 gui.components.log_viewer,此处仅作 re-export,
失败时回退到原始字符串。
"""
try:
# 尝试使用新的日志格式化模块
from gui.components.log_viewer import format_gui_log_line as enhanced_formatter
from gui.components.log_viewer import format_gui_log_line as _impl
return enhanced_formatter(line)
except ImportError:
# 如果新模块不可用,回退到原来的实现
pass
# 回退到原来的精简规则(兼容统一日志格式)
s = (line or "").rstrip("\n")
if not s:
return s
ts_part: str | None = None
msg_part: str | None = None
# 1)新统一日志格式:[YYYY-MM-DD HH:MM:SS.xxx] [LEVEL] ... 业务内容 字段_xxx=...
m = re.match(r"^\[(\d{4}-\d{2}-\d{2} [0-9:.]+)\]\s+\[[A-Z]+\]\s+(.*)$", s)
if m:
ts_part = m.group(1).strip()
msg_part = m.group(2).strip()
# 2)旧统一日志格式:YYYY-MM-DD HH:MM:SS.xxx - [LEVEL] - ... - 业务内容
elif s[0].isdigit() and " - " in s:
parts = s.split(" - ")
if len(parts) >= 3:
ts_part = parts[0].strip()
msg_part = parts[-1].strip()
# 如果没解析出时间戳和消息,返回原字符串
if not ts_part or msg_part is None:
return s
# 从业务文案中拆分出字段_xxx=yyy,非score类字段在GUI中隐藏
keep_tokens: list[str] = []
def _is_score_field(k: str) -> bool:
kl = k.lower()
return (
"score" in kl or "match" in kl or "匹配" in k or "相似" in k or "耗时" in k
)
# 解析字段
words = msg_part.split()
clean_words = []
for word in words:
if "=" in word:
k, v = word.split("=", 1)
if _is_score_field(k):
keep_tokens.append(word)
# else: 其他字段在GUI中隐藏
else:
clean_words.append(word)
clean_msg = " ".join(clean_words)
if keep_tokens:
clean_msg = f"{clean_msg} ({', '.join(keep_tokens)})"
return f"{ts_part} {clean_msg}"
return _impl(line)
except Exception:
return (line or "").rstrip("\n")
def main():
-16
View File
@@ -1,16 +0,0 @@
"""设备操作模块
包含ADB设备操作,如点击、滑动、输入等。
"""
from __future__ import annotations
from typing import Any, Optional
# 临时导入:从原文件导入,后续会逐步迁移
# TODO: 迁移完成后,移除此导入并在此文件中实现
from douyin.core.underlying_operations import underlying_operations
# 导出设备操作相关方法
# TODO: 实现这些函数后添加到__all__列表中
__all__ = []
-16
View File
@@ -1,16 +0,0 @@
"""图像处理操作模块
包含图像裁剪、处理等操作。
"""
from __future__ import annotations
from typing import Any, Optional, Tuple
# 临时导入:从原文件导入,后续会逐步迁移
# TODO: 迁移完成后,移除此导入并在此文件中实现
from douyin.core.underlying_operations import underlying_operations
# 导出图像处理相关方法
# TODO: 实现这些函数后添加到__all__列表中
__all__ = []
-134
View File
@@ -1,134 +0,0 @@
"""简化版后台截图服务,避免文件中重复定义导致的 linter 错误。"""
from __future__ import annotations
import os
import threading
import time
from typing import Optional
from datetime import datetime
from douyin.core import path_config
from operations.screenshot_operations import ScreenshotOperations
class ScreenshotService:
"""后台截图服务(简化实现)。"""
_instance: Optional["ScreenshotService"] = None
_lock = threading.Lock()
def __init__(self):
self._running = False
self._thread: Optional[threading.Thread] = None
self._screenshot_ops = ScreenshotOperations()
self._current_device_id: Optional[str] = None
self._last_screenshot_time = time.time() - 10.0
self._screenshot_interval = 3.5
self._cache_valid_duration = 4.0
self._screenshot_path: Optional[str] = None
self._last_success = False
@classmethod
def get_instance(cls) -> "ScreenshotService":
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = cls()
assert cls._instance is not None
return cls._instance
def start(self, device_id: str, interval: float = 1.5):
with self._lock:
if self._running and self._current_device_id == device_id:
return
if self._running:
self.stop()
self._current_device_id = device_id
self._screenshot_interval = max(0.5, interval)
self._running = True
try:
self._screenshot_path = path_config.get_screenshot_path()
except Exception:
self._screenshot_path = os.path.join("pic", "screenshot.png")
self._thread = threading.Thread(target=self._screenshot_loop, daemon=True, name="ScreenshotService")
self._thread.start()
self._last_screenshot_time = time.time() - self._cache_valid_duration - 1.0
timetag = datetime.now().strftime("%H:%M:%S")
print(f"[{timetag}] [截图服务] 已启动后台截图服务,设备: {device_id}, 间隔: {interval}秒")
def stop(self):
with self._lock:
if not self._running:
return
self._running = False
if self._thread and self._thread.is_alive():
self._thread.join(timeout=2.0)
timetag = datetime.now().strftime("%H:%M:%S")
print(f"[{timetag}] [截图服务] 已停止后台截图服务")
def _screenshot_loop(self):
while self._running:
try:
if not self._current_device_id:
time.sleep(0.1)
continue
start = time.time()
success = self._screenshot_ops.get_screenshot(self._current_device_id, use_service=False)
elapsed = (time.time() - start) * 1000
timetag = datetime.now().strftime("%H:%M:%S")
if success:
self._last_screenshot_time = time.time()
self._last_success = True
print(f"[{timetag}] [截图服务] 后台截图成功,耗时: {elapsed:.0f}ms")
else:
self._last_success = False
print(f"[{timetag}] [截图服务] 后台截图失败,耗时: {elapsed:.0f}ms")
time.sleep(max(0.5, self._screenshot_interval - elapsed / 1000))
except Exception as e:
print(f"[截图服务] 异常: {e}")
time.sleep(1.0)
def get_screenshot(self, device_id: str, force: bool = False) -> bool:
# 优先使用缓存判断,简化版保留核心逻辑
if self._current_device_id != device_id:
self.start(device_id)
time.sleep(0.1)
now = time.time()
if not force and now - self._last_screenshot_time < self._cache_valid_duration:
if self._screenshot_path and os.path.exists(self._screenshot_path):
try:
if os.path.getsize(self._screenshot_path) >= 1024:
return True
except Exception:
pass
# 回退到直接截图
return self._screenshot_ops.get_screenshot(device_id, use_service=False)
def is_running(self) -> bool:
return self._running
def get_last_screenshot_time(self) -> float:
return self._last_screenshot_time
def get_cache_info(self) -> dict:
return {
"running": self._running,
"device_id": self._current_device_id,
"last_screenshot_time": self._last_screenshot_time,
"interval": self._screenshot_interval,
"cache_valid_duration": self._cache_valid_duration,
"last_success": self._last_success,
}
def get_optimal_workers() -> int:
cpu_count = os.cpu_count() or 4
if cpu_count >= 12:
return 10
if cpu_count >= 8:
return 8
if cpu_count >= 4:
return 6
if cpu_count >= 2:
return 3
return 2