seeed-jetson-developer 0.1.0__py3-none-any.whl

seeed_jetson_develop/__init__.py

@@ -0,0 +1,7 @@
+"""
+Seeed Jetson Flash - A tool for flashing Jetson devices
+"""
+
+__version__ = "0.1.0"
+__author__ = "Seeed Studio"
+__email__ = "support@seeedstudio.com"

seeed_jetson_develop/cli.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+命令行接口模块
+"""
+import click
+import json
+import os
+from pathlib import Path
+from .flash import JetsonFlasher
+from .recovery import RecoveryGuide
+
+
+@click.group()
+@click.version_option()
+def cli():
+    """Seeed Jetson Flash - 为 Jetson 设备刷机的工具"""
+    pass
+
+
+@cli.command()
+@click.option('--product', '-p', required=True, help='产品型号 (例如: j4012mini)')
+@click.option('--l4t', '-l', required=True, help='L4T 版本 (例如: 36.3.0)')
+@click.option('--download-only', is_flag=True, help='仅下载固件，不刷写')
+@click.option('--skip-verify', is_flag=True, help='跳过 SHA256 校验')
+def flash(product, l4t, download_only, skip_verify):
+    """刷写 Jetson 设备"""
+    flasher = JetsonFlasher(product, l4t)
+    
+    click.echo(f"正在为 {product} 准备 L4T {l4t} 固件...")
+    
+    # 下载固件
+    if not flasher.download_firmware():
+        click.echo("固件下载失败", err=True)
+        return
+    
+    # 校验固件
+    if not skip_verify:
+        if not flasher.verify_firmware():
+            click.echo("固件校验失败", err=True)
+            return
+    
+    if download_only:
+        click.echo("固件下载完成")
+        return
+    
+    # 解压固件
+    if not flasher.extract_firmware():
+        click.echo("固件解压失败", err=True)
+        return
+    
+    # 刷写固件
+    if not flasher.flash_firmware():
+        click.echo("固件刷写失败", err=True)
+        return
+    
+    click.echo("刷写完成！")
+
+
+@cli.command()
+@click.option('--product', '-p', required=True, help='产品型号')
+def recovery(product):
+    """显示进入 Recovery 模式的教程"""
+    guide = RecoveryGuide(product)
+    guide.show_guide()
+
+
+@cli.command()
+def list_products():
+    """列出所有支持的产品"""
+    data_path = Path(__file__).parent / "data" / "l4t_data.json"
+    with open(data_path, 'r') as f:
+        data = json.load(f)
+    
+    products = {}
+    for item in data:
+        product = item['product']
+        if product not in products:
+            products[product] = []
+        products[product].append(item['l4t'])
+    
+    click.echo("支持的产品列表：\n")
+    for product, l4t_versions in sorted(products.items()):
+        click.echo(f"  {product}")
+        click.echo(f"    L4T 版本: {', '.join(l4t_versions)}")
+        click.echo()
+
+
+@cli.command()
+def gui():
+    """启动图形界面"""
+    try:
+        # 直接导入 main 函数，避免通过 __init__.py
+        import sys
+        from pathlib import Path
+        
+        # 确保可以找到模块
+        module_path = Path(__file__).parent
+        if str(module_path) not in sys.path:
+            sys.path.insert(0, str(module_path))
+        
+        from seeed_jetson_develop.gui.main_window import main as gui_main
+        gui_main()
+    except ImportError as e:
+        click.echo(f"错误: 无法启动 GUI，请安装 PyQt5: pip install PyQt5", err=True)
+        click.echo(f"详细错误: {e}", err=True)
+
+
+def main():
+    cli()
+
+
+if __name__ == '__main__':
+    main()

seeed_jetson_develop/core/__init__.py

@@ -0,0 +1,3 @@
+from .events import bus
+from .runner import Runner
+from .device import DeviceInfo

seeed_jetson_develop/core/config.py

@@ -0,0 +1,45 @@
+"""全局配置持久化"""
+import json
+import os
+from pathlib import Path
+
+_CONFIG_PATH = Path.home() / ".config" / "seeed-jetson-tool" / "config.json"
+DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com"
+
+
+def load() -> dict:
+    try:
+        return json.loads(_CONFIG_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def save(data: dict):
+    _CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _CONFIG_PATH.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def get_runtime_anthropic_settings() -> dict:
+    data = load()
+
+    config_key = (data.get("anthropic_api_key") or "").strip()
+    env_key = (os.environ.get("ANTHROPIC_API_KEY") or "").strip()
+    api_key = config_key or env_key
+    api_key_source = "config" if config_key else ("env" if env_key else "none")
+
+    config_url = (data.get("anthropic_base_url") or "").strip()
+    env_url = (os.environ.get("ANTHROPIC_BASE_URL") or "").strip()
+    base_url = config_url or env_url or DEFAULT_ANTHROPIC_BASE_URL
+    if config_url:
+        base_url_source = "config"
+    elif env_url:
+        base_url_source = "env"
+    else:
+        base_url_source = "default"
+
+    return {
+        "api_key": api_key,
+        "api_key_source": api_key_source,
+        "base_url": base_url,
+        "base_url_source": base_url_source,
+    }

seeed_jetson_develop/core/device.py

@@ -0,0 +1,14 @@
+"""设备信息数据类"""
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class DeviceInfo:
+    ip: str = ""
+    hostname: str = ""
+    model: str = ""          # e.g. "reComputer J4012"
+    jetpack: str = ""        # e.g. "6.0"
+    l4t: str = ""            # e.g. "36.3.0"
+    connected: bool = False
+    diagnostics: dict = field(default_factory=dict)

seeed_jetson_develop/core/events.py

@@ -0,0 +1,28 @@
+"""全局事件总线 — 模块间通信，避免直接 import 耦合"""
+from PyQt5.QtCore import QObject, pyqtSignal
+
+
+class EventBus(QObject):
+    # devices 模块
+    device_connected    = pyqtSignal(dict)   # payload: {ip, name, model}
+    device_disconnected = pyqtSignal(str)    # payload: ip
+    diagnostics_done    = pyqtSignal(dict)   # payload: {item: status}
+
+    # flash 模块
+    flash_started       = pyqtSignal(str, str)  # product, l4t
+    flash_completed     = pyqtSignal(bool, str)  # success, message
+
+    # skills 模块
+    skill_run_requested = pyqtSignal(str)    # skill_id
+    skill_completed     = pyqtSignal(str, bool, str)  # skill_id, success, log
+
+    # apps 模块
+    app_install_requested = pyqtSignal(str)  # app_id
+    app_installed         = pyqtSignal(str, bool)  # app_id, success
+
+    # 导航
+    navigate_to         = pyqtSignal(int)    # page index
+
+
+# 全局单例，所有模块 from seeed_jetson_develop.core import bus
+bus = EventBus()

seeed_jetson_develop/core/platform_detect.py

@@ -0,0 +1,27 @@
+"""运行环境检测 — 判断是否在 Jetson 设备本地运行"""
+import os
+import platform
+
+
+def is_jetson() -> bool:
+    """
+    检测当前是否运行在 NVIDIA Jetson 设备上。
+    判断依据：Linux + aarch64 架构 + Tegra 特有文件。
+    """
+    if platform.system() != "Linux":
+        return False
+    if platform.machine() not in ("aarch64", "armv8l"):
+        return False
+    # Tegra release 标志文件
+    if os.path.exists("/etc/nv_tegra_release"):
+        return True
+    # 设备树 model 文件
+    model_file = "/proc/device-tree/model"
+    if os.path.exists(model_file):
+        try:
+            with open(model_file, "rb") as f:
+                model = f.read().decode("utf-8", errors="ignore").lower()
+                return "jetson" in model or "tegra" in model
+        except Exception:
+            pass
+    return False

seeed_jetson_develop/core/runner.py

@@ -0,0 +1,284 @@
+"""命令执行引擎 — 本地或远程 SSH 执行，统一接口"""
+import os
+import re
+import shlex
+import subprocess
+from typing import Callable, Optional
+
+
+class Runner:
+    """
+    本地命令执行器。
+    后续可扩展 SSHRunner(Runner) 实现远程执行，接口保持一致。
+    """
+
+    def run(
+        self,
+        cmd: str,
+        timeout: int = 30,
+        on_output: Optional[Callable[[str], None]] = None,
+    ) -> tuple[int, str]:
+        """
+        执行命令，返回 (returncode, output)。
+        on_output: 实时输出回调，每行调用一次。
+        同时处理 \\n 和 \\r 分隔（支持 pip 进度条等 \\r 刷新场景）。
+        """
+        env = {**os.environ, "PYTHONUNBUFFERED": "1"}
+        try:
+            proc = subprocess.Popen(
+                cmd, shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                env=env,
+            )
+            fd    = proc.stdout.fileno()
+            buf   = b""
+            lines = []
+
+            while True:
+                try:
+                    chunk = os.read(fd, 65536)   # 有多少读多少，立即返回
+                except OSError:
+                    break
+                if not chunk:
+                    break
+                buf += chunk
+                # 按 \n 或 \r 切割，保留最后未完成的片段
+                parts = re.split(rb"[\n\r]+", buf)
+                for part in parts[:-1]:
+                    line = part.decode("utf-8", errors="replace").strip()
+                    if line:
+                        lines.append(line)
+                        if on_output:
+                            on_output(line)
+                buf = parts[-1]
+
+            # 冲刷剩余缓冲
+            if buf.strip():
+                line = buf.decode("utf-8", errors="replace").strip()
+                lines.append(line)
+                if on_output:
+                    on_output(line)
+
+            proc.wait(timeout=timeout)
+            return proc.returncode, "\n".join(lines)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            return -1, "timeout"
+        except Exception as e:
+            return -1, str(e)
+
+
+class SSHRunner(Runner):
+    """
+    远程 SSH 命令执行器，接口与 Runner 一致。
+    每次 run() 建立一条独立 SSH 连接，适合诊断类低频调用。
+    """
+
+    def __init__(self, host: str, username: str = "seeed",
+                 password: str = "", port: int = 22, sudo_password: str = ""):
+        self.host     = host
+        self.username = username
+        self.password = password
+        self.sudo_password = sudo_password or password
+        self.port     = port
+
+    def _wrap_with_sudo_password(self, cmd: str) -> str:
+        wrapper_parts = ["export TERM=${TERM:-xterm-256color};"]
+        if self.sudo_password:
+            wrapper_parts.extend([
+                f"export SEEED_SUDO_PASSWORD={shlex.quote(self.sudo_password)};",
+                "sudo() { printf '%s\\n' \"$SEEED_SUDO_PASSWORD\" | command sudo -S \"$@\"; };",
+                "export -f sudo;",
+            ])
+        wrapper_parts.append(cmd)
+        wrapper = " ".join(wrapper_parts)
+        return f"bash -lc {shlex.quote(wrapper)}"
+
+    def open_sftp(self):
+        """建立 SSH 连接并返回 (client, sftp)，调用方负责 client.close()。"""
+        import paramiko
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        client.connect(
+            self.host,
+            port=self.port,
+            username=self.username,
+            password=self.password or None,
+            timeout=10,
+            look_for_keys=True,
+            allow_agent=True,
+        )
+        client.get_transport().set_keepalive(30)
+        sftp = client.open_sftp()
+        return client, sftp
+
+    def run(
+        self,
+        cmd: str,
+        timeout: int = 30,
+        on_output: Optional[Callable[[str], None]] = None,
+    ) -> tuple[int, str]:
+        try:
+            import paramiko
+            client = paramiko.SSHClient()
+            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            client.connect(
+                self.host,
+                port=self.port,
+                username=self.username,
+                password=self.password or None,
+                timeout=10,
+                look_for_keys=True,
+                allow_agent=True,
+            )
+            client.get_transport().set_keepalive(30)
+            try:
+                _, stdout, stderr = client.exec_command(
+                    self._wrap_with_sudo_password(cmd),
+                    timeout=timeout,
+                )
+                lines = []
+                for raw in stdout:
+                    line = raw.rstrip("\n")
+                    lines.append(line)
+                    if on_output:
+                        on_output(line)
+                rc  = stdout.channel.recv_exit_status()
+                err = stderr.read().decode("utf-8", errors="replace").strip()
+                if err:
+                    for line in err.splitlines():
+                        if on_output:
+                            on_output(line)
+                    lines.extend(line for line in err.splitlines() if line)
+                out = "\n".join(lines)
+                return rc, out
+            finally:
+                client.close()
+        except Exception as e:
+            return -1, str(e)
+
+
+class SerialRunner(Runner):
+    """
+    通过串口登录 Jetson 并执行命令，接口与 SSHRunner 一致。
+    每次 run() 建立一次串口会话，适合诊断类低频调用。
+    """
+
+    def __init__(self, port: str, username: str = "seeed", password: str = ""):
+        self.port = port
+        self.username = username
+        self.password = password
+
+    def run(
+        self,
+        cmd: str,
+        timeout: int = 30,
+        on_output: Optional[Callable[[str], None]] = None,
+    ) -> tuple[int, str]:
+        import re
+        import time
+        try:
+            import serial
+        except ImportError:
+            return -1, "pyserial 未安装，请运行 pip install pyserial"
+
+        lines: list[str] = []
+
+        def _emit(text: str):
+            if on_output:
+                on_output(text)
+            lines.append(text)
+
+        try:
+            ser = serial.Serial(
+                self.port, baudrate=115200, timeout=0.1,
+                bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE,
+                stopbits=serial.STOPBITS_ONE,
+            )
+        except Exception as exc:
+            return -1, str(exc)
+
+        def _read_until(patterns: list[str], wait: float) -> str:
+            buf = ""
+            deadline = time.time() + wait
+            while time.time() < deadline:
+                if ser.in_waiting:
+                    chunk = ser.read(ser.in_waiting).decode("utf-8", errors="ignore")
+                    if chunk:
+                        buf += chunk
+                else:
+                    time.sleep(0.05)
+                for p in patterns:
+                    if re.search(p, buf):
+                        return buf
+            return buf
+
+        try:
+            for _ in range(3):
+                ser.write(b"\r\n")
+                time.sleep(0.3)
+            buf = _read_until([r"login:", r"[$#]\s*"], 8.0)
+
+            if re.search(r"login:", buf):
+                time.sleep(0.2)
+                ser.write((self.username + "\r\n").encode())
+                buf = _read_until([r"[Pp]assword:", r"[$#]\s*"], 8.0)
+
+            if re.search(r"[Pp]assword:", buf):
+                time.sleep(0.2)
+                ser.write((self.password + "\r\n").encode())
+                buf = _read_until(
+                    [r"[$#]\s*", r"[Ll]ogin incorrect", r"[Aa]uthentication failure"], 10.0)
+
+            if not re.search(r"[$#]\s*", buf):
+                if re.search(r"[Ll]ogin incorrect|[Aa]uthentication failure", buf):
+                    return -1, "用户名或密码错误"
+                return -1, "登录失败，未检测到 shell 提示符"
+
+            time.sleep(0.2)
+            ser.write(b"export TERM=xterm-256color\r\n")
+            _read_until([r"[$#]\s*"], 3.0)
+            ser.write((cmd + "\r\n").encode())
+            result = _read_until([r"[$#]\s*"], float(timeout))
+
+            # 去掉 ANSI 转义码，提取命令输出
+            clean = re.sub(r"\x1B\[[0-?]*[ -/]*[@-~]", "", result)
+            clean = re.sub(r"\x1B[@-_]", "", clean)
+            # 去掉回显的命令行和最后的提示符
+            out_lines = []
+            skip_first = True
+            for line in clean.splitlines():
+                stripped = line.strip()
+                if skip_first and cmd.strip() in stripped:
+                    skip_first = False
+                    continue
+                if re.search(r"[$#]\s*$", stripped) and not stripped.replace("$", "").replace("#", "").strip():
+                    continue
+                if stripped:
+                    out_lines.append(stripped)
+                    if on_output:
+                        on_output(stripped)
+            return 0, "\n".join(out_lines)
+        except Exception as exc:
+            return -1, str(exc)
+        finally:
+            try:
+                ser.close()
+            except Exception:
+                pass
+
+
+# ── 全局活跃 Runner 单例 ────────────────────────────────────────────────────
+_active_runner: Optional[Runner] = None
+
+
+def get_runner() -> Runner:
+    """返回全局活跃 Runner（SSH 已连接则为 SSHRunner，否则为本地 Runner）。"""
+    return _active_runner if _active_runner is not None else Runner()
+
+
+def set_runner(runner: Optional[Runner]) -> None:
+    """切换全局 Runner。传 None 恢复本地模式。"""
+    global _active_runner
+    _active_runner = runner