mirror of
https://github.com/Zippland/Bubbles.git
synced 2026-03-01 08:22:10 +08:00
509 lines
23 KiB
Python
509 lines
23 KiB
Python
import json
|
||
import logging
|
||
import os
|
||
import re
|
||
import time as time_mod
|
||
from datetime import datetime
|
||
from typing import Optional, Match, TYPE_CHECKING
|
||
|
||
from function.func_persona import build_persona_system_prompt
|
||
|
||
if TYPE_CHECKING:
|
||
from .context import MessageContext
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
DEFAULT_CHAT_HISTORY = 30
|
||
DEFAULT_VISIBLE_LIMIT = 30
|
||
|
||
|
||
# ══════════════════════════════════════════════════════════
|
||
# 工具 handler 函数
|
||
# ══════════════════════════════════════════════════════════
|
||
|
||
def _web_search(ctx, query: str = "", deep_research: bool = False, **_) -> str:
|
||
perplexity_instance = getattr(ctx.robot, "perplexity", None)
|
||
if not perplexity_instance:
|
||
return json.dumps({"error": "Perplexity 搜索功能不可用，未配置或未初始化"}, ensure_ascii=False)
|
||
if not query:
|
||
return json.dumps({"error": "请提供搜索关键词"}, ensure_ascii=False)
|
||
try:
|
||
response = perplexity_instance.get_answer(query, ctx.get_receiver(), deep_research=deep_research)
|
||
if not response:
|
||
return json.dumps({"error": "搜索无结果"}, ensure_ascii=False)
|
||
cleaned = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
|
||
return json.dumps({"result": cleaned or response}, ensure_ascii=False)
|
||
except Exception as e:
|
||
return json.dumps({"error": f"搜索失败: {e}"}, ensure_ascii=False)
|
||
|
||
|
||
def _reminder_create(ctx, type: str = "once", time: str = "",
|
||
content: str = "", weekday: int = None, **_) -> str:
|
||
if not hasattr(ctx.robot, "reminder_manager"):
|
||
return json.dumps({"error": "提醒管理器未初始化"}, ensure_ascii=False)
|
||
if not time or not content:
|
||
return json.dumps({"error": "缺少必要字段: time 和 content"}, ensure_ascii=False)
|
||
if len(content.strip()) < 2:
|
||
return json.dumps({"error": "提醒内容太短"}, ensure_ascii=False)
|
||
|
||
if type == "once":
|
||
parsed_dt = None
|
||
for fmt in ("%Y-%m-%d %H:%M", "%Y-%m-%d %H:%M:%S"):
|
||
try:
|
||
parsed_dt = datetime.strptime(time, fmt)
|
||
break
|
||
except ValueError:
|
||
continue
|
||
if not parsed_dt:
|
||
return json.dumps({"error": f"once 类型时间格式应为 YYYY-MM-DD HH:MM，收到: {time}"}, ensure_ascii=False)
|
||
if parsed_dt < datetime.now():
|
||
return json.dumps({"error": f"时间 {time} 已过去，请使用未来的时间"}, ensure_ascii=False)
|
||
time = parsed_dt.strftime("%Y-%m-%d %H:%M")
|
||
elif type in ("daily", "weekly"):
|
||
parsed_time = None
|
||
for fmt in ("%H:%M", "%H:%M:%S"):
|
||
try:
|
||
parsed_time = datetime.strptime(time, fmt)
|
||
break
|
||
except ValueError:
|
||
continue
|
||
if not parsed_time:
|
||
return json.dumps({"error": f"daily/weekly 类型时间格式应为 HH:MM，收到: {time}"}, ensure_ascii=False)
|
||
time = parsed_time.strftime("%H:%M")
|
||
else:
|
||
return json.dumps({"error": f"不支持的提醒类型: {type}"}, ensure_ascii=False)
|
||
|
||
if type == "weekly" and (weekday is None or not (isinstance(weekday, int) and 0 <= weekday <= 6)):
|
||
return json.dumps({"error": "weekly 类型需要 weekday 参数 (0=周一 … 6=周日)"}, ensure_ascii=False)
|
||
|
||
data = {"type": type, "time": time, "content": content, "extra": {}}
|
||
if weekday is not None:
|
||
data["weekday"] = weekday
|
||
|
||
roomid = ctx.msg.roomid if ctx.is_group else None
|
||
success, result = ctx.robot.reminder_manager.add_reminder(ctx.msg.sender, data, roomid=roomid)
|
||
if success:
|
||
type_label = {"once": "一次性", "daily": "每日", "weekly": "每周"}.get(type, type)
|
||
return json.dumps({"success": True, "id": result,
|
||
"message": f"已创建{type_label}提醒: {time} - {content}"}, ensure_ascii=False)
|
||
return json.dumps({"success": False, "error": result}, ensure_ascii=False)
|
||
|
||
|
||
def _reminder_list(ctx, **_) -> str:
|
||
if not hasattr(ctx.robot, "reminder_manager"):
|
||
return json.dumps({"error": "提醒管理器未初始化"}, ensure_ascii=False)
|
||
reminders = ctx.robot.reminder_manager.list_reminders(ctx.msg.sender)
|
||
if not reminders:
|
||
return json.dumps({"reminders": [], "message": "当前没有任何提醒"}, ensure_ascii=False)
|
||
return json.dumps({"reminders": reminders, "count": len(reminders)}, ensure_ascii=False)
|
||
|
||
|
||
def _reminder_delete(ctx, reminder_id: str = "", delete_all: bool = False, **_) -> str:
|
||
if not hasattr(ctx.robot, "reminder_manager"):
|
||
return json.dumps({"error": "提醒管理器未初始化"}, ensure_ascii=False)
|
||
if delete_all:
|
||
success, message, count = ctx.robot.reminder_manager.delete_all_reminders(ctx.msg.sender)
|
||
return json.dumps({"success": success, "message": message, "deleted_count": count}, ensure_ascii=False)
|
||
if not reminder_id:
|
||
return json.dumps({"error": "请提供 reminder_id，或设置 delete_all=true 删除全部"}, ensure_ascii=False)
|
||
success, message = ctx.robot.reminder_manager.delete_reminder(ctx.msg.sender, reminder_id)
|
||
return json.dumps({"success": success, "message": message}, ensure_ascii=False)
|
||
|
||
|
||
def _lookup_chat_history(ctx, mode: str = "", keywords: list = None,
|
||
start_offset: int = None, end_offset: int = None,
|
||
start_time: str = None, end_time: str = None, **_) -> str:
|
||
message_summary = getattr(ctx.robot, "message_summary", None) if ctx.robot else None
|
||
if not message_summary:
|
||
return json.dumps({"error": "消息历史功能不可用"}, ensure_ascii=False)
|
||
|
||
chat_id = ctx.get_receiver()
|
||
visible_limit = DEFAULT_VISIBLE_LIMIT
|
||
raw = getattr(ctx, "specific_max_history", None)
|
||
if raw is not None:
|
||
try:
|
||
visible_limit = int(raw)
|
||
except (TypeError, ValueError):
|
||
pass
|
||
|
||
mode = (mode or "").strip().lower()
|
||
if not mode:
|
||
if start_time and end_time:
|
||
mode = "time"
|
||
elif start_offset is not None and end_offset is not None:
|
||
mode = "range"
|
||
else:
|
||
mode = "keywords"
|
||
|
||
if mode == "keywords":
|
||
if isinstance(keywords, str):
|
||
keywords = [keywords]
|
||
elif not isinstance(keywords, list):
|
||
keywords = []
|
||
cleaned = []
|
||
seen = set()
|
||
for kw in keywords:
|
||
if kw is None:
|
||
continue
|
||
s = str(kw).strip()
|
||
if s and (len(s) > 1 or s.isdigit()):
|
||
low = s.lower()
|
||
if low not in seen:
|
||
seen.add(low)
|
||
cleaned.append(s)
|
||
if not cleaned:
|
||
return json.dumps({"error": "未提供有效关键词", "results": []}, ensure_ascii=False)
|
||
search_results = message_summary.search_messages_with_context(
|
||
chat_id=chat_id, keywords=cleaned, context_window=10,
|
||
max_groups=20, exclude_recent=visible_limit,
|
||
)
|
||
segments, lines_seen = [], set()
|
||
for seg in search_results:
|
||
formatted = [l for l in seg.get("formatted_messages", []) if l not in lines_seen]
|
||
lines_seen.update(formatted)
|
||
if formatted:
|
||
segments.append({"matched_keywords": seg.get("matched_keywords", []), "messages": formatted})
|
||
payload = {"segments": segments, "returned_groups": len(segments), "keywords": cleaned}
|
||
if not segments:
|
||
payload["notice"] = "未找到匹配的消息。"
|
||
return json.dumps(payload, ensure_ascii=False)
|
||
|
||
if mode == "range":
|
||
if start_offset is None or end_offset is None:
|
||
return json.dumps({"error": "range 模式需要 start_offset 和 end_offset"}, ensure_ascii=False)
|
||
try:
|
||
start_offset, end_offset = int(start_offset), int(end_offset)
|
||
except (TypeError, ValueError):
|
||
return json.dumps({"error": "start_offset 和 end_offset 必须是整数"}, ensure_ascii=False)
|
||
if start_offset <= visible_limit or end_offset <= visible_limit:
|
||
return json.dumps({"error": f"偏移量必须大于 {visible_limit} 以排除当前可见消息"}, ensure_ascii=False)
|
||
if start_offset > end_offset:
|
||
start_offset, end_offset = end_offset, start_offset
|
||
result = message_summary.get_messages_by_reverse_range(
|
||
chat_id=chat_id, start_offset=start_offset, end_offset=end_offset,
|
||
)
|
||
payload = {
|
||
"start_offset": result.get("start_offset"), "end_offset": result.get("end_offset"),
|
||
"messages": result.get("messages", []), "returned_count": result.get("returned_count", 0),
|
||
"total_messages": result.get("total_messages", 0),
|
||
}
|
||
if payload["returned_count"] == 0:
|
||
payload["notice"] = "请求范围内没有消息。"
|
||
return json.dumps(payload, ensure_ascii=False)
|
||
|
||
if mode == "time":
|
||
if not start_time or not end_time:
|
||
return json.dumps({"error": "time 模式需要 start_time 和 end_time"}, ensure_ascii=False)
|
||
time_lines = message_summary.get_messages_by_time_window(
|
||
chat_id=chat_id, start_time=start_time, end_time=end_time,
|
||
)
|
||
payload = {"start_time": start_time, "end_time": end_time,
|
||
"messages": time_lines, "returned_count": len(time_lines)}
|
||
if not time_lines:
|
||
payload["notice"] = "该时间范围内没有消息。"
|
||
return json.dumps(payload, ensure_ascii=False)
|
||
|
||
return json.dumps({"error": f"不支持的模式: {mode}"}, ensure_ascii=False)
|
||
|
||
|
||
# ══════════════════════════════════════════════════════════
|
||
# 工具注册表
|
||
# ══════════════════════════════════════════════════════════
|
||
|
||
TOOLS = {
|
||
"web_search": {
|
||
"handler": _web_search,
|
||
"description": "在网络上搜索信息。用于回答需要最新数据、实时信息或你不确定的事实性问题。deep_research 仅在问题非常复杂、需要深度研究时才开启。",
|
||
"status_text": "正在联网搜索: ",
|
||
"status_arg": "query",
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"query": {"type": "string", "description": "搜索关键词或问题"},
|
||
"deep_research": {"type": "boolean", "description": "是否启用深度研究模式（耗时较长，仅用于复杂问题）"},
|
||
},
|
||
"required": ["query"],
|
||
"additionalProperties": False,
|
||
},
|
||
},
|
||
"reminder_create": {
|
||
"handler": _reminder_create,
|
||
"description": "创建提醒。支持 once(一次性)、daily(每日)、weekly(每周) 三种类型。当前时间已在对话上下文中提供，请据此计算目标时间。",
|
||
"status_text": "正在设置提醒...",
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"type": {"type": "string", "enum": ["once", "daily", "weekly"], "description": "提醒类型"},
|
||
"time": {"type": "string", "description": "once → YYYY-MM-DD HH:MM；daily/weekly → HH:MM"},
|
||
"content": {"type": "string", "description": "提醒内容"},
|
||
"weekday": {"type": "integer", "description": "仅 weekly 需要。0=周一 … 6=周日"},
|
||
},
|
||
"required": ["type", "time", "content"],
|
||
"additionalProperties": False,
|
||
},
|
||
},
|
||
"reminder_list": {
|
||
"handler": _reminder_list,
|
||
"description": "查看当前用户的所有提醒列表。",
|
||
"parameters": {"type": "object", "properties": {}, "additionalProperties": False},
|
||
},
|
||
"reminder_delete": {
|
||
"handler": _reminder_delete,
|
||
"description": "删除提醒。需要先调用 reminder_list 获取 ID，再用 reminder_id 精确删除；或设置 delete_all=true 一次性删除全部。",
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"reminder_id": {"type": "string", "description": "要删除的提醒完整 ID"},
|
||
"delete_all": {"type": "boolean", "description": "是否删除该用户全部提醒"},
|
||
},
|
||
"additionalProperties": False,
|
||
},
|
||
},
|
||
"lookup_chat_history": {
|
||
"handler": _lookup_chat_history,
|
||
"description": "查询聊天历史记录。你当前只能看到最近的消息，调用此工具可以回溯更早的上下文。支持 keywords/range/time 三种模式。",
|
||
"status_text": "正在翻阅聊天记录: ",
|
||
"status_arg": "keywords",
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"mode": {"type": "string", "enum": ["keywords", "range", "time"], "description": "查询模式"},
|
||
"keywords": {"type": "array", "items": {"type": "string"}, "description": "mode=keywords 时的搜索关键词"},
|
||
"start_offset": {"type": "integer", "description": "mode=range 时的起始偏移（从最新消息倒数）"},
|
||
"end_offset": {"type": "integer", "description": "mode=range 时的结束偏移"},
|
||
"start_time": {"type": "string", "description": "mode=time 时的开始时间 (YYYY-MM-DD HH:MM)"},
|
||
"end_time": {"type": "string", "description": "mode=time 时的结束时间 (YYYY-MM-DD HH:MM)"},
|
||
},
|
||
"additionalProperties": False,
|
||
},
|
||
},
|
||
}
|
||
|
||
|
||
def _get_openai_tools():
|
||
return [
|
||
{"type": "function", "function": {"name": n, "description": s["description"], "parameters": s["parameters"]}}
|
||
for n, s in TOOLS.items()
|
||
]
|
||
|
||
|
||
def _create_tool_handler(ctx):
|
||
def _send_status(spec, arguments):
|
||
status = spec.get("status_text", "")
|
||
if not status:
|
||
return
|
||
try:
|
||
arg_name = spec.get("status_arg", "")
|
||
if arg_name:
|
||
val = arguments.get(arg_name)
|
||
if val is not None:
|
||
if isinstance(val, list):
|
||
val = "、".join(str(k) for k in val[:3])
|
||
status = f"{status}{val}"
|
||
ctx.send_text(status, record_message=False)
|
||
except Exception:
|
||
pass
|
||
|
||
def handler(tool_name, arguments):
|
||
spec = TOOLS.get(tool_name)
|
||
if not spec:
|
||
return json.dumps({"error": f"Unknown tool: {tool_name}"}, ensure_ascii=False)
|
||
_send_status(spec, arguments)
|
||
try:
|
||
result = spec["handler"](ctx, **arguments)
|
||
if not isinstance(result, str):
|
||
result = json.dumps(result, ensure_ascii=False)
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"工具 {tool_name} 执行失败: {e}", exc_info=True)
|
||
return json.dumps({"error": str(e)}, ensure_ascii=False)
|
||
|
||
return handler
|
||
|
||
|
||
# ══════════════════════════════════════════════════════════
|
||
# Agent 入口
|
||
# ══════════════════════════════════════════════════════════
|
||
|
||
def handle_chitchat(ctx: 'MessageContext', match: Optional[Match]) -> bool:
|
||
"""Agent 入口 —— 处理用户消息，LLM 自主决定是否调用工具。"""
|
||
chat_model = None
|
||
if hasattr(ctx, 'chat'):
|
||
chat_model = ctx.chat
|
||
elif ctx.robot and hasattr(ctx.robot, 'chat'):
|
||
chat_model = ctx.robot.chat
|
||
|
||
if not chat_model:
|
||
if ctx.logger:
|
||
ctx.logger.error("没有可用的AI模型")
|
||
ctx.send_text("抱歉，我现在无法进行对话。")
|
||
return False
|
||
|
||
# 历史消息数量限制
|
||
raw_specific_max_history = getattr(ctx, 'specific_max_history', None)
|
||
specific_max_history = None
|
||
if raw_specific_max_history is not None:
|
||
try:
|
||
specific_max_history = int(raw_specific_max_history)
|
||
except (TypeError, ValueError):
|
||
specific_max_history = None
|
||
if specific_max_history is not None:
|
||
specific_max_history = max(10, min(300, specific_max_history))
|
||
if specific_max_history is None:
|
||
specific_max_history = DEFAULT_CHAT_HISTORY
|
||
setattr(ctx, 'specific_max_history', specific_max_history)
|
||
|
||
# ── 引用图片特殊处理 ──────────────────────────────────
|
||
if getattr(ctx, 'is_quoted_image', False):
|
||
return _handle_quoted_image(ctx, chat_model)
|
||
|
||
# ── 构建用户消息 ──────────────────────────────────────
|
||
content = ctx.text
|
||
sender_name = ctx.sender_name
|
||
|
||
if ctx.robot and hasattr(ctx.robot, "xml_processor"):
|
||
if ctx.is_group:
|
||
msg_data = ctx.robot.xml_processor.extract_quoted_message(ctx.msg)
|
||
else:
|
||
msg_data = ctx.robot.xml_processor.extract_private_quoted_message(ctx.msg)
|
||
q_with_info = ctx.robot.xml_processor.format_message_for_ai(msg_data, sender_name)
|
||
if not q_with_info:
|
||
current_time = time_mod.strftime("%H:%M", time_mod.localtime())
|
||
q_with_info = f"[{current_time}] {sender_name}: {content or '[空内容]'}"
|
||
else:
|
||
current_time = time_mod.strftime("%H:%M", time_mod.localtime())
|
||
q_with_info = f"[{current_time}] {sender_name}: {content or '[空内容]'}"
|
||
|
||
is_auto_random_reply = getattr(ctx, 'auto_random_reply', False)
|
||
|
||
if ctx.is_group and not ctx.is_at_bot and is_auto_random_reply:
|
||
latest_message_prompt = (
|
||
"# 群聊插话提醒\n"
|
||
"你目前是在群聊里主动接话，没有人点名让你发言。\n"
|
||
"请根据下面这句（或者你任选一句）最新消息插入一条自然、不突兀的中文回复，语气放松随和即可：\n"
|
||
f"\u201c{q_with_info}\u201d\n"
|
||
"不要重复任何已知的内容，提出新的思维碰撞（例如：基于上下文的新问题、不同角度的解释等，但是不要反驳任何内容），也不要显得过于正式。"
|
||
)
|
||
else:
|
||
latest_message_prompt = (
|
||
"# 本轮需要回复的用户及其最新信息\n"
|
||
"请你基于下面这条最新收到的用户讯息（和该用户最近的历史消息），直接面向发送者进行自然的中文回复：\n"
|
||
f"\u201c{q_with_info}\u201d\n"
|
||
"请只针对该用户进行回复。"
|
||
)
|
||
|
||
# ── 构建工具列表 ──────────────────────────────────────
|
||
tools = None
|
||
tool_handler = None
|
||
|
||
if not is_auto_random_reply:
|
||
openai_tools = _get_openai_tools()
|
||
if openai_tools:
|
||
tools = openai_tools
|
||
tool_handler = _create_tool_handler(ctx)
|
||
|
||
# ── 构建系统提示 ──────────────────────────────────────
|
||
persona_text = getattr(ctx, 'persona', None)
|
||
system_prompt_override = None
|
||
|
||
tool_guidance = ""
|
||
if tools:
|
||
tool_guidance = (
|
||
"\n\n## 工具使用指引\n"
|
||
"你可以调用工具来辅助回答，以下是决策原则：\n"
|
||
"- 用户询问需要最新信息、实时数据、或你不确定的事实 → 调用 web_search\n"
|
||
"- 用户想设置/查看/删除提醒 → 调用 reminder_create / reminder_list / reminder_delete\n"
|
||
"- 用户提到之前聊过的内容、或你需要回顾更早的对话 → 调用 lookup_chat_history\n"
|
||
"- 日常闲聊、观点讨论、情感交流 → 直接回复，不需要调用任何工具\n"
|
||
"你可以在一次对话中多次调用工具，每次调用的结果会反馈给你继续推理。"
|
||
)
|
||
|
||
if persona_text:
|
||
try:
|
||
base_prompt = build_persona_system_prompt(chat_model, persona_text)
|
||
system_prompt_override = base_prompt + tool_guidance if base_prompt else tool_guidance or None
|
||
except Exception as persona_exc:
|
||
if ctx.logger:
|
||
ctx.logger.error(f"构建人设系统提示失败: {persona_exc}", exc_info=True)
|
||
system_prompt_override = tool_guidance or None
|
||
elif tool_guidance:
|
||
system_prompt_override = tool_guidance
|
||
|
||
# ── 调用 LLM ─────────────────────────────────────────
|
||
try:
|
||
if ctx.logger:
|
||
tool_names = [t["function"]["name"] for t in tools] if tools else []
|
||
ctx.logger.info(f"Agent 调用: tools={tool_names}")
|
||
|
||
rsp = chat_model.get_answer(
|
||
question=latest_message_prompt,
|
||
wxid=ctx.get_receiver(),
|
||
system_prompt_override=system_prompt_override,
|
||
specific_max_history=specific_max_history,
|
||
tools=tools,
|
||
tool_handler=tool_handler,
|
||
tool_max_iterations=20,
|
||
)
|
||
|
||
if rsp:
|
||
ctx.send_text(rsp, "")
|
||
return True
|
||
else:
|
||
if ctx.logger:
|
||
ctx.logger.error("无法从AI获得答案")
|
||
return False
|
||
except Exception as e:
|
||
if ctx.logger:
|
||
ctx.logger.error(f"获取AI回复时出错: {e}", exc_info=True)
|
||
return False
|
||
|
||
|
||
def _handle_quoted_image(ctx, chat_model) -> bool:
|
||
"""处理引用图片消息。"""
|
||
if ctx.logger:
|
||
ctx.logger.info("检测到引用图片消息，尝试处理图片内容...")
|
||
|
||
from ai_providers.ai_chatgpt import ChatGPT
|
||
|
||
support_vision = False
|
||
if isinstance(chat_model, ChatGPT):
|
||
if hasattr(chat_model, 'support_vision') and chat_model.support_vision:
|
||
support_vision = True
|
||
elif hasattr(chat_model, 'model'):
|
||
model_name = getattr(chat_model, 'model', '')
|
||
support_vision = model_name in ("gpt-4.1-mini", "gpt-4o") or "-vision" in model_name
|
||
|
||
if not support_vision:
|
||
ctx.send_text("抱歉，当前 AI 模型不支持处理图片。请联系管理员配置支持视觉的模型。")
|
||
return True
|
||
|
||
try:
|
||
temp_dir = "temp/image_cache"
|
||
os.makedirs(temp_dir, exist_ok=True)
|
||
|
||
image_path = ctx.wcf.download_image(
|
||
id=ctx.quoted_msg_id, extra=ctx.quoted_image_extra,
|
||
dir=temp_dir, timeout=30,
|
||
)
|
||
|
||
if not image_path or not os.path.exists(image_path):
|
||
ctx.send_text("抱歉，无法下载图片进行分析。")
|
||
return True
|
||
|
||
prompt = ctx.text if ctx.text and ctx.text.strip() else "请详细描述这张图片中的内容"
|
||
response = chat_model.get_image_description(image_path, prompt)
|
||
ctx.send_text(response)
|
||
|
||
try:
|
||
if os.path.exists(image_path):
|
||
os.remove(image_path)
|
||
except Exception:
|
||
pass
|
||
return True
|
||
|
||
except Exception as e:
|
||
if ctx.logger:
|
||
ctx.logger.error(f"处理引用图片出错: {e}", exc_info=True)
|
||
ctx.send_text(f"处理图片时发生错误: {str(e)}")
|
||
return True
|