hyper-bot 0.7__py3-none-any.whl

Hyper/Adapters/OneBot.py

@@ -0,0 +1,278 @@
+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.Events import *
+
+reports = queue.Queue()
+config = Configurator.cm.get_cfg()
+logger = Logger.Logger()
+logger.set_level(config.log_level)
+
+
+class Actions:
+    def __init__(self, cnt: Union[Network.WebsocketConnection, Network.HTTPConnection]):
+        self.connection = cnt
+
+        class CustomAction:
+            def __init__(self, cnt_i: Union[Network.WebsocketConnection, Network.HTTPConnection]):
+                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)
+
+                return wrapper
+
+        self.custom = CustomAction(self.connection)
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().send, logger)
+    async def send(self, message: Manager.Message, group_id: int = None, user_id: int = None) -> Manager.Ret:
+        if group_id is not None:
+            packet = Manager.Packet(
+                "send_msg",
+                group_id=group_id,
+                message=await message.get()
+            )
+        elif user_id is not None:
+            packet = Manager.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.")
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().recall, logger)
+    async def del_message(self, message_id: int) -> None:
+        Manager.Packet(
+            "delete_msg",
+            message_id=message_id,
+        ).send_to(self.connection)
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().kick, logger)
+    async def set_group_kick(self, group_id: int, user_id: int) -> None:
+        Manager.Packet(
+            "set_group_kick",
+            group_id=group_id,
+            user_id=user_id,
+        ).send_to(self.connection)
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().mute, logger)
+    async def set_group_ban(self, group_id: int, user_id: int, duration: int = 60) -> None:
+        Manager.Packet(
+            "set_group_ban",
+            group_id=group_id,
+            user_id=user_id,
+            duration=duration,
+        ).send_to(self.connection)
+
+    @Logic.Cacher().cache_async
+    async def get_login_info(self) -> Manager.Ret:
+        packet = Manager.Packet("get_login_info")
+        packet.send_to(self.connection)
+        return get_ret(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)
+
+    async def send_forward_msg(self, message: Manager.Message) -> Manager.Ret:
+        packet = Manager.Packet(
+            "send_forward_msg",
+            messages=await message.get()
+        )
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+    async def send_group_forward_msg(self, group_id: int, message: Manager.Message) -> Manager.Ret:
+        packet = Manager.Packet(
+            "send_group_forward_msg",
+            group_id=group_id,
+            messages=await message.get()
+        )
+        packet.send_to(self.connection)
+        return get_ret(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:
+        Manager.Packet(
+            "set_group_add_request",
+            flag=flag,
+            sub_type=sub_type,
+            approve=approve,
+            reason=reason
+        ).send_to(self.connection)
+
+    @Logic.Cacher().cache_async
+    async def get_stranger_info(self, user_id: int) -> Manager.Ret:
+        packet = Manager.Packet(
+            "get_stranger_info",
+            user_id=user_id,
+            no_cache=True,
+        )
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+    @Logic.Cacher().cache_async
+    async def get_group_member_info(self, group_id: int, user_id: int) -> Manager.Ret:
+        packet = Manager.Packet(
+            "get_group_member_info",
+            group_id=group_id,
+            user_id=user_id,
+            no_cache=True
+        )
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+    @Logic.Cacher().cache_async
+    async def get_group_info(self, group_id: int) -> Manager.Ret:
+        packet = Manager.Packet(
+            "get_group_info",
+            group_id=group_id,
+            no_cache=True
+        )
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+    async def get_status(self) -> Manager.Ret:
+        packet = Manager.Packet("get_status")
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+    @Logger.AutoLogAsync.register(Logger.AutoLog.templates().set_ess, logger)
+    async def set_essence_msg(self, message_id: int) -> None:
+        Manager.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:
+        Manager.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) -> Manager.Ret:
+        packet = Manager.Packet(
+            "get_msg",
+            message_id=msg_id
+        )
+        packet.send_to(self.connection)
+        return get_ret(packet.echo)
+
+
+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))
+    elif data.get("post_type") == "meta_event" or data.get("user_id") == data.get("self_id"):
+        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
+
+
+handler: callable = tester
+connection: callable = tester
+
+
+def reg(func: callable):
+    global handler
+    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")
+        # connection = websocket.WebSocket()
+        if isinstance(config.connection, Configurator.WSConnectionC):
+            connection = Network.WebsocketConnection(f"ws://{config.connection.host}:{config.connection.port}")
+        elif isinstance(config.connection, Configurator.HTTPConnectionC):
+            connection = Network.HTTPConnection(
+                url=f"http://{config.connection.host}:{config.connection.port}",
+                listener_url=f"http://{config.connection.listener_host}:{config.connection.listener_port}"
+            )
+        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/Adapters/OneBotLib/Manager.py

@@ -0,0 +1,93 @@
+from Hyper import Logic, Configurator, Logger, Network
+from Hyper.Logger import levels
+from Hyper.Segments import *
+
+from typing import Union
+import inspect
+import random
+
+config = Configurator.cm.get_cfg()
+logger = Logger.Logger()
+logger.set_level(config.log_level)
+
+servicing = []
+
+
+class Packet:
+    def __init__(self, endpoint: str, **kwargs):
+        self.endpoint = endpoint
+        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):
+            payload = {
+                "action": self.endpoint,
+                "params": self.paras,
+                "echo": self.echo,
+            }
+            connection.send(json.dumps(payload))
+
+        elif isinstance(connection, Network.HTTPConnection):
+            payload = self.paras
+            connection.send(self.endpoint, payload, self.echo)
+
+
+class Message:
+    def __init__(self, contents: list = None):
+        if contents is None:
+            contents = []
+        self.contents = contents
+
+    def add(self, content) -> None:
+        self.contents.append(content)
+
+    async def get(self) -> list:
+        ret = []
+        for i in self.contents:
+            ret.append(i.to_json())
+        return ret
+
+    def get_sync(self) -> list:
+        ret = []
+        for i in self.contents:
+            ret.append(i.to_json())
+        return ret
+
+    def __len__(self) -> int:
+        return len(self.contents)
+
+    def __getitem__(self, index: int):
+        return self.contents[index]
+
+    def __setitem__(self, index: int, content) -> None:
+        self.contents[index] = content
+
+    def __delitem__(self, index: int) -> None:
+        del self.contents[index]
+
+    def __iter__(self):
+        for i in self.contents:
+            yield i
+
+    def __str__(self) -> str:
+        return "".join([str(content) for content in self.contents])
+
+    def __repr__(self) -> str:
+        return str(self.contents)
+
+    def __add__(self, new):
+        self.contents += new.contents
+        return self
+
+    def __iadd__(self, new):
+        self.contents += new.contents
+        return self
+
+
+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.echo = json_data.get("echo")

Hyper/Configurator.py

@@ -0,0 +1,83 @@
+import typing
+
+from Hyper import Logic
+
+
+class WSConnectionC:
+    def __init__(self, host: str, port: int, retries: int = 0):
+        self.host: str = host
+        self.port: int = port
+        self.retries: int = retries
+
+
+class HTTPConnectionC:
+    def __init__(self, host: str, port: int, listener_host: str, listener_port: int, retries: int = 0):
+        self.host: str = host
+        self.port: int = port
+        self.listener_host: str = listener_host
+        self.listener_port: int = listener_port
+        self.retries: int = retries
+
+
+class Config:
+    def __init__(
+            self,
+            file: str = None,
+            protocol: str = "OneBot",
+            owner: list[int] = None,
+            black_list: list[int] = None,
+            silents: list[int] = None,
+            connection: typing.Union[WSConnectionC, HTTPConnectionC] = None,
+            log_level: str = "INFO",
+            others: dict = None
+    ):
+        self.inited = False
+        if file is not None:
+            self.file = file
+        else:
+            self.protocol: str = protocol
+            self.owner: list[int] = owner or list()
+            self.black_list: list[int] = black_list or list()
+            self.silents: list[int] = silents or list
+            self.connection = connection
+            self.log_level = log_level
+            self.others = others or dict()
+            self.inited = True
+
+    def load_from_file(self):
+        config_json = Logic.FileManager.read_as_json(self.file)
+
+        self.protocol: str = config_json["protocol"]
+        self.owner: list[int] = config_json["owner"]
+        self.black_list: list[int] = config_json["black_list"]
+        self.silents: list[int] = config_json["silents"]
+        if config_json["Connection"]["mode"] == "FWS":
+            self.connection = WSConnectionC(
+                config_json["Connection"]["host"],
+                config_json["Connection"]["port"],
+                config_json["Connection"]["retries"]
+            )
+        elif config_json["Connection"]["mode"] == "HTTP":
+            self.connection = HTTPConnectionC(
+                config_json["Connection"]["host"],
+                config_json["Connection"]["port"],
+                config_json["Connection"]["listener_host"],
+                config_json["Connection"]["listener_port"],
+                config_json["Connection"]["retries"]
+            )
+        self.log_level = config_json["Log_level"]
+        self.others = config_json["Others"]
+
+        self.inited = True
+        return self
+
+
+class ConfigManager:
+    def __init__(self, config: Config):
+        self.config: Config = config
+
+    def get_cfg(self) -> Config:
+        return self.config
+
+
+cm: ConfigManager

Hyper/DataBase.py

@@ -0,0 +1,81 @@
+import json
+import uuid
+
+
+class Dataset:
+    def __init__(self, path: str = "./data.json", index: str = "./index.json"):
+        self.path = path
+        self.index = index
+        self.data = {}
+        self.indexes = {}
+
+    def load(self):
+        with open(self.path, "r") as f:
+            self.data = json.load(f)
+        with open(self.index, "r") as f:
+            self.indexes = json.load(f)
+
+    def save(self):
+        with open(self.path, "w") as f:
+            json.dump(self.data, f, indent=2)
+        with open(self.index, "w") as f:
+            json.dump(self.indexes, f, indent=2)
+
+    def set(self, id, key, value):
+        self.data[id][key] = value
+        self.save()
+
+    def dict_set(self, id, item: dict):
+        self.data[id] = item
+        self.save()
+
+    def create(self):
+        id = str(uuid.uuid4())
+        self.data[id] = dict()
+        self.save()
+        return id
+
+    def delete(self, id: str):
+        del self.data[id]
+        self.save()
+
+    def get(self, item: dict = None, id: str = None, index=True):
+        if item is not None:
+            itme_id = self.queue(item, index)
+            if not itme_id:
+                itme_id = self.create()
+                self.dict_set(itme_id, item)
+            return self.data[itme_id]
+        elif id is not None:
+            return self.data[id]
+        return False
+
+    def queue(self, key: dict, index=True):
+        if index:
+            try:
+                return self.indexes[str(key)]
+            except KeyError or TypeError:
+                pass
+        for k, v in key.items():
+            for i in self.data:
+                try:
+                    if self.data[i][k] == v:
+                        if index:
+                            self.indexes[str(key)] = i
+                        return i
+                except KeyError:
+                    pass
+        return False
+
+    def exist(self, item: dict = None, id: str = None, index=True):
+        if item:
+            return True if self.get(item, index=index) else False
+        elif id:
+            return True if self.get({"_id": id}, index=index) else False
+        else:
+            return None
+
+    def clear(self):
+        self.data = {}
+        self.indexes = {}
+        self.save()

Hyper/Errors.py

@@ -0,0 +1,18 @@
+class ButtonRowFulledError(Exception):
+    def __init__(self, message: str = None):
+        super().__init__(message)
+
+
+class NotSupportError(NotImplementedError):
+    def __init__(self, message: str = None):
+        super().__init__(message)
+
+
+class ListenerNotRegisteredError(Exception):
+    def __init__(self, message: str = None):
+        super().__init__(message)
+
+
+class ArgsInvalidError(Exception):
+    def __init__(self, message: str = None):
+        super().__init__(message)