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

{hyper-bot-0.75 → hyper-bot-0.78.2}/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,37 @@ 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 tester(message_data: Union[Event, HyperNotify], actions: Actions) -> None:
     ...
 
 
-async def __handler(data: dict, actions: Actions) -> None:
-    if data.get("echo") is not None:
-        reports.put(Manager.Ret(data))
-    elif data.get("post_type") == "meta_event" or data.get("user_id") == data.get("self_id"):
-        pass
+def __handler(data: Union[dict, HyperNotify], actions: Actions) -> None:
+    if isinstance(data, dict):
+        if data.get("echo") is not None:
+            reports.put(data.get("echo"), 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))
+            asyncio.run(handler(Events.em.new(data), actions))
+            # await 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
     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
+        asyncio.run(handler(data, actions))
 
 
 handler: callable = tester
-connection: callable = tester
 
 
 def reg(func: callable):
@@ -216,16 +213,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():
@@ -258,6 +246,12 @@ def run():
             logger.log("成功建立连接", level=Logger.levels.INFO)
             retried = 0
             actions = Actions(connection)
+            data = HyperListenerStartNotify(
+                time_now=int(time.time()),
+                notify_type="listener_start",
+                connection=connection
+            )
+            threading.Thread(target=lambda: __handler(data, actions)).start()
             while True:
                 try:
                     data = connection.recv()
@@ -266,7 +260,10 @@ 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()
+                # asyncio.create_task(__handler(data, actions))
     except KeyboardInterrupt:
         logger.log("正在退出(Ctrl+C)", level=Logger.levels.WARNING)
         try:
@@ -274,3 +271,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.2}/Hyper/Adapters/OneBotLib/Manager.py

@@ -1,11 +1,14 @@
-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()
+reports = Logic.KeyQueue()
 config = Configurator.cm.get_cfg()
 logger = Logger.Logger()
 logger.set_level(config.log_level)
@@ -33,7 +36,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 +73,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 = []
@@ -90,8 +113,21 @@ class Message:
 
 
 class Ret:
-    def __init__(self, json_data: dict):
+    def __init__(self, json_data: dict, serializer):
         self.status = json_data["status"]
         self.ret_code = json_data["retcode"]
-        self.data = json_data.get("data")
+        self.data = serializer(json_data.get("data"))
         self.echo = json_data.get("echo")
+
+    @classmethod
+    def fetch(cls, echo: str, serializer=Hyper.Utils.TypeExt.ObjectedJson) -> "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
+        return cls(reports.get(echo), serializer)

hyper-bot-0.78.2/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.2/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.2}/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):