AstrBot 4.10.2__py3-none-any.whl → 4.10.4__py3-none-any.whl

astrbot/builtin_stars/reminder/main.py

@@ -0,0 +1,266 @@
+import datetime
+import json
+import os
+import uuid
+import zoneinfo
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from astrbot.api import llm_tool, logger, star
+from astrbot.api.event import AstrMessageEvent, MessageEventResult, filter
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+
+class Main(star.Star):
+    """使用 LLM 待办提醒。只需对 LLM 说想要提醒的事情和时间即可。比如：`之后每天这个时候都提醒我做多邻国`"""
+
+    def __init__(self, context: star.Context) -> None:
+        self.context = context
+        self.timezone = self.context.get_config().get("timezone")
+        if not self.timezone:
+            self.timezone = None
+        try:
+            self.timezone = zoneinfo.ZoneInfo(self.timezone) if self.timezone else None
+        except Exception as e:
+            logger.error(f"时区设置错误: {e}, 使用本地时区")
+            self.timezone = None
+        self.scheduler = AsyncIOScheduler(timezone=self.timezone)
+
+        # set and load config
+        reminder_file = os.path.join(get_astrbot_data_path(), "astrbot-reminder.json")
+        if not os.path.exists(reminder_file):
+            with open(reminder_file, "w", encoding="utf-8") as f:
+                f.write("{}")
+        with open(reminder_file, encoding="utf-8") as f:
+            self.reminder_data = json.load(f)
+
+        self._init_scheduler()
+        self.scheduler.start()
+
+    def _init_scheduler(self):
+        """Initialize the scheduler."""
+        for group in self.reminder_data:
+            for reminder in self.reminder_data[group]:
+                if "id" not in reminder:
+                    id_ = str(uuid.uuid4())
+                    reminder["id"] = id_
+                else:
+                    id_ = reminder["id"]
+
+                if "datetime" in reminder:
+                    if self.check_is_outdated(reminder):
+                        continue
+                    self.scheduler.add_job(
+                        self._reminder_callback,
+                        id=id_,
+                        trigger="date",
+                        args=[group, reminder],
+                        run_date=datetime.datetime.strptime(
+                            reminder["datetime"],
+                            "%Y-%m-%d %H:%M",
+                        ),
+                        misfire_grace_time=60,
+                    )
+                elif "cron" in reminder:
+                    trigger = CronTrigger(**self._parse_cron_expr(reminder["cron"]))
+                    self.scheduler.add_job(
+                        self._reminder_callback,
+                        trigger=trigger,
+                        id=id_,
+                        args=[group, reminder],
+                        misfire_grace_time=60,
+                    )
+
+    def check_is_outdated(self, reminder: dict):
+        """Check if the reminder is outdated."""
+        if "datetime" in reminder:
+            reminder_time = datetime.datetime.strptime(
+                reminder["datetime"],
+                "%Y-%m-%d %H:%M",
+            ).replace(tzinfo=self.timezone)
+            return reminder_time < datetime.datetime.now(self.timezone)
+        return False
+
+    async def _save_data(self):
+        """Save the reminder data."""
+        reminder_file = os.path.join(get_astrbot_data_path(), "astrbot-reminder.json")
+        with open(reminder_file, "w", encoding="utf-8") as f:
+            json.dump(self.reminder_data, f, ensure_ascii=False)
+
+    def _parse_cron_expr(self, cron_expr: str):
+        fields = cron_expr.split(" ")
+        return {
+            "minute": fields[0],
+            "hour": fields[1],
+            "day": fields[2],
+            "month": fields[3],
+            "day_of_week": fields[4],
+        }
+
+    @llm_tool("reminder")
+    async def reminder_tool(
+        self,
+        event: AstrMessageEvent,
+        text: str | None = None,
+        datetime_str: str | None = None,
+        cron_expression: str | None = None,
+        human_readable_cron: str | None = None,
+    ):
+        """Call this function when user is asking for setting a reminder.
+
+        Args:
+            text(string): Must Required. The content of the reminder.
+            datetime_str(string): Required when user's reminder is a single reminder. The datetime string of the reminder, Must format with %Y-%m-%d %H:%M
+            cron_expression(string): Required when user's reminder is a repeated reminder. The cron expression of the reminder. Monday is 0 and Sunday is 6.
+            human_readable_cron(string): Optional. The human readable cron expression of the reminder.
+
+        """
+        if event.get_platform_name() == "qq_official":
+            yield event.plain_result("reminder 暂不支持 QQ 官方机器人。")
+            return
+
+        if event.unified_msg_origin not in self.reminder_data:
+            self.reminder_data[event.unified_msg_origin] = []
+
+        if not cron_expression and not datetime_str:
+            raise ValueError(
+                "The cron_expression and datetime_str cannot be both None.",
+            )
+        reminder_time = ""
+
+        if not text:
+            text = "未命名待办事项"
+
+        if cron_expression:
+            d = {
+                "text": text,
+                "cron": cron_expression,
+                "cron_h": human_readable_cron,
+                "id": str(uuid.uuid4()),
+            }
+            self.reminder_data[event.unified_msg_origin].append(d)
+            trigger = CronTrigger(**self._parse_cron_expr(cron_expression))
+            self.scheduler.add_job(
+                self._reminder_callback,
+                trigger,
+                id=d["id"],
+                misfire_grace_time=60,
+                args=[event.unified_msg_origin, d],
+            )
+            if human_readable_cron:
+                reminder_time = f"{human_readable_cron}(Cron: {cron_expression})"
+        else:
+            if datetime_str is None:
+                raise ValueError("datetime_str cannot be None.")
+            d = {"text": text, "datetime": datetime_str, "id": str(uuid.uuid4())}
+            self.reminder_data[event.unified_msg_origin].append(d)
+            datetime_scheduled = datetime.datetime.strptime(
+                datetime_str,
+                "%Y-%m-%d %H:%M",
+            )
+            self.scheduler.add_job(
+                self._reminder_callback,
+                "date",
+                id=d["id"],
+                args=[event.unified_msg_origin, d],
+                run_date=datetime_scheduled,
+                misfire_grace_time=60,
+            )
+            reminder_time = datetime_str
+        await self._save_data()
+        yield event.plain_result(
+            "成功设置待办事项。\n内容: "
+            + text
+            + "\n时间: "
+            + reminder_time
+            + "\n\n使用 /reminder ls 查看所有待办事项。\n使用 /tool off reminder 关闭此功能。",
+        )
+
+    @filter.command_group("reminder")
+    def reminder(self):
+        """待办提醒"""
+
+    async def get_upcoming_reminders(self, unified_msg_origin: str):
+        """Get upcoming reminders."""
+        reminders = self.reminder_data.get(unified_msg_origin, [])
+        if not reminders:
+            return []
+        now = datetime.datetime.now(self.timezone)
+        upcoming_reminders = [
+            reminder
+            for reminder in reminders
+            if "datetime" not in reminder
+            or datetime.datetime.strptime(
+                reminder["datetime"],
+                "%Y-%m-%d %H:%M",
+            ).replace(tzinfo=self.timezone)
+            >= now
+        ]
+        return upcoming_reminders
+
+    @reminder.command("ls")
+    async def reminder_ls(self, event: AstrMessageEvent):
+        """List upcoming reminders."""
+        reminders = await self.get_upcoming_reminders(event.unified_msg_origin)
+        if not reminders:
+            yield event.plain_result("没有正在进行的待办事项。")
+        else:
+            parts = ["正在进行的待办事项：\n"]
+            for i, reminder in enumerate(reminders):
+                time_ = reminder.get("datetime", "")
+                if not time_:
+                    cron_expr = reminder.get("cron", "")
+                    time_ = reminder.get("cron_h", "") + f"(Cron: {cron_expr})"
+                parts.append(f"{i + 1}. {reminder['text']} - {time_}\n")
+            parts.append("\n使用 /reminder rm <id> 删除待办事项。\n")
+            reminder_str = "".join(parts)
+            yield event.plain_result(reminder_str)
+
+    @reminder.command("rm")
+    async def reminder_rm(self, event: AstrMessageEvent, index: int):
+        """Remove a reminder by index."""
+        reminders = await self.get_upcoming_reminders(event.unified_msg_origin)
+
+        if not reminders:
+            yield event.plain_result("没有待办事项。")
+        elif index < 1 or index > len(reminders):
+            yield event.plain_result("索引越界。")
+        else:
+            reminder = reminders.pop(index - 1)
+            job_id = reminder.get("id")
+
+            # self.reminder_data[event.unified_msg_origin] = reminder
+            users_reminders = self.reminder_data.get(event.unified_msg_origin, [])
+            for i, r in enumerate(users_reminders):
+                if r.get("id") == job_id:
+                    users_reminders.pop(i)
+
+            try:
+                self.scheduler.remove_job(job_id)
+            except Exception as e:
+                logger.error(f"Remove job error: {e}")
+                yield event.plain_result(
+                    f"成功移除对应的待办事项。删除定时任务失败: {e!s} 可能需要重启 AstrBot 以取消该提醒任务。",
+                )
+            await self._save_data()
+            yield event.plain_result("成功删除待办事项：\n" + reminder["text"])
+
+    async def _reminder_callback(self, unified_msg_origin: str, d: dict):
+        """The callback function of the reminder."""
+        logger.info(f"Reminder Activated: {d['text']}, created by {unified_msg_origin}")
+        await self.context.send_message(
+            unified_msg_origin,
+            MessageEventResult().message(
+                "待办提醒: \n\n"
+                + d["text"]
+                + "\n时间: "
+                + d.get("datetime", "")
+                + d.get("cron_h", ""),
+            ),
+        )
+
+    async def terminate(self):
+        self.scheduler.shutdown()
+        await self._save_data()
+        logger.info("Reminder plugin terminated.")

astrbot/builtin_stars/reminder/metadata.yaml

@@ -0,0 +1,4 @@
+name: astrbot-reminder
+desc: 使用 LLM 待办提醒
+author: Soulter
+version: 0.0.1

astrbot/builtin_stars/session_controller/main.py

@@ -0,0 +1,114 @@
+import copy
+from sys import maxsize
+
+import astrbot.api.message_components as Comp
+from astrbot.api import logger
+from astrbot.api.event import AstrMessageEvent, filter
+from astrbot.api.star import Context, Star
+from astrbot.core.utils.session_waiter import (
+    FILTERS,
+    USER_SESSIONS,
+    SessionController,
+    SessionWaiter,
+    session_waiter,
+)
+
+
+class Main(Star):
+    """会话控制"""
+
+    def __init__(self, context: Context):
+        super().__init__(context)
+
+    @filter.event_message_type(filter.EventMessageType.ALL, priority=maxsize)
+    async def handle_session_control_agent(self, event: AstrMessageEvent):
+        """会话控制代理"""
+        for session_filter in FILTERS:
+            session_id = session_filter.filter(event)
+            if session_id in USER_SESSIONS:
+                await SessionWaiter.trigger(session_id, event)
+                event.stop_event()
+
+    @filter.event_message_type(filter.EventMessageType.ALL, priority=maxsize - 1)
+    async def handle_empty_mention(self, event: AstrMessageEvent):
+        """实现了对只有一个 @ 的消息内容的处理"""
+        try:
+            messages = event.get_messages()
+            cfg = self.context.get_config(umo=event.unified_msg_origin)
+            p_settings = cfg["platform_settings"]
+            wake_prefix = cfg.get("wake_prefix", [])
+            if len(messages) == 1:
+                if (
+                    isinstance(messages[0], Comp.At)
+                    and str(messages[0].qq) == str(event.get_self_id())
+                    and p_settings.get("empty_mention_waiting", True)
+                ) or (
+                    isinstance(messages[0], Comp.Plain)
+                    and messages[0].text.strip() in wake_prefix
+                ):
+                    if p_settings.get("empty_mention_waiting_need_reply", True):
+                        try:
+                            # 尝试使用 LLM 生成更生动的回复
+                            func_tools_mgr = self.context.get_llm_tool_manager()
+
+                            # 获取用户当前的对话信息
+                            curr_cid = await self.context.conversation_manager.get_curr_conversation_id(
+                                event.unified_msg_origin,
+                            )
+                            conversation = None
+
+                            if curr_cid:
+                                conversation = await self.context.conversation_manager.get_conversation(
+                                    event.unified_msg_origin,
+                                    curr_cid,
+                                )
+                            else:
+                                # 创建新对话
+                                curr_cid = await self.context.conversation_manager.new_conversation(
+                                    event.unified_msg_origin,
+                                    platform_id=event.get_platform_id(),
+                                )
+
+                            # 使用 LLM 生成回复
+                            yield event.request_llm(
+                                prompt=(
+                                    "注意，你正在社交媒体上中与用户进行聊天，用户只是通过@来唤醒你，但并未在这条消息中输入内容，他可能会在接下来一条发送他想发送的内容。"
+                                    "你友好地询问用户想要聊些什么或者需要什么帮助，回复要符合人设，不要太过机械化。"
+                                    "请注意，你仅需要输出要回复用户的内容，不要输出其他任何东西"
+                                ),
+                                func_tool_manager=func_tools_mgr,
+                                session_id=curr_cid,
+                                contexts=[],
+                                system_prompt="",
+                                conversation=conversation,
+                            )
+                        except Exception as e:
+                            logger.error(f"LLM response failed: {e!s}")
+                            # LLM 回复失败，使用原始预设回复
+                            yield event.plain_result("想要问什么呢？😄")
+
+                    @session_waiter(60)
+                    async def empty_mention_waiter(
+                        controller: SessionController,
+                        event: AstrMessageEvent,
+                    ):
+                        event.message_obj.message.insert(
+                            0,
+                            Comp.At(qq=event.get_self_id(), name=event.get_self_id()),
+                        )
+                        new_event = copy.copy(event)
+                        # 重新推入事件队列
+                        self.context.get_event_queue().put_nowait(new_event)
+                        event.stop_event()
+                        controller.stop()
+
+                    try:
+                        await empty_mention_waiter(event)
+                    except TimeoutError as _:
+                        pass
+                    except Exception as e:
+                        yield event.plain_result("发生错误，请联系管理员: " + str(e))
+                    finally:
+                        event.stop_event()
+        except Exception as e:
+            logger.error("handle_empty_mention error: " + str(e))

astrbot/builtin_stars/session_controller/metadata.yaml

@@ -0,0 +1,5 @@
+name: session_controller
+desc: 为插件支持会话控制
+author: Cvandia & Soulter
+version: v1.0.1
+repo: https://astrbot.app

astrbot/builtin_stars/web_searcher/engines/__init__.py

@@ -0,0 +1,111 @@
+import random
+import urllib.parse
+from dataclasses import dataclass
+
+from aiohttp import ClientSession
+from bs4 import BeautifulSoup, Tag
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 6.1; rv:84.0) Gecko/20100101 Firefox/84.0",
+    "Accept": "*/*",
+    "Connection": "keep-alive",
+    "Accept-Language": "en-GB,en;q=0.5",
+}
+
+USER_AGENT_BING = "Mozilla/5.0 (Windows NT 6.1; rv:84.0) Gecko/20100101 Firefox/84.0"
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Version/14.1.2 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Version/14.1 Safari/537.36",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0",
+]
+
+
+@dataclass
+class SearchResult:
+    title: str
+    url: str
+    snippet: str
+
+    def __str__(self) -> str:
+        return f"{self.title} - {self.url}\n{self.snippet}"
+
+
+class SearchEngine:
+    """搜索引擎爬虫基类"""
+
+    def __init__(self) -> None:
+        self.TIMEOUT = 10
+        self.page = 1
+        self.headers = HEADERS
+
+    def _set_selector(self, selector: str) -> str:
+        raise NotImplementedError
+
+    def _get_next_page(self, query: str):
+        raise NotImplementedError
+
+    async def _get_html(self, url: str, data: dict | None = None) -> str:
+        headers = self.headers
+        headers["Referer"] = url
+        headers["User-Agent"] = random.choice(USER_AGENTS)
+        if data:
+            async with (
+                ClientSession() as session,
+                session.post(
+                    url,
+                    headers=headers,
+                    data=data,
+                    timeout=self.TIMEOUT,
+                ) as resp,
+            ):
+                ret = await resp.text(encoding="utf-8")
+                return ret
+        else:
+            async with (
+                ClientSession() as session,
+                session.get(
+                    url,
+                    headers=headers,
+                    timeout=self.TIMEOUT,
+                ) as resp,
+            ):
+                ret = await resp.text(encoding="utf-8")
+                return ret
+
+    def tidy_text(self, text: str) -> str:
+        """清理文本，去除空格、换行符等"""
+        return text.strip().replace("\n", " ").replace("\r", " ").replace("  ", " ")
+
+    def _get_url(self, tag: Tag) -> str:
+        return self.tidy_text(tag.get_text())
+
+    async def search(self, query: str, num_results: int) -> list[SearchResult]:
+        query = urllib.parse.quote(query)
+
+        try:
+            resp = await self._get_next_page(query)
+            soup = BeautifulSoup(resp, "html.parser")
+            links = soup.select(self._set_selector("links"))
+            results = []
+            for link in links:
+                # Safely get the title text (select_one may return None)
+                title_elem = link.select_one(self._set_selector("title"))
+                title = ""
+                if title_elem is not None:
+                    title = self.tidy_text(title_elem.get_text())
+
+                url_tag = link.select_one(self._set_selector("url"))
+                snippet = ""
+                if title and url_tag:
+                    url = self._get_url(url_tag)
+                    results.append(SearchResult(title=title, url=url, snippet=snippet))
+            return results[:num_results] if len(results) > num_results else results
+        except Exception as e:
+            raise e

astrbot/builtin_stars/web_searcher/engines/bing.py

@@ -0,0 +1,30 @@
+from . import USER_AGENT_BING, SearchEngine
+
+
+class Bing(SearchEngine):
+    def __init__(self) -> None:
+        super().__init__()
+        self.base_urls = ["https://cn.bing.com", "https://www.bing.com"]
+        self.headers.update({"User-Agent": USER_AGENT_BING})
+
+    def _set_selector(self, selector: str):
+        selectors = {
+            "url": "div.b_attribution cite",
+            "title": "h2",
+            "text": "p",
+            "links": "ol#b_results > li.b_algo",
+            "next": 'div#b_content nav[role="navigation"] a.sb_pagN',
+        }
+        return selectors[selector]
+
+    async def _get_next_page(self, query) -> str:
+        # if self.page == 1:
+        #     await self._get_html(self.base_url)
+        for base_url in self.base_urls:
+            try:
+                url = f"{base_url}/search?q={query}"
+                return await self._get_html(url, None)
+            except Exception as _:
+                self.base_url = base_url
+                continue
+        raise Exception("Bing search failed")

astrbot/builtin_stars/web_searcher/engines/sogo.py

@@ -0,0 +1,52 @@
+import random
+import re
+from typing import cast
+
+from bs4 import BeautifulSoup, Tag
+
+from . import USER_AGENTS, SearchEngine, SearchResult
+
+
+class Sogo(SearchEngine):
+    def __init__(self) -> None:
+        super().__init__()
+        self.base_url = "https://www.sogou.com"
+        self.headers["User-Agent"] = random.choice(USER_AGENTS)
+
+    def _set_selector(self, selector: str):
+        selectors = {
+            "url": "h3 > a",
+            "title": "h3",
+            "text": "",
+            "links": "div.results > div.vrwrap:not(.middle-better-hintBox)",
+            "next": "",
+        }
+        return selectors[selector]
+
+    async def _get_next_page(self, query) -> str:
+        url = f"{self.base_url}/web?query={query}"
+        return await self._get_html(url, None)
+
+    def _get_url(self, tag: Tag) -> str:
+        return cast(str, tag.get("href"))
+
+    async def search(self, query: str, num_results: int) -> list[SearchResult]:
+        results = await super().search(query, num_results)
+        for result in results:
+            if result.url.startswith("/link?"):
+                result.url = self.base_url + result.url
+                result.url = await self._parse_url(result.url)
+        return results
+
+    async def _parse_url(self, url) -> str:
+        html = await self._get_html(url)
+        soup = BeautifulSoup(html, "html.parser")
+        script = soup.find("script")
+        if script:
+            script_text = (
+                script.string if script.string is not None else script.get_text()
+            )
+            match = re.search(r'window.location.replace\("(.+?)"\)', script_text)
+            if match:
+                url = match.group(1)
+        return url