sdpy-kit 0.4.0__tar.gz → 0.4.2__tar.gz

{sdpy_kit-0.4.0 → sdpy_kit-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sdpy-kit
-Version: 0.4.0
+Version: 0.4.2
 Summary: SDPY Kit——统一数据库访问层（PG/MySQL/SQLite）与 AI/Redis/文件/文档/向量工具集
 Author-email: Clark <changhongyuan@126.com>
 License-Expression: MIT
@@ -17,6 +17,7 @@ Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.13
+Requires-Dist: cryptography>=46.0.7
 Requires-Dist: pydantic-settings>=2.15.0
 Requires-Dist: pydantic>=2.14.1
 Requires-Dist: sqlalchemy~=2.0.54

{sdpy_kit-0.4.0 → sdpy_kit-0.4.2}/kit/__init__.py

@@ -23,7 +23,7 @@ Author: Clark Chang
 数据库访问通过 kit.db 子包提供（基于 SQLModel）。
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"
 
 from kit.db import (
     MYSQL,

{sdpy_kit-0.4.0 → sdpy_kit-0.4.2}/kit/config/log_config.py

@@ -24,6 +24,7 @@ Author: Clark Chang
 import logging
 import os
 import sys
+import threading
 from logging.handlers import RotatingFileHandler
 
 from kit.config.kit_config import get_settings
@@ -49,6 +50,43 @@ def ensure_log_dir(log_dir: str) -> None:
     os.makedirs(log_dir, exist_ok=True)
 
 
+# 同一日志文件路径共享单例文件 handler：
+# 进程内该文件仅一个句柄，避免 Windows 下多句柄占用导致轮转必失败（WinError 32）。
+# 参数策略 first-wins：maxBytes / backupCount / formatter 以首个创建者为准。
+_file_handlers: dict[str, RotatingFileHandler] = {}
+_file_handlers_lock = threading.Lock()
+
+
+def _file_handler_cache_key(log_file_path: str) -> str:
+    """计算共享 handler 缓存 key（归一 Windows 大小写、分隔符与相对路径）"""
+    return os.path.normcase(os.path.abspath(log_file_path))
+
+
+def _get_shared_file_handler(
+    log_file_path: str, max_bytes: int, backup_count: int, formatter: logging.Formatter
+) -> RotatingFileHandler:
+    """获取指定日志文件路径的共享文件 handler（不存在则创建）"""
+    key = _file_handler_cache_key(log_file_path)
+    with _file_handlers_lock:
+        handler = _file_handlers.get(key)
+        if handler is None:
+            handler = RotatingFileHandler(
+                log_file_path,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8",
+            )
+            handler.setFormatter(formatter)
+            _file_handlers[key] = handler
+        return handler
+
+
+def _reset_file_handlers() -> None:
+    """复位共享 handler 缓存（仅供测试隔离使用，不进 __all__）"""
+    with _file_handlers_lock:
+        _file_handlers.clear()
+
+
 def setup_logger(
     name: str | None = None,
     log_level: str | None = None,
@@ -77,13 +115,12 @@ def setup_logger(
     if settings.LOG_TO_FILE:
         ensure_log_dir(settings.LOG_DIR)
         log_file_path = log_file or os.path.join(settings.LOG_DIR, settings.LOG_FILE)
-        file_handler = RotatingFileHandler(
+        file_handler = _get_shared_file_handler(
             log_file_path,
-            maxBytes=max_bytes,
-            backupCount=backup_count,
-            encoding="utf-8",
+            max_bytes=max_bytes,
+            backup_count=backup_count,
+            formatter=formatter,
         )
-        file_handler.setFormatter(formatter)
         logger.addHandler(file_handler)
 
     return logger

sdpy_kit-0.4.2/kit/license_kit.py

@@ -0,0 +1,524 @@
+"""
+Copyright (c) 2021-2026 Clark Chang. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Project: sdpy
+Author: Clark Chang
+"""
+
+# date: 2026-10-16
+"""license 授权工具类：机器指纹 + 离线签名授权文件（Ed25519）
+
+面向单机分发场景的轻量授权体系（防君子定位）：应用以打包 exe 形式离线分发，
+无远端授权服务。工作流：
+
+1. 客户机 `export_fingerprint_file()` 导出 `.fp` 指纹文件；
+2. 签发方 `parse_fingerprint_file()` 解析，填入 `LicensePayload` 后
+   `sign()` 生成 `.lic` 授权文件回签；
+3. 客户机 `LicenseVerifier.verify()` 验签 + 绑定校验（product / 机器码 / 有效期）。
+
+安全边界（务必知悉）：
+
+- 非对称体系安全性**仅依赖私钥保密**；本模块代码（含 `sign`）公开可读无碍；
+- 离线体系无法吊销永久授权；订阅场景靠 `expires_at` 到期不续签实现"软吊销"；
+- `expires_at` 依赖系统时钟，回拨可延长——防君子定位下接受，不做时钟防护；
+- 指纹 = MachineGuid + 系统盘卷序列号组合短码：VM 克隆镜像会复制指纹，
+  重装系统需重新授权；
+- 私钥丢失 = 全部已发授权作废，务必备份（换钥需重发全部授权）。
+
+时间约定：payload 的时间字段一律 **aware UTC**（naive 直接拒绝），
+规范化 JSON 序列化后签名，杜绝字段顺序 / 空白差异导致验签漂移。
+
+用法：
+    from kit.license_kit import (
+        LicensePayload, LicenseVerifier, export_fingerprint_file,
+        generate_keypair, parse_fingerprint_file, sign,
+    )
+
+    private_pem, public_pem = generate_keypair()
+    payload = LicensePayload(product="myapp", machine_code="0123456789abcdef",
+                             issued_at=datetime.now(timezone.utc),
+                             expires_at=None)
+    lic_text = sign(payload, private_pem)
+
+    verifier = LicenseVerifier(public_pem, Path("license.lic"))
+    info = verifier.verify(product="myapp", machine_code="0123456789abcdef")
+"""
+
+import base64
+import hashlib
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+)
+from pydantic import BaseModel, field_validator
+
+from kit.config.log_config import get_default_logger
+
+logger = get_default_logger(__name__)
+
+# 指纹文件格式版本（结构变更时递增；parse 只接受 <= 当前版本）
+FINGERPRINT_FORMAT_VERSION = 1
+# license 载荷格式版本（载荷结构变更时递增；verify 只接受当前版本）
+LICENSE_PAYLOAD_VERSION = 1
+# 机器码短码长度（SHA256 截断，16 hex = 64bit，单机场景碰撞可忽略）
+MACHINE_CODE_LENGTH = 16
+# 指纹文件标识（parse 时强校验，防止拿错文件）
+_FINGERPRINT_KIND = "sdpy-fingerprint"
+
+_MACHINE_GUID_KEY_PATH = r"SOFTWARE\Microsoft\Cryptography"
+_MACHINE_GUID_VALUE_NAME = "MachineGuid"
+
+_HEX16_RE = re.compile(r"^[0-9a-f]{16}$")
+
+
+# ---------------------------------------------------------------------------
+# 异常体系（独立基线，不挂 DBError——license 非 db 域）
+# ---------------------------------------------------------------------------
+
+
+class LicenseError(Exception):
+    """license 域异常基类"""
+
+
+class LicenseUnsupportedPlatformError(LicenseError):
+    """当前平台不支持指纹采集（指纹实现仅覆盖 Windows）"""
+
+
+class LicenseFormatError(LicenseError):
+    """文件损坏 / JSON 结构不合法 / 格式版本不识别 / 密钥类型不符"""
+
+
+class LicenseSignatureError(LicenseError):
+    """Ed25519 签名验证失败（文件被篡改或公钥不匹配）"""
+
+
+class LicenseProductMismatchError(LicenseError):
+    """product 与验签方期望值不符（防跨项目重放）"""
+
+
+class LicenseMachineMismatchError(LicenseError):
+    """machine_code 与本机指纹不符（授权被拷贝到其他机器）"""
+
+
+class LicenseExpiredError(LicenseError):
+    """授权已过期（expires_at 早于当前时间）"""
+
+
+# ---------------------------------------------------------------------------
+# 机器指纹（Windows 专属；winreg/ctypes 延迟导入保证模块可在任意平台 import）
+# ---------------------------------------------------------------------------
+
+
+def _read_machine_guid() -> str:
+    """读注册表 MachineGuid（重装系统才变化的主机标识）"""
+    import winreg
+
+    with winreg.OpenKey(
+        winreg.HKEY_LOCAL_MACHINE, _MACHINE_GUID_KEY_PATH
+    ) as key:
+        value, _ = winreg.QueryValueEx(key, _MACHINE_GUID_VALUE_NAME)
+        guid = str(value).strip()
+        if not guid:
+            raise LicenseFormatError("注册表 MachineGuid 为空")
+        return guid
+
+
+def _read_volume_serial() -> str:
+    """读系统盘卷序列号（GetVolumeInformationW，十进制字符串）"""
+    import ctypes.wintypes
+    import os
+
+    drive = os.environ.get("SystemDrive", "C:") + "\\"
+    serial = ctypes.wintypes.DWORD(0)
+    # GetVolumeInformationW 只需要根路径与序列号出参，其余参数可传占位
+    ok = ctypes.windll.kernel32.GetVolumeInformationW(
+        ctypes.c_wchar_p(drive),
+        None,
+        0,
+        ctypes.byref(serial),
+        None,
+        None,
+        None,
+        0,
+    )
+    if not ok or serial.value == 0:
+        raise LicenseFormatError(f"读取系统盘卷序列号失败：{drive}")
+    return str(serial.value)
+
+
+def _collect_components() -> tuple[str, str]:
+    """采集原始指纹组件，返回 (machine_guid, volume_serial)；非 Windows 抛错"""
+    if sys.platform != "win32":
+        raise LicenseUnsupportedPlatformError(
+            f"机器指纹采集仅支持 Windows，当前平台：{sys.platform}"
+        )
+    return _read_machine_guid(), _read_volume_serial()
+
+
+def get_machine_code() -> str:
+    """计算本机机器码：组合指纹 SHA256 短码（16 hex 小写）
+
+    Returns:
+        str: 16 位十六进制机器码
+
+    Raises:
+        LicenseUnsupportedPlatformError: 非 Windows 平台
+        LicenseFormatError: 指纹组件读取失败
+    """
+    machine_guid, volume_serial = _collect_components()
+    digest = hashlib.sha256(f"{machine_guid}|{volume_serial}".encode("utf-8"))
+    return digest.hexdigest()[:MACHINE_CODE_LENGTH]
+
+
+def export_fingerprint_file(path: Path) -> Path:
+    """导出指纹文件（.fp）：机器码 + 原始组件 + 导出时间
+
+    原始组件仅用于报障诊断（作者侧可看出哪个组件不匹配），验签只比短码。
+
+    Args:
+        path: 指纹文件输出路径
+
+    Returns:
+        Path: 实际写入的文件路径
+
+    Raises:
+        LicenseUnsupportedPlatformError: 非 Windows 平台
+        LicenseFormatError: 指纹组件读取失败
+    """
+    machine_guid, volume_serial = _collect_components()
+    machine_code = hashlib.sha256(
+        f"{machine_guid}|{volume_serial}".encode("utf-8")
+    ).hexdigest()[:MACHINE_CODE_LENGTH]
+    document = {
+        "kind": _FINGERPRINT_KIND,
+        "format_version": FINGERPRINT_FORMAT_VERSION,
+        "machine_code": machine_code,
+        "components": {
+            "machine_guid": machine_guid,
+            "volume_serial": volume_serial,
+        },
+        "exported_at": datetime.now(timezone.utc).isoformat(),
+    }
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        json.dumps(document, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    logger.info("指纹文件已导出：%s（机器码 %s）", target, machine_code)
+    return target
+
+
+def parse_fingerprint_file(path: Path) -> str:
+    """解析指纹文件，返回机器码（签发侧使用；跨机器无法重算原文，只校验结构）
+
+    Args:
+        path: 指纹文件路径
+
+    Returns:
+        str: 16 位十六进制机器码
+
+    Raises:
+        LicenseFormatError: 文件缺失 / JSON 损坏 / 标识或版本不符 / 机器码格式非法
+    """
+    source = Path(path)
+    if not source.is_file():
+        raise LicenseFormatError(f"指纹文件不存在：{source}")
+    try:
+        document = json.loads(source.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise LicenseFormatError(f"指纹文件读取或解析失败：{exc}") from exc
+    if not isinstance(document, dict):
+        raise LicenseFormatError("指纹文件结构不合法（顶层应为 JSON 对象）")
+    if document.get("kind") != _FINGERPRINT_KIND:
+        raise LicenseFormatError("指纹文件标识不符（kind）")
+    version = document.get("format_version")
+    if not isinstance(version, int) or version > FINGERPRINT_FORMAT_VERSION:
+        raise LicenseFormatError(f"指纹文件格式版本不识别：{version!r}")
+    machine_code = document.get("machine_code")
+    if not isinstance(machine_code, str) or not _HEX16_RE.fullmatch(machine_code):
+        raise LicenseFormatError("指纹文件缺少合法机器码（16 hex）")
+    return machine_code
+
+
+# ---------------------------------------------------------------------------
+# 密钥
+# ---------------------------------------------------------------------------
+
+
+def generate_keypair() -> tuple[str, str]:
+    """生成 Ed25519 密钥对（一次性初始化用）
+
+    Returns:
+        tuple[str, str]: (private_pem, public_pem)，均为 PEM 文本；
+            私钥务必本机妥善保管（丢失 = 已发授权全部作废）
+    """
+    private_key = Ed25519PrivateKey.generate()
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    ).decode("utf-8")
+    public_pem = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    ).decode("utf-8")
+    return private_pem, public_pem
+
+
+# ---------------------------------------------------------------------------
+# 载荷与签名（格式唯一事实源——签发与验签共用本模块实现）
+# ---------------------------------------------------------------------------
+
+
+class LicensePayload(BaseModel):
+    """授权载荷（license 文件中承载的业务信息）"""
+
+    version: int = LICENSE_PAYLOAD_VERSION
+    product: str  # 应用标识，防跨项目重放
+    machine_code: str  # 授权绑定的机器码（16 hex）
+    tier: str = "full"  # 档位，语义由应用侧定义
+    customer_id: str | None = None  # 可选，便于售后检索
+    issued_at: datetime  # 签发时间（aware UTC）
+    expires_at: datetime | None = None  # 过期时间；None = 买断永久
+
+    @field_validator("version")
+    @classmethod
+    def _check_version(cls, value: int) -> int:
+        if value != LICENSE_PAYLOAD_VERSION:
+            raise ValueError(f"不支持的载荷版本：{value}")
+        return value
+
+    @field_validator("product")
+    @classmethod
+    def _check_product(cls, value: str) -> str:
+        if not value.strip():
+            raise ValueError("product 不能为空")
+        return value
+
+    @field_validator("machine_code")
+    @classmethod
+    def _check_machine_code(cls, value: str) -> str:
+        normalized = value.strip().lower()
+        if not _HEX16_RE.fullmatch(normalized):
+            raise ValueError("machine_code 必须为 16 位十六进制短码")
+        return normalized
+
+    @field_validator("issued_at", "expires_at")
+    @classmethod
+    def _require_aware_utc(cls, value: datetime | None) -> datetime | None:
+        if value is None:
+            return None
+        if value.tzinfo is None:
+            raise ValueError("时间字段必须为 aware datetime（拒绝 naive）")
+        return value.astimezone(timezone.utc)
+
+
+def _canonical_bytes(payload: dict) -> bytes:
+    """规范化 JSON 字节：键排序 + 紧凑分隔符 + UTF-8（签发/验签共用）"""
+    return json.dumps(
+        payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False
+    ).encode("utf-8")
+
+
+def sign(payload: LicensePayload, private_key_pem: str) -> str:
+    """对载荷签名，返回 license 文件内容（JSON 文本，即 .lic）
+
+    Args:
+        payload: 授权载荷
+        private_key_pem: Ed25519 私钥 PEM（PKCS8）
+
+    Returns:
+        str: license 文件内容 `{"payload": {...}, "signature": "<b64>"}`
+
+    Raises:
+        LicenseFormatError: 私钥解析失败或类型不是 Ed25519
+    """
+    try:
+        private_key = serialization.load_pem_private_key(
+            private_key_pem.encode("utf-8"), password=None
+        )
+    except (ValueError, TypeError) as exc:
+        raise LicenseFormatError(f"私钥 PEM 解析失败：{exc}") from exc
+    if not isinstance(private_key, Ed25519PrivateKey):
+        raise LicenseFormatError("私钥类型不是 Ed25519")
+    payload_dict = payload.model_dump(mode="json")
+    signature = private_key.sign(_canonical_bytes(payload_dict))
+    document = {
+        "payload": payload_dict,
+        "signature": base64.b64encode(signature).decode("ascii"),
+    }
+    logger.info(
+        "license 已签发：product=%s machine_code=%s",
+        payload.product,
+        payload.machine_code,
+    )
+    return json.dumps(document, ensure_ascii=False, indent=2)
+
+
+# ---------------------------------------------------------------------------
+# 验签
+# ---------------------------------------------------------------------------
+
+
+class LicenseVerifier:
+    """license 文件验签器（应用启动/请求时校验授权）
+
+    校验链：签名 → product 匹配 → machine_code 匹配 → 未过期；
+    各环节失败抛对应 LicenseError 子类，应用侧可区分提示语。
+    """
+
+    def __init__(self, public_key_pem: str, license_path: Path) -> None:
+        """保存公钥与 license 路径（文件读取延迟到 verify 时）
+
+        Args:
+            public_key_pem: Ed25519 公钥 PEM（应用配置注入）
+            license_path: license 文件路径（应用侧显式给出，不做路径猜测）
+        """
+        self._public_key_pem = public_key_pem
+        self._license_path = Path(license_path)
+        self._public_key: Ed25519PublicKey | None = None
+        # 最近一次 verify 成功的上下文，供 reverify() 使用
+        self._verified_context: tuple[str, str] | None = None
+
+    def _load_public_key(self) -> Ed25519PublicKey:
+        """解析并缓存公钥；类型不符抛 LicenseFormatError"""
+        if self._public_key is None:
+            try:
+                key = serialization.load_pem_public_key(
+                    self._public_key_pem.encode("utf-8")
+                )
+            except (ValueError, TypeError) as exc:
+                raise LicenseFormatError(f"公钥 PEM 解析失败：{exc}") from exc
+            if not isinstance(key, Ed25519PublicKey):
+                raise LicenseFormatError("公钥类型不是 Ed25519")
+            self._public_key = key
+        return self._public_key
+
+    def _load_document(self) -> tuple[dict, bytes]:
+        """读 license 文件并拆出 (payload dict, 签名字节)"""
+        if not self._license_path.is_file():
+            raise LicenseFormatError(f"license 文件不存在：{self._license_path}")
+        try:
+            document = json.loads(self._license_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            raise LicenseFormatError(f"license 文件读取或解析失败：{exc}") from exc
+        if not isinstance(document, dict):
+            raise LicenseFormatError("license 文件结构不合法（顶层应为 JSON 对象）")
+        payload_dict = document.get("payload")
+        signature_text = document.get("signature")
+        if not isinstance(payload_dict, dict) or not isinstance(signature_text, str):
+            raise LicenseFormatError("license 文件缺少 payload 或 signature 字段")
+        try:
+            signature = base64.b64decode(signature_text, validate=True)
+        except (ValueError, TypeError) as exc:
+            raise LicenseFormatError(f"signature 不是合法 base64：{exc}") from exc
+        return payload_dict, signature
+
+    def verify(
+        self,
+        *,
+        product: str,
+        machine_code: str,
+        now: datetime | None = None,
+    ) -> LicensePayload:
+        """全量校验 license，返回载荷
+
+        Args:
+            product: 期望的应用标识
+            machine_code: 期望的机器码（本机 `get_machine_code()` 结果）
+            now: 判定"当前时间"；None 取 aware UTC 当前时刻；naive 按 UTC 处理
+
+        Returns:
+            LicensePayload: 校验通过的授权载荷
+
+        Raises:
+            LicenseFormatError: 文件缺失/损坏/版本不识别/字段非法
+            LicenseSignatureError: 签名验证失败
+            LicenseProductMismatchError: product 不匹配
+            LicenseMachineMismatchError: machine_code 不匹配
+            LicenseExpiredError: 已过期
+        """
+        check_time = now or datetime.now(timezone.utc)
+        if check_time.tzinfo is None:
+            check_time = check_time.replace(tzinfo=timezone.utc)
+        payload_dict, signature = self._load_document()
+        try:
+            self._load_public_key().verify(signature, _canonical_bytes(payload_dict))
+        except InvalidSignature as exc:
+            raise LicenseSignatureError("license 签名验证失败") from exc
+        payload = self._validated_payload(payload_dict)
+        if payload.product != product:
+            raise LicenseProductMismatchError(
+                f"product 不匹配：期望 {product!r}，实际 {payload.product!r}"
+            )
+        expected_code = machine_code.strip().lower()
+        if payload.machine_code != expected_code:
+            raise LicenseMachineMismatchError(
+                f"机器码不匹配：期望 {expected_code!r}，实际 {payload.machine_code!r}"
+            )
+        if payload.expires_at is not None and check_time > payload.expires_at:
+            raise LicenseExpiredError(
+                f"授权已于 {payload.expires_at.isoformat()} 过期"
+            )
+        self._verified_context = (product, expected_code)
+        logger.info("license 校验通过：product=%s tier=%s", payload.product, payload.tier)
+        return payload
+
+    def _validated_payload(self, payload_dict: dict) -> LicensePayload:
+        """载荷 dict → 模型校验（版本/字段/时间格式），失败归一为 LicenseFormatError"""
+        try:
+            return LicensePayload.model_validate(payload_dict)
+        except Exception as exc:  # noqa: BLE001 - pydantic 校验错误统一归一
+            raise LicenseFormatError(f"license 载荷校验失败：{exc}") from exc
+
+    def file_signature(self) -> str:
+        """license 文件内容指纹：SHA256(文件字节)
+
+        供应用侧运行中检测文件被替换（每请求比对，变化即调 `reverify()`）。
+        只哈希内容、不含 mtime——mtime 在解压/拷贝场景随机变化，参与比对只会误触发。
+
+        Returns:
+            str: 十六进制 SHA256
+
+        Raises:
+            LicenseFormatError: 文件缺失或不可读
+        """
+        try:
+            content = self._license_path.read_bytes()
+        except OSError as exc:
+            raise LicenseFormatError(f"license 文件不可读：{exc}") from exc
+        return hashlib.sha256(content).hexdigest()
+
+    def reverify(self) -> LicensePayload:
+        """用最近一次成功 verify 的上下文重新全量校验（文件被换时相应失败）
+
+        Returns:
+            LicensePayload: 重新校验通过的授权载荷
+
+        Raises:
+            LicenseError: 尚未成功执行过 verify()
+        """
+        if self._verified_context is None:
+            raise LicenseError("尚未成功执行 verify()，无法 reverify")
+        product, machine_code = self._verified_context
+        return self.verify(product=product, machine_code=machine_code)

{sdpy_kit-0.4.0 → sdpy_kit-0.4.2}/pyproject.toml

@@ -33,6 +33,8 @@ classifiers = [
 dependencies = [
     "pydantic>=2.14.1",
     "pydantic-settings>=2.15.0",
+    # Ed25519 签名/验签（kit/license_kit.py）：零传递依赖 + abi3 wheel，评审定案放 base
+    "cryptography>=46.0.7",
     "sqlalchemy~=2.0.54",
     "sqlmodel>=0.0.48",
 ]