hyper-bot 0.7__py3-none-any.whl

Hyper/Network.py

@@ -0,0 +1,70 @@
+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()
+
+    def connect(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()
+        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()

Hyper/Segments.py

@@ -0,0 +1,289 @@
+import json
+import typing
+import uuid
+
+from Hyper.Errors import *
+
+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:
+                    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
+                        new_arg[i] = anns[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:
+                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__"
+
+
+@segment_builder("text", "<text>")
+class Text(Base):
+    text: str
+
+
+@segment_builder("image", "[图片]")
+class Image(Base):
+    file: str
+    url: str = ""
+    summary: str = "[图片]"
+
+
+@segment_builder("at", f"@<qq>")
+class At(Base):
+    qq: str
+
+
+@segment_builder("reply", "")
+class Reply(Base):
+    id: str
+
+
+@segment_builder("face", "[表情: <id>]")
+class Faces(Base):
+    id: str
+
+
+@segment_builder("location", "[位置: <lat>, <lon>]")
+class Location(Base):
+    lat: str
+    lon: str
+
+
+@segment_builder("record", "[语音]")
+class Record(Base):
+    file: str
+
+
+@segment_builder("video", "[视频]")
+class Video(Base):
+    file: str
+
+
+@segment_builder("poke", "[拍一拍]")
+class Poke(Base):
+    type: str
+    id: str
+
+
+@segment_builder("contact")
+class Contact(Base):
+    type: str
+    id: str
+
+    def __str__(self) -> str:
+        return f"[推荐{'群' if self.type == 'group' else '用户'}: {self.id}]"
+
+
+@segment_builder("forward", "[转发消息]")
+class Forward(Base):
+    id: str
+
+
+@segment_builder("node", "[转发消息]")
+class Node(Base):
+    id: str
+
+
+class CustomNode:
+    def __init__(self, user_id: str, nick_name: str, content):
+        self.content = {"type": "node",
+                        "data": {"user_id": user_id, "nick_name": nick_name, "content": content.get_sync()}}
+
+    def to_json(self) -> dict:
+        return self.content
+
+    def __str__(self) -> str:
+        return f"[自定义节点]"
+
+
+class KeyBoardButton:
+    def __init__(self,
+                 text: str,
+                 style: int = 1,
+                 button_type: int = 2,
+                 data: str = "Hello World",
+                 enter: bool = False,
+                 permission: int = 2,
+                 specify_user_ids=None):
+        self.content = {
+            "id": str(uuid.uuid4()),
+            "render_data": {
+                "label": text,
+                "visited_label": text,
+                "style": style
+            },
+            "action": {
+                "type": button_type,
+                "permission": {
+                    "type": permission,
+                    "specify_user_ids": specify_user_ids
+                },
+                "enter": enter,
+                "unsupport_tips": "Harcic",
+                "data": data
+            }
+        }
+
+    def get(self) -> dict:
+        return self.content
+
+    def __str__(self) -> str:
+        return f"[按键{self.content['render_data']['label']}]"
+
+
+class KeyBoardRow:
+    def __init__(self, buttons: list[KeyBoardButton] = None):
+        self.content = {
+            "buttons": []
+        }
+        buttons = [] if buttons is None else buttons
+        for i in buttons:
+            self.content["buttons"].append(i.get())
+
+    def add(self, button: KeyBoardButton) -> None:
+        if len(self.content["buttons"]) < 5:
+            self.content["buttons"].append(button.get())
+        else:
+            raise ButtonRowFulledError("This button row is full")
+
+    def get(self) -> dict:
+        return self.content
+
+
+class KeyBoard:
+    def __init__(self, button_rows: list[KeyBoardRow]):
+        self.content = {"type": "keyboard",
+                        "data": {"content": {"rows": [i.get() for i in button_rows]}, "bot_appid": 0}}
+
+    def to_json(self) -> dict:
+        return self.content
+
+    def __str__(self) -> str:
+        return f"[自定按键版]"
+
+
+class MarkdownContent:
+    def __init__(self, raw_content: str):
+        self.content = (
+            raw_content
+            .replace('"', r'\\\"')
+            .replace(r"\`", r"\`")
+        )
+
+
+class MarkDown:
+    def __init__(self, content: MarkdownContent):
+        self.content = {"type": "markdown",
+                        "data": {"content": json.dumps({"content": content.content}).replace('"', '"')}}
+
+    def set(self, content: MarkdownContent) -> None:
+        self.__init__(content)
+
+    def to_json(self) -> dict:
+        return self.content
+
+    def __str__(self) -> str:
+        return f"[MarkDown]"
+
+
+@segment_builder("longmsg", "[<id>]")
+class LongMessage(Base):
+    id: str
+
+
+@segment_builder("json", "[Json]")
+class Json(Base):
+    data: typing.Union[dict, list, str]
+
+
+@segment_builder("mface", "[表情]")
+class MarketFace(Base):
+    face_id: str
+    tab_id: str
+    key: str
+
+
+@segment_builder("dice", "[骰子]")
+class Dice(Base):
+    pass
+
+
+@segment_builder("rps", "[猜拳]")
+class Rps(Base):
+    pass
+
+
+@segment_builder("music", "[音乐]")
+class Music(Base):
+    type: str
+    id: str = None
+    url: str = None
+    audio: str = None
+    title: str = None
+

Hyper/WordSafety.py

@@ -0,0 +1,68 @@
+import jieba
+import logging
+import asyncio
+
+from Hyper import Logic
+
+logging.getLogger("jieba").setLevel(logging.ERROR)
+
+
+class Result:
+    def __init__(self, message: str, result: bool):
+        self.message = message
+        self.result = result
+
+
+class AsyncChecker:
+    def __init__(self, hot_words: list[dict[str, str]]):
+        self.hot_words = hot_words
+
+    async def check(self, text: list) -> Result:
+        for j in self.hot_words:
+            if j["word"] in text:
+                ret = Result(f"检测到类型为{j['type']}的敏感用词", False)
+                return ret
+
+        ret = Result("未检出敏感词", True)
+        return ret
+
+
+with open("assets/dict.txt", "r", encoding="utf-8") as f:
+    words: list[dict[str, str]] = []
+    word = f.read()
+    word = word.split("\n")
+    inner_words: list[AsyncChecker] = []
+    tmp: list[dict[str, str]] = []
+    for i in word:
+        temp = i.split("	")
+        words.append({"word": temp[0], "type": temp[1]})
+        tmp.append({"word": temp[0], "type": temp[1]})
+        if len(tmp) == 50:
+            inner_words.append(AsyncChecker(tmp))
+            tmp = []
+
+
+@Logic.Cacher().cache
+def check(text: str) -> Result:
+    texts = jieba.lcut(text)
+    for j in words:
+        if j["word"] in texts:
+            ret = Result(f"检测到类型为{j['type']}的敏感用词", False)
+            return ret
+
+    ret = Result("未检出敏感词", True)
+    return ret
+
+
+@Logic.Cacher().cache
+async def check_async(text: str) -> Result:
+    texts = jieba.lcut(text)
+    __tasks: list[asyncio.Task] = []
+    for j in inner_words:
+        __tasks.append(asyncio.create_task(j.check(texts)))
+    await asyncio.gather(*__tasks)
+    for j in __tasks:
+        if not j.result().result:
+            return j.result()
+    ret = Result("未检出敏感词", True)
+    return ret