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

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

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

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

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

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

@@ -105,6 +105,26 @@ class Actions:
         packet.send_to(self.connection)
         return common.Ret.fetch(packet.echo, SendForwardRsp)
 
+    async def get_forward_msg(self, sid: str) -> common.Ret[common.Message]:
+        packet = common.Packet(
+            "get_forward_msg",
+            id=sid,
+        )
+        packet.send_to(self.connection)
+        ret = common.Ret.fetch(packet.echo, events.gen_message)
+        for i in ret.data:
+            if isinstance(i, segments.Node):
+                i.content = gen_message({"message": i.content})
+
+        return ret
+
+    async def forward_solve(self, message: common.Message) -> common.Message:
+        for i in message:
+            if isinstance(i, segments.Forward):
+                data = await self.get_forward_msg(i.id)
+                return data.data
+        raise ValueError("Incorrect message type")
+
     async def send_group_forward_msg(self, group_id: int, message: common.Message) -> common.Ret[SendGrpForwardRsp]:
         packet = common.Packet(
             "send_group_forward_msg",
@@ -114,7 +134,8 @@ class Actions:
         packet.send_to(self.connection)
         return common.Ret.fetch(packet.echo, SendForwardRsp)
 
-    async def set_group_add_request(self, flag: str, sub_type: str, approve: bool, reason: str = "Not Mentioned") -> None:
+    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,
@@ -179,6 +200,14 @@ class Actions:
         packet.send_to(self.connection)
         return common.Ret.fetch(packet.echo, GetMsgRsp)
 
+    async def send_callback(self, group_id: int, bot_id: int, data: dict) -> None:
+        common.Packet(
+            "send_group_bot_callback",
+            group_id=group_id,
+            bot_id=bot_id,
+            **data
+        ).send_to(self.connection)
+
 
 async def tester(
         message_data: Union[Event, HyperNotify], actions: Actions

hyper_bot-0.80.7/hyperot/__init__.py

@@ -0,0 +1,82 @@
+from . import configurator
+from .utils import screens
+
+from typing import Union
+import asyncio
+import sys
+import os
+
+HYPER_BOT_VERSION = "0.80.7"
+
+# listener = None
+
+screens.play_startup()
+screens.play_info(HYPER_BOT_VERSION)
+
+
+class Client:
+    def __init__(self):
+        self.records = {}
+        self.lis = None
+
+    def subscribe(
+            self,
+            func: callable,
+            event: Union[
+                "events.GroupMessageEvent",
+                "events.PrivateMessageEvent",
+                "events.GroupFileUploadEvent",
+                "events.GroupAdminEvent",
+                "events.GroupMemberDecreaseEvent",
+                "events.GroupMemberIncreaseEvent",
+                "events.GroupMuteEvent",
+                "events.FriendAddEvent",
+                "events.GroupRecallEvent",
+                "events.FriendRecallEvent",
+                "events.NotifyEvent",
+                "events.GroupEssenceEvent",
+                "events.MessageReactionEvent",
+                "events.GroupAddInviteEvent",
+                "events.HyperListenerStartNotify",
+                "events.HyperListenerStopNotify"
+            ]
+    ) -> None:
+        if not self.records.get(event):
+            self.records[event] = [func]
+        else:
+            self.records[event].append(func)
+
+    async def distributor(
+            self, message_data: Union["events.Event", "events.HyperNotify"], actions: "Listener.Actions"
+    ) -> None:
+        if type(message_data) in list(self.records.keys()):
+            tasks = []
+            for i in self.records[type(message_data)]:
+                tasks.append(asyncio.create_task(i(message_data, actions)))
+            await asyncio.gather(*tasks)
+        else:
+            return
+
+    def run(self):
+        from . import listener
+        self.lis = listener
+        self.lis.reg(self.distributor)
+        if self.records:
+            self.lis.run()
+
+    def restart(self) -> None:
+        self.lis.stop()
+        os.execv(sys.executable, [sys.executable] + sys.argv)
+        # os._exit(1)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass

{hyper_bot-0.80.2 → hyper_bot-0.80.7}/hyperot/common.py

@@ -7,19 +7,19 @@ from typing import Generic, Type, Self
 
 config = configurator.BotConfig.get("hyper-bot")
 
-if config.protocol == "OneBot":
-    from .Adapters.OneBotLib.Manager import *
-elif config.protocol == "Satori":
-    raise NotImplementedError()
-elif config.protocol == "Lagrange":
-    raise NotImplementedError()
-elif config.protocol == "Kritor":
-    from .Adapters.KritorLib.Manager import *
+# if config.protocol == "OneBot":
+#     from .Adapters.OneBotLib.Manager import *
+# elif config.protocol == "Satori":
+#     raise NotImplementedError()
+# elif config.protocol == "Lagrange":
+#     raise NotImplementedError()
+# elif config.protocol == "Kritor":
+#     from .Adapters.KritorLib.Manager import *
 
+from .Adapters.OneBotLib.Manager import *
 
 init()
 
-
 __all__ = ["Message", "MessageBuilder", "Packet", "Ret", "reports"]
 
 

{hyper_bot-0.80.2 → hyper_bot-0.80.7}/hyperot/events.py

@@ -36,6 +36,7 @@ class EventManager:
         return wrapper
 
     def new(self, data: dict) -> "Event":
+        logger.trace(str(data))
         try:
             return self.event_lis[data["post_type"]][data[f"{data['post_type']}_type"]](data)
         except KeyError:

{hyper_bot-0.80.2 → hyper_bot-0.80.7}/hyperot/listener.py

@@ -4,14 +4,16 @@ config = configurator.BotConfig.get("hyper-bot")
 
 __all__ = ["run", "stop", "Actions"]
 
-if config.protocol == "OneBot":
-    from .Adapters.OneBot import *
-elif config.protocol == "Satori":
-    raise NotImplementedError()
-elif config.protocol == "Lagrange":
-    raise NotImplementedError()
-elif config.protocol == "Kritor":
-    from .Adapters.Kritor import *
+# if config.protocol == "OneBot":
+#     from .Adapters.OneBot import *
+# elif config.protocol == "Satori":
+#     raise NotImplementedError()
+# elif config.protocol == "Lagrange":
+#     raise NotImplementedError()
+# elif config.protocol == "Kritor":
+#     from .Adapters.Kritor import *
+
+from .Adapters.OneBot import *
 
 events.init()
 

{hyper_bot-0.80.2 → hyper_bot-0.80.7}/hyperot/network.py

@@ -8,11 +8,11 @@ import traceback
 import json
 import logging
 import threading
-from grpclib.client import Channel
-
-from .Adapters.KritorLib.protos.authentication import AuthenticationServiceStub, AuthenticateRequest
-from .Adapters.KritorLib.protos.event import EventServiceStub
-from .Adapters.KritorLib.Res import EventService
+# from grpclib.client import Channel
+#
+# from .Adapters.KritorLib.protos.authentication import AuthenticationServiceStub, AuthenticateRequest
+# from .Adapters.KritorLib.protos.event import EventServiceStub
+# from .Adapters.KritorLib.Res import EventService
 
 
 class WebsocketConnection:
@@ -131,35 +131,39 @@ class SatoriConnection:
 class KritorConnection:
     def __init__(self, host: str, port: int, account: str = None, ticket: str = None):
         # self.channel = grpc.insecure_channel(f"{host}:{port}")
-        self.channel = Channel(host=host, port=port)
-        self.account = account
-        self.ticket = ticket
+        # self.channel = Channel(host=host, port=port)
+        # self.account = account
+        # self.ticket = ticket
+        raise NotImplementedError()
 
     def connect(self) -> None:
-        if self.account and self.ticket:
-            auth_stub = AuthenticationServiceStub(self.channel)
-            response = asyncio.run(
-                auth_stub.authenticate(
-                    AuthenticateRequest(
-                        account=self.account,
-                        ticket=self.ticket
-                    )
-                )
-            )
-            if response.code != 0:
-                raise ConnectionError("鉴权失败")
-        else:
-            pass
+        # if self.account and self.ticket:
+        #     auth_stub = AuthenticationServiceStub(self.channel)
+        #     response = asyncio.run(
+        #         auth_stub.authenticate(
+        #             AuthenticateRequest(
+        #                 account=self.account,
+        #                 ticket=self.ticket
+        #             )
+        #         )
+        #     )
+        #     if response.code != 0:
+        #         raise ConnectionError("鉴权失败")
+        # else:
+        #     pass
+        raise NotImplementedError()
         # threading.Thread(target=lambda: asyncio.run(self.event_service.run())).start()
 
     def send(self, stub, payload: dict, echo: str = None) -> None:
         raise NotImplementedError()
 
     def close(self) -> None:
-        self.channel.close()
+        # self.channel.close()
+        raise NotImplementedError()
 
     async def recv(self) -> None:
-        event_service = EventService(EventServiceStub(self.channel))
-        # asyncio.run(event_service.run())
-        # asyncio.get_running_loop().run_until_complete(event_service.run())
-        await event_service.run()
+        # event_service = EventService(EventServiceStub(self.channel))
+        # # asyncio.run(event_service.run())
+        # # asyncio.get_running_loop().run_until_complete(event_service.run())
+        # await event_service.run()
+        raise NotImplementedError()

{hyper_bot-0.80.2 → hyper_bot-0.80.7}/hyperot/segments.py

@@ -4,22 +4,24 @@ import typing
 import uuid
 
 from .utils.errors import *
+from .utils.hypetyping import Union
 from . import configurator
 
 config = configurator.BotConfig.get("hyper-bot")
-if config.protocol == "OneBot":
-    # from Hyper.Adapters.OneBotLib.Res import segment_builder, Base, message_types
-    from .Adapters.OneBotLib.Res import SegmentBase, message_types
-elif config.protocol == "Satori":
-    # from Hyper.Adapters.SatoriLib.Res import segment_builder, Base, message_types
-    raise NotImplementedError()
-elif config.protocol == "Lagrange":
-    # from Hyper.Adapters.LagrangeLib.Res import segment_builder, Base, message_types
-    raise NotImplementedError()
-elif config.protocol == "Kritor":
-    # from Hyper.Adapters.KritorLib.Res import segment_builder, Base, message_types
-    from .Adapters.KritorLib.Res import SegmentBase, message_types
-
+# if config.protocol == "OneBot":
+#     # from Hyper.Adapters.OneBotLib.Res import segment_builder, Base, message_types
+#     from .Adapters.OneBotLib.Res import SegmentBase, message_types
+# elif config.protocol == "Satori":
+#     # from Hyper.Adapters.SatoriLib.Res import segment_builder, Base, message_types
+#     raise NotImplementedError()
+# elif config.protocol == "Lagrange":
+#     # from Hyper.Adapters.LagrangeLib.Res import segment_builder, Base, message_types
+#     raise NotImplementedError()
+# elif config.protocol == "Kritor":
+#     # from Hyper.Adapters.KritorLib.Res import segment_builder, Base, message_types
+#     from .Adapters.KritorLib.Res import SegmentBase, message_types
+
+from .Adapters.OneBotLib.Res import SegmentBase, message_types
 
 class MediaSeg(SegmentBase):
     @classmethod
@@ -47,6 +49,9 @@ class Text(SegmentBase, st="text", su="<text>"):
     text: str
 
 
+class StreamTest(SegmentBase, st="stream", su="[Stream] <text>"):
+    text: str
+
 class Image(MediaSeg, st="image", su="[Image]"):
     file: str
     url: str
@@ -99,7 +104,9 @@ class Forward(SegmentBase, st="forward", su="[Forward]"):
 
 
 class Node(SegmentBase, st="node", su="[Node]"):
-    id: str
+    user_id: str
+    nickname: str
+    content: Union[dict, "common.Message"]
 
 
 class CustomNode:

{hyper_bot-0.80.2 → hyper_bot-0.80.7}/hyperot/utils/apiresponse.py

@@ -185,7 +185,8 @@ class GetMsgRsp(BaseResponse):
 
     @classmethod
     def build(
-            cls, time: int, message_type: Literal["private", "group"], message_id: int, real_id: int, sender: dict, message: dict
+            cls, time: int, message_type: Literal["private", "group"], message_id: int, real_id: int, sender: dict,
+            message: dict
     ):
         return cls(
             {
@@ -197,5 +198,3 @@ class GetMsgRsp(BaseResponse):
                 "message": message
             }
         )
-
-

hyper_bot-0.80.2/hyperot/__init__.py

@@ -1,87 +0,0 @@
-from . import configurator
-from .utils import screens
-
-from typing import Union
-import asyncio
-import importlib
-import sys
-import os
-
-HYPER_BOT_VERSION = "0.80.2"
-
-listener: "Listener"
-
-screens.play_startup()
-screens.play_info(HYPER_BOT_VERSION)
-
-
-def _load_listener() -> None:
-    global listener
-    listener = importlib.import_module("Hyper.Listener")
-
-
-def restart() -> None:
-    listener.stop()
-    os.execv(sys.executable, [sys.executable] + sys.argv)
-    # os._exit(1)
-
-
-class Client:
-    def __init__(self):
-        self.records = {}
-
-    def subscribe(
-            self,
-            func: callable,
-            event: Union[
-                "Events.GroupMessageEvent",
-                "Events.PrivateMessageEvent",
-                "Events.GroupFileUploadEvent",
-                "Events.GroupAdminEvent",
-                "Events.GroupMemberDecreaseEvent",
-                "Events.GroupMemberIncreaseEvent",
-                "Events.GroupMuteEvent",
-                "Events.FriendAddEvent",
-                "Events.GroupRecallEvent",
-                "Events.FriendRecallEvent",
-                "Events.NotifyEvent",
-                "Events.GroupEssenceEvent",
-                "Events.MessageReactionEvent",
-                "Events.GroupAddInviteEvent",
-                "Events.HyperListenerStartNotify",
-                "Events.HyperListenerStopNotify"
-            ]
-    ) -> None:
-        if not self.records.get(event):
-            self.records[event] = [func]
-        else:
-            self.records[event].append(func)
-
-    async def distributor(
-            self, message_data: Union["Events.Event", "Events.HyperNotify"], actions: "Listener.Actions"
-    ) -> None:
-        if type(message_data) in list(self.records.keys()):
-            tasks = []
-            for i in self.records[type(message_data)]:
-                tasks.append(asyncio.create_task(i(message_data, actions)))
-            await asyncio.gather(*tasks)
-        else:
-            return
-
-    def run(self):
-        _load_listener()
-        listener.reg(self.distributor)
-        if self.records:
-            listener.run()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        pass