raytoolsbox 1.0.0__py3-none-any.whl

raytoolsbox/crypto_manager.py

@@ -0,0 +1,524 @@
+import os
+
+from cryptography.hazmat.primitives import serialization, hashes
+from cryptography.hazmat.primitives.asymmetric import x25519, ed25519
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
+
+
+from pathlib import Path
+
+class CryptoManager:
+    """
+    ✅ 现代化 ECC 加密管理器（无签名版）
+
+    - 使用 X25519 进行密钥交换
+    - 使用 ChaCha20-Poly1305 进行对称加密
+    - 原始数据支持 str / bytes / 文件，加密或签名后返回二进制数据包
+    """
+    _SIGN_LEN = 64  # Ed25519 固定长度
+    # 数据类型信息
+    _TYPE_TEXT = b"\x01"
+    _TYPE_BYTES = b"\x02"
+    # 二进制格式数据包指纹
+    _MAGIC = b"ECC1"
+    _VERSION = b"\x01"
+    _SIGN_MAGIC = b"SIGN"
+    _SIGN_VERSION = b"\x01"
+
+    def __init__(self, key_dir=None, PIN="toolsbox"):
+        self._PIN = PIN
+        self._key_dir = None
+
+        if key_dir is not None:
+            self.set_key_dir(key_dir)
+
+    def set_key_dir(self, key_dir):
+        """
+        切换 / 设置密钥目录
+        """
+        self._key_dir = Path(key_dir)
+        self._key_dir.mkdir(parents=True, exist_ok=True)
+
+        self._crypt_key_path = self._key_dir / "crypt_key.pem"
+        self._crypt_pub_path = self._key_dir / "crypt_pub.pem"
+        self._sign_key_path = self._key_dir / "sign_key.pem"
+        self._sign_pub_path = self._key_dir / "sign_pub.pem"
+        
+    # -----------------------------------------
+    #      密钥生成 / 保存 / 加载
+    # -----------------------------------------
+    def generate_keys(self):
+
+        """ X25519与Ed25519公私钥对生成 """
+        crypt_key = x25519.X25519PrivateKey.generate()
+        crypt_pub = crypt_key.public_key()
+        # Ed25519公私钥对生成 
+        sign_key = ed25519.Ed25519PrivateKey.generate()
+        sign_pub  = sign_key.public_key()
+        if self._key_dir:
+            self._save_keypair(crypt_key, crypt_pub, sign_key, sign_pub)
+        return crypt_key, crypt_pub, sign_key, sign_pub
+
+    # -----------------------------------------
+    def _save_keypair(self, crypt_key, crypt_pub, sign_key, sign_pub):
+        """保存密钥对为 PEM 文件"""
+
+        pin = self._PIN
+        enc = (
+            serialization.BestAvailableEncryption(pin.encode())
+            if pin else serialization.NoEncryption()
+        )
+        with open(self._crypt_key_path, "wb") as f:
+            f.write(crypt_key.private_bytes(
+                serialization.Encoding.PEM,
+                serialization.PrivateFormat.PKCS8,
+                enc
+            ))
+        with open(self._crypt_pub_path, "wb") as f:
+            f.write(crypt_pub.public_bytes(
+                serialization.Encoding.PEM,
+                serialization.PublicFormat.SubjectPublicKeyInfo
+            ))
+        with open(self._sign_key_path, "wb") as f:
+            f.write(sign_key.private_bytes(
+                serialization.Encoding.PEM,
+                serialization.PrivateFormat.PKCS8,
+                enc
+            ))
+        with open(self._sign_pub_path, "wb") as f:
+            f.write(sign_pub.public_bytes(
+                serialization.Encoding.PEM,
+                serialization.PublicFormat.SubjectPublicKeyInfo
+            ))
+
+    # -----------------------------------------
+    def _load_keypair(self):
+        """加载私钥和公钥"""
+        if not all(p.exists() for p in (
+                self._crypt_key_path,
+                self._crypt_pub_path,
+                self._sign_key_path,
+                self._sign_pub_path
+            )):
+            print("密钥文件不存在")
+            return None, None, None, None
+
+        pwd = self._PIN.encode()
+
+        try:
+            with open(self._crypt_key_path, "rb") as f:
+                crypt_key = serialization.load_pem_private_key(f.read(), password=pwd)
+            with open(self._crypt_pub_path, "rb") as f:
+                crypt_pub = serialization.load_pem_public_key(f.read())
+            with open(self._sign_key_path, "rb") as f:
+                sign_key = serialization.load_pem_private_key(f.read(), password=pwd)
+            with open(self._sign_pub_path, "rb") as f:
+                sign_pub = serialization.load_pem_public_key(f.read())
+            return crypt_key, crypt_pub, sign_key, sign_pub
+        except Exception as e:
+            raise RuntimeError(f"加载密钥失败: {e}")
+
+    # ============================================
+    #  混合加密（ECC + AEAD）
+    #  text → 加密 → dict
+    # ============================================
+
+    def encrypt(self, data=None, pubkey=None,data_path=None,save="off") -> bytes:
+        """
+        参数：
+            data: str | bytes | data_path
+            pubkey: 公钥（X25519）
+            data_path: 数据文件路径（可选）
+            save: 为空时不保存。否则保存到data_path同名.enc文件或者指定文件路径
+
+        返回：
+            bytes: 二进制数据包
+        """
+
+        if pubkey is None and self._key_dir is not None:
+            _, pubkey, _, _ = self._load_keypair()
+        if pubkey is None and self._key_dir is None:
+            raise ValueError("未提供公钥，且未指定密钥目录")
+        if data is None and data_path is None:
+            raise ValueError("必须提供数据或数据路径")
+        if not isinstance(pubkey, X25519PublicKey):
+            raise TypeError("pubkey 必须是 X25519 公钥")
+
+        if data_path is not None:
+            path = Path(data_path)
+            data = path.read_bytes()
+
+        # ✅ 统一转 bytes
+        if isinstance(data, str):
+            plaintext = self._TYPE_TEXT+data.encode("utf-8")
+        elif isinstance(data, bytes):
+            plaintext = self._TYPE_BYTES+data
+        else:
+            raise TypeError("加密数据必须是 str 或 bytes")
+        
+        # 成一次性密钥（前向安全）
+        eph_priv = x25519.X25519PrivateKey.generate()
+        eph_pub = eph_priv.public_key()
+
+        # ECDH 计算共享密钥
+        shared_key = eph_priv.exchange(pubkey)
+
+        key = HKDF(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=self._MAGIC + self._VERSION,
+            info=b"SIMPLE-ECC",
+        ).derive(shared_key)
+
+        # ChaCha20-Poly1305 加密（带认证）
+        nonce = os.urandom(12)
+
+        eph_pub_bytes = eph_pub.public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw
+        )
+        aad = self._MAGIC + self._VERSION + eph_pub_bytes
+        
+        ciphertext = ChaCha20Poly1305(key).encrypt(
+            nonce,
+            plaintext,
+            aad
+        )
+
+        packet = (
+            self._MAGIC +
+            self._VERSION +
+            eph_pub_bytes +
+            nonce +
+            ciphertext
+        )
+        # ===== 保存文件 =====
+        if save != 'off':
+            if data_path is not None:
+                if save == 'on':
+                    out_path = path.with_suffix(path.suffix + ".enc")
+                else:
+                    out_path = save
+            else:
+                if save == 'on':
+                    out_path = Path.cwd() / "encrypt_output.enc"
+                else:
+                    out_path = save
+            out_path = Path(out_path)
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(out_path, "wb") as f:
+                f.write(packet)
+
+        return packet
+    
+    # ============================================
+    #  解密流程：ECC → AEAD → text
+    def decrypt(self, packet: bytes = None, privkey=None, enc_data_path=None, save="off"):
+        """
+        参数：
+            packet (bytes): get_encrypt() 返回的数据
+            privkey: 私钥（X25519）
+            enc_data_path: .enc 文件路径（可选）
+            save: 保存文件名（不含后缀）；若 enc_data_path 存在则自动去掉 .enc
+        返回：
+            str | bytes
+        """
+        if privkey is None and self._key_dir is not None:
+            privkey, _, _, _ = self._load_keypair()
+        if privkey is None and self._key_dir is None:
+            raise ValueError("未提供私钥，且未指定密钥目录")
+
+        if packet is None and enc_data_path is None:
+            raise ValueError("必须提供 packet 或 enc_data_path")
+
+        # ✅ 从文件读取
+        if enc_data_path is not None:
+            path = Path(enc_data_path)
+            packet = path.read_bytes()
+
+        try:
+            # ===== 解析头部 =====
+            if len(packet) < 4 + 1 + 32 + 12:
+                raise ValueError("数据长度不合法")
+
+            magic = packet[:4]
+            version = packet[4]
+
+            if magic != self._MAGIC:
+                raise ValueError("未知数据格式")
+            if version != self._VERSION[0]:
+                raise ValueError(f"不支持的版本: {version}")
+
+            offset = 5
+            eph_pub_bytes = packet[offset:offset + 32]
+            offset += 32
+            nonce = packet[offset:offset + 12]
+            offset += 12
+            ciphertext = packet[offset:]
+
+            eph_pub = x25519.X25519PublicKey.from_public_bytes(eph_pub_bytes)
+
+            # ===== ECDH + HKDF =====
+            shared_key = privkey.exchange(eph_pub)
+
+            key = HKDF(
+                algorithm=hashes.SHA256(),
+                length=32,
+                salt=self._MAGIC + self._VERSION,
+                info=b"SIMPLE-ECC",
+            ).derive(shared_key)
+
+            aad = self._MAGIC + self._VERSION + eph_pub_bytes
+            plaintext = ChaCha20Poly1305(key).decrypt(nonce, ciphertext, aad)
+
+            # ===== 解包 =====
+            if not plaintext:
+                raise ValueError("空明文")
+
+            t = plaintext[0:1]
+            body = plaintext[1:]
+            if t == self._TYPE_TEXT:
+                result = body.decode("utf-8")
+                ext = ".txt"
+                out_data = body
+            elif t == self._TYPE_BYTES:
+                result = body
+                ext = ""
+                out_data = body
+            else:
+                raise ValueError("未知明文类型")
+
+            # ===== 保存文件 =====
+
+            # ===== 保存文件 =====
+            if save != 'off':
+                if enc_data_path is not None:
+                    orig_path = path.with_suffix("")  # 去掉 .enc
+                    if save == 'on':
+                        # 原文件名 + _decrypt + 原后缀
+                        out_path = orig_path.with_name(
+                            f"{orig_path.stem}_decrypt{orig_path.suffix}"
+                        )
+                    else:
+                        out_path = save
+                else:
+                    if save == 'on':
+                        out_path = Path.cwd() / "decrypt_output.bin"
+                    else:
+                        out_path = save
+                out_path = Path(out_path)
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+
+                with open(out_path, "wb") as f:
+                    f.write(out_data)
+
+            return result
+
+        except Exception as e:
+            print("解密失败:", e)
+            return None
+        
+    # ============================================
+    #  数字签名与验签功能（Ed25519）
+    # ============================================
+    def sign(self, data=None, sign_key=None, data_path=None, save="off"):
+        """
+        使用 Ed25519 对数据进行数字签名，并生成自描述的签名数据包。
+
+        参数：
+            data (str | bytes | None): 待签名的数据内容。
+
+            sign_key (ed25519.Ed25519PrivateKey | None): 可选密钥
+
+            data_path (str | Path | None): 可选待签名文件的路径（覆盖data）
+
+            save (str): 控制是否将签名数据包保存为文件。"off"（默认）
+
+        返回：
+            bytes: 签名数据包（二进制格式），结构如下：
+
+        """
+        if sign_key is None and self._key_dir is not None:
+            _, _, sign_key, _ = self._load_keypair()
+        
+        if sign_key is None and self._key_dir is None:
+            raise ValueError("未提供签名私钥，且未指定密钥目录")
+        if data is None and data_path is None:
+            raise ValueError("必须提供 data 或 data_path")
+
+        # ===== 读取数据 =====
+        if data_path is not None:
+            path = Path(data_path)
+            payload = path.read_bytes()      # ✅ 文件永远按 bytes
+            t = self._TYPE_BYTES
+        else:
+            if isinstance(data, str):
+                payload = data.encode("utf-8")
+                t = self._TYPE_TEXT
+            elif isinstance(data, bytes):
+                payload = data
+                t = self._TYPE_BYTES
+            else:
+                raise TypeError("签名数据必须是 str 或 bytes")
+
+        body = t + payload
+
+        # ===== Ed25519 签名 =====
+        sig = sign_key.sign(body)
+
+        packet = (
+            self._SIGN_MAGIC +
+            self._SIGN_VERSION +
+            body +
+            sig
+        )
+
+        # ===== 保存签名文件 =====
+        if save != 'off':
+            if data_path is not None:
+                # 自动生成：原名 + _signed + 原后缀
+                if save == 'on':
+                    out_path = path.with_name(
+                        f"{path.stem}_signed{path.suffix}"
+                    )
+                else: out_path = save
+            else:
+                if save == 'on':
+                    out_path = Path.cwd() / "signed_output.bin"
+                else:
+                    out_path = save
+                
+            out_path = Path(out_path)
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # ===== 写入签名包 =====
+            with open(out_path, "wb") as f:
+                f.write(packet)
+
+        return packet
+
+    # --------------------------------------------
+    def verify(self, signed_data=None, verify_key=None, signed_data_path=None, save="off"):
+        """
+        验证 Ed25519 签名
+
+        参数:
+            signed_data:
+                - bytes            : 签名数据包
+                - str (base64)     : 签名数据包
+            signed_data_path:
+                - None             : 从签名包验签
+                - 文件路径(str)    : 对指定文件验签
+
+        返回：
+            - str          : 验签成功并还原文本数据
+            - None         : 验签失败
+        """
+        if verify_key is None and self._key_dir is not None:
+            _, _, _, verify_key = self._load_keypair()
+        if verify_key is None and self._key_dir is None:
+            raise ValueError("未提供验签公钥，且未指定密钥目录")
+
+        try:
+            # ===== 文件验签模式 =====
+            if signed_data_path is not None:
+                path = Path(signed_data_path)
+                packet = path.read_bytes()
+
+            # ===== 传输层解码 =====
+            else:
+                if isinstance(signed_data, str):
+                    import base64
+                    packet = base64.b64decode(signed_data.encode("ascii"))
+                elif isinstance(signed_data, bytes):
+                    packet = signed_data
+                else:
+                    raise TypeError("验签数据必须是 str 或 bytes")
+
+            # ===== 基本校验 =====
+            if len(packet) < 4 + 1 + 1 + self._SIGN_LEN:
+                raise ValueError("签名数据长度不合法")
+
+            magic = packet[:4]
+            version = packet[4]
+
+            if magic != self._SIGN_MAGIC:
+                raise ValueError("未知签名格式")
+            if version != self._SIGN_VERSION[0]:
+                raise ValueError("不支持的签名版本")
+
+            offset = 5
+            t = packet[offset:offset + 1]
+            offset += 1
+
+            payload = packet[offset:-self._SIGN_LEN]
+            sig = packet[-self._SIGN_LEN:]
+
+            # ===== 数据验签模式 =====
+            verify_key.verify(sig, t + payload)
+
+            # ===== 保存文件 =====
+            if save != 'off':
+                if signed_data_path is not None:
+                    # 自动生成：原名 + _verify + 原后缀
+                    if save == 'on':
+                        out_path = path.with_name(
+                            f"{path.stem}_verify{path.suffix}"
+                        )
+                    else: out_path = save
+                else:
+                    if save == 'on':
+                        out_path = Path.cwd() / "verify_output.bin"
+                    else:
+                        out_path = save
+                    
+                out_path = Path(out_path)
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+
+                # ===== 写入签名包 =====
+                with open(out_path, "wb") as f:
+                    f.write(payload)
+
+
+            #   还原数据，根据类型返回str或bytes    
+            if t == self._TYPE_TEXT:
+                return payload.decode("utf-8")
+            elif t == self._TYPE_BYTES:
+                return payload
+            else:
+                raise ValueError("未知数据类型")
+
+        except Exception as e:
+            print("验签失败:", e)
+            return None
+
+
+
+
+if __name__ == "__main__":
+
+    from raytoolsbox import useful_func
+    tt=useful_func.make_timer()
+
+    test_data_dir = Path("tests/testData")
+    if not test_data_dir.exists():
+        test_data_dir.mkdir(parents=True, exist_ok=True)
+    with open(test_data_dir / "测试文档.txt", "r", encoding="utf-8") as f:
+        plaintext0 = f.read()
+    tt()
+    cm = CryptoManager(test_data_dir / "ecc_keys")
+    priv, pub,_,_ = cm.generate_keypair()
+    tt("密钥对生成完成")
+    js=cm.get_encrypt(plaintext0, pub)
+    tt("加密完成")
+    plaintext = cm.get_decrypt(js, priv)
+    if plaintext==plaintext0:
+        print("解密成功，内容一致")
+    tt("解密完成")
+    # 写到文件
+    with open(test_data_dir / "test_decrypt.txt", "w", encoding="utf-8") as f:
+        f.write(plaintext)
+    tt()

raytoolsbox/mailToPhone.py

@@ -0,0 +1,81 @@
+import smtplib
+from email.mime.text import MIMEText
+from email.header import Header
+from email.utils import formataddr
+import yaml
+from pathlib import Path
+
+def _load_email_config(provider: str)-> bool:
+    # 1. 当前脚本所在目录
+    local_config = Path(__file__).parent / "email_config.yaml"
+
+    # 2. 用户主目录
+    home_config = Path.home() / ".email_config.yaml"
+
+    # 挑选存在的一个
+    config_path = local_config if local_config.exists() else home_config
+
+    if not config_path.exists():
+        raise FileNotFoundError(
+            f"未找到配置文件: {config_path}\n"
+            "你需要手动创建，内容格式如下：\n"
+            "qq:\n"
+            "  smtp_server: smtp.qq.com\n"
+            "  smtp_port: 465\n"
+            "  from_addr: your@qq.com\n"
+            "  password: your_auth_code"
+        )
+
+    with open(config_path, "r", encoding="utf-8") as f:
+        all_config = yaml.safe_load(f)
+    return all_config[provider]
+
+
+def send_email(
+        subject: str='HelloWorld', 
+        content: str='这是一个测试邮件', 
+        to_addr: str='',
+        serverName: str='',
+        use_smtp:str='qq') -> None:
+    """
+    :param subject: 邮件主题 
+    :param content: 邮件内容
+    :param to_addr: 接收邮箱地址
+    :param serverName: 服务器名称
+    :param use_smtp: 使用的SMTP服务提供商
+    """
+    try:
+        config = _load_email_config(use_smtp)
+    except Exception as e:
+        print(f"加载配置失败: {e}")
+        return False
+
+    smtp_server = config['smtp_server']
+    smtp_port = config['smtp_port']
+    from_addr = config['from_addr']
+    password = config['password']
+
+    nickname = serverName  # 这里自定义你的备注
+    if not to_addr:
+        to_addr=from_addr  # 如果没有指定收件人，则发给自己
+    
+    message = MIMEText(content, 'html', 'utf-8')
+    # 用 formataddr，可以自动支持中文昵称
+    message['From'] = formataddr((str(Header(nickname, 'utf-8')), from_addr))
+    message['To'] = Header(to_addr)
+    message['Subject'] = Header(subject, 'utf-8')
+    
+    try:
+        server = smtplib.SMTP_SSL(smtp_server, smtp_port)
+        server.login(from_addr, password)
+        server.sendmail(from_addr, [to_addr], message.as_string())
+        server.quit()
+        print('消息发送成功！')
+        return True
+    except Exception as e:
+        print('发送失败:', e)
+        return False
+
+# 下面按你的用法
+if __name__ == '__main__':
+    print(send_email())

raytoolsbox/to_github.py

@@ -0,0 +1,73 @@
+import requests
+# token: str | None = None,  意思是 token 可以是字符串类型，也可以是 None 类型 。默认值是 None 。
+def list_github_repos(username: str, token: str | None = None, print_result: bool = True):
+    """
+    获取 GitHub 仓库列表。
+    
+    :param username: GitHub 用户名（可以是自己，也可以是别人）
+    :param token: 不传则访问别人公开仓库；传入则可访问自己的公开+私有
+    :param print_result: 是否打印
+    :return: 仓库列表 [{name, size_mb, private}, ...]
+    """
+    # 选择 API URL
+    if token and username:  
+        # token 一般只能访问“当前登录用户”
+        # 所以如果 username == token中的用户 → /user/repos
+        api_url = "https://api.github.com/user/repos"
+        use_auth = True
+    else:
+        # 无 token → 访问公开仓库
+        api_url = f"https://api.github.com/users/{username}/repos"
+        use_auth = False
+
+    headers = {"Accept": "application/vnd.github+json"}
+    if token:
+        headers["Authorization"] = f"token {token}"
+
+    repos = []
+    page = 1
+
+    while True:
+        resp = requests.get(api_url, headers=headers, params={"page": page, "per_page": 100})
+
+                # ========== 处理错误 Token ==========
+        if resp.status_code == 401:
+            print("❌ GitHub Token 无效（Bad credentials）, 请检查：")
+            print("   1. Token 是否拼写正确")
+            print("   2. Token 是否未过期")
+            print("   3. 如果访问别人公开仓库 → 不要传 token")
+            return None  # 或者 raise ValueError("无效 Token")
+
+        # ========== 其它错误 ==========
+        if resp.status_code != 200:
+            raise RuntimeError(
+                f"GitHub API 请求失败：{resp.status_code}\n{resp.text}"
+            )
+
+        batch = resp.json()
+        if not batch:
+            break
+
+        for r in batch:
+            repos.append({
+                "name": r["name"],
+                "size_mb": r["size"] / 1024,
+                "private": r["private"],
+            })
+
+        page += 1
+
+        # 如果是 /user/repos，但 username 不是 token 的用户 → 会只返回公开仓库（合理情况）
+    
+    # 打印结果
+    if print_result:
+        for r in repos:
+            print(f"{r['name']:25} {r['size_mb']:7.2f} MB  {'private' if r['private'] else 'public'}")
+
+    return repos
+
+if __name__ == "__main__":
+
+    user = "2dust"
+    data = list_github_repos(user)
+    # print(data)

raytoolsbox/useful_func.py

@@ -0,0 +1,45 @@
+import os
+import sys  
+
+def get_resource_path(relpath):
+    # PyInstaller 运行环境资源路径修正
+    if hasattr(sys, "_MEIPASS"):
+        return os.path.join(sys._MEIPASS, relpath)
+    return os.path.join(os.path.dirname(__file__), relpath)
+    
+# 居中窗口
+def center_window(win, width=None, height=None):
+    win.update_idletasks()
+    w = width or win.winfo_width()
+    h = height or win.winfo_height()
+    sw = win.winfo_screenwidth()
+    sh = win.winfo_screenheight()
+    x = (sw - w) // 2
+    y = (sh - h) // 3
+    win.geometry(f"{w}x{h}+{x}+{y}")
+
+import time
+
+def make_timer():
+    last_time = None
+    count = -1
+
+    def tt(msg=""):
+        nonlocal last_time, count
+        now = time.time()
+        count += 1
+        if last_time is None:
+            msg_time=f"第{count}次调用（{msg}）：首次调用，无上次时间参考。"
+            print(msg_time)
+        else:
+            elapsed = (now - last_time) * 1000  # 转为毫秒
+            if msg:
+                msg_time=f"第{count}次调用（{msg}）：用时 {elapsed:.2f} ms"
+                print(msg_time)
+            else:
+                msg_time=f"第{count}次调用：用时 {elapsed:.2f} ms"
+                print(msg_time)
+        last_time = now
+        return msg_time
+
+    return tt

raytoolsbox-1.0.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: raytoolsbox
+Version: 1.0.0
+Summary: Add your description here
+Author: TIMLES@https://github.com/TIMLES
+License: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=46.0.4
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: requests>=2.32.5
+
+
+# raytoolsbox
+
+一个不断进化的 **个人 Python 工具合集（Toolbox）**。  
+包含常用开发工具、实用脚本、个人算法、桌面应用助手、Web 小工具等。
+
+项目以 **模块化、可扩展、易维护** 为目标，为日常开发与个人项目提供稳定的工具支持。
+
+---
+
+## ✨ 特性（Features）
+
+- 📧 **邮件工具**  
+  简洁易用的邮件发送函数，可自动读取本地或用户目录的配置文件，自动处理 SSL、中文昵称等问题。
+
+- 🔐 **个人加密算法（计划中）**  
+  自定义加密/解密模块，适用于本地存储与信息传输。
+
+- 🌐 **Web 工具（计划中）**  
+  轻量级 FastAPI/Flask 封装，用于快速构建本地服务或 API。
+
+- 🖥️ **屏幕工具 & GUI 工具（计划中）**  
+  自动 DPI 检测、屏幕尺寸工具、Tkinter/Qt 通用辅助函数。
+
+- 🧰 **更多工具持续加入中……**
+
+---
+
+## 📦 安装（Installation）
+
+### 使用 uv（推荐）
+```
+uv add raytoolsbox
+```
+
+### 使用 pip
+```
+pip install raytoolsbox
+```
+
+---
+
+## 🚀 快速开始（Quick Start）
+
+
+
+---
+
+## 📂 目录结构（Project Layout）
+
+```
+raytoolsbox/
+│
+├── pyproject.toml         # 项目信息 + 依赖管理（uv）
+├── README.md              # 项目文档
+├── src/
+│   └── raytoolsbox/
+│       ├── __init__.py
+│       └── maillToPhone.py
+│
+└── tests/
+    └── test_send_email.py # pytest 单元测试
+```
+
+---
+
+## 🧪 测试（Testing）
+
+本项目使用 pytest：
+
+```
+uv run pytest
+```
+
+全部测试应通过：
+
+```
+2 passed
+```
+
+---
+
+## 🛠️ 开发路线图（Roadmap）
+
+### 已完成
+- [x] 邮件发送工具封装
+- [x] 可本地覆盖的配置系统
+- [x] pytest 自动化测试（mock 网络发送）
+- [x] 个人加密算法模块（AES + 自定义混淆）
+- [x] 计时工具
+
+### 开发中 / 计划中
+- [ ] Web 工具（FastAPI/Flask 封装）
+- [ ] 屏幕工具（DPI、尺寸测量、窗口工具）
+- [ ] Tkinter / PySide6 GUI 工具类
+- [ ] 文件操作工具（临时文件、下载器）
+- [ ] 日期工具、定时工具、任务提醒系统
+- [ ] 扩展 CLI（命令行使用工具箱）
+
+如果你有想加入的功能欢迎告诉我！
+
+---
+
+## 🤝 贡献（Contributing）
+
+欢迎 Issue 或 PR！  
+可提交：
+
+- Bug 报告  
+- 新功能建议  
+- 工具模块  
+- 文档改进  
+
+---
+
+## 📄 License
+
+使用 MIT License，自由商用/修改/发布。
+
+---

raytoolsbox-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+raytoolsbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raytoolsbox/crypto_manager.py,sha256=Oc4Qg_Jw79iWBgu_Wm0jlNgis-eqbApFoHem3nqXbSs,18880
+raytoolsbox/mailToPhone.py,sha256=JhVRMhPlzrQ-B3-Sf2YVNsfa3N1LZSlOSoYJnd4rbNo,2600
+raytoolsbox/to_github.py,sha256=gvOg_ltE2dXQQ2hhpoa0A4Eth-h36NYl0qLRlizxnRM,2602
+raytoolsbox/useful_func.py,sha256=Ks35PHR8IyxdZ1WIIkxL-BNqgKsp7cVYImnHVSRuW_M,1332
+raytoolsbox-1.0.0.dist-info/METADATA,sha256=EqAarP_UBCG3dHydPlgLkY8dlpV2qxY651SHGCOHpV0,2944
+raytoolsbox-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+raytoolsbox-1.0.0.dist-info/top_level.txt,sha256=W3bjrGqlV1zMr5MySZQhI4ZT8K-rs2zXQdSNdLI6JDE,12
+raytoolsbox-1.0.0.dist-info/RECORD,,

raytoolsbox-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

raytoolsbox-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+raytoolsbox