uel-toolcraft 0.1.0__tar.gz

uel_toolcraft-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+.venv/
+build/

uel_toolcraft-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Samuel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uel_toolcraft-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: uel-toolcraft
+Version: 0.1.0
+Summary: A Unified Essential Library toolcraft (uel-toolcraft) for personal usage.
+Author: Samuel
+License: MIT
+License-File: LICENSE
+Keywords: models,tools,utilities
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: json5>=0.9.0
+Requires-Dist: pycryptodome>=3.15.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: all
+Requires-Dist: ffmpeg-python>=0.2.0; extra == 'all'
+Requires-Dist: gitpython>=3.1.0; extra == 'all'
+Requires-Dist: pyqt6>=6.5.0; extra == 'all'
+Requires-Dist: rclone-python>=0.1.0; extra == 'all'
+Requires-Dist: supabase>=2.0.0; extra == 'all'
+Requires-Dist: upstash-redis>=0.1.0; extra == 'all'
+Provides-Extra: ffmpeg
+Requires-Dist: ffmpeg-python>=0.2.0; extra == 'ffmpeg'
+Provides-Extra: git
+Requires-Dist: gitpython>=3.1.0; extra == 'git'
+Provides-Extra: pyqt
+Requires-Dist: pyqt6>=6.5.0; extra == 'pyqt'
+Provides-Extra: rclone
+Requires-Dist: rclone-python>=0.1.0; extra == 'rclone'
+Provides-Extra: redis
+Requires-Dist: upstash-redis>=0.1.0; extra == 'redis'
+Provides-Extra: supabase
+Requires-Dist: supabase>=2.0.0; extra == 'supabase'
+Description-Content-Type: text/markdown
+
+# uel-toolcraft
+
+A Unified Essential Library toolcraft for personal usage.
+
+## Installation
+
+```bash
+pip install uel-toolcraft
+```
+
+Install with optional dependencies:
+
+```bash
+# All optional dependencies
+pip install uel-toolcraft[all]
+
+# Specific extras
+pip install uel-toolcraft[pyqt,ffmpeg,git]
+```
+
+Local development install:
+
+```bash
+git clone https://github.com/iShengren/uel-toolcraft.git
+cd uel-toolcraft
+uv pip install -e ".[all]"
+```
+
+## Usage
+
+### Models
+
+```python
+from uel_toolcraft.models import AESCipher, SQLiteHelper, BarkClient
+
+cipher = AESCipher("my-secret-key")
+db = SQLiteHelper("mydb.sqlite")
+bark = BarkClient("https://bark.example.com", "device_key")
+```
+
+### Tools
+
+```python
+from uel_toolcraft.tools import read_json_file, write_json_file, md5sum
+
+data = read_json_file("config.json")
+checksum = md5sum("large_file.bin")
+write_json_file({"key": "value"}, "output.json")
+```
+
+### CLI
+
+```bash
+uel-toolcraft --version
+python -m uel_toolcraft --version
+```
+
+## Optional Dependencies
+
+| Extra | Packages | Used by |
+|---|---|---|
+| `pyqt` | PyQt6 | `PyQtAsyncHelper`, `ui_tools` |
+| `ffmpeg` | ffmpeg-python | `ffmpeg_tools` |
+| `rclone` | rclone-python | `rclone_tools` |
+| `supabase` | supabase | `supabase_tools` |
+| `git` | GitPython | `git_tools` |
+| `redis` | upstash-redis | `redis_upstash` |
+
+## License
+
+MIT

uel_toolcraft-0.1.0/README.md

@@ -0,0 +1,71 @@
+# uel-toolcraft
+
+A Unified Essential Library toolcraft for personal usage.
+
+## Installation
+
+```bash
+pip install uel-toolcraft
+```
+
+Install with optional dependencies:
+
+```bash
+# All optional dependencies
+pip install uel-toolcraft[all]
+
+# Specific extras
+pip install uel-toolcraft[pyqt,ffmpeg,git]
+```
+
+Local development install:
+
+```bash
+git clone https://github.com/iShengren/uel-toolcraft.git
+cd uel-toolcraft
+uv pip install -e ".[all]"
+```
+
+## Usage
+
+### Models
+
+```python
+from uel_toolcraft.models import AESCipher, SQLiteHelper, BarkClient
+
+cipher = AESCipher("my-secret-key")
+db = SQLiteHelper("mydb.sqlite")
+bark = BarkClient("https://bark.example.com", "device_key")
+```
+
+### Tools
+
+```python
+from uel_toolcraft.tools import read_json_file, write_json_file, md5sum
+
+data = read_json_file("config.json")
+checksum = md5sum("large_file.bin")
+write_json_file({"key": "value"}, "output.json")
+```
+
+### CLI
+
+```bash
+uel-toolcraft --version
+python -m uel_toolcraft --version
+```
+
+## Optional Dependencies
+
+| Extra | Packages | Used by |
+|---|---|---|
+| `pyqt` | PyQt6 | `PyQtAsyncHelper`, `ui_tools` |
+| `ffmpeg` | ffmpeg-python | `ffmpeg_tools` |
+| `rclone` | rclone-python | `rclone_tools` |
+| `supabase` | supabase | `supabase_tools` |
+| `git` | GitPython | `git_tools` |
+| `redis` | upstash-redis | `redis_upstash` |
+
+## License
+
+MIT

uel_toolcraft-0.1.0/main.py

@@ -0,0 +1,4 @@
+from uel_toolcraft.__main__ import main
+
+if __name__ == "__main__":
+    main()

uel_toolcraft-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "uel-toolcraft"
+version = "0.1.0"
+description = "A Unified Essential Library toolcraft (uel-toolcraft) for personal usage."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "Samuel"},
+]
+keywords = ["tools", "utilities", "models"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+dependencies = [
+    "json5>=0.9.0",
+    "pycryptodome>=3.15.0",
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+pyqt = ["PyQt6>=6.5.0"]
+ffmpeg = ["ffmpeg-python>=0.2.0"]
+rclone = ["rclone-python>=0.1.0"]
+supabase = ["supabase>=2.0.0"]
+git = ["GitPython>=3.1.0"]
+redis = ["upstash-redis>=0.1.0"]
+all = [
+    "PyQt6>=6.5.0",
+    "ffmpeg-python>=0.2.0",
+    "rclone-python>=0.1.0",
+    "supabase>=2.0.0",
+    "GitPython>=3.1.0",
+    "upstash-redis>=0.1.0",
+]
+
+[project.scripts]
+uel-toolcraft = "main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["uel_toolcraft"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/uel_toolcraft",
+    "/main.py",
+    "/README.md",
+    "/LICENSE",
+]

uel_toolcraft-0.1.0/uel_toolcraft/__init__.py

@@ -0,0 +1,12 @@
+"""
+uel-toolcraft — A Unified Essential Library toolcraft for personal usage.
+
+Models: AES encryption, Bark push, logging, PyQt async, Redis, SQLite, WeCom.
+Tools: config, ffmpeg, filesystem, git, json, pickle, rclone, supabase, text, UI, utils.
+"""
+
+try:
+    from importlib.metadata import version as _get_version
+    __version__ = _get_version("uel-toolcraft")
+except Exception:
+    __version__ = "0.1.0"

uel_toolcraft-0.1.0/uel_toolcraft/__main__.py

@@ -0,0 +1,19 @@
+"""Entry point for `python -m uel_toolcraft`."""
+
+import argparse
+from importlib.metadata import version as _get_version
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="uel-toolcraft — A Unified Essential Library toolcraft"
+    )
+    parser.add_argument(
+        "--version", action="version",
+        version=f"uel-toolcraft {_get_version('uel-toolcraft')}"
+    )
+    parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

uel_toolcraft-0.1.0/uel_toolcraft/models/AESCipher.py

@@ -0,0 +1,134 @@
+import base64
+import logging
+from .logging_config import LogConfig
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Random import get_random_bytes
+
+# 获取日志记录器
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class AESCipher:
+    def __init__(self, key, iv=None, mode: str = 'CBC', padding_style: str = 'pkcs7'):
+        """
+        初始化AES加密器
+
+        :param key: 密钥 bytes (16/24/32字节分别对应AES-128/192/256)
+        :param iv: 初始化向量 (CBC/GCM模式需要，16字节)
+        :param mode: 加密模式 'CBC'/'ECB'/'GCM'
+        """
+        self.key = key if type(key) is bytes else key.encode('utf-8')  # 将字符串转换为字节
+        self.mode_name = mode.upper()
+        if self.mode_name == 'CBC':
+            self.mode = AES.MODE_CBC
+            if iv is None:
+                raise ValueError("IV is required for CBC mode")
+            self.iv = iv
+        elif self.mode_name == 'ECB':
+            self.mode = AES.MODE_ECB
+            self.iv = None
+        elif self.mode_name == 'GCM':
+            self.mode = AES.MODE_GCM
+            if iv is None:
+                raise ValueError("IV is required for GCM mode")
+            self.iv = iv
+        else:
+            raise ValueError(f"Unsupported AES mode: {mode}")
+        if (self.iv is not None) and (type(self.iv) is str):
+            self.iv = self.iv.encode('utf-8')  # 将字符串转换为字节
+        self.padding_style = padding_style  # 默认填充方式
+
+    def encrypt(self, plaintext: str) -> str:
+        """
+        加密数据并返回 base64 编码字符串
+
+        :param plaintext: 原文字符串
+        :return: base64加密结果
+        """
+        plaintext_bytes = plaintext.encode('utf-8')
+
+        if self.mode_name in ['CBC', 'ECB']:
+            padded_data = pad(plaintext_bytes, AES.block_size, style=self.padding_style)  # padding 填充
+            # 创建 AES 加密器
+            if self.iv:
+                cipher = AES.new(self.key, self.mode, iv=self.iv)  # 忽略意外类型 "(Any, Literal[11], Any)"
+            else:
+                cipher = AES.new(self.key, self.mode)
+            encrypted = cipher.encrypt(padded_data)  # 加密数据
+        elif self.mode_name == 'GCM':
+            # # GCM 模式不需要填充
+            # padded_data = pad(plaintext_bytes, AES.block_size, style=self.padding_style)  # padding 填充
+            cipher = AES.new(self.key, self.mode, nonce=self.iv)
+            encrypted, tag = cipher.encrypt_and_digest(plaintext_bytes)  # 加密数据
+            encrypted += tag  # 将tag附加到密文末尾
+        else:
+            raise ValueError("Unsupported encryption mode.")
+
+        # 将加密结果转换为base64编码
+        base64_encrypted = base64.b64encode(encrypted).decode('utf-8')
+
+        return base64_encrypted
+
+    def decrypt(self, encrypted_base64: str) -> str:
+        """
+        解密 base64 数据并返回原文字符串
+
+        :param encrypted_base64: base64编码的加密数据
+        :return: 解密后的原文
+        """
+        encrypted_bytes = base64.b64decode(encrypted_base64)
+
+        if self.mode_name in ['CBC', 'ECB']:
+            if self.iv:
+                cipher = AES.new(self.key, self.mode, iv=self.iv)  # 忽略意外类型 "(Any, Literal[11], Any)"
+            else:
+                cipher = AES.new(self.key, self.mode)
+            decrypted_padded = cipher.decrypt(encrypted_bytes)
+            plaintext = unpad(decrypted_padded, AES.block_size, self.padding_style).decode('utf-8')  # 去除填充
+        elif self.mode_name == 'GCM':
+            cipher = AES.new(self.key, self.mode, nonce=self.iv)  # 忽略意外类型
+            tag = encrypted_bytes[-AES.block_size:]
+            encrypted_data = encrypted_bytes[:-AES.block_size]
+            plaintext = cipher.decrypt_and_verify(encrypted_data, tag).decode('utf-8')
+        else:
+            raise ValueError("Unsupported decryption mode.")
+
+        return plaintext
+
+    @staticmethod
+    def generate_key(bits: int = 128, output_format: str = "str") -> bytes|str:
+        """
+        生成随机AES密钥
+
+        :param bits: 密钥长度（128/192/256）
+        :param output_format: 输出格式（"bytes" 或 "str"）
+        :return: 随机密钥 bytes 或 str
+        """
+        if bits not in [128, 192, 256]:
+            raise ValueError("Key length must be 128, 192, or 256 bits.")
+        # 生成随机密钥
+        random_bytes = get_random_bytes(bits // 8)
+        if output_format == "str":
+            # 将字节转换为字符串, 取前 bits // 8 字节，并使用 URL-safe base64 编码
+            return base64.urlsafe_b64encode(random_bytes).decode('utf-8')[:(bits // 8)]
+        else:
+            return random_bytes
+
+
+if __name__ == "__main__":
+    LogConfig(level=logging.DEBUG)  # 初始化日志配置
+
+    # 示例用法
+    key_ = AESCipher.generate_key(128, output_format="str")  # 生成128位密钥
+    iv_ = get_random_bytes(16)  # 生成16字节IV
+    aes_cipher_ = AESCipher(key_, iv_, mode='CBC', padding_style='pkcs7')
+    plaintext_ = '{"body": "This is a aes cipher test message", "title": "AES Cipher Test"}'
+    encrypted_ = aes_cipher_.encrypt(plaintext_)
+    decrypted_ = aes_cipher_.decrypt(encrypted_)
+
+    print(f"Key: {key_}")
+    print(f"IV: {iv_}")
+    print(f"Plaintext: {plaintext_}")
+    print(f"Encrypted: {encrypted_}")
+    print(f"Decrypted: {decrypted_}")

uel_toolcraft-0.1.0/uel_toolcraft/models/BarkClient.py

@@ -0,0 +1,120 @@
+import requests
+import json
+from .AESCipher import AESCipher
+import logging
+from .logging_config import LogConfig
+
+# 获取日志记录器
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class BarkClient:
+    def __init__(self, server_url: str, device_key: str | list, debug: bool = False):
+        """
+        初始化 BarkClient
+        :param server_url: Bark服务器地址，例如 http://127.0.0.1:8080
+        :param device_key: 设备的推送key，例如 "your_bark_device_token" 或 ["device_key1", "device_key2"]
+        :param debug: 是否开启调试模式，默认为 False
+        """
+        self.debug = debug  # 是否开启调试模式
+        self.server_url = server_url.rstrip('/')
+        self.device_key = device_key
+        self.push_url = f"{self.server_url}/push"
+        self.headers = {
+            "Content-Type": "application/json; charset=utf-8",
+        }
+        self.supported_parameters = [
+            "title", "subtitle", "body", "device_key", "device_keys", "level", "volume", "badge", "call", "autoCopy", "copy", "sound", "icon", "group", "ciphertext", "isArchive", "url", "action"
+        ]
+
+        # 根据 device_key 的类型设置 payload 中的 device_key 键名称
+        if isinstance(self.device_key, list):
+            # 如果 device_key 是列表，parameters 中的 device_key 应该是 device_keys
+            self.device_key_payload_name = "device_keys"
+            if self.debug:
+                logger.debug(f"✅ [BarkClient] device_key is a list, using 'device_keys' in payload.")
+        elif isinstance(self.device_key, str):
+            # 如果 device_key 是字符串，parameters 中的 device_key 应该是 device_key
+            self.device_key_payload_name = "device_key"
+            if self.debug:
+                logger.debug(f"✅ [BarkClient] device_key is a string, using 'device_key' in payload.")
+        else:
+            logger.error("❌ [BarkClient] device_key must be a string or a list of strings.")
+            raise ValueError("device_key must be a string or a list of strings.")
+
+    def send(self, body: str, title: str = "", **extra_fields):
+        """
+        发送推送，支持额外动态字段
+        :param body: 消息正文
+        :param title: 消息标题
+        :param extra_fields: 其他自定义参数（sound, badge, icon, group, url等, 帮助文档: "https://bark.day.app/#/tutorial"）
+        """
+        payload = {
+            "body": body,
+            self.device_key_payload_name: self.device_key,
+            "title": title
+        }
+
+        # 是否加密
+        encrypt = False
+
+        # 动态添加额外参数
+        for field_name, value in extra_fields.items():
+            if (field_name in self.supported_parameters) and (value is not None):
+                payload[field_name] = value
+            elif (field_name in ["encrypt", "aes"]) and (value is not None):
+                # 如果参数是 encrypt，则设置 encrypt 变量
+                encrypt = value
+
+        try:
+            if encrypt:
+                # 如果需要加密，则使用 AES 加密
+                key = extra_fields.get("key", None)  # 默认密钥
+                if key is None:
+                    logger.error("❌ [BarkClient] Key is required for encryption.")
+                    raise ValueError("Key is required for encryption.")
+                # 从 extra_fields 中获取 IV, 如果没有提供则生成一个默认的 IV
+                iv = extra_fields.get("iv") or AESCipher.generate_key(128)  # 默认 IV
+                mode = extra_fields.get("mode", "CBC")  # 默认模式为 CBC
+                aes_cipher = AESCipher(key=key, iv=iv, mode=mode)
+                payload_str = json.dumps(payload)
+                encrypted_payload = aes_cipher.encrypt(payload_str)
+                # 构建含有加密文本的 payload
+                payload = {
+                    self.device_key_payload_name: self.device_key,
+                    "ciphertext": encrypted_payload,
+                    "iv": iv,
+                }
+
+            # 发送请求
+            send_response = requests.post(
+                url=self.push_url,
+                headers=self.headers,
+                data=json.dumps(payload),
+                timeout=10
+            )
+
+            if self.debug:
+                # 检查响应状态码
+                logger.debug(f"✅ [BarkClient] Response Status Code: {send_response.status_code}")
+                logger.debug(f"✅ [BarkClient] Response Body: {send_response.content.decode('utf-8')}")
+
+            return send_response
+        except requests.exceptions.RequestException as e:
+            logger.error(f"❌ [BarkClient] Request failed: {e}")
+            return None
+
+
+if __name__ == "__main__":
+    LogConfig(level=logging.DEBUG)  # 初始化日志配置
+    bark = BarkClient(server_url="https://api.day.app/", device_key="your_bark_device_token", debug=True)
+    response = bark.send(
+        body="This is a test message.",
+        title="Test",
+        group="Test Group",
+        debug=False,
+        encrypt=False,
+        mode="CBC",
+        key="aes_16_byte_key",
+        iv="aes_16_byte_iv"  # CBC 模式需要 16 字节 IV, 如果不指定则自动生成 16 字节 IV
+    )

uel_toolcraft-0.1.0/uel_toolcraft/models/PyQtAsyncHelper.py

@@ -0,0 +1,91 @@
+import asyncio
+from threading import Thread
+from PyQt6.QtCore import QObject, pyqtSignal, QCoreApplication
+
+
+class AsyncRunner:
+    """
+    全局异步执行器，允许在非主线程中运行异步任务。
+    使用 asyncio.run_coroutine_threadsafe 方法将协程提交到事件循环。
+    通过线程安全的方式与 PyQt 信号系统交互。
+    该类在初始化时创建一个新的事件循环，并在独立线程中运行该循环。
+    可以通过 run_async 方法提交异步任务。
+    该类适用于需要在 PyQt 应用程序中执行异步操作的场景。
+    例如，可以在按钮点击事件中调用 run_async 方法来执行异步任务。
+    该类的设计使得异步任务可以在后台线程中运行，而不会阻塞主线程的 UI 更新。
+    通过使用 PyQt 的信号机制，可以在异步任务完成后安全地更新 UI。
+    该类的使用方式如下：
+    1. 创建 AsyncRunner 实例：`runner = AsyncRunner()`
+    2. 定义异步任务：`async def my_async_task(): ...`
+    3. 提交异步任务：`runner.run_async(my_async_task())`
+    4. 在异步任务中使用 `self.signals.result_ready.emit(result)`
+    来发送信号到主线程。
+    5. 在主线程中连接信号：`self.signals.result_ready.connect(self.display_result)`
+    6. 在 `display_result` 方法中处理结果并更新 UI。
+    该类的设计使得异步任务可以在 PyQt 应用程序中安全地执行，同时保持 UI 的响应性。
+    """
+    def __init__(self):
+        self.loop = asyncio.new_event_loop()
+        self.thread = Thread(target=self._start_loop, daemon=True)
+        self.thread.start()
+
+    def _start_loop(self):
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_forever()
+
+    def run_async(self, coro):
+        return asyncio.run_coroutine_threadsafe(coro, self.loop)
+
+
+class SignalEmitter(QObject):
+    """
+    信号发射器类，用于在 PyQt 应用程序中发出信号。
+    该类继承自 QObject，并定义了一个信号 result_ready。
+    该信号可以在异步任务完成后发出结果，以便在主线程中处理。
+    使用该类可以实现线程安全的信号发射，确保在 PyQt 应用程序中正确地更新 UI。
+    该类的使用方式如下：
+    1. 创建 SignalEmitter 实例：`self.signals = SignalEmitter()`
+    2. 在异步任务中发出信号：`self.signals.result_ready.emit(result)`
+    3. 在主线程中连接信号：`self.signals.result_ready.connect(self.display_result)`
+    4. 在 `display_result` 方法中处理结果并更新 UI。
+    该类的设计使得异步任务可以在后台线程中运行，而不会阻塞主线程的 UI 更新。
+    通过使用 PyQt 的信号机制，可以在异步任务完成后安全地更新 UI。
+
+    """
+    result_ready = pyqtSignal(str)
+
+
+class SignalEmitter2(QObject):
+    """
+    信号发射器类，用于在 PyQt 应用程序中发出信号。
+    该类继承自 QObject，并定义了一个信号 result_ready。
+    该信号可以在异步任务完成后发出结果，以便在主线程中处理。
+    使用该类可以实现线程安全的信号发射，确保在 PyQt 应用程序中正确地更新 UI。
+    该类的使用方式如下：
+    1. 创建 SignalEmitter 实例：`self.signals = SignalEmitter()`
+    2. 在异步任务中发出信号：`self.signals.result_ready.emit(result)`
+    3. 在主线程中连接信号：`self.signals.result_ready.connect(self.display_result)`
+    4. 在 `display_result` 方法中处理结果并更新 UI。
+    该类的设计使得异步任务可以在后台线程中运行，而不会阻塞主线程的 UI 更新。
+    通过使用 PyQt 的信号机制，可以在异步任务完成后安全地更新 UI。
+
+    """
+    result_ready = pyqtSignal(str, str)
+
+
+class SignalEmitter3(QObject):
+    """
+    信号发射器类，用于在 PyQt 应用程序中发出信号。
+    该类继承自 QObject，并定义了一个信号 result_ready。
+    该信号可以在异步任务完成后发出结果，以便在主线程中处理。
+    使用该类可以实现线程安全的信号发射，确保在 PyQt 应用程序中正确地更新 UI。
+    该类的使用方式如下：
+    1. 创建 SignalEmitter 实例：`self.signals = SignalEmitter()`
+    2. 在异步任务中发出信号：`self.signals.result_ready.emit(result)`
+    3. 在主线程中连接信号：`self.signals.result_ready.connect(self.display_result)`
+    4. 在 `display_result` 方法中处理结果并更新 UI。
+    该类的设计使得异步任务可以在后台线程中运行，而不会阻塞主线程的 UI 更新。
+    通过使用 PyQt 的信号机制，可以在异步任务完成后安全地更新 UI。
+
+    """
+    result_ready = pyqtSignal(str, str, str)