hyper-bot 0.75__tar.gz → 0.78__tar.gz

{hyper-bot-0.75 → hyper-bot-0.78}/Hyper/Adapters/OneBot.py

@@ -1,15 +1,15 @@
 import json
-import queue
 import threading
 import time
 import asyncio
 import os
 from typing import Union
 
-from Hyper import Configurator, Errors, Logger, Logic, Manager, Network, Events
+from Hyper import Network, Events
+from Hyper.Utils import Errors, Logic
+from Hyper.Manager import reports
 from Hyper.Events import *
 
-reports = queue.Queue()
 config = Configurator.cm.get_cfg()
 logger = Logger.Logger()
 logger.set_level(config.log_level)
@@ -24,20 +24,13 @@ class Actions:
                 self.connection = cnt_i
 
             def __getattr__(self, item) -> callable:
-                def wrapper(no_return: bool, **kwargs) -> Manager.Ret | None:
-                    if no_return:
-                        Manager.Packet(
-                            str(item),
-                            **kwargs
-                        ).send_to(self.connection)
-                        return None
-                    else:
-                        packet = Manager.Packet(
-                            str(item),
-                            **kwargs
-                        )
-                        packet.send_to(self.connection)
-                        return get_ret(packet.echo)
+                async def wrapper(**kwargs) -> str:
+                    packet = Manager.Packet(
+                        str(item),
+                        **kwargs
+                    )
+                    packet.send_to(self.connection)
+                    return packet.echo
 
                 return wrapper
 
@@ -60,7 +53,7 @@ class Actions:
         else:
             raise Errors.ArgsInvalidError("'send' API requires 'group_id' or 'user_id' but none of them are provided.")
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     @Logger.AutoLogAsync.register(Logger.AutoLog.templates().recall, logger)
     async def del_message(self, message_id: int) -> None:
@@ -90,13 +83,13 @@ class Actions:
     async def get_login_info(self) -> Manager.Ret:
         packet = Manager.Packet("get_login_info")
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     @Logic.Cacher().cache_async
     async def get_version_info(self) -> Manager.Ret:
         packet = Manager.Packet("get_version_info")
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     async def send_forward_msg(self, message: Manager.Message) -> Manager.Ret:
         packet = Manager.Packet(
@@ -104,7 +97,7 @@ class Actions:
             messages=await message.get()
         )
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     async def send_group_forward_msg(self, group_id: int, message: Manager.Message) -> Manager.Ret:
         packet = Manager.Packet(
@@ -113,7 +106,7 @@ class Actions:
             messages=await message.get()
         )
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     @Logger.AutoLogAsync.register(Logger.AutoLog.templates().set_req, logger)
     async def set_group_add_request(self, flag: str, sub_type: str, approve: bool, reason: str = "Refused") -> None:
@@ -133,7 +126,7 @@ class Actions:
             no_cache=True,
         )
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     @Logic.Cacher().cache_async
     async def get_group_member_info(self, group_id: int, user_id: int) -> Manager.Ret:
@@ -144,7 +137,7 @@ class Actions:
             no_cache=True
         )
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     @Logic.Cacher().cache_async
     async def get_group_info(self, group_id: int) -> Manager.Ret:
@@ -154,12 +147,12 @@ class Actions:
             no_cache=True
         )
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     async def get_status(self) -> Manager.Ret:
         packet = Manager.Packet("get_status")
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
     @Logger.AutoLogAsync.register(Logger.AutoLog.templates().set_ess, logger)
     async def set_essence_msg(self, message_id: int) -> None:
@@ -182,33 +175,33 @@ class Actions:
             message_id=msg_id
         )
         packet.send_to(self.connection)
-        return get_ret(packet.echo)
+        return Manager.Ret.fetch(packet.echo)
 
 
 async def tester(message_data: Event, actions: Actions) -> None:
     ...
 
 
-async def __handler(data: dict, actions: Actions) -> None:
+def __handler(data: dict, actions: Actions) -> None:
     if data.get("echo") is not None:
-        reports.put(Manager.Ret(data))
+        reports.put(data)
     elif data.get("post_type") == "meta_event" or data.get("user_id") == data.get("self_id"):
         pass
     else:
-        task = asyncio.create_task(handler(Events.em.new(data), actions))
-        timed = 0
-
-        while not task.done():
-            await asyncio.sleep(0.1)
-            timed += 0.1
-            if timed >= 30:
-                task.cancel()
-                logger.log(f"处理{task.get_name()}超时", level=Logger.levels.ERROR)
-                break
+        # task = asyncio.create_task(handler(Events.em.new(data), actions))
+        asyncio.run(handler(Events.em.new(data), actions))
+        # timed = 0
+        #
+        # while not task.done():
+        #     time.sleep(0.1)
+        #     timed += 0.1
+        #     if timed >= 30:
+        #         task.cancel()
+        #         logger.log(f"处理{task.get_name()}超时", level=Logger.levels.ERROR)
+        #         break
 
 
 handler: callable = tester
-connection: callable = tester
 
 
 def reg(func: callable):
@@ -216,16 +209,7 @@ def reg(func: callable):
     handler = func
 
 
-def get_ret(echo: str) -> Manager.Ret:
-    old = None
-    while True:
-        content: Manager.Ret = reports.get()
-        if old is not None:
-            reports.put(old)
-        if content.echo == echo:
-            return content
-        else:
-            old = content
+connection: Union[Network.WebsocketConnection, Network.HTTPConnection]
 
 
 def run():
@@ -266,7 +250,9 @@ def run():
                     break
                 except json.decoder.JSONDecodeError:
                     logger.log("收到错误的JSON内容", level=Logger.levels.ERROR)
-                threading.Thread(target=lambda: asyncio.run(__handler(data, actions))).start()
+                    continue
+                # threading.Thread(target=lambda: asyncio.run(__handler(data, actions))).start()
+                threading.Thread(target=lambda: __handler(data, actions)).start()
     except KeyboardInterrupt:
         logger.log("正在退出(Ctrl+C)", level=Logger.levels.WARNING)
         try:
@@ -274,3 +260,11 @@ def run():
         except:
             pass
         os._exit(0)
+
+
+def stop() -> None:
+    try:
+        connection.close()
+    except:
+        pass
+    logger.log("停止运行监听器", level=Logger.levels.WARNING)

{hyper-bot-0.75 → hyper-bot-0.78}/Hyper/Adapters/OneBotLib/Manager.py

@@ -1,11 +1,13 @@
-from Hyper import Logic, Configurator, Logger, Network
-from Hyper.Logger import levels
-from Hyper.Segments import *
+import Hyper.Utils.TypeExt
+from Hyper import Configurator, Logger, Network, Segments
+from Hyper.Utils import Logic
 
 from typing import Union
-import inspect
+import queue
 import random
+import json
 
+reports = queue.Queue()
 config = Configurator.cm.get_cfg()
 logger = Logger.Logger()
 logger.set_level(config.log_level)
@@ -33,7 +35,30 @@ class Packet:
             connection.send(self.endpoint, payload, self.echo)
 
 
+class MessageBuilder:
+    def __init__(self):
+        self.sgs = []
+
+    def __getattr__(self, item):
+        if item == "build":
+            def build() -> Message:
+                return Message(*self.sgs)
+
+            return build
+
+        elif item in Segments.message_types.keys():
+            def wrapper(*args, **kwargs):
+                self.sgs.append(Segments.message_types[item]["type"](*args, **kwargs))
+                return self
+
+            return wrapper
+        else:
+            return None
+
+
 class Message:
+    builder = MessageBuilder()
+
     def __init__(self, *args):
         if len(args) == 1 and isinstance(args[0], list):
             contents = args[0]
@@ -47,10 +72,7 @@ class Message:
         self.contents.append(content)
 
     async def get(self) -> list:
-        ret = []
-        for i in self.contents:
-            ret.append(i.to_json())
-        return ret
+        return self.get_sync()
 
     def get_sync(self) -> list:
         ret = []
@@ -93,5 +115,17 @@ class Ret:
     def __init__(self, json_data: dict):
         self.status = json_data["status"]
         self.ret_code = json_data["retcode"]
-        self.data = json_data.get("data")
+        self.data = Hyper.Utils.TypeExt.ObjectedJson(json_data.get("data"))
         self.echo = json_data.get("echo")
+
+    @classmethod
+    def fetch(cls, echo: str) -> "Ret":
+        old = None
+        while True:
+            content = reports.get()
+            if old is not None:
+                reports.put(old)
+            if content["echo"] == echo:
+                return cls(content)
+            else:
+                old = content

hyper-bot-0.78/Hyper/Adapters/OneBotLib/Res.py

@@ -0,0 +1,111 @@
+message_types = {}
+
+
+def segment_builder(sg_type: str, summary_tmp: str = None):
+    # print(inspect.get_annotations(cls))
+    def inner_builder(cls):
+        var = dict(vars(cls))
+        anns: dict = var.get("__annotations__", False) or dict()
+
+        def init(self, *args, **kwargs):
+            arg = {}
+            if len(args) > 0:
+                for i in args:
+                    arg[list(anns.keys())[list(args).index(i)]] = i
+
+            if len(kwargs) > 0:
+                for i in kwargs:
+                    try:
+                        arg[i] = anns[i](kwargs[i])
+                    except TypeError:
+                        arg[i] = kwargs[i]
+            new_arg = arg.copy()
+
+            if len(anns) > len(arg):
+                for i in anns.keys():
+                    if i not in arg.keys():
+                        if i not in var.keys():
+                            new_arg[i] = None
+                            continue
+                        if not isinstance(var[i], anns[i]):
+                            new_arg[i] = anns[i](var[i])
+                        else:
+                            new_arg[i] = var[i]
+
+            for i in new_arg:
+                setattr(self, i, new_arg[i])
+
+        cls.__init__ = init
+
+        def to_json(self) -> dict:
+            base = {"type": sg_type, "data": {}}
+            for i in anns:
+                if getattr(self, i) is None:
+                    continue
+                if not isinstance(getattr(self, i), anns[i]):
+                    base["data"][i] = anns[i](getattr(self, i))
+                else:
+                    base["data"][i] = getattr(self, i)
+                # try:
+                #     base["data"][i] = anns[i](getattr(self, i))
+                # except TypeError:
+                #     base["data"][i] = getattr(self, i)
+            return base
+
+        cls.to_json = to_json
+
+        def to_str(self) -> str:
+            text = summary_tmp
+            if text is None:
+                text = "[]"
+            if "<" not in text and ">" not in text:
+                return text
+
+            for i in anns:
+                if f"<{i}>" in summary_tmp:
+                    try:
+                        v = self.__getattribute__(i)
+                    except AttributeError:
+                        v = None
+                    text = text.replace(f"<{i}>", str(v))
+
+            return text
+
+        cls.__str__ = to_str if cls().__str__() == "__not_set__" else cls.__str__
+
+        def eq(self, other) -> bool:
+            if type(self) is type(other) and self.to_json() == other.to_json():
+                return True
+            else:
+                return False
+
+        cls.__eq__ = eq
+
+        def ne(self, other) -> bool:
+            if type(self) is type(other) and self.to_json() == other.to_json():
+                return False
+            else:
+                return True
+
+        cls.__ne__ = ne
+
+        message_types[sg_type] = {
+            "type": cls,
+            "args": list(anns.keys())
+        }
+
+        return cls
+
+    return inner_builder
+
+
+class Base:
+    def __init__(self, *args, **kwargs): ...
+
+    def to_json(self) -> dict: ...
+
+    def __str__(self) -> str: return "__not_set__"
+
+    def __eq__(self, other) -> bool: ...
+
+    def __ne__(self, other) -> bool: ...

hyper-bot-0.78/Hyper/Adapters/Satori.py

@@ -0,0 +1,105 @@
+from Hyper.Adapters.OneBot import *
+from Hyper.Utils.Errors import *
+
+
+class Actions(Actions):
+    def __init__(self, cnt: Union[Network.WebsocketConnection, Network.HTTPConnection, Network.SatoriConnection]):
+        self.connection = cnt
+
+        class CustomAction:
+            def __init__(self,
+                         cnt_i: Union[Network.WebsocketConnection, Network.HTTPConnection, Network.SatoriConnection]):
+                self.connection = cnt_i
+
+            def __getattr__(self, item) -> callable:
+                def wrapper(**kwargs) -> str:
+                    packet = Manager.Packet(
+                        str(item),
+                        **kwargs
+                    )
+                    packet.send_to(self.connection)
+                    return packet.echo
+
+                return wrapper
+
+        self.custom = CustomAction(self.connection)
+
+
+async def __handler(data: dict, actions: Actions) -> None:
+    if data["op"] == 2:
+        pass
+    else:
+        # task = asyncio.create_task(handler(Events.em.new(data), actions))
+        # timed = 0
+        #
+        # while not task.done():
+        #     await asyncio.sleep(0.1)
+        #     timed += 0.1
+        #     if timed >= 30:
+        #         task.cancel()
+        #         logger.log(f"处理{task.get_name()}超时", level=Logger.levels.ERROR)
+        #         break
+        print(data)
+
+
+def reg(func: callable):
+    global handler
+    handler = func
+
+
+connection: Union[Network.WebsocketConnection, Network.SatoriConnection]
+
+
+def run():
+    global connection
+    try:
+        if handler is tester:
+            raise Errors.ListenerNotRegisteredError("No handler registered")
+        # connection = websocket.WebSocket()
+        if isinstance(config.connection, Configurator.WSConnectionC):
+            connection = Network.SatoriConnection(
+                config.connection.host, config.connection.port, config.connection.token
+            )
+        else:
+            raise ConfigError
+        retried = 0
+        while True:
+            try:
+                connection.connect()
+            except ConnectionRefusedError or TimeoutError:
+                if retried >= config.connection.retries:
+                    logger.log(f"重试次数达到最大值({config.connection.retries})，退出", level=Logger.levels.CRITICAL)
+                    break
+
+                logger.log(f"连接建立失败，3秒后重试({retried}/{config.connection.retries})",
+                           level=Logger.levels.WARNING)
+                retried += 1
+                time.sleep(3)
+                continue
+            logger.log("成功建立连接", level=Logger.levels.INFO)
+            retried = 0
+            actions = Actions(connection)
+            while True:
+                try:
+                    data = connection.recv()
+                except ConnectionResetError:
+                    logger.log("连接断开", level=Logger.levels.ERROR)
+                    break
+                except json.decoder.JSONDecodeError:
+                    logger.log("收到错误的JSON内容", level=Logger.levels.ERROR)
+                threading.Thread(target=lambda: asyncio.run(__handler(data, actions))).start()
+    except KeyboardInterrupt:
+        logger.log("正在退出(Ctrl+C)", level=Logger.levels.WARNING)
+        try:
+            connection.close()
+        except:
+            pass
+        os._exit(0)
+
+
+def stop() -> None:
+    try:
+        connection.close()
+    except:
+        pass
+    logger.log("停止运行监听器", level=Logger.levels.WARNING)

{hyper-bot-0.75 → hyper-bot-0.78}/Hyper/Configurator.py

@@ -1,13 +1,23 @@
+import json
 import typing
 
-from Hyper import Logic
+from Hyper.Utils import Logic
 
 
 class WSConnectionC:
-    def __init__(self, host: str, port: int, retries: int = 0):
+    def __init__(self, host: str, port: int, retries: int = 0, satori_token: str = None):
         self.host: str = host
         self.port: int = port
         self.retries: int = retries
+        self.token: str = satori_token
+
+    def to_json(self) -> dict:
+        return dict(
+            host=self.host,
+            port=self.port,
+            retries=self.retries,
+            satori_token=self.token
+        )
 
 
 class HTTPConnectionC:
@@ -18,6 +28,15 @@ class HTTPConnectionC:
         self.listener_port: int = listener_port
         self.retries: int = retries
 
+    def to_json(self) -> dict:
+        return dict(
+            host=self.host,
+            port=self.port,
+            listener_host=self.listener_host,
+            listener_port=self.listener_port,
+            retries=self.retries
+        )
+
 
 class Config:
     def __init__(
@@ -55,7 +74,8 @@ class Config:
             self.connection = WSConnectionC(
                 config_json["Connection"]["host"],
                 config_json["Connection"]["port"],
-                config_json["Connection"]["retries"]
+                config_json["Connection"]["retries"],
+                config_json["Connection"].get("satori_token")
             )
         elif config_json["Connection"]["mode"] == "HTTP":
             self.connection = HTTPConnectionC(
@@ -71,6 +91,21 @@ class Config:
         self.inited = True
         return self
 
+    def dump(self, file: str = None) -> None:
+        if file or self.file:
+            file = file or self.file
+            cfg = dict(
+                owner=self.owner,
+                black_list=self.black_list,
+                silents=self.silents,
+                Connection=self.connection.to_json(),
+                log_level=self.log_level,
+                protocol=self.protocol,
+                Others=self.others
+            )
+            with open(file, "w", encoding="utf-8") as f:
+                f.write(json.dumps(cfg, indent=2))
+
 
 class ConfigManager:
     def __init__(self, config: Config):

{hyper-bot-0.75 → hyper-bot-0.78}/Hyper/Events.py

@@ -1,5 +1,6 @@
 from Hyper import Configurator, Logger, Manager
-from Hyper.Segments import message_types
+from Hyper.Utils.TypeExt import Integer
+from Hyper.Segments import message_types, At
 from Hyper.Logger import levels
 
 config = Configurator.cm.get_cfg()
@@ -14,10 +15,12 @@ class EventManager:
             "notice": {},
             "request": {}
         }
+        self.events = []
 
     def reg(self, type_of: str, str_eql: str) -> callable:
         def wrapper(cls):
             self.event_lis[type_of][str_eql] = cls
+            self.events.append(cls)
             return cls
 
         return wrapper
@@ -28,6 +31,7 @@ class EventManager:
         except KeyError:
             typ = data[f"{data['post_type']}_type"]
             logger.log(f"不存在的事件类型：{data['post_type']}.{typ}", levels.WARNING)
+            logger.log(str(data), levels.DEBUG)
             return Event(data)
 
 
@@ -75,6 +79,7 @@ def gen_message(data: dict) -> Manager.Message:
             message.add(message_types[i["type"]]["type"](*args))
         else:
             logger.log(f"无法序列化的消息段 {i['type']}", levels.WARNING)
+            logger.log(str(i), levels.DEBUG)
 
     return message
 
@@ -88,8 +93,7 @@ class Event:
         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.is_owner = Integer.convert_from(self.user_id) in config.owner
         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
 
@@ -103,6 +107,7 @@ class MessageEvent(Event):
         self.sub_type = data.get("sub_type")
         self.message_id = str(data.get("message_id"))
         self.message = gen_message(data=data)
+        self.msg_str = str(self.message)
 
 
 @em.reg("message", "private")
@@ -123,6 +128,7 @@ class GroupMessageEvent(MessageEvent):
         super().__init__(data)
         self.sender = GroupSender(data.get("sender"))
         self.anonymous = GroupAnonymous(data.get("anonymous"))
+        self.is_mentioned = True if At(str(self.self_id)) in self.message else False
 
         self.print_log()
 
@@ -245,6 +251,33 @@ class NotifyEvent(NoticeEvent):
         self.honor_type = data.get("honor_type")
 
 
+@em.reg("notice", "essence")
+class GroupEssenceEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.sub_type = data.get("sub_type")
+        self.sender_id = data.get("sender_id")
+        self.operator_id = data.get("operator_id")
+        self.message_id = data.get("message_id")
+
+        self.print_log()
+
+    def print_log(self) -> None:
+        action = "设置" if self.sub_type == "add" else "移除"
+        logger.log(f"{self.operator_id} 在群 {self.group_id} 中将 {self.sender_id} 的消息 {self.message_id} {action}精华")
+
+
+@em.reg("notice", "reaction")
+class MessageReactionEvent(NoticeEvent):
+    def __init__(self, data: dict):
+        super().__init__(data)
+        self.message_id = data.get("message_id")
+        self.operator_id = data.get("operator_id")
+        self.sub_type = data.get("sub_type")
+        self.code = data.get("code")
+        self.count = data.get("count")
+
+
 class RequestEvent(Event):
     def __init__(self, data: dict):
         super().__init__(data)

hyper-bot-0.78/Hyper/Listener.py

@@ -0,0 +1,18 @@
+from Hyper import Configurator
+
+import sys
+import os
+
+config = Configurator.cm.get_cfg()
+
+if config.protocol == "OneBot":
+    from Hyper.Adapters.OneBot import *
+elif config.protocol == "Satori":
+    from Hyper.Adapters.Satori import *
+
+
+def restart() -> None:
+    stop()
+    os.execv(sys.executable, ['python'] + sys.argv)
+    os._exit(1)
+