hyper-bot 0.741__tar.gz → 0.772__tar.gz

{hyper-bot-0.741 → hyper-bot-0.772}/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 Errors, Network, Events
+from Hyper.Utils import 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)
+                def wrapper(**kwargs) -> str:
+                    packet = Manager.Packet(
+                        str(item),
+                        **kwargs
+                    )
+                    packet.send_to(self.connection)
+                    return packet.echo
 
                 return wrapper
 
@@ -59,8 +52,17 @@ 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)
+        retried = 0
+        while 1:
+            packet.send_to(self.connection)
+            result = Manager.Ret.fetch(packet.echo)
+            if result.ret_code != 0 or (4 <= len(str(result.data.message_id)) <= 6):
+                retried += 1
+                if retried >= 5:
+                    return result
+                await asyncio.sleep(1)
+            else:
+                return result
 
     @Logger.AutoLogAsync.register(Logger.AutoLog.templates().recall, logger)
     async def del_message(self, message_id: int) -> None:
@@ -90,13 +92,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 +106,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 +115,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 +135,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 +146,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 +156,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,7 +184,7 @@ 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:
@@ -191,7 +193,7 @@ async def tester(message_data: Event, actions: Actions) -> None:
 
 async 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:
@@ -208,7 +210,6 @@ async def __handler(data: dict, actions: Actions) -> None:
 
 
 handler: callable = tester
-connection: callable = tester
 
 
 def reg(func: callable):
@@ -216,20 +217,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
-
-
 def run():
-    global connection
     try:
         if handler is tester:
             raise Errors.ListenerNotRegisteredError("No handler registered")

{hyper-bot-0.741 → hyper-bot-0.772}/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.ObjectedDict(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.772/Hyper/Adapters/OneBotLib/Res.py

@@ -0,0 +1,90 @@
+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__
+
+        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__"

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

@@ -0,0 +1,94 @@
+from Hyper.Adapters.OneBot import *
+from Hyper.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
+
+
+def run():
+    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)
+

{hyper-bot-0.741 → hyper-bot-0.772}/Hyper/Configurator.py

@@ -1,13 +1,14 @@
 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
 
 
 class HTTPConnectionC:
@@ -55,7 +56,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"]["satori_token"]
             )
         elif config_json["Connection"]["mode"] == "HTTP":
             self.connection = HTTPConnectionC(

{hyper-bot-0.741 → hyper-bot-0.772}/Hyper/Errors.py

@@ -16,3 +16,9 @@ class ListenerNotRegisteredError(Exception):
 class ArgsInvalidError(Exception):
     def __init__(self, message: str = None):
         super().__init__(message)
+
+
+class ConfigError(Exception):
+    def __init__(self, message: str = None):
+        super().__init__(message)
+

{hyper-bot-0.741 → hyper-bot-0.772}/Hyper/Events.py

@@ -1,4 +1,5 @@
 from Hyper import Configurator, Logger, Manager
+from Hyper.Utils.TypeExt import Integer
 from Hyper.Segments import message_types
 from Hyper.Logger import levels
 
@@ -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
@@ -88,7 +91,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.is_owner = Integer.convert_from(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
@@ -103,6 +106,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")

{hyper-bot-0.741 → hyper-bot-0.772}/Hyper/Listener.py

@@ -4,4 +4,6 @@ config = Configurator.cm.get_cfg()
 
 if config.protocol == "OneBot":
     from Hyper.Adapters.OneBot import *
+elif config.protocol == "Satori":
+    from Hyper.Adapters.Satori import *
 servicing = []

{hyper-bot-0.741 → hyper-bot-0.772}/Hyper/Manager.py

@@ -4,3 +4,5 @@ config = cm.get_cfg()
 
 if config.protocol == "OneBot":
     from Hyper.Adapters.OneBotLib.Manager import *
+elif config.protocol == "Satori":
+    from Hyper.Adapters.SatoriLib.Manager import *

hyper-bot-0.772/Hyper/Network.py

@@ -0,0 +1,156 @@
+import asyncio
+import time
+import websocket
+import httpx
+import queue
+import flask
+import traceback
+import json
+import logging
+import threading
+
+
+class WebsocketConnection:
+    def __init__(self, url: str):
+        self.ws = websocket.WebSocket()
+        self.url = url
+
+    def connect(self) -> None:
+        self.ws.connect(self.url)
+
+    def send(self, message: str) -> None:
+        self.ws.send(message)
+
+    def close(self) -> None:
+        self.ws.close()
+
+    def recv(self) -> dict:
+        return json.loads(self.ws.recv())
+
+
+class HTTPConnection:
+    def __init__(self, url: str, listener_url: str):
+        self.url = url
+        listener_url = listener_url.replace("http://", "")
+        listener_url = listener_url.replace("https://", "")
+        self.listener_url = listener_url.split(":")[0]
+        try:
+            self.port = int(listener_url.split(":")[1])
+        except IndexError:
+            self.port = 8080
+        self.app = flask.Flask(__name__)
+        self.app.config["LOGGER_HANDLER_POLICY"] = "never"
+        logging.getLogger("werkzeug").setLevel(logging.ERROR)
+        self.reports = queue.Queue()
+
+        self.listener_started = False
+
+    def __start_listener(self) -> None:
+        @self.app.route("/", methods=["POST"])
+        def listener():
+            self.reports.put(flask.request.json)
+            return {}
+
+            # self.app.run(host=self.listener_url, port=self.port)
+
+        threading.Thread(target=lambda: self.app.run(host=self.listener_url, port=self.port)).start()
+        self.listener_started = True
+
+    def connect(self) -> None:
+        if not self.listener_started:
+            self.__start_listener()
+        httpx.post(self.url)
+        traceback.print_exc()
+
+    def recv(self) -> dict:
+        return self.reports.get()
+
+    def send(self, endpoint: str, data: dict, echo: str) -> None:
+        response = httpx.post(f"{self.url}/{endpoint}", json=data)
+        res = response.json()
+        res["echo"] = echo
+        self.reports.put(res)
+
+    @staticmethod
+    def close() -> None:
+        shutdown_func = flask.request.environ.get('werkzeug.server.shutdown')
+        if shutdown_func is None:
+            raise RuntimeError('Not running with the Werkzeug Server')
+        shutdown_func()
+
+
+class SatoriConnection:
+    def __init__(self, host: str, port: int, token: str = None):
+        self.ws = websocket.WebSocket()
+        self.host = host
+        self.port = port
+        self.token = token
+        self.reports = queue.Queue()
+
+    def heart_beat(self) -> None:
+        while 1:
+            time.sleep(10)
+            self.ws.send(json.dumps({"op": 1, "body": {}}))
+
+    def connect(self) -> None:
+        self.ws.connect(f"ws://{self.host}:{self.port}/v1/events")
+        payload = {
+            "op": 3,
+            "body": {
+                "token": self.token
+            }
+        }
+        self.ws.send(json.dumps(payload))
+        res = json.loads(self.ws.recv())
+        if res["op"] == 4:
+            threading.Thread(target=self.heart_beat).start()
+        else:
+            raise ConnectionError("连接失败")
+
+    def send(self, payload: dict, echo: str = None) -> None:
+        response = httpx.post(f"http://{self.host}:{self.port}", json=payload)
+        try:
+            data = response.json()
+            data["echo"] = echo
+            self.reports.put(data)
+        except:
+            pass
+
+    def close(self) -> None:
+        pass
+
+    def recv(self) -> dict:
+        return json.loads(self.ws.recv())
+
+#
+# class KritorConnection:
+#     def __init__(self, host: str, port: int, account: str, ticket: str):
+#         self.channel = grpc.insecure_channel(f"{host}:{port}")
+#         self.account = account
+#         self.ticket = ticket
+#
+#     def connect(self) -> None:
+#         auth_stub = AuthenticationServiceStub(self.channel)
+#         response = auth_stub.Authenticate(
+#             AuthenticateRequest(
+#                 account=self.account,
+#                 ticket=self.ticket
+#             )
+#         )
+#         if response.AuthenticateResponseCode != 0:
+#             raise ConnectionError("鉴权失败")
+#
+#     def send(self, stub, payload: dict, echo: str = None) -> None:
+#         response = httpx.post(f"http://{self.host}:{self.port}", json=payload)
+#         try:
+#             data = response.json()
+#             data["echo"] = echo
+#             self.reports.put(data)
+#         except:
+#             pass
+#
+#     def close(self) -> None:
+#         pass
+#
+#     def recv(self) -> dict:
+#         return json.loads(self.ws.recv())