hyper-bot 0.79.5__tar.gz → 0.80.2__tar.gz

{hyper_bot-0.79.5 → hyper_bot-0.80.2}/PKG-INFO

@@ -1,8 +1,10 @@
 Metadata-Version: 2.1
 Name: hyper-bot
-Version: 0.79.5
+Version: 0.80.2
 Summary: 稳定高效、易于开发的QQ Bot框架
 Home-page: https://github.com/HarcicYang/HypeR_Bot
 Author: Harcic
 Author-email: harcic@outlook.com
+Provides: hyperot
 License-File: LICENSE
+Requires-Dist: ucfgr

{hyper_bot-0.79.5 → hyper_bot-0.80.2}/hyper_bot.egg-info/PKG-INFO

@@ -1,8 +1,10 @@
 Metadata-Version: 2.1
 Name: hyper-bot
-Version: 0.79.5
+Version: 0.80.2
 Summary: 稳定高效、易于开发的QQ Bot框架
 Home-page: https://github.com/HarcicYang/HypeR_Bot
 Author: Harcic
 Author-email: harcic@outlook.com
+Provides: hyperot
 License-File: LICENSE
+Requires-Dist: ucfgr

hyper_bot-0.80.2/hyper_bot.egg-info/SOURCES.txt

@@ -0,0 +1,44 @@
+LICENSE
+setup.py
+hyper_bot.egg-info/PKG-INFO
+hyper_bot.egg-info/SOURCES.txt
+hyper_bot.egg-info/dependency_links.txt
+hyper_bot.egg-info/requires.txt
+hyper_bot.egg-info/top_level.txt
+hyperot/__init__.py
+hyperot/common.py
+hyperot/configurator.py
+hyperot/events.py
+hyperot/hyperogger.py
+hyperot/listener.py
+hyperot/network.py
+hyperot/segments.py
+hyperot/service.py
+hyperot/Adapters/Kritor.py
+hyperot/Adapters/OneBot.py
+hyperot/Adapters/KritorLib/Manager.py
+hyperot/Adapters/KritorLib/Res.py
+hyperot/Adapters/KritorLib/protos/__init__.py
+hyperot/Adapters/KritorLib/protos/authentication/__init__.py
+hyperot/Adapters/KritorLib/protos/common/__init__.py
+hyperot/Adapters/KritorLib/protos/core/__init__.py
+hyperot/Adapters/KritorLib/protos/customization/__init__.py
+hyperot/Adapters/KritorLib/protos/developer/__init__.py
+hyperot/Adapters/KritorLib/protos/event/__init__.py
+hyperot/Adapters/KritorLib/protos/file/__init__.py
+hyperot/Adapters/KritorLib/protos/friend/__init__.py
+hyperot/Adapters/KritorLib/protos/group/__init__.py
+hyperot/Adapters/KritorLib/protos/guild/__init__.py
+hyperot/Adapters/KritorLib/protos/message/__init__.py
+hyperot/Adapters/KritorLib/protos/process/__init__.py
+hyperot/Adapters/KritorLib/protos/reverse/__init__.py
+hyperot/Adapters/KritorLib/protos/web/__init__.py
+hyperot/Adapters/OneBotLib/Manager.py
+hyperot/Adapters/OneBotLib/Res.py
+hyperot/utils/ArkSignHelper.py
+hyperot/utils/apiresponse.py
+hyperot/utils/errors.py
+hyperot/utils/hypetyping.py
+hyperot/utils/logic.py
+hyperot/utils/screens.py
+hyperot/utils/typextensions.py

hyper_bot-0.80.2/hyper_bot.egg-info/requires.txt

@@ -0,0 +1 @@
+ucfgr

hyper_bot-0.80.2/hyper_bot.egg-info/top_level.txt

@@ -0,0 +1 @@
+hyperot

{hyper_bot-0.79.5/Hyper → hyper_bot-0.80.2/hyperot}/Adapters/Kritor.py

@@ -4,27 +4,27 @@ import sys
 import threading
 import time
 
-from Hyper import Comm
-from Hyper.Adapters.OneBot import Actions as OneBotActions
-from Hyper.Adapters.KritorLib.Res import event_queue, to_protos, message_ids
-from Hyper.Events import Event, HyperNotify, HyperListenerStartNotify, em
-from Hyper.Service import FuncCall, IServiceStartUp, IServiceBase
-from Hyper.Network import KritorConnection
-from Hyper.Utils import Errors
-from Hyper.Utils.APIRsp import *
-from Hyper import Configurator, Logger
-
-from Hyper.Adapters.KritorLib.protos.common import Contact, Scene
-from Hyper.Adapters.KritorLib.protos.core import GetVersionRequest, CoreServiceStub
-from Hyper.Adapters.KritorLib.protos.message import (
+from .. import common
+from ..Adapters.OneBot import Actions as OneBotActions
+from ..Adapters.KritorLib.Res import event_queue, to_protos, message_ids
+from ..events import Event, HyperNotify, HyperListenerStartNotify, em
+from ..service import FuncCall, IServiceStartUp, IServiceBase
+from ..network import KritorConnection
+from ..utils import errors
+from ..utils.apiresponse import *
+from .. import configurator, hyperogger
+
+from ..Adapters.KritorLib.protos.common import Contact, Scene
+from ..Adapters.KritorLib.protos.core import GetVersionRequest, CoreServiceStub
+from ..Adapters.KritorLib.protos.message import (
     MessageServiceStub,
     SendMessageRequest,
     RecallMessageRequest,
     GetMessageRequest
 )
 
-config = Configurator.BotConfig.get("hyper-bot")
-logger = Logger.Logger()
+config = configurator.BotConfig.get("hyper-bot")
+logger = hyperogger.Logger()
 logger.set_level(config.log_level)
 
 
@@ -41,10 +41,9 @@ class Actions(OneBotActions):
     def __init__(self, cnt: KritorConnection):
         self.connection = cnt
 
-    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().send, logger)
     async def send(
-            self, message: Comm.Message, group_id: int = None, user_id: int = None
-    ) -> Comm.Ret[MsgSendRsp]:
+            self, message: common.Message, group_id: int = None, user_id: int = None
+    ) -> common.Ret[MsgSendRsp]:
         msg = to_protos(message.get_sync())
         if group_id is not None:
             contact = Contact(
@@ -63,19 +62,19 @@ class Actions(OneBotActions):
         )
         res = await MessageServiceStub(self.connection.channel).send_message(req)
         message_ids[res.message_id] = len(message_ids)
-        return Comm.Ret(
+        return common.Ret(
             {"data": {"message_id": message_ids[res.message_id]}},
             MsgSendRsp
         )
 
-    async def get_version_info(self) -> Comm.Ret[GetVerInfoRsp]:
+    async def get_version_info(self) -> common.Ret[GetVerInfoRsp]:
         res = await CoreServiceStub(self.connection.channel).get_version(GetVersionRequest())
-        return Comm.Ret(
+        return common.Ret(
             {"data": {"app_name": res.app_name, "app_version": res.version, "protocol_version": None}},
             GetVerInfoRsp
         )
 
-    async def get_msg(self, msg_id: int) -> Comm.Ret[GetMsgRsp]:
+    async def get_msg(self, msg_id: int) -> common.Ret[GetMsgRsp]:
         try:
             mid = list(filter(lambda x: message_ids[x] == msg_id, message_ids))[1]
         except IndexError:
@@ -87,7 +86,7 @@ class Actions(OneBotActions):
             )
             res = await MessageServiceStub(self.connection.channel).get_message(GetMessageRequest(contact, mid))
             print(res)
-            return Comm.Ret(
+            return common.Ret(
                 {
                     "time": res.message.time,
                     "message_type": "group",
@@ -113,7 +112,7 @@ class Actions(OneBotActions):
                 peer=str(mid_res(mid)[1]),
             )
             res = await MessageServiceStub(self.connection.channel).get_message(GetMessageRequest(contact, mid))
-            return Comm.Ret(
+            return common.Ret(
                 {
                     "time": res.message.time,
                     "message_type": "private",
@@ -178,7 +177,7 @@ def run():
     async def hy_i_runner():
         global connection
         if handler is tester:
-            raise Errors.ListenerNotRegisteredError("No handler registered")
+            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}")
@@ -198,15 +197,15 @@ def run():
             except ConnectionRefusedError or TimeoutError:
                 if retried >= config.connection.retries:
                     logger.log(f"重试次数达到最大值({config.connection.retries})，退出",
-                               level=Logger.levels.CRITICAL)
+                               level=hyperogger.levels.CRITICAL)
                     break
 
                 logger.log(f"连接建立失败，3秒后重试({retried}/{config.connection.retries})",
-                           level=Logger.levels.WARNING)
+                           level=hyperogger.levels.WARNING)
                 retried += 1
                 time.sleep(3)
                 continue
-            logger.log("成功建立连接", level=Logger.levels.INFO)
+            logger.log("成功建立连接", level=hyperogger.levels.INFO)
             retried = 0
             actions = Actions(connection)
             data = HyperListenerStartNotify(
@@ -223,7 +222,7 @@ def run():
                     await task
                 except ConnectionResetError:
                     task = None
-                    logger.log("连接断开", level=Logger.levels.ERROR)
+                    logger.log("连接断开", level=hyperogger.levels.ERROR)
                     break
                 # threading.Thread(target=lambda: asyncio.run(__handler(data, actions))).start()
                 # threading.Thread(target=lambda: __handler(data, actions)).start()
@@ -232,7 +231,7 @@ def run():
     try:
         asyncio.get_event_loop().run_until_complete(hy_i_runner())
     except KeyboardInterrupt:
-        logger.log("正在退出(Ctrl+C)", level=Logger.levels.WARNING)
+        logger.log("正在退出(Ctrl+C)", level=hyperogger.levels.WARNING)
         sys.exit()
 
 
@@ -241,4 +240,4 @@ def stop() -> None:
         connection.close()
     except:
         pass
-    logger.log("停止运行监听器", level=Logger.levels.WARNING)
+    logger.log("停止运行监听器", level=hyperogger.levels.WARNING)

hyper_bot-0.80.2/hyperot/Adapters/KritorLib/Manager.py

@@ -0,0 +1 @@
+from ...Adapters.OneBotLib.Manager import *

{hyper_bot-0.79.5/Hyper → hyper_bot-0.80.2/hyperot}/Adapters/KritorLib/Res.py

@@ -1,4 +1,4 @@
-from Hyper.Adapters.KritorLib.protos.event import (
+from ...Adapters.KritorLib.protos.event import (
     EventServiceStub,
     RequestPushEvent,
     EventType,
@@ -7,7 +7,7 @@ from Hyper.Adapters.KritorLib.protos.event import (
     GroupMemberDecreasedNoticeGroupMemberDecreasedType,
     GroupMemberIncreasedNoticeGroupMemberIncreasedType
 )
-from Hyper.Adapters.KritorLib.protos.common import (
+from ...Adapters.KritorLib.protos.common import (
     ElementElementType,
     PushMessageBody,
     Scene, Element,
@@ -18,8 +18,8 @@ from Hyper.Adapters.KritorLib.protos.common import (
     VoiceElement,
     ImageElement
 )
-from Hyper.Configurator import BotConfig
-from Hyper.Utils.Logic import SimpleQueue
+from ...configurator import BotConfig
+from ...utils.logic import SimpleQueue
 
 import traceback
 import asyncio

{hyper_bot-0.79.5/Hyper → hyper_bot-0.80.2/hyperot}/Adapters/OneBot.py

@@ -5,33 +5,31 @@ import asyncio
 import sys
 import subprocess
 from typing import Any, NoReturn
-# from concurrent.futures import ThreadPoolExecutor
 
-from Hyper import Network, Events, Comm
-from Hyper.Service import FuncCall, IServiceBase, IServiceStartUp
-from Hyper.Utils import Errors, Logic
-from Hyper.Utils.APIRsp import *
-from Hyper.Adapters.OneBotLib.Manager import reports
-from Hyper.Events import *
+from .. import network, events, common, segments
+from ..service import FuncCall, IServiceBase, IServiceStartUp
+from ..utils import errors, logic
+from ..utils.apiresponse import *
+from ..Adapters.OneBotLib.Manager import reports
+from ..events import *
 
-config = Configurator.BotConfig.get("hyper-bot")
-logger = Logger.Logger()
+config = configurator.BotConfig.get("hyper-bot")
+logger = hyperogger.Logger()
 logger.set_level(config.log_level)
-# pool = ThreadPoolExecutor(max_workers=config.max_workers)
 listener_ran = False
 
 
 class Actions:
-    def __init__(self, cnt: Union[Network.WebsocketConnection, Network.HTTPConnection]):
+    def __init__(self, cnt: Union[network.WebsocketConnection, network.HTTPConnection]):
         self.connection = cnt
 
         class CustomAction:
-            def __init__(self, cnt_i: Union[Network.WebsocketConnection, Network.HTTPConnection]):
+            def __init__(self, cnt_i: Union[network.WebsocketConnection, network.HTTPConnection]):
                 self.connection = cnt_i
 
             def __getattr__(self, item) -> callable:
                 async def wrapper(**kwargs) -> str:
-                    packet = Comm.Packet(
+                    packet = common.Packet(
                         str(item),
                         **kwargs
                     )
@@ -42,148 +40,144 @@ class Actions:
 
         self.custom = CustomAction(self.connection)
 
-    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().send, logger)
     async def send(
-            self, message: Comm.Message, group_id: int = None, user_id: int = None
-    ) -> Comm.Ret[MsgSendRsp]:
+            self, message: Union[common.Message, str], group_id: int = None, user_id: int = None
+    ) -> common.Ret[MsgSendRsp]:
         if group_id is not None:
-            packet = Comm.Packet(
+            if isinstance(message, str):
+                message = common.Message(segments.Text(message))
+            packet = common.Packet(
                 "send_msg",
                 group_id=group_id,
                 message=await message.get()
             )
         elif user_id is not None:
-            packet = Comm.Packet(
+            packet = common.Packet(
                 "send_msg",
                 user_id=user_id,
                 message=await message.get()
             )
         else:
-            raise Errors.ArgsInvalidError("'send' API requires 'group_id' or 'user_id' but none of them are provided.")
+            raise errors.ArgsInvalidError("'send' API requires 'group_id' or 'user_id' but none of them are provided.")
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, MsgSendRsp)
+        logger.info(f"向{(('群 ' + str(group_id)) if group_id else ('用户' + str(user_id))) + ' '}发送：{str(message)}")
+        return common.Ret.fetch(packet.echo, MsgSendRsp)
 
-    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().recall, logger)
     async def del_message(self, message_id: int) -> None:
-        Comm.Packet(
+        common.Packet(
             "delete_msg",
             message_id=message_id,
         ).send_to(self.connection)
+        logger.info(f"撤回 {message_id}")
 
-    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().kick, logger)
     async def set_group_kick(self, group_id: int, user_id: int) -> None:
-        Comm.Packet(
+        common.Packet(
             "set_group_kick",
             group_id=group_id,
             user_id=user_id,
         ).send_to(self.connection)
+        logger.info(f"将用户 {user_id} 移出群 {group_id}")
 
-    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().mute, logger)
     async def set_group_ban(self, group_id: int, user_id: int, duration: int = 60) -> None:
-        Comm.Packet(
+        common.Packet(
             "set_group_ban",
             group_id=group_id,
             user_id=user_id,
             duration=duration,
         ).send_to(self.connection)
+        logger.info(f"在群 {group_id} 将用户 {user_id} 禁言 {duration}s")
 
-    @Logic.Cacher().cache_async
-    async def get_login_info(self) -> Comm.Ret[GetLoginInfoRsp]:
-        packet = Comm.Packet("get_login_info")
+    async def get_login_info(self) -> common.Ret[GetLoginInfoRsp]:
+        packet = common.Packet("get_login_info")
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, GetLoginInfoRsp)
+        return common.Ret.fetch(packet.echo, GetLoginInfoRsp)
 
-    @Logic.Cacher().cache_async
-    async def get_version_info(self) -> Comm.Ret[GetVerInfoRsp]:
-        packet = Comm.Packet("get_version_info")
+    async def get_version_info(self) -> common.Ret[GetVerInfoRsp]:
+        packet = common.Packet("get_version_info")
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, GetVerInfoRsp)
+        return common.Ret.fetch(packet.echo, GetVerInfoRsp)
 
-    async def send_forward_msg(self, message: Comm.Message) -> Comm.Ret[SendForwardRsp]:
-        packet = Comm.Packet(
+    async def send_forward_msg(self, message: common.Message) -> common.Ret[SendForwardRsp]:
+        packet = common.Packet(
             "send_forward_msg",
             messages=await message.get()
         )
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, SendForwardRsp)
+        return common.Ret.fetch(packet.echo, SendForwardRsp)
 
-    async def send_group_forward_msg(self, group_id: int, message: Comm.Message) -> Comm.Ret[SendGrpForwardRsp]:
-        packet = Comm.Packet(
+    async def send_group_forward_msg(self, group_id: int, message: common.Message) -> common.Ret[SendGrpForwardRsp]:
+        packet = common.Packet(
             "send_group_forward_msg",
             group_id=group_id,
             messages=await message.get()
         )
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, SendForwardRsp)
+        return common.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:
-        Comm.Packet(
+    async def set_group_add_request(self, flag: str, sub_type: str, approve: bool, reason: str = "Not Mentioned") -> None:
+        common.Packet(
             "set_group_add_request",
             flag=flag,
             sub_type=sub_type,
             approve=approve,
             reason=reason
         ).send_to(self.connection)
+        logger.info(f"由于 {reason}，{'通过' if approve else '拒绝'} {flag} 请求")
 
-    @Logic.Cacher().cache_async
-    async def get_stranger_info(self, user_id: int) -> Comm.Ret[GetStrInfoRsp]:
-        packet = Comm.Packet(
+    async def get_stranger_info(self, user_id: int) -> common.Ret[GetStrInfoRsp]:
+        packet = common.Packet(
             "get_stranger_info",
             user_id=user_id,
             no_cache=True,
         )
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, GetStrInfoRsp)
+        return common.Ret.fetch(packet.echo, GetStrInfoRsp)
 
-    @Logic.Cacher().cache_async
-    async def get_group_member_info(self, group_id: int, user_id: int) -> Comm.Ret[GetGrpMemInfoRsp]:
-        packet = Comm.Packet(
+    async def get_group_member_info(self, group_id: int, user_id: int) -> common.Ret[GetGrpMemInfoRsp]:
+        packet = common.Packet(
             "get_group_member_info",
             group_id=group_id,
             user_id=user_id,
             no_cache=True
         )
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, GetGrpMemInfoRsp)
+        return common.Ret.fetch(packet.echo, GetGrpMemInfoRsp)
 
-    @Logic.Cacher().cache_async
-    async def get_group_info(self, group_id: int) -> Comm.Ret[GetGrpInfoRsp]:
-        packet = Comm.Packet(
+    async def get_group_info(self, group_id: int) -> common.Ret[GetGrpInfoRsp]:
+        packet = common.Packet(
             "get_group_info",
             group_id=group_id,
             no_cache=True
         )
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, GetGrpInfoRsp)
+        return common.Ret.fetch(packet.echo, GetGrpInfoRsp)
 
-    async def get_status(self) -> Comm.Ret:
-        packet = Comm.Packet("get_status")
+    async def get_status(self) -> common.Ret:
+        packet = common.Packet("get_status")
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo)
+        return common.Ret.fetch(packet.echo)
 
-    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().set_ess, logger)
     async def set_essence_msg(self, message_id: int) -> None:
-        Comm.Packet(
+        common.Packet(
             "set_essence_msg",
             message_id=message_id
         ).send_to(self.connection)
 
     async def set_group_special_title(self, group_id: int, user_id: int, title: str) -> None:
-        Comm.Packet(
+        common.Packet(
             "set_group_special_title",
             group_id=group_id,
             user_id=user_id,
             special_title=title,
         ).send_to(self.connection)
 
-    async def get_msg(self, msg_id: int) -> Comm.Ret[GetMsgRsp]:
-        packet = Comm.Packet(
+    async def get_msg(self, msg_id: int) -> common.Ret[GetMsgRsp]:
+        packet = common.Packet(
             "get_msg",
             message_id=msg_id
         )
         packet.send_to(self.connection)
-        return Comm.Ret.fetch(packet.echo, GetMsgRsp)
+        return common.Ret.fetch(packet.echo, GetMsgRsp)
 
 
 async def tester(
@@ -199,7 +193,7 @@ def __handler(data: Union[dict, HyperNotify], actions: Actions) -> None:
         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))
+            asyncio.run(handler(events.em.new(data), actions))
     else:
         asyncio.run(handler(data, actions))
 
@@ -212,7 +206,7 @@ def reg(func: callable) -> None:
     handler = func
 
 
-connection: Union[Network.WebsocketConnection, Network.HTTPConnection]
+connection: Union[network.WebsocketConnection, network.HTTPConnection]
 
 
 class LagrangeOneBotService(IServiceBase):
@@ -220,7 +214,7 @@ class LagrangeOneBotService(IServiceBase):
     def handler(self, func: FuncCall) -> Any:
         pass
 
-    async def server(self, bot_config: Configurator.BotConfig) -> None:
+    async def server(self, bot_config: configurator.BotConfig) -> None:
         proc = subprocess.Popen(
             args=config.connection.ob_exec,
             cwd=config.connection.ob_startup_path,
@@ -236,12 +230,11 @@ def run() -> NoReturn:
     listener_ran = True
     try:
         if handler is tester:
-            raise Errors.ListenerNotRegisteredError("No handler registered")
-        # connection = websocket.WebSocket()
-        if isinstance(config.connection, Configurator.BotWSC):
-            connection = Network.WebsocketConnection(f"ws://{config.connection.host}:{config.connection.port}")
-        elif isinstance(config.connection, Configurator.BotHTTPC):
-            connection = Network.HTTPConnection(
+            raise errors.ListenerNotRegisteredError("No handler registered")
+        if isinstance(config.connection, configurator.BotWSC):
+            connection = network.WebsocketConnection(f"ws://{config.connection.host}:{config.connection.port}")
+        elif isinstance(config.connection, configurator.BotHTTPC):
+            connection = network.HTTPConnection(
                 url=f"http://{config.connection.host}:{config.connection.port}",
                 listener_url=f"http://{config.connection.listener_host}:{config.connection.listener_port}"
             )
@@ -270,7 +263,6 @@ def run() -> NoReturn:
                 connection=connection
             )
             threading.Thread(target=lambda: __handler(data, actions), daemon=True).start()
-            # asyncio.get_event_loop().run_in_executor(pool, __handler, data, actions)
             while True:
                 try:
                     data = connection.recv()
@@ -280,9 +272,7 @@ def run() -> NoReturn:
                 except json.decoder.JSONDecodeError:
                     logger.error("收到错误的JSON内容")
                     continue
-                # threading.Thread(target=lambda: asyncio.run(__handler(data, actions))).start()
                 threading.Thread(target=lambda: __handler(data, actions), daemon=True).start()
-                # asyncio.create_task(__handler(data, actions))
     except KeyboardInterrupt:
         logger.warning("正在退出(Ctrl+C)")
         try:
@@ -297,4 +287,4 @@ def stop() -> None:
         connection.close()
     except:
         pass
-    logger.log("停止运行监听器", level=Logger.levels.WARNING)
+    logger.log("停止运行监听器", level=hyperogger.levels.WARNING)

{hyper_bot-0.79.5/Hyper → hyper_bot-0.80.2/hyperot}/Adapters/OneBotLib/Manager.py

@@ -1,22 +1,21 @@
-from Hyper import Configurator, Logger, Network
-from Hyper.Utils import Logic
-from Hyper.Utils.HyperTyping import OneBotJsonPacket
+from ... import configurator, hyperogger, network
+from ...utils import logic
+from ...utils.hypetyping import OneBotJsonPacket
 
 from typing import Union
 import random
 import json
 
-# reports = queue.Queue()
-reports = Logic.KeyQueue()
+reports = logic.KeyQueue()
 
-config: Configurator.BotConfig
-logger: Logger.Logger
+config: configurator.BotConfig
+logger: hyperogger.Logger
 
 
 def init() -> None:
     global config, logger
-    config = Configurator.BotConfig.get("hyper-bot")
-    logger = Logger.Logger()
+    config = configurator.BotConfig.get("hyper-bot")
+    logger = hyperogger.Logger()
     logger.set_level(config.log_level)
 
 
@@ -29,8 +28,8 @@ class Packet:
         self.paras = kwargs
         self.echo = f"{endpoint}_{random.randint(1000, 9999)}"
 
-    def send_to(self, connection: Union[Network.WebsocketConnection, Network.HTTPConnection]) -> None:
-        if isinstance(connection, Network.WebsocketConnection):
+    def send_to(self, connection: Union[network.WebsocketConnection, network.HTTPConnection]) -> None:
+        if isinstance(connection, network.WebsocketConnection):
             payload: OneBotJsonPacket = {
                 "action": self.endpoint,
                 "params": self.paras,
@@ -38,7 +37,7 @@ class Packet:
             }
             connection.send(json.dumps(payload))
 
-        elif isinstance(connection, Network.HTTPConnection):
+        elif isinstance(connection, network.HTTPConnection):
             payload = self.paras
             connection.send(self.endpoint, payload, self.echo)
 

{hyper_bot-0.79.5/Hyper → hyper_bot-0.80.2/hyperot}/Adapters/OneBotLib/Res.py

@@ -1,7 +1,6 @@
 from abc import ABC
-from typing import Self
 
-from Hyper.Utils.HyperTyping import OneBotSegReg
+from ...utils.hypetyping import OneBotSegReg
 
 
 message_types = {}

{hyper_bot-0.79.5/Hyper → hyper_bot-0.80.2/hyperot}/__init__.py

@@ -1,5 +1,5 @@
-from Hyper import Configurator
-from Hyper.Utils import Screens
+from . import configurator
+from .utils import screens
 
 from typing import Union
 import asyncio
@@ -7,12 +7,12 @@ import importlib
 import sys
 import os
 
-HYPER_BOT_VERSION = "0.79.5"
+HYPER_BOT_VERSION = "0.80.2"
 
 listener: "Listener"
 
-Screens.play_startup()
-Screens.play_info(HYPER_BOT_VERSION)
+screens.play_startup()
+screens.play_info(HYPER_BOT_VERSION)
 
 
 def _load_listener() -> None: