hyper-bot 0.7__py3-none-any.whl

Hyper/Events.py

@@ -0,0 +1,268 @@
+from Hyper import Configurator, Logger, Manager
+from Hyper.Segments import message_types
+from Hyper.Logger import levels
+
+config = Configurator.cm.get_cfg()
+logger = Logger.Logger()
+logger.set_level(config.log_level)
+
+
+class EventManager:
+    def __init__(self):
+        self.event_lis = {
+            "message": {},
+            "notice": {},
+            "request": {}
+        }
+
+    def reg(self, type_of: str, str_eql: str) -> callable:
+        def wrapper(cls):
+            self.event_lis[type_of][str_eql] = cls
+            return cls
+
+        return wrapper
+
+    def new(self, data: dict) -> "Event":
+        try:
+            return self.event_lis[data["post_type"]][data[f"{data['post_type']}_type"]](data)
+        except KeyError:
+            typ = data[f"{data['post_type']}_type"]
+            logger.log(f"不存在的事件类型：{data['post_type']}.{typ}", levels.WARNING)
+            return Event(data)
+
+
+em = EventManager()
+
+
+class GroupSender:
+    def __init__(self, json_data: dict):
+        self.user_id = json_data.get("user_id")
+        self.nickname = json_data.get("nickname")
+        self.sex = json_data.get("sex")
+        self.age = json_data.get("age")
+        self.card = json_data.get("card")
+        self.area = json_data.get("area")
+        self.level = json_data.get("level")
+        self.role = json_data.get("role")
+        self.title = json_data.get("title")
+
+
+class PrivateSender:
+    def __init__(self, json_data: dict):
+        self.user_id = json_data.get("user_id")
+        self.nickname = json_data.get("nickname")
+        self.sex = json_data.get("sex")
+        self.age = json_data.get("age")
+
+
+class GroupAnonymous:
+    def __init__(self, json_data: dict):
+        if json_data is None:
+            pass
+        else:
+            self.id = json_data.get("id")
+            self.name = json_data.get("name")
+            self.flag = json_data.get("flag")
+
+
+def gen_message(data: dict) -> Manager.Message:
+    message = Manager.Message()
+    for i in data["message"]:
+        if i["type"] in message_types:
+            args = []
+            for j in message_types[i["type"]]["args"]:
+                args.append(i["data"].get(j))
+            message.add(message_types[i["type"]]["type"](*args))
+        else:
+            logger.log(f"无法序列化的消息段 {i['type']}", levels.WARNING)
+
+    return message
+
+
+class Event:
+    def __init__(self, data: dict):
+        self.data = data
+        self.time = data.get("time")
+        self.self_id = data.get("self_id")
+        self.post_type = data.get("post_type")
+        self.user_id = data.get("user_id")
+        self.group_id = data.get("group_id")
+
+        self.is_owner = int(self.user_id) in config.owner
+        self.servicing = False
+        self.blocked = True if self.user_id in config.black_list or self.group_id in config.black_list else False
+        self.is_silent = self.user_id in config.silents or self.group_id in config.silents or 0 in config.silents
+
+    def print_log(self, **kwargs) -> None:
+        ...
+
+
+class MessageEvent(Event):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+        self.message_id = str(data.get("message_id"))
+        self.message = gen_message(data=data)
+
+
+@em.reg("message", "private")
+class PrivateMessageEvent(MessageEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sender = PrivateSender(data.get("sender"))
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"收到 {self.user_id} 的消息：{self.message}")
+
+
+@em.reg("message", "group")
+class GroupMessageEvent(MessageEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sender = GroupSender(data.get("sender"))
+        self.anonymous = GroupAnonymous(data.get("anonymous"))
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"收到来自群 {self.group_id} 中 {self.user_id} 的消息： {self.message}")
+
+
+class NoticeEvent(Event):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.notice_type = data.get("notice_type")
+
+
+@em.reg("notice", "group_upload")
+class GroupFileUploadEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.file = data.get("file")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"{self.user_id} 在 {self.group_id} 上传了文件 {self.file}")
+
+
+@em.reg("notice", "group_admin")
+class GroupAdminEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"用户 {self.user_id} 在群 {self.group_id} 被{'设置' if self.sub_type == 'set' else '取消'}管理员身份")
+
+
+@em.reg("notice", "group_decrease")
+class GroupMemberDecreaseEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+        self.operator_id = data.get("operator_id")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"{self.user_id} 离开群 {self.group_id}， [{self.sub_type}, {self.operator_id}]")
+
+
+@em.reg("notice", "group_increase")
+class GroupMemberIncreaseEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+        self.operator_id = data.get("operator_id")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"{self.user_id} 加入群 {self.group_id}， [{self.sub_type}, {self.operator_id}]")
+
+
+@em.reg("notice", "group_ban")
+class GroupMuteEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+        self.operator_id = data.get("operator_id")
+        self.duration = data.get("duration")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"{self.user_id} 在群 {self.group_id} 被{'' if self.sub_type == 'ban' else '解除'}禁言， 时长为{self.duration}")
+
+
+@em.reg("notice", "friend_add")
+class FriendAddEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"收到 {self.user_id} 的好友请求")
+
+
+@em.reg("notice", "group_recall")
+class GroupRecallEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.operator_id = data.get("operator_id")
+        self.message_id = data.get("message_id")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"{self.operator_id} 在群 {self.group_id} 中撤回了 {self.user_id} 的消息 {self.message_id}")
+
+
+@em.reg("notice", "friend_recall")
+class FriendRecallEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.message_id = data.get("message_id")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        logger.log(f"{self.user_id} 撤回了一条消息")
+
+
+@em.reg("notice", "notify")
+class NotifyEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+        self.target_id = data.get("target_id")
+        self.honor_type = data.get("honor_type")
+
+
+class RequestEvent(Event):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.comment = data.get("comment")
+        self.flag = data.get("flag")
+
+
+@em.reg("request", "friend")
+class FriendAddEvent(RequestEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+
+
+@em.reg("request", "group")
+class GroupAddInviteEvent(RequestEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+
+
+

Hyper/Listener.py

@@ -0,0 +1,7 @@
+from Hyper import Configurator
+
+config = Configurator.cm.get_cfg()
+
+if config.protocol == "OneBot":
+    from Hyper.Adapters.OneBot import *
+servicing = []

Hyper/Logger.py

@@ -0,0 +1,156 @@
+import textwrap
+import datetime
+import typing
+import inspect
+from functools import wraps
+
+
+class Levels:
+    def __init__(self):
+        self.TRACE = f"✔️ \033[{47}m\033[{30}mTRACE \033[0m\033[0m "
+        self.INFO = f"ℹ️ \033[{47}m\033[{30}mINFO \033[0m\033[0m "
+        self.WARNING = f"⚠️ \033[{43}mWARN \033[0m "
+        self.ERROR = f"❌ \033[{41}mERROR\033[0m "
+        self.CRITICAL = f"🔴 \033[{41};{1}m*CRIT\033[0m "
+        self.DEBUG = f"🛠️ \033[{43}mDEBUG\033[0m "
+
+        self.level_nums = {
+            self.TRACE: -1,
+            self.INFO: 0,
+            self.WARNING: 1,
+            self.ERROR: 2,
+            self.CRITICAL: 3,
+            self.DEBUG: 10,
+        }
+
+        self.level_names = {
+            "TRACE": self.TRACE,
+            "INFO": self.INFO,
+            "WARNING": self.WARNING,
+            "ERROR": self.ERROR,
+            "CRITICAL": self.CRITICAL,
+            "DEBUG": self.DEBUG,
+        }
+
+
+levels = Levels()
+
+
+class Logger:
+    def __init__(self):
+        self.log_level = levels.INFO
+
+    def set_level(self, level: str):
+        if level in levels.level_names:
+            self.log_level = levels.level_names[level]
+        else:
+            self.log("未知的日志等级", levels.ERROR)
+
+    def log(self, message: str, level: str = levels.INFO):
+        if levels.level_nums[level] < levels.level_nums[self.log_level]:
+            return None
+        time = datetime.datetime.now()
+        if "\n" in message:
+            listed = message.split("\n")
+            for i in listed:
+                content = f" \033[38;5;244m[{str(time)[:-4]}]\033[0m {level} {i}"
+                print(content)
+        else:
+            content = f" \033[38;5;244m[{str(time)[:-4]}]\033[0m {level} {message}"
+            print(content)
+
+
+class AutoLog:
+    def __init__(self, func: callable, template: str, logger: Logger, level: str = levels.INFO):
+        self.func = func
+        self.template = template
+        self.logger = logger
+        self.level = level
+
+    @staticmethod
+    def templates(lang: str = "zh_CN"):
+        class Base:
+            on_message: str
+            on_notice: str
+            on_request: str
+            send: str
+            recall: str
+            kick: str
+            mute: str
+            unmute: str
+            set_req: str
+            set_ess: str
+
+        if lang == "zh_CN":
+            class Templates(Base):
+                on_message = "收到群 <group_id> 中 <user_id> 的消息：<message>"
+                on_notice = "在 <group_id> 中 <operator_id> 对 <user_id> 进行了 <notice_type>/<sub_type> 操作"
+                on_request = "在群 <group_id> 收到来自 <user_id> 的 <request_type>/<sub_type> 请求"
+                send = "向群 <group_id> 用户 <user_id> 发送消息：<message>"
+                recall = "撤回消息 <message_id>"
+                kick = "将 <user_id> 踢出 <group_id>"
+                mute = "将 <user_id> 在 <group_id> 禁言 <duration> 秒"
+                unmute = "将 <user_id> 在 <group_id> 解除禁言"
+                set_req = "处理 <sub_type> 请求 <flag> 的结果为 <approve>"
+                set_ess = "将 <message_id> 设为精华"
+        else:
+            class Templates(Base):
+                on_message = "Msg received in grp <group_id> from <user_id> : <message>"
+                on_notice = "<operator_id> acted '<notice_type>/<sub_type>' to <user_id> in <group_id>"
+                on_request = "Received '<request_type>/<sub_type>' request from <user_id> in <group_id>"
+                send = "Sent a msg in grp <group_id> to <user_id> : <message>"
+                recall = "Deleted <message_id>"
+                kick = "kicked <user_id> out of <group_id>"
+                mute = "Muted <user_id> in <group_id> for <duration>s"
+                unmute = "Unmuted <user_id> in <group_id>"
+                set_req = "Resulted <sub_type>/<flag> as <approve>"
+                set_ess = "Pinned msg <message_id>"
+
+        return Templates
+
+    def __rel_tpl(self, args: dict) -> str:
+        log = self.template
+        for i in args:
+            if f"<{i}>" in log:
+                log = log.replace(f"<{i}>", str(args[i]))
+        return log
+
+    @classmethod
+    def register(cls, *args, **kwargs) -> callable:
+        def create(func):
+            @wraps(func)
+            def wrapper(*args_, **kwargs_):
+                return cls(func, *args, **kwargs)(*args_, **kwargs_)
+
+            return wrapper
+
+        return create
+
+    def handler(self, res, *args, **kwargs) -> typing.Any:
+        sig = inspect.signature(self.func)
+        argv = {}
+
+        if len(list(args)) > 0:
+            sigs = list(sig.parameters.items())
+            for i in list(args):
+                index = list(args).index(i)
+                argv[sigs[index][0]] = i
+
+        if len(kwargs) > 0:
+            for i in kwargs:
+                argv[i] = kwargs[i]
+
+        log = self.__rel_tpl(argv)
+        self.logger.log(log, level=self.level)
+
+        return res
+
+    def __call__(self, *args, **kwargs) -> typing.Any:
+        res = self.func(*args, **kwargs)
+        return self.handler(res, *args, **kwargs)
+
+
+class AutoLogAsync(AutoLog):
+    async def __call__(self, *args, **kwargs) -> typing.Any:
+        res = await self.func(*args, **kwargs)
+        return self.handler(res, *args, **kwargs)

Hyper/Logic.py

@@ -0,0 +1,167 @@
+import json
+import os
+import shutil
+import traceback
+
+from Hyper import Logger
+
+
+class Cacher:
+    def __init__(self, cache_time: int = 5):
+        self.cache_time: int = cache_time
+        self.cached: dict = {}
+
+    def cache(self, func):
+        def wrapper(*args, **kwargs):
+            if kwargs.get("no_cache", False):
+                kwargs.pop("no_cache")
+                return func(*args, **kwargs)
+            if str(kwargs) not in self.cached:
+                ret = func(*args, **kwargs)
+                self.cached[str(kwargs)] = ret
+                if len(self.cached) >= self.cache_time:
+                    for i in self.cached:
+                        del self.cached[i]
+                        break
+                return ret
+            else:
+                return self.cached[str(kwargs)]
+
+        return wrapper
+
+    def cache_async(self, func):
+        async def wrapper(*args, **kwargs):
+            if kwargs.get("no_cache", False):
+                kwargs.pop("no_cache")
+                return await func(*args, **kwargs)
+            if str(kwargs) not in self.cached:
+                ret = await func(*args, **kwargs)
+                self.cached[str(kwargs)] = ret
+                if len(self.cached) >= self.cache_time:
+                    for i in self.cached:
+                        del self.cached[i]
+                        break
+                return ret
+            else:
+                return self.cached[str(kwargs)]
+
+        return wrapper
+
+
+class ErrorHandler:
+    def __init__(self, level=Logger.levels.ERROR, retries: int = 0):
+        self.level = level
+        self.logger = Logger.Logger()
+        self.retries = retries
+
+    def handle(self, func):
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except:
+                self.logger.log(f"出现错误：\n{str(traceback.format_exc())}", level=self.level)
+
+        return wrapper
+
+    def handle_async(self, func):
+        async def wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except:
+                self.logger.log(f"出现错误：\n{str(traceback.format_exc())}", level=self.level)
+
+        return wrapper
+
+    def auto_retry(self, func):
+        def wrapper(*args, **kwargs):
+            retried = 0
+            while retried < self.retries:
+                retried += 1
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    self.logger.log(f"出现错误：\n{str(e)}, 正在重试...", level=self.level)
+            self.logger.log(f"错误在{retried}次重试后失败", level=self.level)
+
+        return wrapper
+
+    def auto_retry_async(self, func):
+        async def wrapper(*args, **kwargs):
+            retried = 0
+            while retried < self.retries:
+                retried += 1
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    self.logger.log(f"出现错误：\n{str(e)}, 正在重试...", level=self.level)
+            self.logger.log(f"错误在{retried}次重试后失败", level=self.level)
+
+        return wrapper
+
+
+class Random:
+    def __init__(self, seed: int = None):
+        self.seed = seed
+
+    def random(self) -> int:
+        self.seed = self.seed ** 2
+        self.seed = int(str(self.seed)[:7])
+        return int(str(self.seed)[1:5])
+
+    def __call__(self) -> int:
+        return self.random()
+
+
+class FileManager:
+    @staticmethod
+    def create(path: str) -> bool:
+        try:
+            with open(path, "w") as f:
+                f.write("")
+        except (FileExistsError | OSError | IOError):
+            return False
+
+        return True
+
+    @staticmethod
+    def exists(path: str) -> bool:
+        try:
+            with open(path, "r") as f:
+                f.read()
+                return True
+        except FileNotFoundError:
+            return False
+
+    @staticmethod
+    @Cacher(7).cache
+    def read_as_text(path: str, encoding: str = "utf-8") -> str:
+        with open(path, "r", encoding=encoding) as f:
+            return f.read()
+
+    @staticmethod
+    @Cacher(7).cache
+    def read_as_json(path: str, encoding: str = "utf-8") -> dict | list:
+        with open(path, "r", encoding=encoding) as f:
+            return json.load(f)
+
+    @staticmethod
+    @Cacher(7).cache
+    def read_raw(path: str) -> bytes:
+        with open(path, "rb") as f:
+            return f.read()
+
+    @staticmethod
+    def delete(path: str) -> bool:
+        try:
+            os.remove(path)
+            return True
+        except (FileNotFoundError | OSError | IOError):
+            return False
+
+    @staticmethod
+    def copy(path1: str, path2: str) -> bool:
+        try:
+            shutil.copy(path1, path2)
+            return True
+        except (FileNotFoundError | OSError | IOError):
+            return False

Hyper/Manager.py

@@ -0,0 +1,6 @@
+from Hyper.Configurator import *
+
+config = cm.get_cfg()
+
+if config.protocol == "OneBot":
+    from Hyper.Adapters.OneBotLib.Manager import *

Hyper/ModuleClass.py

@@ -0,0 +1,67 @@
+from Hyper import Events, Listener, Logger, Configurator
+
+import dataclasses
+
+config = Configurator.cm.get_cfg()
+logger = Logger.Logger()
+logger.set_level(config.log_level)
+
+
+@dataclasses.dataclass
+class ModuleInfo:
+    is_hidden: bool = True
+    module_name: str = "None"
+    author: str = "None"
+    version: str = "0.0"
+    desc: str = "None"
+    helps: str = "None"
+
+
+class Module:
+    def __init__(self, actions, event):
+        self.actions = actions
+        self.event = event
+
+    async def handle(self):
+        pass
+
+    @staticmethod
+    def info() -> ModuleInfo:
+        return ModuleInfo()
+
+
+class InnerHandler:
+    def __init__(self, module: Module, allowed: list):
+        self.module = module
+        self.allowed = allowed
+
+
+register_modules: list[InnerHandler] = []
+
+
+class ModuleRegister:
+    @staticmethod
+    def register(*args):
+        def decorator(cls):
+            if len(args) < 1:
+                allowed = [Events.Event]
+            else:
+                allowed = list(args)
+
+            from typing import Union
+
+            def init(self, actions: Listener.Actions, event: Union[*allowed]):
+                self.actions = actions
+                self.event = event
+
+            cls.__init__ = init
+
+            register_modules.append(InnerHandler(cls, allowed))
+
+            return cls
+
+        return decorator
+
+    @staticmethod
+    def get_registered() -> list:
+        return register_modules