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

{hyper-bot-0.75 → 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.75 → 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.75 → 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.75 → 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.75 → 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.75 → 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.75 → 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())

{hyper-bot-0.75 → hyper-bot-0.772}/Hyper/Segments.py

@@ -1,98 +1,36 @@
 import json
+import os.path
 import typing
 import uuid
 
 from Hyper.Errors import *
+from Hyper.Configurator import cm
 
-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()
-        arg = {}
-
-        def init(self, *args, **kwargs):
-            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 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): ...
+config = cm.get_cfg()
+if config.protocol == "OneBot":
+    from Hyper.Adapters.OneBotLib.Res import segment_builder, Base, message_types
+elif config.protocol == "Satori":
+    # from Hyper.Adapters.SatoriLib.Res import segment_builder, Base, message_types
+    pass
 
-    def to_json(self) -> dict: ...
 
-    def __str__(self) -> str: return "__not_set__"
+class MediaSeg(Base):
+    @classmethod
+    def build(cls, file: str):
+        if file.startswith("http") or file.startswith("file:") or file.startswith("base64:"):
+            return cls(file=file)
+        else:
+            if os.path.isfile(file):
+                if os.path.isabs(file):
+                    res = cls()
+                    res.file = f"file://{file}"
+                    return res
+                else:
+                    res = cls()
+                    res.file = f"file://{os.path.abspath(file)}"
+                    return res
+            else:
+                return None
 
 
 @segment_builder("text", "<text>")
@@ -101,9 +39,9 @@ class Text(Base):
 
 
 @segment_builder("image", "[图片]")
-class Image(Base):
+class Image(MediaSeg):
     file: str
-    url: str = ""
+    url: str
     summary: str = "[图片]"
 
 
@@ -129,13 +67,15 @@ class Location(Base):
 
 
 @segment_builder("record", "[语音]")
-class Record(Base):
+class Record(MediaSeg):
     file: str
+    url: str
 
 
 @segment_builder("video", "[视频]")
-class Video(Base):
+class Video(MediaSeg):
     file: str
+    url: str
 
 
 @segment_builder("poke", "[拍一拍]")
@@ -296,6 +236,6 @@ class Rps(Base):
 class Music(Base):
     type: str
     id: str = None
-    url: str = None
+    url: str
     audio: str = None
     title: str = None

{hyper-bot-0.75/Hyper → hyper-bot-0.772/Hyper/Utils}/Logic.py

@@ -3,6 +3,7 @@ import os
 import shutil
 import traceback
 import asyncio
+from typing import Union
 import aiohttp
 import time
 import requests
@@ -103,26 +104,13 @@ class ErrorHandler:
         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):
+        except (FileExistsError, OSError, IOError):
             return False
 
         return True
@@ -144,7 +132,7 @@ class FileManager:
 
     @staticmethod
     @Cacher(7).cache
-    def read_as_json(path: str, encoding: str = "utf-8") -> dict | list:
+    def read_as_json(path: str, encoding: str = "utf-8") -> Union[list, dict]:
         with open(path, "r", encoding=encoding) as f:
             return json.load(f)
 
@@ -159,7 +147,7 @@ class FileManager:
         try:
             os.remove(path)
             return True
-        except (FileNotFoundError | OSError | IOError):
+        except (FileNotFoundError, OSError, IOError):
             return False
 
     @staticmethod
@@ -167,7 +155,7 @@ class FileManager:
         try:
             shutil.copy(path1, path2)
             return True
-        except (FileNotFoundError | OSError | IOError):
+        except (FileNotFoundError, OSError, IOError):
             return False
 
 
@@ -245,10 +233,12 @@ class TempDownloader:
         self.index = index
         self.silent = silent
 
-    async def get_bytes(self) -> dict[str, bytes]:
+    async def get_bytes(self, ua: str = None) -> dict[str, bytes]:
         result_to_re = {}
         this: bytes = bytes()
         headers = {"Range": f"bytes={self.part[0]}-{self.part[1]}"}
+        if ua:
+            headers["User-Agent"] = ua
 
         async with aiohttp.ClientSession() as session:
             async with session.get(self.url, headers=headers) as resp:
@@ -296,10 +286,16 @@ class Downloader:
         result[-1][-1] = size - 1
         return result
 
-    async def download(self):
+    async def download(self, ua: str = None):
         if not self.check():
             raise Exception
-        response = requests.get(self.url, stream=True, verify=False)
+        if ua:
+            headers = {
+                "User-Agent": ua
+            }
+            response = requests.get(self.url, stream=True, verify=False, headers=headers)
+        else:
+            response = requests.get(self.url, stream=True, verify=False)
         if response.status_code != 200:
             raise ConnectionError
 
@@ -326,7 +322,7 @@ class Downloader:
                 for i in parts:
                     _ = TempDownloader(url=self.url, part=i, index=parts.index(i), silent=self.silent)
 
-                    tasks.append(asyncio.create_task(_.get_bytes()))
+                    tasks.append(asyncio.create_task(_.get_bytes(ua=ua)))
 
                 await asyncio.gather(*tasks)
                 for i in tasks:

hyper-bot-0.772/Hyper/Utils/TypeExt.py

@@ -0,0 +1,177 @@
+import re
+import json
+from typing import Union
+
+
+class ObjectedDict:
+    def __init__(self, content: dict = None):
+        if content is None:
+            self.__content = dict()
+        else:
+            self.__content = content
+
+    def __getattr__(self, attr):
+        if attr == "_ObjectedDict__content" or attr == "raw":
+            return self.__content
+        else:
+            att = self.__content.get(attr)
+        if isinstance(att, dict):
+            return ObjectedDict(att)
+        else:
+            return att
+
+    def __setattr__(self, attr, value):
+        if attr == "_ObjectedDict__content":
+            super().__setattr__(attr, value)
+        else:
+            self.__content[attr] = value
+
+    def __getitem__(self, item):
+        return self.__content.get(item)
+
+    def __setitem__(self, key, value):
+        if self.__content.get(key):
+            self.__content[key] = value
+
+    def __str__(self) -> str:
+        return self.__content.__str__()
+
+
+class Char(str):
+    @classmethod
+    def convert_from(cls, obj: Union[str, "String"]):
+        if len(obj) != 1:
+            raise TypeError("Char is not fxxking String!")
+        else:
+            return cls(obj)
+
+    @property
+    def width(self) -> int:
+        char = self
+        if len(char) != 1:
+            raise TypeError("String too long")
+        o = ord(char)
+        widths = [
+            (126, 1), (159, 0), (687, 1), (710, 0), (711, 1),
+            (727, 0), (733, 1), (879, 0), (1154, 1), (1161, 0),
+            (4347, 1), (4447, 1.75), (7467, 1), (7521, 0), (8369, 1),
+            (8426, 0), (9000, 1), (9002, 1.75), (11021, 1), (12350, 1.75),
+            (12351, 1), (12438, 1.75), (12442, 0), (19893, 1.75), (19967, 1),
+            (55203, 1.75), (63743, 1), (64106, 1.75), (65039, 1), (65059, 0),
+            (65131, 1.75), (65279, 1), (65376, 1.75), (65500, 1), (65510, 1.75),
+            (120831, 1), (262141, 1.75), (1114109, 1),
+        ]
+        if o == 0xe or o == 0xf:
+            return 0
+        for num, wid in widths:
+            if o <= num:
+                return wid
+        return 1
+
+
+class String(str):
+    def cmdl_parse(self) -> list:
+        args = []
+        temp = ""
+        in_sub = False
+        last_sig = ""
+        for i in (self if self.endswith(" ") else self + " "):
+            if in_sub and i == " ":
+                temp += i
+            elif not in_sub and i == " ":
+                args.append(temp)
+                temp = ""
+            elif i == '"' or i == "'":
+                if not in_sub:
+                    in_sub = True
+                    last_sig = i
+                elif i == last_sig:
+                    in_sub = False
+            else:
+                temp += i
+
+        res = []
+
+        for i in args:
+            if "=" in i:
+                if " " in i:
+                    continue
+                index = args.index(i)
+                new = args[index].split("=", 1)
+                args[index] = {new[0]: new[1]}
+
+        for i in args:
+            if str(i) != "":
+                if isinstance(i, dict):
+                    res.append(i)
+                else:
+                    res.append(String(i))
+
+        del temp, in_sub, last_sig, args
+
+        return res
+
+    def match(self, par: str) -> bool:
+        return True if re.match(par, self) else False
+
+    def clear(self) -> "String":
+        if len(self) != 0:
+            return String("")
+        else:
+            return self
+
+    def to_json(self) -> Union[list, dict]:
+        return json.loads(self)
+
+    def format(self, w_p_l: int = 110) -> "String":
+        c_lis = list(map(Char.convert_from, list(self)))
+        lines = []
+        temp_line = ""
+        temp_length = 0
+        for i in c_lis:
+            if i == "\n":
+                lines.append(temp_line)
+                temp_line = ""
+                temp_length = 0
+            temp_line += i
+            temp_length += i.width
+            if temp_length >= w_p_l:
+                lines.append(temp_line)
+                temp_line = ""
+                temp_length = 0
+
+        lines.append(temp_line)
+
+        return String("\n".join(lines))
+
+
+class List(list):
+    def __getitem__(self, item):
+        try:
+            return super().__getitem__(item)
+        except IndexError:
+            return None
+
+
+class Integer(int):
+    @classmethod
+    def convert_from(cls, target):
+        if isinstance(target, int):
+            return cls(target)
+
+        try:
+            return cls(int(target))
+        except:
+            return cls(-1)
+
+
+class Enum:
+    def __init__(self, *args):
+        self.items = list(args)
+
+    def __getattr__(self, item):
+        if item in self.items:
+            return self.items.index(item)
+        else:
+            return None
+

{hyper-bot-0.75 → hyper-bot-0.772}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyper-bot
-Version: 0.75
+Version: 0.772
 Summary: 稳定高效、易于开发的QQ Bot框架
 Home-page: https://github.com/HarcicYang/HypeR_Bot
 Author: Harcic

{hyper-bot-0.75 → hyper-bot-0.772}/hyper_bot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyper-bot
-Version: 0.75
+Version: 0.772
 Summary: 稳定高效、易于开发的QQ Bot框架
 Home-page: https://github.com/HarcicYang/HypeR_Bot
 Author: Harcic

{hyper-bot-0.75 → hyper-bot-0.772}/hyper_bot.egg-info/SOURCES.txt

@@ -6,13 +6,15 @@ Hyper/Errors.py
 Hyper/Events.py
 Hyper/Listener.py
 Hyper/Logger.py
-Hyper/Logic.py
 Hyper/Manager.py
-Hyper/ModuleClass.py
 Hyper/Network.py
 Hyper/Segments.py
 Hyper/Adapters/OneBot.py
+Hyper/Adapters/Satori.py
 Hyper/Adapters/OneBotLib/Manager.py
+Hyper/Adapters/OneBotLib/Res.py
+Hyper/Utils/Logic.py
+Hyper/Utils/TypeExt.py
 hyper_bot.egg-info/PKG-INFO
 hyper_bot.egg-info/SOURCES.txt
 hyper_bot.egg-info/dependency_links.txt

{hyper-bot-0.75 → hyper-bot-0.772}/setup.py

@@ -4,11 +4,11 @@ from setuptools import setup
 
 setup(
     name="hyper-bot",
-    version="0.75",
+    version="0.772",
     description="稳定高效、易于开发的QQ Bot框架",
     author="Harcic",
     author_email="harcic@outlook.com",
     url="https://github.com/HarcicYang/HypeR_Bot",
-    packages=["Hyper", "Hyper.Adapters", "Hyper.Adapters.OneBotLib"],
+    packages=["Hyper", "Hyper.Adapters", "Hyper.Adapters.OneBotLib", "Hyper.Utils"],
     include_package_data=True,
 )

hyper-bot-0.75/Hyper/ModuleClass.py

@@ -1,67 +0,0 @@
-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: Listener.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

hyper-bot-0.75/Hyper/Network.py

@@ -1,77 +0,0 @@
-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()