441 lines
14 KiB
Python
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']
|