flash-sim 0.0.1__py3-none-any.whl

flash/_core/credentials/_core.py

@@ -0,0 +1,277 @@
+"""
+Flash 凭据管理 -- 核心加密/解密
+==============================
+提供 CredentialManager 封装及公共辅助函数。
+供其他 cred_* 模块导入使用。
+"""
+
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ._config import DEFAULT_USER_NAME, ENTRIES, ENTRIES_BY_NAME
+
+# ── 凭据管理器缓存 (确保同一会话内单例) ──
+_CREDENTIAL_MANAGER_CACHE = None
+
+
+# ── 敏感字段名: 列表展示时自动掩码 ──
+_SECRET_FIELDS = {"password", "api_key", "secret", "token", "access_key", "private_key"}
+
+_DEFAULT_PASSWORD = "123"
+
+
+def get_default_password() -> str:
+    """获取默认密码 (用于 SSH 账户设置提示)。"""
+    return _DEFAULT_PASSWORD
+
+
+def get_credential_manager():
+    """获取 CredentialManager 实例 (Flash 专属存储)，会话内缓存。
+
+    优先使用 physimx_core（加密存储），回退到内存最小实现。
+    使用模块级缓存确保同一会话内返回同一实例。
+    """
+    global _CREDENTIAL_MANAGER_CACHE
+    if _CREDENTIAL_MANAGER_CACHE is not None:
+        return _CREDENTIAL_MANAGER_CACHE
+
+    try:
+        from physimx_core.credentials import CredentialManager
+        # 使用 Flash 专属子目录: ~/.physimx/flash/
+        _CREDENTIAL_MANAGER_CACHE = CredentialManager(subdir="flash")
+    except ImportError:
+        # physimx_core 未安装时，使用内存最小实现
+        from ._minimal import MinimalCredentialManager
+        _CREDENTIAL_MANAGER_CACHE = MinimalCredentialManager(subdir="flash")
+    return _CREDENTIAL_MANAGER_CACHE
+
+
+# ── 用户名字段 ──────────────────────────────────────────
+
+def get_user_name() -> str:
+    """获取用户名 (优先继承 physimx_core, fallback Flash 自己的 __meta__)。"""
+    try:
+        from physimx_core.credentials import get_user_name as _gun
+        return _gun()
+    except ImportError:
+        # fallback: 从 __meta__ 读取
+        try:
+            cm = get_credential_manager()
+            meta = cm.get("__meta__") or {}
+            return meta.get("default_user_name", DEFAULT_USER_NAME)
+        except Exception:
+            return DEFAULT_USER_NAME
+
+
+def get_user_name_source() -> str:
+    """返回用户名来源: 'physimx_core' 或 'flash'。"""
+    try:
+        from physimx_core.credentials import get_user_name as _gun
+        _gun()
+        return "physimx_core"
+    except ImportError:
+        return "flash"
+
+
+def set_user_name(name: str) -> None:
+    """设置用户名。"""
+    try:
+        from physimx_core.credentials import set_user_name as _sun
+        _sun(name)
+    except ImportError:
+        # fallback: 写入 __meta__
+        try:
+            cm = get_credential_manager()
+            meta = cm.get("__meta__") or {}
+            meta["default_user_name"] = name
+            cm.set("__meta__", meta)
+        except Exception:
+            pass
+
+
+def ask_one(label: str, default) -> str:
+    """询问一个字段，回车返回默认值。"""
+    val = input(f"  {label:12s} [{default}]: ").strip()
+    return val if val else str(default)
+
+
+def mask_secret(data: Dict[str, Any]) -> Dict[str, Any]:
+    """对敏感字段进行掩码处理，返回安全可展示的副本。"""
+    masked = dict(data)
+    for k, v in masked.items():
+        if k in _SECRET_FIELDS:
+            if isinstance(v, str) and len(v) > 4:
+                masked[k] = v[:2] + "*" * (len(v) - 4) + v[-2:]
+            elif isinstance(v, str):
+                masked[k] = "****"
+    return masked
+
+
+# ── SSH 账户辅助 ──
+
+def collect_ssh_accounts(cm) -> List[str]:
+    """收集所有 flash_ssh 开头的凭据名，排序返回。"""
+    all_creds = cm._load_raw()
+    return sorted([k for k in all_creds if k.startswith("flash_ssh")])
+
+
+def get_primary_ssh(cm) -> str:
+    """获取主 SSH 账户名。"""
+    meta = cm.get("__meta__") or {}
+    return meta.get("primary_ssh", "flash_ssh")
+
+
+def set_primary_ssh(cm, account_name: str) -> None:
+    """设置主 SSH 账户。"""
+    meta = cm.get("__meta__") or {}
+    meta["primary_ssh"] = account_name
+    cm.set("__meta__", meta)
+
+
+# ── SSH 编号工具 ──
+
+def next_ssh_number(cm) -> int:
+    """计算下一个可用的 SSH 账户编号。"""
+    existing = collect_ssh_accounts(cm)
+    used = set()
+    for name in existing:
+        if name == "flash_ssh":
+            used.add(1)
+        elif name.startswith("flash_ssh_"):
+            try:
+                used.add(int(name.split("_")[-1]))
+            except ValueError:
+                pass
+    n = 1
+    while n in used:
+        n += 1
+    return n
+
+
+def ssh_account_name(num: int) -> str:
+    """根据编号生成 SSH 账户名 (1 -> flash_ssh, 2+ -> flash_ssh_N)。"""
+    return "flash_ssh" if num == 1 else f"flash_ssh_{num}"
+
+
+# ── 通用凭据辅助 ──
+
+def get_entry_def(name: str) -> Optional[Dict[str, Any]]:
+    """根据名称获取凭据条目定义。"""
+    return ENTRIES_BY_NAME.get(name)
+
+
+def list_all_entries() -> List[Dict[str, Any]]:
+    """列出所有凭据条目定义。"""
+    return ENTRIES
+
+
+# ── 旧接口兼容桥接 ──
+#    以下函数是旧 _core/credentials.py (单文件) 中的 API，
+#    供 flash_run/ 和 scenarios/flash_demo/ 等模块直接使用。
+#    使用 Flash 专属存储 (get_credential_manager)。
+#    =================================================
+
+def load_ssh_credentials(name: Optional[str] = None) -> Optional[Dict[str, Any]]:
+    """加载 FLASH SSH 凭据（自动解析路由）。
+
+    返回的凭据包含 host/port/username/password 等连接所需字段。
+    优先使用已缓存的 active_route，否则从预配置路由自动选择第一条。
+
+    参数:
+        name: 凭据名 (如 "flash_ssh")，为 None 时返回主账户凭据。
+
+    返回:
+        凭据字典 (含 host/port/username/password)，未找到返回 None。
+    """
+    try:
+        cm = get_credential_manager()
+    except SystemExit:
+        return None
+    if name is not None:
+        raw = cm.get(name)
+        _effective_name = name
+    else:
+        primary = get_primary_ssh(cm)
+        raw = cm.get(primary)
+        _effective_name = primary
+        if raw is None:
+            raw = cm.get("flash_ssh")
+            _effective_name = "flash_ssh"
+    if not raw:
+        return None
+
+    # 如果已有完整字段，直接返回
+    if raw.get("host") and raw.get("username"):
+        return dict(raw)
+
+    # ── 路由解析 ──
+    from ._config import get_ssh_routes, ENTRIES_BY_NAME
+    result = dict(raw)
+
+    # route_key: 从预配置条目中补齐
+    entry = ENTRIES_BY_NAME.get(_effective_name)
+    if entry and "route_key" not in result:
+        rk = entry.get("route_key")
+        if rk:
+            result["route_key"] = rk
+
+    # 用户名: 优先使用 raw 中的，否则从预配置获取
+    if "username" not in result or not result["username"]:
+        ssh_user = raw.get("ssh_username", "")
+        if ssh_user:
+            result["username"] = ssh_user
+
+    # 路由: 按 active_route → 第一条 → None
+    routes = get_ssh_routes(_effective_name)
+    route = None
+    active_idx = raw.get("active_route")
+    if active_idx is not None and isinstance(active_idx, int) and 0 <= active_idx < len(routes):
+        route = routes[active_idx]
+    elif routes:
+        route = routes[0]  # 默认第一条
+
+    if route:
+        result.setdefault("host", route["host"])
+        result.setdefault("port", route["port"])
+
+    return result
+
+
+def load_all_ssh_credentials() -> Dict[str, Dict[str, Any]]:
+    """加载所有超算 SSH 凭据（自动解析路由）。
+
+    返回:
+        {凭据名: 凭据字典, ...}，每个字典包含 host/port/username/password。
+        仅包含可解析出 host 的有效凭据。
+    """
+    try:
+        cm = get_credential_manager()
+    except SystemExit:
+        return {}
+    names = collect_ssh_accounts(cm)
+    result = {}
+    for name in names:
+        resolved = load_ssh_credentials(name)
+        if resolved and resolved.get("host"):
+            result[name] = resolved
+    return result
+
+
+def get_best_route(cred_name: str) -> Optional[Dict[str, Any]]:
+    """获取凭据已缓存的最佳路由。
+
+    参数:
+        cred_name: 凭据名 (如 "flash_ssh")
+
+    返回:
+        路由字典 {"host": ..., "port": ..., "label": ...}，未缓存返回 None。
+    """
+    try:
+        cm = get_credential_manager()
+    except SystemExit:
+        return None
+    cred = cm.get(cred_name)
+    if cred is None:
+        return None
+    return cred.get("best_route")

flash/_core/credentials/_flash_entries.py

@@ -0,0 +1,83 @@
+"""
+Flash 包 -- 凭据条目定义
+========================
+
+这是 flash 包自己的凭据配置。
+在 flash/_core/credentials/_config.py 中注册。
+
+注意: SSH 线路定义在 _config.py 中 (共享基础设施)。
+"""
+
+# ── 导入 register 函数 (兼容直接运行和模块运行) ─────────────────────
+try:
+    # 相对导入 (作为包的一部分运行时)
+    from ._config import register_entries, register_ssh_accounts
+except (ImportError, ValueError):
+    # 绝对导入 (直接运行时)
+    from flash._core.credentials._config import register_entries, register_ssh_accounts
+
+
+# ── 预配置 SSH 账户 ───────────────────────────────
+
+register_ssh_accounts([
+    {
+        "name": "flash_ssh",
+        "title": "FLASH 超算 SSH #1 (ParaCloud 中卫 NC-E)",
+        "ssh_username": "scfa2696@NC-E",
+        "routes": [
+            {"host": "ssh.cn-zhongwei-1.paracloud.com",     "port": 8443, "label": "中卫-1 (8443)"},
+            {"host": "ssh.cn-hongkong-1.paracloud.com",     "port": 22,   "label": "香港-1 (22)"},
+            {"host": "ssh.cn-zhongwei-1.paracloud.com",      "port": 22,   "label": "中卫-1 (22)"},
+            {"host": "ssh.cn-zhongwei-1-v6.paracloud.com",  "port": 22,   "label": "中卫-1-v6 (22)"},
+            {"host": "ssh.cn-zhongwei-1.paracloud.com",      "port": 2222, "label": "中卫-1 (2222)"},
+            {"host": "ssh.cn-zhongwei-1-v6.paracloud.com",  "port": 2222, "label": "中卫-1-v6 (2222)"},
+            {"host": "ssh.cn-zhongwei-cstnet.paracloud.com", "port": 22,   "label": "中卫-cstnet (22)"},
+            {"host": "ssh.cn-zhongwei-cstnet-v6.paracloud.com","port": 22, "label": "中卫-cstnet-v6 (22)"},
+            {"host": "ssh.paracloud.com",                    "port": 2222, "label": "ParaCloud (2222)"},
+        ],
+    },
+    {
+        "name": "flash_ssh_2",
+        "title": "FLASH 超算 SSH #2 (ParaCloud 中卫 BSCC-T6)",
+        "ssh_username": "sch0348@BSCC-T6",
+        "routes": [
+            {"host": "ssh.cn-zhongwei-1.paracloud.com",     "port": 8443, "label": "中卫-1 (8443)"},
+            {"host": "ssh.cn-hongkong-1.paracloud.com",     "port": 22,   "label": "香港-1 (22)"},
+            {"host": "ssh.cn-zhongwei-1.paracloud.com",      "port": 22,   "label": "中卫-1 (22)"},
+            {"host": "ssh.cn-zhongwei-1-v6.paracloud.com",  "port": 22,   "label": "中卫-1-v6 (22)"},
+            {"host": "ssh.cn-zhongwei-1.paracloud.com",      "port": 2222, "label": "中卫-1 (2222)"},
+            {"host": "ssh.cn-zhongwei-1-v6.paracloud.com",  "port": 2222, "label": "中卫-1-v6 (2222)"},
+            {"host": "ssh.cn-zhongwei-cstnet.paracloud.com", "port": 22,   "label": "中卫-cstnet (22)"},
+            {"host": "ssh.cn-zhongwei-cstnet-v6.paracloud.com","port": 22, "label": "中卫-cstnet-v6 (22)"},
+            {"host": "ssh.paracloud.com",                    "port": 2222, "label": "ParaCloud (2222)"},
+        ],
+    },
+])
+
+
+# ── 普通凭据条目 ──────────────────────────────────
+
+register_entries([
+    # Gitee 凭据
+    {
+        "name": "gitee",
+        "type": "gitee",
+        "title": "Gitee 访问令牌",
+        "fields": [
+            ("token",    "访问令牌 (Personal Access Token)", "123"),
+            ("username", "用户名",                                 "hello"),
+            ("repo_url", "仓库 URL (可选)",                      "https://gitee.com/physimx/flash.git"),
+        ],
+    },
+
+    # DeepSeek API
+    {
+        "name": "deepseek_api",
+        "type": "api",
+        "title": "DeepSeek API (太极网关)",
+        "fields": [
+            ("base_url", "API 地址", "https://gateway.taichuai.cn/modelhub/api/v1"),
+            ("api_key",  "API Key", "123"),
+        ],
+    },
+])

flash/_core/credentials/_minimal.py

@@ -0,0 +1,73 @@
+"""MinimalCredentialManager — 最小化凭据管理器 (physimx_core 不可用时的回退)
+
+- 存储位置: ~/.physimx/flash/credentials.json (与 physimx_core 的 subdir="flash" 对齐)
+- 简单 JSON 持久化，无加密 (仅作为 physimx_core 缺失时的回退)
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class MinimalCredentialManager:
+    """最小化凭据管理器 — JSON 文件持久化，无加密。
+
+    存储路径: {HOME}/.physimx/{subdir}/credentials.json
+    """
+
+    def __init__(self, subdir: str = "flash"):
+        self._subdir = subdir
+        self._store: Dict[str, Any] = {}
+        self._file = self._resolve_file()
+        self._load()
+
+    # ── 文件路径 ──
+    def _resolve_file(self) -> Path:
+        home = Path(os.path.expanduser("~"))
+        return home / ".physimx" / self._subdir / "credentials.json"
+
+    def _load(self) -> None:
+        """从磁盘加载凭据。文件不存在时使用空存储 + 默认 __meta__。"""
+        try:
+            if self._file.exists():
+                data = json.loads(self._file.read_text(encoding="utf-8"))
+                self._store = data if isinstance(data, dict) else {}
+            else:
+                self._store = {}
+        except (json.JSONDecodeError, OSError):
+            self._store = {}
+        # 确保 __meta__ 存在
+        self._store.setdefault("__meta__", {"default_user_name": "hello"})
+
+    def _save(self) -> None:
+        """持久化到磁盘 (原子写入)。"""
+        try:
+            self._file.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self._file.with_suffix(".json.tmp")
+            tmp.write_text(
+                json.dumps(self._store, ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+            os.replace(tmp, self._file)
+        except OSError:
+            # 磁盘写入失败时静默降级为内存存储 (不崩溃)
+            pass
+
+    # ── 公开 API ──
+    def get(self, key: str, default=None) -> Optional[Any]:
+        return self._store.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._store[key] = value
+        self._save()
+
+    def delete(self, key: str) -> None:
+        self._store.pop(key, None)
+        self._save()
+
+    def list_all(self) -> Dict[str, Any]:
+        return dict(self._store)
+
+    def _load_raw(self) -> Dict[str, Any]:
+        return dict(self._store)

flash/_core/credentials/api_keys.py

@@ -0,0 +1,225 @@
+"""
+Flash 凭据管理 -- API 密钥管理
+====================================
+管理各种 AI API 密钥 (DeepSeek、OpenAI、Claude、Gemini 等)。
+
+用法:
+    python -m flash._core.credentials.api_keys           # 交互菜单
+    python -m flash._core.credentials.api_keys setup     # 设置 API 密钥
+    python -m flash._core.credentials.api_keys list      # 列出所有 API 凭据
+"""
+
+import sys
+from typing import Dict, Any, Optional, List
+
+from ._core import (
+    ask_one,
+    get_credential_manager,
+    mask_secret,
+)
+from ._config import ENTRIES, ENTRIES_BY_NAME, DEFAULT_PASSWORD
+
+
+# API 类型的凭据名识别: 名称以 _api 结尾
+def _is_api_entry(entry: Dict[str, Any]) -> bool:
+    """判断是否为 API 类型的凭据。"""
+    return entry["name"].endswith("_api")
+
+
+def _get_api_entries() -> List[Dict[str, Any]]:
+    """获取所有 API 类型的凭据定义。"""
+    return [e for e in ENTRIES if _is_api_entry(e)]
+
+
+def setup_api(name: str) -> bool:
+    """设置指定 API 的凭据。"""
+    cm = get_credential_manager()
+
+    entry_def = ENTRIES_BY_NAME.get(name)
+    if entry_def is None:
+        print(f"\n  [错误] 未找到 API 定义: {name}")
+        return False
+
+    print(f"\n  📝 设置 {entry_def['title']}")
+    print(f"  {'─' * 50}")
+
+    data = {}
+    for key, label, default in entry_def["fields"]:
+        # 使用全局默认值
+        if default == "123":
+            default = DEFAULT_PASSWORD
+        data[key] = ask_one(label, default)
+
+    cm.set(name, data)
+    print(f"\n  ✅ {entry_def['title']} 凭据已保存。")
+    return True
+
+
+def show_api(name: str, raw: bool = False) -> None:
+    """查看指定 API 的凭据。"""
+    cm = get_credential_manager()
+    data = cm.get(name)
+
+    if not data:
+        entry_def = ENTRIES_BY_NAME.get(name)
+        title = entry_def["title"] if entry_def else name
+        print(f"\n  [提示] 尚未设置: {title}")
+        return
+
+    entry_def = ENTRIES_BY_NAME.get(name)
+    title = entry_def["title"] if entry_def else name
+
+    print(f"\n  {'─' * 50}")
+    print(f"  {title}")
+    print(f"  {'─' * 50}")
+
+    display = data if raw else mask_secret(data)
+    for k, v in display.items():
+        print(f"    {k:12s}: {v}")
+    print(f"  {'─' * 50}")
+    if not raw:
+        print(f"  💡 使用 --raw 查看原始密钥")
+
+
+def list_all_api() -> None:
+    """列出所有 API 凭据。"""
+    cm = get_credential_manager()
+    api_entries = _get_api_entries()
+
+    print(f"\n  {'─' * 50}")
+    print(f"  API 凭据列表")
+    print(f"  {'─' * 50}")
+
+    found = False
+    for entry_def in api_entries:
+        name = entry_def["name"]
+        data = cm.get(name)
+        if data:
+            found = True
+            title = entry_def["title"]
+            print(f"\n  [{name}]")
+            print(f"    名称: {title}")
+            masked = mask_secret(data)
+            for k, v in masked.items():
+                print(f"    {k:12s}: {v}")
+
+    if not found:
+        print("\n  [提示] 尚未设置任何 API 凭据。")
+    print(f"\n  {'─' * 50}")
+
+
+def delete_api(name: str) -> bool:
+    """删除指定 API 的凭据。"""
+    cm = get_credential_manager()
+
+    if not cm.get(name):
+        entry_def = ENTRIES_BY_NAME.get(name)
+        title = entry_def["title"] if entry_def else name
+        print(f"\n  [提示] 尚未设置: {title}")
+        return False
+
+    confirm = input(f"\n  确认删除 {name} 凭据? [y/N]: ").strip().lower()
+    if confirm != "y":
+        print("\n  [已取消]")
+        return False
+
+    try:
+        cm.delete(name)
+        print(f"\n  ✅ {name} 凭据已删除。")
+        return True
+    except Exception as e:
+        print(f"\n  ❌ 删除失败: {e}")
+        return False
+
+
+def interactive_menu() -> None:
+    """交互式菜单。"""
+    while True:
+        api_entries = _get_api_entries()
+
+        print(f"\n  {'=' * 50}")
+        print(f"  API 密钥管理")
+        print(f"  {'=' * 50}")
+        print("  [1] 设置 API 密钥")
+        print("  [2] 查看所有 API 凭据")
+        print("  [3] 删除 API 凭据")
+        print("  [0] 返回")
+
+        choice = input("\n  请选择 [0-3]: ").strip()
+
+        if choice == "1":
+            _setup_menu(api_entries)
+        elif choice == "2":
+            list_all_api()
+        elif choice == "3":
+            _delete_menu()
+        elif choice == "0":
+            break
+        else:
+            print("  [无效选择]")
+
+
+def _setup_menu(api_entries: List[Dict[str, Any]]) -> None:
+    """选择要设置的 API。"""
+    if not api_entries:
+        print("\n  [提示] 尚未定义任何 API 类型。")
+        return
+
+    print("\n  可选 API:")
+    for i, entry in enumerate(api_entries, 1):
+        print(f"    [{i}] {entry['title']}")
+
+    choice = input(f"\n  选择要设置的 API [1-{len(api_entries)}, 0=取消]: ").strip()
+    try:
+        idx = int(choice) - 1
+        if 0 <= idx < len(api_entries):
+            setup_api(api_entries[idx]["name"])
+    except ValueError:
+        pass
+
+
+def _delete_menu() -> None:
+    """删除菜单（选择要删除的 API）。"""
+    cm = get_credential_manager()
+    api_entries = _get_api_entries()
+
+    # 只显示已设置的
+    existing = [(e["name"], e["title"]) for e in api_entries if cm.get(e["name"])]
+
+    if not existing:
+        print("\n  [提示] 尚未设置任何 API 凭据。")
+        return
+
+    print("\n  可选 API 凭据:")
+    for i, (name, title) in enumerate(existing, 1):
+        print(f"    [{i}] {title}")
+
+    choice = input(f"\n  选择要删除的编号 [1-{len(existing)}, 0=取消]: ").strip()
+    try:
+        idx = int(choice) - 1
+        if 0 <= idx < len(existing):
+            delete_api(existing[idx][0])
+    except ValueError:
+        pass
+
+
+if __name__ == "__main__":
+    main_arg = sys.argv[1] if len(sys.argv) > 1 else None
+
+    if main_arg == "setup":
+        name = sys.argv[2] if len(sys.argv) > 2 else "deepseek_api"
+        setup_api(name)
+    elif main_arg == "show":
+        name = sys.argv[2] if len(sys.argv) > 2 else "deepseek_api"
+        raw = "--raw" in sys.argv
+        show_api(name, raw)
+    elif main_arg == "list":
+        list_all_api()
+    elif main_arg == "del":
+        name = sys.argv[2] if len(sys.argv) > 2 else None
+        if name:
+            delete_api(name)
+        else:
+            _delete_menu()
+    else:
+        interactive_menu()