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

hyper-bot-0.78.7/Hyper/Adapters/Kritor.py

@@ -0,0 +1,114 @@
+import asyncio
+from typing import Union
+import os
+import threading
+import time
+
+from Hyper.Adapters.OneBot import Actions as OneBotActions
+from Hyper.Events import Event, HyperNotify, HyperListenerStartNotify
+from Hyper.Network import KritorConnection
+from Hyper.Utils import Errors
+from Hyper import Configurator, Logger
+
+config = Configurator.cm.get_cfg()
+logger = Logger.Logger()
+logger.set_level(config.log_level)
+
+
+class Actions(OneBotActions):
+    def __init__(self, cnt: KritorConnection):
+        self.connection = cnt
+
+
+async def tester(message_data: Union[Event, HyperNotify], actions: Actions) -> None:
+    ...
+
+
+def __handler(data: Union[dict, HyperNotify], actions: Actions) -> None:
+    print(data)
+
+
+handler: callable = tester
+
+
+def reg(func: callable):
+    global handler
+    handler = func
+
+
+connection: KritorConnection
+listener_ran = False
+
+
+def run():
+    async def runner():
+        global connection, listener_ran
+        try:
+            if handler is tester:
+                raise Errors.ListenerNotRegisteredError("No handler registered")
+            # connection = websocket.WebSocket()
+            # if isinstance(config.connection, Configurator.WSConnectionC):
+            #     connection = Network.WebsocketConnection(f"ws://{config.connection.host}:{config.connection.port}")
+            # elif isinstance(config.connection, Configurator.HTTPConnectionC):
+            #     connection = Network.HTTPConnection(
+            #         url=f"http://{config.connection.host}:{config.connection.port}",
+            #         listener_url=f"http://{config.connection.listener_host}:{config.connection.listener_port}"
+            #     )
+            connection = KritorConnection(
+                host=config.connection.host,
+                port=config.connection.port,
+            )
+            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)
+                data = HyperListenerStartNotify(
+                    time_now=int(time.time()),
+                    notify_type="listener_start",
+                    connection=connection
+                )
+                threading.Thread(target=lambda: __handler(data, actions)).start()
+                task = []
+                while True:
+                    try:
+                        if not task:
+                            task.append(asyncio.create_task(connection.recv()))
+                        else:
+                            await asyncio.sleep(1)
+                    except ConnectionResetError:
+                        logger.log("连接断开", level=Logger.levels.ERROR)
+                        break
+                    # 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:
+                connection.close()
+            except:
+                pass
+            os._exit(0)
+
+    asyncio.get_event_loop().run_until_complete(runner())
+
+
+def stop() -> None:
+    try:
+        connection.close()
+    except:
+        pass
+    logger.log("停止运行监听器", level=Logger.levels.WARNING)

hyper-bot-0.78.7/Hyper/Adapters/LagrangePy.py

@@ -0,0 +1,113 @@
+from Hyper.Adapters.LagrangeLib.Res import get_msg_id, uc, get_msg_info
+from Hyper.Adapters.OneBot import *
+from Hyper.Adapters.LagrangeLib.LagrangeClient import lgr, event_queue
+from Hyper.Utils.TypeExt import ObjectedJson
+import Hyper
+
+from lagrange.client.client import Client as LgrCli
+from lagrange.client.events.service import ClientOnline
+
+
+class Actions(Actions):
+    def __init__(self, cli: LgrCli):
+        self.client = cli
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().send, logger)
+    async def send(self, message: Manager.Message, group_id: int = None, user_id: int = None) -> Manager.Ret:
+        chain = await message.get(group_id, user_id)
+        try:
+            if group_id:
+                seq = await self.client.send_grp_msg(chain, group_id)
+            elif user_id:
+                seq = await self.client.send_friend_msg(chain, uc.to_uid(user_id))
+            else:
+                raise Exception()
+            msg_id = get_msg_id(seq, self.client.uin)
+            data = {"status": "ok", "retcode": 0, "data": {"message_id": msg_id}}
+        except Exception as e:
+            data = {"status": "failed", "retcode": 1400, "data": None}
+
+        return Manager.Ret(data, ObjectedJson)
+
+    async def get_version_info(self) -> Manager.Ret:
+        return Manager.Ret(
+            {
+                "status": "ok",
+                "retcode": 0,
+                "data": {
+                    "app_name": "LagrangePython with HypeR",
+                    "app_version": Hyper.HYPER_BOT_VERSION,
+                    "protocol_version": "None"
+                }
+            }, ObjectedJson
+        )
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().recall, logger)
+    async def del_message(self, message_id: int) -> None:
+        seq, uin, gid = get_msg_info(message_id)
+        if gid != 0:
+            await self.client.recall_grp_msg(gid, seq)
+        else:
+            pass
+
+
+def __handler(data: dict, 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:
+            asyncio.run(handler(Events.em.new(data), actions))
+    else:
+        asyncio.run(handler(data, actions))
+
+
+def reg(func: callable):
+    global handler
+    handler = func
+
+
+listener_ran = False
+
+
+def run():
+    def start_listener() -> None:
+        global listener_ran
+        listener_ran = True
+        try:
+            if handler is tester:
+                raise Errors.ListenerNotRegisteredError("No handler registered")
+            while True:
+                logger.log("Lagrange 已在运行", level=Logger.levels.INFO)
+                retried = 0
+                actions = Actions(lgr.client)
+                data = HyperListenerStartNotify(
+                    time_now=int(time.time()),
+                    notify_type="listener_start_lgr_py"
+                )
+                threading.Thread(target=lambda: __handler(data, actions)).start()
+                while True:
+                    data = event_queue.get()
+                    threading.Thread(target=lambda: __handler(data, actions)).start()
+        except KeyboardInterrupt:
+            logger.log("正在退出(Ctrl+C)", level=Logger.levels.WARNING)
+            try:
+                connection.close()
+            except:
+                pass
+            os._exit(0)
+
+    async def run_listener(_1, _2) -> None:
+        threading.Thread(target=start_listener).start()
+
+    lgr.subscribe(ClientOnline, run_listener)
+    lgr.launch()
+
+
+def stop() -> None:
+    try:
+        connection.close()
+    except:
+        pass
+    logger.log("停止运行监听器", level=Logger.levels.WARNING)

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

@@ -3,16 +3,17 @@ import threading
 import time
 import asyncio
 import os
-from typing import Union
 
 from Hyper import Network, Events
 from Hyper.Utils import Errors, Logic
+from Hyper.Utils.APIRsp import *
 from Hyper.Manager import reports
 from Hyper.Events import *
 
 config = Configurator.cm.get_cfg()
 logger = Logger.Logger()
 logger.set_level(config.log_level)
+listener_ran = False
 
 
 class Actions:
@@ -37,7 +38,9 @@ class Actions:
         self.custom = CustomAction(self.connection)
 
     @Logger.AutoLogAsync.register(Logger.AutoLog.templates().send, logger)
-    async def send(self, message: Manager.Message, group_id: int = None, user_id: int = None) -> Manager.Ret:
+    async def send(
+            self, message: Manager.Message, group_id: int = None, user_id: int = None
+    ) -> Manager.Ret[MsgSendRsp]:
         if group_id is not None:
             packet = Manager.Packet(
                 "send_msg",
@@ -53,7 +56,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 Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, MsgSendRsp)
 
     @Logger.AutoLogAsync.register(Logger.AutoLog.templates().recall, logger)
     async def del_message(self, message_id: int) -> None:
@@ -80,33 +83,33 @@ class Actions:
         ).send_to(self.connection)
 
     @Logic.Cacher().cache_async
-    async def get_login_info(self) -> Manager.Ret:
+    async def get_login_info(self) -> Manager.Ret[GetLoginInfoRsp]:
         packet = Manager.Packet("get_login_info")
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, GetLoginInfoRsp)
 
     @Logic.Cacher().cache_async
-    async def get_version_info(self) -> Manager.Ret:
+    async def get_version_info(self) -> Manager.Ret[GetVerInfoRsp]:
         packet = Manager.Packet("get_version_info")
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, GetVerInfoRsp)
 
-    async def send_forward_msg(self, message: Manager.Message) -> Manager.Ret:
+    async def send_forward_msg(self, message: Manager.Message) -> Manager.Ret[SendForwardRsp]:
         packet = Manager.Packet(
             "send_forward_msg",
             messages=await message.get()
         )
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, SendForwardRsp)
 
-    async def send_group_forward_msg(self, group_id: int, message: Manager.Message) -> Manager.Ret:
+    async def send_group_forward_msg(self, group_id: int, message: Manager.Message) -> Manager.Ret[SendGrpForwardRsp]:
         packet = Manager.Packet(
             "send_group_forward_msg",
             group_id=group_id,
             messages=await message.get()
         )
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, SendForwardRsp)
 
     @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:
@@ -119,17 +122,17 @@ class Actions:
         ).send_to(self.connection)
 
     @Logic.Cacher().cache_async
-    async def get_stranger_info(self, user_id: int) -> Manager.Ret:
+    async def get_stranger_info(self, user_id: int) -> Manager.Ret[GetStrInfoRsp]:
         packet = Manager.Packet(
             "get_stranger_info",
             user_id=user_id,
             no_cache=True,
         )
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, GetStrInfoRsp)
 
     @Logic.Cacher().cache_async
-    async def get_group_member_info(self, group_id: int, user_id: int) -> Manager.Ret:
+    async def get_group_member_info(self, group_id: int, user_id: int) -> Manager.Ret[GetGrpMemInfoRsp]:
         packet = Manager.Packet(
             "get_group_member_info",
             group_id=group_id,
@@ -137,17 +140,17 @@ class Actions:
             no_cache=True
         )
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, GetGrpMemInfoRsp)
 
     @Logic.Cacher().cache_async
-    async def get_group_info(self, group_id: int) -> Manager.Ret:
+    async def get_group_info(self, group_id: int) -> Manager.Ret[GetGrpInfoRsp]:
         packet = Manager.Packet(
             "get_group_info",
             group_id=group_id,
             no_cache=True
         )
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, GetGrpInfoRsp)
 
     async def get_status(self) -> Manager.Ret:
         packet = Manager.Packet("get_status")
@@ -169,36 +172,29 @@ class Actions:
             special_title=title,
         ).send_to(self.connection)
 
-    async def get_msg(self, msg_id: int) -> Manager.Ret:
+    async def get_msg(self, msg_id: int) -> Manager.Ret[GetMsgRsp]:
         packet = Manager.Packet(
             "get_msg",
             message_id=msg_id
         )
         packet.send_to(self.connection)
-        return Manager.Ret.fetch(packet.echo)
+        return Manager.Ret.fetch(packet.echo, GetMsgRsp)
 
 
-async def tester(message_data: Event, actions: Actions) -> None:
+async def tester(message_data: Union[Event, HyperNotify], actions: Actions) -> None:
     ...
 
 
-def __handler(data: dict, actions: Actions) -> None:
-    if data.get("echo") is not None:
-        reports.put(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:
+            asyncio.run(handler(Events.em.new(data), actions))
     else:
-        # 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
+        asyncio.run(handler(data, actions))
 
 
 handler: callable = tester
@@ -213,7 +209,8 @@ connection: Union[Network.WebsocketConnection, Network.HTTPConnection]
 
 
 def run():
-    global connection
+    global connection, listener_ran
+    listener_ran = True
     try:
         if handler is tester:
             raise Errors.ListenerNotRegisteredError("No handler registered")
@@ -239,9 +236,18 @@ def run():
                 retried += 1
                 time.sleep(3)
                 continue
-            logger.log("成功建立连接", level=Logger.levels.INFO)
             retried = 0
+            logger.log(
+                f"成功在 {connection.url} 建立连接",
+                level=Logger.levels.INFO
+            )
             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()
@@ -253,6 +259,7 @@ def run():
                     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:

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

@@ -1,16 +1,24 @@
-import Hyper.Utils.TypeExt
 from Hyper import Configurator, Logger, Network, Segments
 from Hyper.Utils import Logic
+from Hyper.Utils.TypeExt import ObjectedJson
 
-from typing import Union
-import queue
+from typing import Union, Generic, TypeVar
 import random
 import json
 
-reports = queue.Queue()
-config = Configurator.cm.get_cfg()
-logger = Logger.Logger()
-logger.set_level(config.log_level)
+# reports = queue.Queue()
+reports = Logic.KeyQueue()
+
+config: Configurator.Config
+logger: Logger.Logger
+
+
+def init() -> None:
+    global config, logger
+    config = Configurator.cm.get_cfg()
+    logger = Logger.Logger()
+    logger.set_level(config.log_level)
+
 
 servicing = []
 
@@ -111,21 +119,26 @@ class Message:
         return self
 
 
-class Ret:
-    def __init__(self, json_data: dict):
+T = TypeVar("T")
+
+
+class Ret(Generic[T]):
+    def __init__(self, json_data: dict, serializer):
+        self.raw = json_data.copy()
         self.status = json_data["status"]
         self.ret_code = json_data["retcode"]
-        self.data = Hyper.Utils.TypeExt.ObjectedJson(json_data.get("data"))
+        self.data: T = serializer(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
+    def fetch(cls, echo: str, serializer=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.7/Hyper/Adapters/OneBotLib/Res.py

@@ -0,0 +1,101 @@
+from abc import ABC
+
+message_types = {}
+
+
+class SegmentBase(ABC):
+    def __init__(self, *args, **kwargs):
+        var = self.__var
+        anns = self.__anns
+        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])
+
+    def __init_subclass__(cls, **kwargs):
+        sg_type = kwargs.get("sg_type") or kwargs.get("st")
+        summary_tmp = kwargs.get("summary_tmp") or kwargs.get("su")
+
+        if sg_type is summary_tmp is None:
+            return
+
+        cls.__sg_type = sg_type
+        cls.__var = dict(vars(cls))
+        cls.__anns: dict = cls.__var.get("__annotations__", False) or dict()
+
+        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 cls.__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__
+
+        message_types[sg_type] = {
+            "type": cls,
+            "args": list(cls.__anns.keys())
+        }
+
+        return cls
+
+    def to_json(self) -> dict:
+        base = {"type": self.__sg_type, "data": {}}
+        for i in self.__anns:
+            if i.startswith("__") or getattr(self, i) is None:
+                continue
+            if not isinstance(getattr(self, i), self.__anns[i]):
+                base["data"][i] = self.__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
+
+    def __str__(self) -> str: return "__not_set__"
+
+    def __eq__(self, other) -> bool:
+        if type(self) is type(other) and self.to_json() == other.to_json():
+            return True
+        else:
+            return False
+
+    def __ne__(self, other) -> bool:
+        if type(self) is type(other) and self.to_json() == other.to_json():
+            return False
+        else:
+            return True

{hyper-bot-0.78 → hyper-bot-0.78.7}/Hyper/Adapters/Satori.py

@@ -47,11 +47,13 @@ def reg(func: callable):
     handler = func
 
 
+listener_ran = False
 connection: Union[Network.WebsocketConnection, Network.SatoriConnection]
 
 
 def run():
-    global connection
+    global connection, listener_ran
+    listener_ran = True
     try:
         if handler is tester:
             raise Errors.ListenerNotRegisteredError("No handler registered")

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

@@ -48,6 +48,7 @@ class Config:
             silents: list[int] = None,
             connection: typing.Union[WSConnectionC, HTTPConnectionC] = None,
             log_level: str = "INFO",
+            uin: int = 0,
             others: dict = None
     ):
         self.inited = False
@@ -60,6 +61,7 @@ class Config:
             self.silents: list[int] = silents or list
             self.connection = connection
             self.log_level = log_level
+            self.uin = uin
             self.others = others or dict()
             self.inited = True
 
@@ -86,6 +88,7 @@ class Config:
                 config_json["Connection"]["retries"]
             )
         self.log_level = config_json["Log_level"]
+        self.uin = config_json["uin"]
         self.others = config_json["Others"]
 
         self.inited = True
@@ -116,3 +119,8 @@ class ConfigManager:
 
 
 cm: ConfigManager
+
+
+def init(cfg: Config):
+    global cm
+    cm = ConfigManager(cfg)