Files
2026-11-02 22:54:14 +08:00

441 lines
14 KiB
Python

"""
app/services/config/managers.py - 配置子管理器
职责:
- 全局配置管理(元素定义)
- 图片预设管理
"""
import json
import os
import copy
from app.core.config import get_logger
from typing import Dict, List, Any, Optional
from app.models.schemas import (
SelectorDefinition,
get_default_selector_definitions,
get_default_image_extraction_config
)
logger = get_logger("CFG_MGR")
# ================= 全局配置管理器 =================
class GlobalConfigManager:
"""
全局配置管理器
管理 _global 节点中的配置,包括:
- selector_definitions: 元素定义列表
- 以及任意扩展字段(通过 get/set 访问)
"""
def __init__(self):
self._selector_definitions: List[SelectorDefinition] = get_default_selector_definitions()
self._extra: Dict[str, Any] = {} # 通用扩展存储
def load(self, global_section: Dict[str, Any]):
"""从 _global 节点加载配置"""
self._extra = {}
self._selector_definitions = get_default_selector_definitions()
if not global_section:
return
if "selector_definitions" in global_section:
defs = global_section["selector_definitions"]
if isinstance(defs, list):
self._selector_definitions = self._merge_selector_definitions(defs)
logger.debug(f"已加载 {len(defs)} 个元素定义")
# 加载所有非 selector_definitions 的字段到通用存储
for key, value in global_section.items():
if key != "selector_definitions":
self._extra[key] = copy.deepcopy(value)
if "commands" in self._extra:
cmd_count = len(self._extra["commands"]) if isinstance(self._extra["commands"], list) else 0
logger.debug(f"已加载 {cmd_count} 个自动化命令")
def get_selector_definitions(self) -> List[SelectorDefinition]:
"""获取元素定义列表"""
return copy.deepcopy(self._selector_definitions)
def set_selector_definitions(self, definitions: List[SelectorDefinition]):
"""设置元素定义列表"""
self._selector_definitions = self._merge_selector_definitions(definitions)
@staticmethod
def _normalize_selector_definition(raw_item: Any) -> Optional[SelectorDefinition]:
if not isinstance(raw_item, dict):
return None
key = raw_item.get("key")
if not isinstance(key, str):
return None
key = key.strip()
if not key:
return None
description = raw_item.get("description", "")
if not isinstance(description, str):
description = str(description) if description is not None else ""
return {
"key": key,
"description": description,
"enabled": bool(raw_item.get("enabled", True)),
"required": bool(raw_item.get("required", False)),
}
def _merge_selector_definitions(self, definitions: List[SelectorDefinition]) -> List[SelectorDefinition]:
"""合并内置默认字段,确保升级后新增的选择器能自动出现。"""
merged = []
existing_keys = set()
for item in definitions or []:
normalized = self._normalize_selector_definition(item)
if not normalized:
continue
key = normalized["key"]
if key in existing_keys:
continue
merged.append(normalized)
existing_keys.add(key)
for default_def in get_default_selector_definitions():
normalized_default = self._normalize_selector_definition(default_def)
if not normalized_default:
continue
key = normalized_default.get("key")
if key not in existing_keys:
merged.append(normalized_default)
existing_keys.add(key)
return merged
def get_enabled_definitions(self) -> List[SelectorDefinition]:
"""获取启用的元素定义"""
return [
copy.deepcopy(d)
for d in self._selector_definitions
if isinstance(d, dict) and d.get("enabled", True)
]
def get_fallback_selectors(self) -> Dict[str, Optional[str]]:
"""
生成回退选择器字典
基于元素定义生成,用于 SelectorValidator
"""
fallback_map = {
"input_box": "textarea",
"send_btn": 'button[type="submit"]',
"result_container": "div",
"new_chat_btn": None,
"retry_send_btn": None,
"message_wrapper": None,
"generating_indicator": None,
"upload_btn": None,
"file_input": 'input[type="file"]',
"drop_zone": None,
}
result = {}
for d in self._selector_definitions:
if not isinstance(d, dict):
continue
key = d.get("key")
if not isinstance(key, str) or not key:
continue
result[key] = fallback_map.get(key, None)
return result
def build_prompt_selector_list(self) -> str:
"""
生成 AI 提示词中的元素查找列表
只包含 enabled=True 的元素
"""
lines = []
for d in self._selector_definitions:
if not isinstance(d, dict):
continue
if not d.get("enabled", True):
continue
key = str(d.get("key") or "").strip()
if not key:
continue
desc = str(d.get("description") or "")
required = d.get("required", False)
if required:
tag = "[REQUIRED]"
else:
tag = "[OPTIONAL, return null if not found]"
lines.append(f"- `{key}`: {desc} {tag}")
return "\n".join(lines)
def build_prompt_json_keys(self) -> str:
"""
生成 AI 提示词中的 JSON 输出格式说明
"""
lines = []
for d in self._selector_definitions:
if not isinstance(d, dict):
continue
if not d.get("enabled", True):
continue
key = str(d.get("key") or "").strip()
if not key:
continue
desc = str(d.get("description") or "")
lines.append(f'- `{key}`: {desc}')
return "\n".join(lines)
def get(self, key: str, default: Any = None) -> Any:
"""获取通用配置值"""
return copy.deepcopy(self._extra.get(key, default))
def set(self, key: str, value: Any):
"""设置通用配置值"""
self._extra[key] = copy.deepcopy(value)
def remove(self, key: str) -> bool:
"""删除通用配置值"""
if key not in self._extra:
return False
del self._extra[key]
return True
def to_dict(self) -> Dict[str, Any]:
"""导出为字典(用于保存)"""
result = {
"selector_definitions": self._selector_definitions
}
# 合并通用存储中的所有字段
result.update(self._extra)
return copy.deepcopy(result)
# ================= 图片预设管理器 =================
class ImagePresetsManager:
"""
图片提取预设管理器
职责:
- 加载预设配置文件
- 提供站点预设查询
- 应用预设到站点配置
"""
def __init__(self, presets_file: str):
self.presets_file = presets_file
self.presets: Dict[str, Any] = {}
self._load_presets()
@staticmethod
def _default_presets_payload() -> Dict[str, Any]:
return {
"_default": {
"name": "Default",
"description": "Built-in fallback image extraction preset",
"image_extraction": get_default_image_extraction_config(),
}
}
@staticmethod
def _get_preset_image_config(preset_data: Any) -> Optional[Dict[str, Any]]:
if not isinstance(preset_data, dict):
return None
config = preset_data.get("image_extraction")
return copy.deepcopy(config) if isinstance(config, dict) else None
@staticmethod
def _get_preset_text(preset_data: Dict[str, Any], key: str, default: str = "") -> str:
value = preset_data.get(key, default)
if value is None:
return default
if isinstance(value, (str, int, float, bool)):
return str(value)
return default
def _find_matching_preset(self, domain: str) -> Optional[tuple[str, Dict[str, Any]]]:
domain = str(domain or "").strip().lower().rstrip(".")
if not domain:
return None
normalized_presets = []
for preset_domain, preset_data in self.presets.items():
if preset_domain.startswith("_") or not isinstance(preset_data, dict):
continue
normalized_preset_domain = str(preset_domain).strip().lower().rstrip(".")
if not normalized_preset_domain:
continue
normalized_presets.append((preset_domain, preset_data, normalized_preset_domain))
for preset_domain, preset_data, normalized_preset_domain in normalized_presets:
if domain == normalized_preset_domain:
return preset_domain, preset_data
suffix_matches = [
item
for item in normalized_presets
if domain.endswith(f".{item[2]}")
]
if suffix_matches:
preset_domain, preset_data, _ = max(
suffix_matches,
key=lambda item: len(item[2]),
)
logger.debug(f"使用模糊匹配预设: {domain} -> {preset_domain}")
return preset_domain, preset_data
return None
def _use_default_presets_or_keep_existing(self, keep_existing: bool) -> None:
if keep_existing and self.presets:
logger.warning("图片预设加载失败,保留当前内存中的预设")
return
self.presets = self._default_presets_payload()
def _load_presets(self, keep_existing_on_error: bool = False):
"""加载预设配置文件"""
if not os.path.exists(self.presets_file):
logger.warning(f"图片预设文件不存在: {self.presets_file}")
self._use_default_presets_or_keep_existing(keep_existing_on_error)
return
try:
with open(self.presets_file, 'r', encoding='utf-8') as f:
data = json.load(f)
if not isinstance(data, dict):
logger.error("预设文件格式错误: 顶层必须是对象")
self._use_default_presets_or_keep_existing(keep_existing_on_error)
return
# 移除元数据
loaded_presets = {
str(k): v
for k, v in data.items()
if k != "_meta" and isinstance(v, dict)
}
skipped_count = len([k for k, v in data.items() if k != "_meta" and not isinstance(v, dict)])
if skipped_count:
logger.warning(f"已跳过 {skipped_count} 个格式无效的图片预设")
if not loaded_presets:
self._use_default_presets_or_keep_existing(keep_existing_on_error)
logger.debug(f"已加载 {len(self.presets)} 个图片预设")
return
self.presets = loaded_presets
logger.debug(f"已加载 {len(self.presets)} 个图片预设")
except json.JSONDecodeError as e:
logger.error(f"预设文件格式错误: {e}")
self._use_default_presets_or_keep_existing(keep_existing_on_error)
except Exception as e:
logger.error(f"加载预设失败: {e}")
self._use_default_presets_or_keep_existing(keep_existing_on_error)
def get_preset(self, domain: str) -> Optional[Dict]:
"""
获取站点的预设配置
Args:
domain: 站点域名
Returns:
预设配置字典,不存在返回 None
"""
match = self._find_matching_preset(domain)
if match is None:
return None
return self._get_preset_image_config(match[1])
def list_presets(self) -> List[Dict[str, Any]]:
"""
列出所有可用预设
Returns:
预设列表,每项包含 domain、name、description、enabled
"""
result = []
for domain, data in self.presets.items():
if domain == "_meta":
continue
if not isinstance(data, dict):
continue
config = self._get_preset_image_config(data) or {}
item = {
"domain": domain,
"name": self._get_preset_text(data, "name", domain),
"description": self._get_preset_text(data, "description", ""),
"enabled": config.get("enabled", False),
"notes": self._get_preset_text(data, "notes", ""),
"config": config
}
result.append(item)
result.sort(key=lambda x: x["domain"])
return result
def get_preset_for_display(self, domain: str) -> Dict[str, Any]:
"""
获取用于显示的预设信息
Args:
domain: 站点域名
Returns:
包含 available、preset_domain、config 的字典
"""
match = self._find_matching_preset(domain)
if match is None:
preset_config = None
else:
preset_config = self._get_preset_image_config(match[1])
if preset_config:
matched_domain, matched_data = match
return {
"available": True,
"preset_domain": matched_domain,
"name": self._get_preset_text(
matched_data,
"name",
"",
),
"config": preset_config
}
return {
"available": False,
"preset_domain": None,
"name": None,
"config": None
}
def reload(self):
"""重新加载预设文件"""
self._load_presets(keep_existing_on_error=True)
__all__ = ['GlobalConfigManager', 'ImagePresetsManager']