sdev 0.2.2__tar.gz → 0.3.0__tar.gz

sdev-0.3.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: sdev
+Version: 0.3.0
+Summary: 串口控制器工具包
+Home-page: https://github.com/klrc/sdev
+Author: klrc
+Author-email: klrc <144069824@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/klrc/sdev
+Project-URL: Repository, https://github.com/klrc/sdev
+Project-URL: Bug Tracker, https://github.com/klrc/sdev/issues
+Keywords: serial,controller,hardware,embedded
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial>=3.5
+Requires-Dist: loguru>=0.6.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# SDEV
+
+串口开发板控制器：后台按行读缓冲、按 flag 扫描与回显着色、执行命令、存活检测。
+
+## 安装
+
+```bash
+pip install sdev
+```
+
+## 命令行
+
+安装后可使用 `sdev` 命令，在默认串口上执行单条命令并回显：
+
+```bash
+sdev shell "lsmod | grep -E 'mmz|nnp|vdsp'"
+sdev -p /dev/ttyUSB1 -b 115200 shell "ls"
+sdev --no-check-alive shell "echo hello"
+```
+
+- `-p` / `--port`：串口路径（默认取环境变量 `SDEV_PORT` 或 `/dev/ttyUSB0`）
+- `-b` / `--baudrate`：波特率（默认取 `SDEV_BAUDRATE` 或 `115200`）
+- `--flag`：提示符结束标志（默认 `" #"`）
+- `--timeout`：等待输出超时秒数
+- `--no-check-alive`：连接后不执行存活检测
+
+## 快速使用（Python）
+
+```python
+from sdev import SerialDevice
+
+with SerialDevice("/dev/ttyUSB0", 115200) as board:
+    # connect 时默认会 check_alive(STABLE_FLAG)，未接串口会轮询等待
+    out = board.execute_command("ls")  # 发命令并收到提示符为止，返回输出列表
+    print(out)
+```
+
+不自动做存活检测时：
+
+```python
+board = SerialDevice("/dev/ttyUSB0", 115200, check_alive=False)
+board.connect()
+board.wait_for_flag("~ #", timeout=20)  # 可选：等到指定提示符
+board.execute_command("ls")
+board.disconnect()
+```
+
+## 主要接口
+
+| 方法 / 属性 | 说明 |
+|-------------|------|
+| `SerialDevice.STABLE_FLAG` | 类常量 `" #"`，常用作稳定提示符 |
+| `connect()` / `disconnect()` | 打开/关闭串口并启停后台读线程；`connect` 可选执行 `check_alive(STABLE_FLAG)` |
+| `send(text)` | 发送一行（自动加换行）；`text` 不得含 `\n` / `\r` |
+| `execute_command(cmd, flag=" #", stream=False, timeout=None)` | 清缓冲 → 发 `cmd` → 先等命令回显再等含 `flag` 的提示行；返回列表或生成器；`cmd=Ctrl+C` 时兼容 ^C 回显 |
+| `check_alive(stable_flag)` | 有输出则 `wait_for_flag(stable_flag)` 后返回；否则发 Ctrl-C 再等；超时则打 warning 并轮询直到有输出 |
+| `wait_for_flag(flag, timeout)` | 消费输出直到出现 `flag` 或超时 |
+| `send_interrupt(timeout, end_flag=" #")` | 发 Ctrl-C 并等含 `end_flag` 的提示行；超时抛 `TimeoutError` |
+| `clear()` | 清空读缓冲（保留 sentinel），一般由 `execute_command` 内部调用 |
+
+- 回显：匹配到 flag 的行为绿色，命令回显行为青色，其余灰色；设备折行会拼行再判 flag。
+
+## 依赖
+
+- Python >= 3.7
+- pyserial >= 3.5
+- loguru >= 0.6.0

sdev-0.3.0/README.md

@@ -0,0 +1,67 @@
+# SDEV
+
+串口开发板控制器：后台按行读缓冲、按 flag 扫描与回显着色、执行命令、存活检测。
+
+## 安装
+
+```bash
+pip install sdev
+```
+
+## 命令行
+
+安装后可使用 `sdev` 命令，在默认串口上执行单条命令并回显：
+
+```bash
+sdev shell "lsmod | grep -E 'mmz|nnp|vdsp'"
+sdev -p /dev/ttyUSB1 -b 115200 shell "ls"
+sdev --no-check-alive shell "echo hello"
+```
+
+- `-p` / `--port`：串口路径（默认取环境变量 `SDEV_PORT` 或 `/dev/ttyUSB0`）
+- `-b` / `--baudrate`：波特率（默认取 `SDEV_BAUDRATE` 或 `115200`）
+- `--flag`：提示符结束标志（默认 `" #"`）
+- `--timeout`：等待输出超时秒数
+- `--no-check-alive`：连接后不执行存活检测
+
+## 快速使用（Python）
+
+```python
+from sdev import SerialDevice
+
+with SerialDevice("/dev/ttyUSB0", 115200) as board:
+    # connect 时默认会 check_alive(STABLE_FLAG)，未接串口会轮询等待
+    out = board.execute_command("ls")  # 发命令并收到提示符为止，返回输出列表
+    print(out)
+```
+
+不自动做存活检测时：
+
+```python
+board = SerialDevice("/dev/ttyUSB0", 115200, check_alive=False)
+board.connect()
+board.wait_for_flag("~ #", timeout=20)  # 可选：等到指定提示符
+board.execute_command("ls")
+board.disconnect()
+```
+
+## 主要接口
+
+| 方法 / 属性 | 说明 |
+|-------------|------|
+| `SerialDevice.STABLE_FLAG` | 类常量 `" #"`，常用作稳定提示符 |
+| `connect()` / `disconnect()` | 打开/关闭串口并启停后台读线程；`connect` 可选执行 `check_alive(STABLE_FLAG)` |
+| `send(text)` | 发送一行（自动加换行）；`text` 不得含 `\n` / `\r` |
+| `execute_command(cmd, flag=" #", stream=False, timeout=None)` | 清缓冲 → 发 `cmd` → 先等命令回显再等含 `flag` 的提示行；返回列表或生成器；`cmd=Ctrl+C` 时兼容 ^C 回显 |
+| `check_alive(stable_flag)` | 有输出则 `wait_for_flag(stable_flag)` 后返回；否则发 Ctrl-C 再等；超时则打 warning 并轮询直到有输出 |
+| `wait_for_flag(flag, timeout)` | 消费输出直到出现 `flag` 或超时 |
+| `send_interrupt(timeout, end_flag=" #")` | 发 Ctrl-C 并等含 `end_flag` 的提示行；超时抛 `TimeoutError` |
+| `clear()` | 清空读缓冲（保留 sentinel），一般由 `execute_command` 内部调用 |
+
+- 回显：匹配到 flag 的行为绿色，命令回显行为青色，其余灰色；设备折行会拼行再判 flag。
+
+## 依赖
+
+- Python >= 3.7
+- pyserial >= 3.5
+- loguru >= 0.6.0

{sdev-0.2.2 → sdev-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdev"
-version = "0.2.2"
+version = "0.3.0"
 description = "串口控制器工具包"
 readme = "README.md"
 license = {text = "MIT"}
@@ -32,6 +32,9 @@ dependencies = [
     "loguru>=0.6.0",
 ]
 
+[project.scripts]
+sdev = "sdev.cli_wrapper:main"
+
 [project.urls]
 Homepage = "https://github.com/klrc/sdev"
 Repository = "https://github.com/klrc/sdev"

{sdev-0.2.2 → sdev-0.3.0}/sdev/__init__.py

@@ -4,10 +4,10 @@ SDEV - 串口控制器工具包
 Demoboard：串口连接、后台异步读、发送、按行/按 flag 读、回显、组合命令、存活检测。
 """
 
-from .demoboard import Demoboard
+from .core import SerialDevice
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"
 __author__ = "klrc"
-__email__ = "144069824@qq.com"
+__email__ = "1440698245@qq.com"
 
-__all__ = ["Demoboard"]
+__all__ = ["SerialDevice"]

sdev-0.3.0/sdev/cli_wrapper.py

@@ -0,0 +1,81 @@
+"""
+命令行入口：sdev shell "cmd" 在串口设备上执行单条命令并回显输出。
+"""
+
+import argparse
+import os
+import sys
+
+from .core import SerialDevice
+
+
+def _get_default_port() -> str:
+    return os.environ.get("SDEV_PORT", "/dev/ttyUSB0")
+
+
+def _get_default_baudrate() -> int:
+    try:
+        return int(os.environ.get("SDEV_BAUDRATE", "115200"))
+    except ValueError:
+        return 115200
+
+
+def cmd_shell(args: argparse.Namespace) -> int:
+    port = args.port or _get_default_port()
+    baudrate = args.baudrate or _get_default_baudrate()
+    with SerialDevice(port, baudrate, check_alive=not args.no_check_alive) as board:
+        try:
+            board.execute_command(args.command, flag=args.flag, timeout=args.timeout)
+        except TimeoutError as e:
+            print(e, file=sys.stderr)
+            return 1
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        prog="sdev",
+        description="串口开发板控制器：在串口设备上执行命令或等待提示符。",
+    )
+    parser.add_argument(
+        "-p", "--port",
+        default=None,
+        help="串口路径（默认: SDEV_PORT 或 /dev/ttyUSB0）",
+    )
+    parser.add_argument(
+        "-b", "--baudrate",
+        type=int,
+        default=None,
+        help="波特率（默认: SDEV_BAUDRATE 或 115200）",
+    )
+    subparsers = parser.add_subparsers(dest="subcommand", required=True)
+
+    shell_parser = subparsers.add_parser("shell", help="在板子上执行单条命令并回显输出")
+    shell_parser.add_argument(
+        "command",
+        help="要执行的命令，如: ls 或 \"lsmod | grep nnp\"",
+    )
+    shell_parser.add_argument(
+        "--flag",
+        default=SerialDevice.STABLE_FLAG,
+        help="提示符结束标志（默认: %(default)r）",
+    )
+    shell_parser.add_argument(
+        "--timeout",
+        type=float,
+        default=None,
+        help="等待命令输出的超时秒数",
+    )
+    shell_parser.add_argument(
+        "--no-check-alive",
+        action="store_true",
+        help="connect 后不执行 check_alive",
+    )
+    shell_parser.set_defaults(func=cmd_shell)
+
+    parsed = parser.parse_args()
+    return parsed.func(parsed)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sdev-0.3.0/sdev/core.py

@@ -0,0 +1,249 @@
+"""
+串口设备：连接、后台按行读、发送、按 flag 扫描/回显、执行命令、存活检测。
+"""
+
+from itertools import chain
+import queue
+import threading
+import time
+from typing import Literal, Optional
+
+from loguru import logger
+import serial
+
+CTRL_C = "\x03"
+
+
+def _content_contains_ctrl_c(text: str) -> bool:
+    """是否包含设备回显的 Ctrl+C（\\x03 或 ^C、^C\\x00 等）。"""
+    n = text.replace("\x00", "")
+    return CTRL_C in n or "^C" in n
+
+
+def _line_matches_flag(line: str, flag: str) -> bool:
+    """行（rstrip 后）是否以 flag 结尾；CTRL_C 兼容 \\x03 / \"^C\" 等回显形式。"""
+    stripped = line.rstrip()
+    if flag != CTRL_C:
+        return stripped.endswith(flag)
+    normalized = stripped.strip().replace("\x00", "")
+    return normalized == CTRL_C or normalized == "^C" or normalized.endswith("^C") or stripped.endswith(flag)
+
+
+_GREY = "\033[90m"
+_SENT = "\033[36m"
+_GREEN = "\033[32m"
+_RESET = "\033[0m"
+
+
+class SerialDevice:
+    STABLE_FLAG = " #"
+
+    def __init__(self, port: str, baudrate: int = 115200, check_alive=True):
+        self.port = port
+        self.baudrate = baudrate
+        self._serial: Optional[serial.Serial] = None
+        self._buffer: queue.Queue = queue.Queue()
+        self._reader_thread: Optional[threading.Thread] = None
+        self._is_connected = False
+        self._stop_reading = False
+        self._display = True
+        self._check_alive = check_alive
+
+        self._reboot_timeout = 20  # check_alive 时 wait_for_flag 等稳定提示符的最大秒数
+        self._check_alive_timeout = 0.5
+        self._join_timeout = 2.0
+        self._scan_timeout = 0.1
+
+    def _serial_reader(self) -> None:
+        """后台 daemon：readline → UTF-8 解码 → put(line)；解码失败则跳过该行。disconnect 时 _stop_reading + put(None) 唤醒阻塞 get()。"""
+        while not self._stop_reading and self._serial is not None and self._serial.is_open:
+            raw = self._serial.readline()
+            if raw:
+                try:
+                    line = raw.decode("utf-8")
+                    if line:
+                        self._buffer.put(line)
+                except UnicodeDecodeError:
+                    continue
+
+    def connect(self):
+        """打开串口、启动 _serial_reader；已连接则直接 return。若 check_alive 则 connect 后自动 check_alive(STABLE_FLAG)。"""
+        if self._is_connected:
+            return
+        self._serial = serial.Serial(self.port, self.baudrate, timeout=self._scan_timeout)
+        if not self._serial.is_open:
+            raise RuntimeError(f"无法打开串口 {self.port}")
+        self._stop_reading = False
+        self._reader_thread = threading.Thread(target=self._serial_reader, daemon=True)
+        self._reader_thread.start()
+        self._is_connected = True
+
+        self._max_lines_per_prompt = 2
+
+        if self._check_alive:
+            self.check_alive(self.STABLE_FLAG)
+
+    def disconnect(self):
+        """置 _stop_reading、put(None) 唤醒 get()、join 读线程、关串口；幂等。"""
+        if not self._is_connected:
+            return
+        self._stop_reading = True
+        self._buffer.put(None)  # unblock any read() waiting on get()
+        if self._reader_thread is not None and self._reader_thread.is_alive():
+            self._reader_thread.join(timeout=self._join_timeout)
+        self._reader_thread = None
+        if self._serial is not None and self._serial.is_open:
+            self._serial.close()
+            self._serial = None
+        self._is_connected = False
+
+    def send(self, prompt: str):
+        """发送 prompt + 换行并 flush；prompt 不得含 \\n/\\r。"""
+        if not self._is_connected or self._serial is None:
+            raise RuntimeError("not connected")
+        assert "\n" not in prompt and "\r" not in prompt, "send(prompt) 不得包含换行符"
+        self._serial.write((prompt + "\n").encode("utf-8"))
+        self._serial.flush()
+
+    def _scan(self, timeout: Optional[float] = None):
+        """从 _buffer 逐行 yield；有 timeout 时每轮用 scan_timeout 轮询，总时长超时抛 TimeoutError；收到 None 结束。"""
+        if not self._is_connected:
+            raise RuntimeError("not connected")
+        deadline = (time.monotonic() + timeout) if timeout is not None else None
+        scan_timeout = self._scan_timeout if deadline is not None else None
+
+        while True:  # timeout loop
+            if deadline is not None and time.monotonic() > deadline:
+                raise TimeoutError("scan deadline exceeded")
+            try:
+                line = self._buffer.get(timeout=scan_timeout) if scan_timeout else self._buffer.get()
+            except queue.Empty:
+                continue
+            if line is None:  # _serial_reader sentinel
+                return
+            yield line
+
+    def _echo_prompt(self, line: str) -> None:
+        print(f"{_SENT}{line}{_RESET}", end="", flush=True)
+
+    def _echo_normal(self, line: str) -> None:
+        print(f"{_GREY}{line}{_RESET}", end="", flush=True)
+
+    def _echo_flag(self, line: str) -> None:
+        print(f"{_GREEN}{line}{_RESET}", end="", flush=True)
+
+    def scan(self, end_flag: str, timeout: Optional[float] = None, replace_with_acc=False):
+        """
+        从 _buffer 逐行 yield，直到出现 end_flag 或超时/None。
+        逻辑：用 acc_cache 保留最近几行，拼成 acc_line（无换行），避免设备折行把 flag 拆到两行导致 in 判不到；
+        命中时若 replace_with_acc 则 yield 整段 acc_line 加换行，否则逐行 yield cache 后 break。CTRL_C 按 _content_contains_ctrl_c 判。
+        """
+        acc_cache = []
+        for line in self._scan(timeout):
+            acc_cache.append(line)
+            if len(acc_cache) > self._max_lines_per_prompt:
+                yield acc_cache.pop(0)
+            acc_line = "".join([x.rstrip("\r\n") for x in acc_cache])
+            found = end_flag in acc_line or (end_flag == CTRL_C and _content_contains_ctrl_c(acc_line))
+            if found:
+                if replace_with_acc:
+                    yield acc_line + "\n"
+                else:
+                    for x in acc_cache:
+                        yield x
+                break
+
+    def scan_and_display(self, flag: str, flag_type: Literal["end_flag", "prompt"], timeout: Optional[float] = None, replace_with_acc=False):
+        """对 scan(flag) 的每一行按 flag_type 回显（end_flag 绿、prompt 青、其余灰）并 yield 该行；超时重抛。"""
+        try:
+            for line in self.scan(flag, timeout=timeout, replace_with_acc=replace_with_acc):
+                if self._display:
+                    find_flag = _line_matches_flag(line, flag)
+                    if find_flag:
+                        if flag_type == "end_flag":
+                            self._echo_flag(line)
+                        elif flag_type == "prompt":
+                            self._echo_prompt(line)
+                    else:
+                        self._echo_normal(line)
+                yield line
+        except TimeoutError:
+            t = f"{timeout}s" if timeout is not None else "None"
+            raise TimeoutError(f"scan_and_display timeout: flag={flag!r}, flag_type={flag_type!r}, timeout={t}")
+
+    def clear(self):
+        """清空 _buffer 中已入队行；取到 None 则 put(None) 后 return（保留 sentinel），用于 execute_command 前清残留。"""
+        while True:
+            try:
+                item = self._buffer.get_nowait()
+                if item is None:
+                    self._buffer.put(None)
+                    return
+            except queue.Empty:
+                return
+
+    def execute_command(
+        self,
+        cmd: str,
+        flag: str = " #",
+        stream: bool = False,
+        timeout: Optional[float] = None,
+    ):
+        """
+        执行单条命令并收集到「含 flag 的结束行」为止的输出。
+        逻辑：clear → send(cmd) → 两段 chain：先 scan(cmd) 跳过命令回显行，再 scan(flag) 收到提示符行；
+        cmd=CTRL_C 时第一段会按 ^C 回显形式识别。stream=False 返回 list，True 返回生成器；超时抛 TimeoutError。
+        """
+        self.clear()
+        self.send(cmd)
+        gen = chain(self.scan_and_display(cmd, "prompt", timeout=timeout, replace_with_acc=True), self.scan_and_display(flag, "end_flag", timeout=timeout))
+        if stream:
+            return gen
+        return list(gen)
+
+    def _has_output_in_buffer(self) -> bool:
+        """qsize() > 0 即视为有数据（多线程下为近似值）。"""
+        return self._buffer.qsize() > 0
+
+    def send_interrupt(self, timeout: float, end_flag: str = " #") -> None:
+        """发送 CTRL_C 后 execute_command(cmd=CTRL_C, flag=end_flag, timeout=timeout)；超时抛 TimeoutError。"""
+        self.execute_command(cmd=CTRL_C, flag=end_flag, timeout=timeout)
+
+    def wait_for_flag(self, flag: str, timeout: float):
+        """消费 scan_and_display(flag, \"end_flag\", timeout)，直到出现 flag 或超时。"""
+        gen = self.scan_and_display(flag, "end_flag", timeout=timeout)
+        _ = list(gen)
+
+    def check_alive(self, stable_flag: str):
+        """
+        确认板子存活：有输出则 wait_for_flag(stable_flag) 后 return；否则 send_interrupt，成功则 return。
+        若 send_interrupt 超时则打 warning 并轮询 _has_output_in_buffer()，有数据再 wait_for_flag 后 return；未接串口会一直循环。
+        """
+        time.sleep(self._check_alive_timeout)
+        if self._has_output_in_buffer():  # 可能正在启动，等待稳定标志
+            self.wait_for_flag(stable_flag, self._reboot_timeout)
+            return
+
+        # 测试是否能够接收ctrlc信号，若无反应, wait for boot
+        try:
+            self.send_interrupt(self._check_alive_timeout, stable_flag)
+        except TimeoutError:
+            logger.warning(f"请接入串口")
+            while True:
+                time.sleep(self._check_alive_timeout)
+                if self._has_output_in_buffer():
+                    self.wait_for_flag(stable_flag, self._reboot_timeout)
+                    return
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.disconnect()
+        print()
+
+
+if __name__ == "__main__":
+    with SerialDevice("/dev/ttyUSB0", 115200) as board:
+        board.execute_command("ls")

sdev-0.3.0/sdev.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: sdev
+Version: 0.3.0
+Summary: 串口控制器工具包
+Home-page: https://github.com/klrc/sdev
+Author: klrc
+Author-email: klrc <144069824@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/klrc/sdev
+Project-URL: Repository, https://github.com/klrc/sdev
+Project-URL: Bug Tracker, https://github.com/klrc/sdev/issues
+Keywords: serial,controller,hardware,embedded
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial>=3.5
+Requires-Dist: loguru>=0.6.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# SDEV
+
+串口开发板控制器：后台按行读缓冲、按 flag 扫描与回显着色、执行命令、存活检测。
+
+## 安装
+
+```bash
+pip install sdev
+```
+
+## 命令行
+
+安装后可使用 `sdev` 命令，在默认串口上执行单条命令并回显：
+
+```bash
+sdev shell "lsmod | grep -E 'mmz|nnp|vdsp'"
+sdev -p /dev/ttyUSB1 -b 115200 shell "ls"
+sdev --no-check-alive shell "echo hello"
+```
+
+- `-p` / `--port`：串口路径（默认取环境变量 `SDEV_PORT` 或 `/dev/ttyUSB0`）
+- `-b` / `--baudrate`：波特率（默认取 `SDEV_BAUDRATE` 或 `115200`）
+- `--flag`：提示符结束标志（默认 `" #"`）
+- `--timeout`：等待输出超时秒数
+- `--no-check-alive`：连接后不执行存活检测
+
+## 快速使用（Python）
+
+```python
+from sdev import SerialDevice
+
+with SerialDevice("/dev/ttyUSB0", 115200) as board:
+    # connect 时默认会 check_alive(STABLE_FLAG)，未接串口会轮询等待
+    out = board.execute_command("ls")  # 发命令并收到提示符为止，返回输出列表
+    print(out)
+```
+
+不自动做存活检测时：
+
+```python
+board = SerialDevice("/dev/ttyUSB0", 115200, check_alive=False)
+board.connect()
+board.wait_for_flag("~ #", timeout=20)  # 可选：等到指定提示符
+board.execute_command("ls")
+board.disconnect()
+```
+
+## 主要接口
+
+| 方法 / 属性 | 说明 |
+|-------------|------|
+| `SerialDevice.STABLE_FLAG` | 类常量 `" #"`，常用作稳定提示符 |
+| `connect()` / `disconnect()` | 打开/关闭串口并启停后台读线程；`connect` 可选执行 `check_alive(STABLE_FLAG)` |
+| `send(text)` | 发送一行（自动加换行）；`text` 不得含 `\n` / `\r` |
+| `execute_command(cmd, flag=" #", stream=False, timeout=None)` | 清缓冲 → 发 `cmd` → 先等命令回显再等含 `flag` 的提示行；返回列表或生成器；`cmd=Ctrl+C` 时兼容 ^C 回显 |
+| `check_alive(stable_flag)` | 有输出则 `wait_for_flag(stable_flag)` 后返回；否则发 Ctrl-C 再等；超时则打 warning 并轮询直到有输出 |
+| `wait_for_flag(flag, timeout)` | 消费输出直到出现 `flag` 或超时 |
+| `send_interrupt(timeout, end_flag=" #")` | 发 Ctrl-C 并等含 `end_flag` 的提示行；超时抛 `TimeoutError` |
+| `clear()` | 清空读缓冲（保留 sentinel），一般由 `execute_command` 内部调用 |
+
+- 回显：匹配到 flag 的行为绿色，命令回显行为青色，其余灰色；设备折行会拼行再判 flag。
+
+## 依赖
+
+- Python >= 3.7
+- pyserial >= 3.5
+- loguru >= 0.6.0

{sdev-0.2.2 → sdev-0.3.0}/sdev.egg-info/SOURCES.txt

@@ -4,9 +4,11 @@ README.md
 pyproject.toml
 setup.py
 sdev/__init__.py
-sdev/demoboard.py
+sdev/cli_wrapper.py
+sdev/core.py
 sdev.egg-info/PKG-INFO
 sdev.egg-info/SOURCES.txt
 sdev.egg-info/dependency_links.txt
+sdev.egg-info/entry_points.txt
 sdev.egg-info/requires.txt
 sdev.egg-info/top_level.txt

sdev-0.3.0/sdev.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sdev = sdev.cli_wrapper:main

{sdev-0.2.2 → sdev-0.3.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="sdev",
-    version="0.2.2",
+    version="0.3.0",
     author="klrc",
     author_email="144069824@qq.com",
     description="串口控制器工具包",
@@ -30,5 +30,9 @@ setup(
     python_requires=">=3.7",
     install_requires=[
         "pyserial>=3.5",
+        "loguru>=0.6.0",
     ],
+    entry_points={
+        "console_scripts": ["sdev=sdev.cli_wrapper:main"],
+    },
 ) 

sdev-0.2.2/PKG-INFO

@@ -1,77 +0,0 @@
-Metadata-Version: 2.4
-Name: sdev
-Version: 0.2.2
-Summary: 串口控制器工具包
-Home-page: https://github.com/klrc/sdev
-Author: klrc
-Author-email: klrc <144069824@qq.com>
-License: MIT
-Project-URL: Homepage, https://github.com/klrc/sdev
-Project-URL: Repository, https://github.com/klrc/sdev
-Project-URL: Bug Tracker, https://github.com/klrc/sdev/issues
-Keywords: serial,controller,hardware,embedded
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Hardware
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyserial>=3.5
-Requires-Dist: loguru>=0.6.0
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# SDEV
-
-串口开发板控制器工具包：后台异步读缓冲、按行/按 flag 读、回显着色、组合命令、存活检测。
-
-## 安装
-
-```bash
-pip install sdev
-```
-
-## 快速使用
-
-```python
-from sdev import Demoboard
-
-with Demoboard("/dev/ttyUSB0", 115200) as board:
-    board.check_alive("~ #")           # 确认板子存活（未接则轮询等待）
-    out = board.execute_command("ls")  # 发命令并收到提示符为止，返回输出列表
-    print(out)
-```
-
-## 主要接口
-
-| 方法 | 说明 |
-|------|------|
-| `connect()` / `disconnect()` | 打开/关闭串口并启停后台读线程 |
-| `send(text)` | 发送一行（自动加换行）；`text` 不得含换行符 |
-| `read(display=..., timeout=...)` | 消费缓冲直至断开或超时，返回行列表 |
-| `read_until(flag, timeout=..., skip_echo_of=...)` | 读到含 `flag` 且非「命令回显」的行为止 |
-| `execute_command(cmd, flag=" #", stream=False, ...)` | 先 `clear()` 再 `send(cmd)` 再 `read_until(flag, skip_echo_of=cmd)` |
-| `check_alive(reboot_flag=..., prompt_flag=" #", ...)` | 有缓冲数据或能响应 Ctrl-C 即视为存活；超时则轮询等待 |
-| `clear()` | 清空读缓冲（保留 disconnect 用 sentinel） |
-| `send_interrupt(prompt_flag=..., timeout=...)` | 发 Ctrl-C 并等到含 `prompt_flag` 的提示行 |
-
-- 使用 `stream_read` / `stream_read_until` 可逐行迭代；`read` / `read_until` 为列表版。
-- `display=True` 时：本机发送回显为青色，匹配 flag 行为绿色，其余为灰色；板端折行会拼成一行再显示。
-
-## 特性
-
-- 后台线程读串口入队，主流程不阻塞
-- 不假定提示符左边格式（如 `~ #` / ` #` 均可），通过 `skip_echo_of` 区分命令回显与提示行
-- 超时在底层 `get(timeout=...)` 实现，可靠
-- 依赖：Python >= 3.7，pyserial >= 3.5，loguru >= 0.6.0

sdev-0.2.2/README.md

@@ -1,43 +0,0 @@
-# SDEV
-
-串口开发板控制器工具包：后台异步读缓冲、按行/按 flag 读、回显着色、组合命令、存活检测。
-
-## 安装
-
-```bash
-pip install sdev
-```
-
-## 快速使用
-
-```python
-from sdev import Demoboard
-
-with Demoboard("/dev/ttyUSB0", 115200) as board:
-    board.check_alive("~ #")           # 确认板子存活（未接则轮询等待）
-    out = board.execute_command("ls")  # 发命令并收到提示符为止，返回输出列表
-    print(out)
-```
-
-## 主要接口
-
-| 方法 | 说明 |
-|------|------|
-| `connect()` / `disconnect()` | 打开/关闭串口并启停后台读线程 |
-| `send(text)` | 发送一行（自动加换行）；`text` 不得含换行符 |
-| `read(display=..., timeout=...)` | 消费缓冲直至断开或超时，返回行列表 |
-| `read_until(flag, timeout=..., skip_echo_of=...)` | 读到含 `flag` 且非「命令回显」的行为止 |
-| `execute_command(cmd, flag=" #", stream=False, ...)` | 先 `clear()` 再 `send(cmd)` 再 `read_until(flag, skip_echo_of=cmd)` |
-| `check_alive(reboot_flag=..., prompt_flag=" #", ...)` | 有缓冲数据或能响应 Ctrl-C 即视为存活；超时则轮询等待 |
-| `clear()` | 清空读缓冲（保留 disconnect 用 sentinel） |
-| `send_interrupt(prompt_flag=..., timeout=...)` | 发 Ctrl-C 并等到含 `prompt_flag` 的提示行 |
-
-- 使用 `stream_read` / `stream_read_until` 可逐行迭代；`read` / `read_until` 为列表版。
-- `display=True` 时：本机发送回显为青色，匹配 flag 行为绿色，其余为灰色；板端折行会拼成一行再显示。
-
-## 特性
-
-- 后台线程读串口入队，主流程不阻塞
-- 不假定提示符左边格式（如 `~ #` / ` #` 均可），通过 `skip_echo_of` 区分命令回显与提示行
-- 超时在底层 `get(timeout=...)` 实现，可靠
-- 依赖：Python >= 3.7，pyserial >= 3.5，loguru >= 0.6.0

sdev-0.2.2/sdev/demoboard.py

@@ -1,382 +0,0 @@
-"""
-Demoboard: 串口连接、后台异步读、发送、按行/按 flag 读、回显、组合命令、存活检测。
-不兼容旧 SerialController/Demoboard 实现。
-"""
-
-import queue
-import sys
-import threading
-import time
-from typing import Generator, List, Optional, Union
-
-from loguru import logger
-import serial
-
-CTRL_C = "\x03"
-
-# ANSI（发送回显用青色，比紫色柔和、与绿色区分明显）
-_GREY = "\033[90m"
-_SENT = "\033[36m"  # cyan 青色，护眼
-_GREEN = "\033[32m"
-_RESET = "\033[0m"
-
-
-def _echo_grey(line: str) -> None:
-    """普通设备输出：整行灰色打印。flush 保证与串口交错时顺序正确。"""
-    print(f"{_GREY}{line}{_RESET}", end="", flush=True)
-
-
-def _echo_sent(line: str) -> None:
-    """本机发送内容的回显：整行青色（含 CTRL_C 显示为 ^C 的行）。"""
-    print(f"{_SENT}{line}{_RESET}", end="", flush=True)
-
-
-def _echo_green(line: str) -> None:
-    """read_until 匹配到 flag 的那一行：整行绿色（如提示符行）。"""
-    print(f"{_GREEN}{line}{_RESET}", end="", flush=True)
-
-
-class Demoboard:
-    """
-    串口开发板控制器：连接、后台异步读缓冲、发送、按行/按 flag 读、回显、组合命令、存活检测。
-
-    构造后需显式 connect()，或使用 with Demoboard(port) as board。
-    """
-
-    def __init__(self, port: str, baudrate: int = 115200) -> None:
-        """
-        只保存端口和波特率，不打开串口、不启动读线程。
-
-        - 连接需显式调用 connect() 或使用 with。
-        - 未 connect 前调用 send/read 会抛 RuntimeError。
-        """
-        self.port = port
-        self.baudrate = baudrate
-        self._serial: Optional[serial.Serial] = None
-        self._buffer: queue.Queue = queue.Queue()
-        self._reader_thread: Optional[threading.Thread] = None
-        self._stop_reading = False
-        self._connected = False
-        self._pending_sent: Optional[str] = None  # 仅作标记，在 read 中匹配到时用 _echo_sent 打印一次
-        self._pending_flag: Optional[str] = None  # 仅作标记，在 read 中匹配到时整行绿色打印一次
-
-    def _serial_reader(self) -> None:
-        """
-        后台线程：从串口按行读入并放入 _buffer。
-
-        行为：
-            - 循环 readline()，UTF-8 解码并 strip，非空则 put(line)。
-            - 解码失败则跳过该行；OSError/SerialException 则退出循环。
-
-        原理：及时消费串口，避免缓冲满丢数，且不阻塞主流程。
-        注意：daemon 线程；disconnect 时通过 _stop_reading 与 put(None) 结束并唤醒阻塞的 get()。
-        """
-        while not self._stop_reading and self._serial is not None and self._serial.is_open:
-            try:
-                raw = self._serial.readline()
-                if raw:
-                    try:
-                        line = raw.decode("utf-8")
-                        if line:
-                            self._buffer.put(line)
-                    except UnicodeDecodeError:
-                        continue
-            except (OSError, serial.SerialException):
-                break
-            except Exception:
-                continue
-
-    def _has_output_in_buffer(self) -> bool:
-        """
-        队列里是否已有数据（qsize > 0 即视为有）。
-
-        用于 check_alive：有任意输出就认为设备存活，不依赖提示符格式。
-        注意：多线程下 qsize() 为近似值，用于布尔判断足够。
-        """
-        return self._buffer.qsize() > 0
-
-    def _is_echo_of(self, line: str, sent: str) -> bool:
-        """
-        判断该行是否为「刚发送内容」的回显。
-
-        行为：
-            - line 等于 sent，或以 " " + sent 结尾 → 视为回显。
-            - sent 为 CTRL_C 时，设备常显示 "^C"，也视为回显。
-
-        用于 read_until(..., skip_echo_of=...)：区分命令回显行（如 "~ # ls"）和纯提示符行（如 "~ #"），
-        不假定提示符左边格式。仅做字符串匹配，sent 为普通命令或 CTRL_C 即可。
-        """
-        s = line.rstrip()
-        if s == sent or s.endswith(" " + sent):
-            return True
-        if sent == CTRL_C and (s.strip() == "^C" or "^C" in line or CTRL_C in line):
-            return True
-        return False
-
-    @property
-    def is_connected(self) -> bool:
-        """是否已连接（串口已打开且读线程已启动）。"""
-        return self._connected
-
-    def connect(self) -> None:
-        """
-        打开串口并启动后台读线程，后续数据写入 _buffer。
-
-        行为：创建 Serial(port, baudrate, timeout=0.1)，启动 _serial_reader，置 _connected=True。
-        已连接则直接 return（幂等）。
-        注意：串口打开失败只打 error 日志并 return，不抛异常；调用方用 is_connected 判断。
-        """
-        if self._connected:
-            return
-        self._serial = serial.Serial(self.port, self.baudrate, timeout=0.1)
-        if not self._serial.is_open:
-            logger.error(f"无法打开串口 {self.port}")
-            return
-        self._stop_reading = False
-        self._reader_thread = threading.Thread(target=self._serial_reader, daemon=True)
-        self._reader_thread.start()
-        self._connected = True
-
-    def disconnect(self) -> None:
-        """
-        停止读线程并关闭串口，幂等。
-
-        行为：置 _stop_reading，put(None) 唤醒阻塞的 get()，join 读线程，关闭串口。
-        None 为 sentinel，stream_read 收到后结束迭代。未连接则直接 return。
-        注意：join 最多等 2s，超时后仍会关串口，不抛异常。
-        """
-        if not self._connected:
-            return
-        self._stop_reading = True
-        self._buffer.put(None)  # unblock any read() waiting on get()
-        if self._reader_thread is not None and self._reader_thread.is_alive():
-            self._reader_thread.join(timeout=2.0)
-        self._reader_thread = None
-        if self._serial is not None and self._serial.is_open:
-            self._serial.close()
-            self._serial = None
-        self._connected = False
-
-    def send(self, text: str) -> None:
-        """
-        向串口发送 text + 换行，不等待回显。
-
-        行为：写入 (text + "\\n") 并 flush，同时设 _pending_sent = text。
-        回显在 stream_read 里在匹配到 sent 前扣押多行、去换行拼接，匹配后整行青色打印。
-        未连接抛 RuntimeError；text 不得含换行符（便于与板端折行回显拼接匹配）。
-        """
-        if not self._connected or self._serial is None:
-            raise RuntimeError("not connected")
-        assert "\n" not in text and "\r" not in text, "send(text) 不得包含换行符"
-        self._serial.write((text + "\n").encode("utf-8"))
-        self._serial.flush()
-        self._pending_sent = text
-
-    def _sent_echo_matches(self, acc: str, sent: str) -> bool:
-        """拼接后的 acc 行尾是否匹配本次发送内容（用于板端折行回显）。"""
-        if not acc:
-            return False
-        s = acc.rstrip()
-        if s == sent or s.endswith(" " + sent):
-            return True
-        if sent == CTRL_C and (s.strip() == "^C" or "^C" in acc or CTRL_C in acc):
-            return True
-        return False
-
-    def stream_read(self, display: bool = True, timeout: Optional[float] = None) -> Generator[str, None, None]:
-        """
-        从 _buffer 逐行 yield，直到 disconnect 或超时。
-
-        行为：
-            - 收到 None 则结束迭代。
-            - display 且 _pending_sent 不为 None 时：持续 get 并扣押，去换行拼接为 acc，直到 acc 行尾匹配 sent，再整行青色打印并 yield 已扣押的每一行；保证 send 的输入完整显示为一行（板端折行也会被拼回）。
-            - 其余行：按 flag/sent 匹配做绿/青/灰单行显示。
-        """
-        if not self._connected:
-            raise RuntimeError("not connected")
-        deadline = (time.monotonic() + timeout) if timeout is not None else None
-        get_timeout = 0.1 if deadline is not None else None
-        while True:
-            if deadline is not None and time.monotonic() > deadline:
-                raise TimeoutError("read deadline exceeded")
-            if display and self._pending_sent is not None:
-                acc = ""
-                lines_buf: List[str] = []
-                while True:
-                    try:
-                        line = self._buffer.get(timeout=get_timeout) if get_timeout else self._buffer.get()
-                    except queue.Empty:
-                        continue
-                    if line is None:
-                        if lines_buf:
-                            _echo_grey(acc + "\n")
-                            for L in lines_buf:
-                                yield L
-                        self._buffer.put(None)
-                        return
-                    lines_buf.append(line)
-                    acc += line.rstrip("\r\n")
-                    if self._sent_echo_matches(acc, self._pending_sent):
-                        self._pending_sent = None
-                        _echo_sent(acc + "\n")
-                        for L in lines_buf:
-                            yield L
-                        break
-                continue
-            try:
-                line = self._buffer.get(timeout=get_timeout) if get_timeout else self._buffer.get()
-            except queue.Empty:
-                continue
-            if line is None:
-                return
-            if display:
-                flag_ok = self._pending_flag is not None and self._pending_flag in line
-                if flag_ok:
-                    self._pending_flag = None
-                    _echo_green(line)
-                else:
-                    _echo_grey(line)
-            yield line
-
-    def stream_read_until(
-        self,
-        flag: str,
-        timeout: Optional[float] = None,
-        display: bool = True,
-        skip_echo_of: Optional[str] = None,
-    ) -> Generator[str, None, None]:
-        """
-        从 _buffer 逐行 yield，直到某行「包含 flag 且不是 skip_echo_of 的回显」则结束（该行会 yield）。
-
-        行为：
-            - 设 _pending_flag=flag，迭代 stream_read。
-            - 若行含 flag：当 skip_echo_of 不为 None 且该行是「刚发送内容的回显」则继续读（跳过 "~ # ls" 这类）；否则 return。
-
-        与旧 SerialController 一致，不假定提示符左边格式；flag 如 " #"、"~ #" 通用。
-        skip_echo_of=None 时等价于「包含 flag 即停」。超时抛带 flag/timeout 信息的 TimeoutError。
-        """
-        self._pending_flag = flag
-        try:
-            for line in self.stream_read(display=display, timeout=timeout):
-                yield line
-                if flag not in line:
-                    continue
-                if skip_echo_of is not None and self._is_echo_of(line, skip_echo_of):
-                    continue
-                return
-        except TimeoutError:
-            raise TimeoutError(f"read_until timeout: flag={flag!r}, timeout={timeout}s") from None
-        finally:
-            self._pending_flag = None
-
-    def read(self, display: bool = True, timeout: Optional[float] = None) -> List[str]:
-        """把 stream_read 全部消费成列表返回。超时抛 TimeoutError。"""
-        return list(self.stream_read(display, timeout))
-
-    def read_until(
-        self,
-        flag: str,
-        timeout: Optional[float] = None,
-        display: bool = True,
-        skip_echo_of: Optional[str] = None,
-    ) -> List[str]:
-        """把 stream_read_until 全部消费成列表返回（含结束行）。超时抛 TimeoutError。"""
-        return list(self.stream_read_until(flag, timeout, display, skip_echo_of))
-
-    def clear(self) -> None:
-        """
-        清空 _buffer 里已入队的行，不丢弃 sentinel（None）。
-
-        行为：循环 get_nowait()，取到 None 则 put(None) 后 return，否则丢弃；队列空则 return。
-        用于 execute_command 前清残留（与旧 SerialController 的 clear_queue 一致），避免上次提示符干扰本次匹配。
-        注意：取到 None 必须放回，否则 stream_read 无法正常结束。
-        """
-        while True:
-            try:
-                item = self._buffer.get_nowait()
-                if item is None:
-                    self._buffer.put(None)
-                    return
-            except queue.Empty:
-                return
-
-    def send_interrupt(self, prompt_flag: str = " #", timeout: float = 0.5) -> None:
-        """
-        发送 CTRL_C，并等待出现含 prompt_flag 的提示行（跳过 ^C 回显行）。
-
-        内部：send(CTRL_C) 后 read_until(prompt_flag, timeout, display=True, skip_echo_of=CTRL_C)。
-        超时抛 TimeoutError，由 check_alive 等调用方处理。
-        """
-        self.send(CTRL_C)
-        self.read_until(prompt_flag, timeout=timeout, display=True, skip_echo_of=CTRL_C)
-
-    def check_alive(
-        self,
-        reboot_flag: Optional[str] = None,
-        prompt_flag: str = " #",
-        timeout: float = 0.5,
-    ) -> None:
-        """
-        确认开发板存活；能正常返回即表示 alive。
-        内容：若 _has_output_in_buffer() 为真则视为已有输出（如已进 shell），可选 read_until(reboot_flag) 吃到启动信息后 return；否则 send_interrupt(prompt_flag, timeout)，成功则 return。若 send_interrupt 超时则打 warning，然后死循环：每隔 timeout 秒检查 _has_output_in_buffer()，有则可选 read_until(reboot_flag) 后 return。
-        原理：不依赖「正在输出」，只依赖「队列里曾有过数据」或「能响应 Ctrl-C 并回到 prompt」；重启上电后无输出则等 prompt，未接串口则一直轮询直到有输出。
-        边界：reboot_flag 用于上电后等待特定行（如 "~ #"）；未接串口时会永久循环并周期性 warning。
-        """
-        # wait for boot
-        time.sleep(timeout)
-        if self._has_output_in_buffer():
-            if reboot_flag is not None:
-                self.read_until(reboot_flag, display=True)
-            return
-
-        # 测试是否能够接收ctrlc信号，若无反应, wait for boot
-        try:
-            self.send_interrupt(prompt_flag, timeout)
-        except TimeoutError:
-            logger.warning(f"请接入串口")
-            while True:
-                time.sleep(timeout)
-                if self._has_output_in_buffer():
-                    if reboot_flag is not None:
-                        self.read_until(reboot_flag, display=True)
-                    return
-
-    def execute_command(
-        self,
-        cmd: str,
-        flag: str = " #",
-        stream: bool = False,
-        timeout: Optional[float] = None,
-        display: bool = True,
-    ) -> Union[List[str], Generator[str, None, None]]:
-        """
-        执行单条命令，并收集到「含 flag 的结束行」为止的输出。
-
-        行为：先 clear()，再 send(cmd)，再 stream_read_until(flag, ..., skip_echo_of=cmd)。
-        stream=False 返回整段输出的列表；stream=True 返回生成器。
-
-        与旧 SerialController 一致：clear 避免残留；skip_echo_of=cmd 让命令回显行（如 "~ # ls"）不当作结束，
-        只在真正的新提示符行结束，不假定提示符左边格式。超时抛 TimeoutError；cmd 为 CTRL_C 时也会跳过 "^C" 行。
-        """
-        self.clear()
-        self.send(cmd)
-        gen = self.stream_read_until(flag, timeout=timeout, display=display, skip_echo_of=cmd)
-        if stream:
-            return gen
-        return list(gen)
-
-    def __enter__(self) -> "Demoboard":
-        """with 入口：connect() 并返回 self。"""
-        self.connect()
-        return self
-
-    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
-        """with 出口：disconnect()；异常不吞，继续向外抛。"""
-        self.disconnect()
-        print()  # 强制换行以刷新可能的日志末尾
-
-
-if __name__ == "__main__":
-    with Demoboard("/dev/ttyUSB0", 115200) as board:
-        board.check_alive("~ #")
-        board.execute_command("ls")

sdev-0.2.2/sdev.egg-info/PKG-INFO

@@ -1,77 +0,0 @@
-Metadata-Version: 2.4
-Name: sdev
-Version: 0.2.2
-Summary: 串口控制器工具包
-Home-page: https://github.com/klrc/sdev
-Author: klrc
-Author-email: klrc <144069824@qq.com>
-License: MIT
-Project-URL: Homepage, https://github.com/klrc/sdev
-Project-URL: Repository, https://github.com/klrc/sdev
-Project-URL: Bug Tracker, https://github.com/klrc/sdev/issues
-Keywords: serial,controller,hardware,embedded
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Hardware
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyserial>=3.5
-Requires-Dist: loguru>=0.6.0
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# SDEV
-
-串口开发板控制器工具包：后台异步读缓冲、按行/按 flag 读、回显着色、组合命令、存活检测。
-
-## 安装
-
-```bash
-pip install sdev
-```
-
-## 快速使用
-
-```python
-from sdev import Demoboard
-
-with Demoboard("/dev/ttyUSB0", 115200) as board:
-    board.check_alive("~ #")           # 确认板子存活（未接则轮询等待）
-    out = board.execute_command("ls")  # 发命令并收到提示符为止，返回输出列表
-    print(out)
-```
-
-## 主要接口
-
-| 方法 | 说明 |
-|------|------|
-| `connect()` / `disconnect()` | 打开/关闭串口并启停后台读线程 |
-| `send(text)` | 发送一行（自动加换行）；`text` 不得含换行符 |
-| `read(display=..., timeout=...)` | 消费缓冲直至断开或超时，返回行列表 |
-| `read_until(flag, timeout=..., skip_echo_of=...)` | 读到含 `flag` 且非「命令回显」的行为止 |
-| `execute_command(cmd, flag=" #", stream=False, ...)` | 先 `clear()` 再 `send(cmd)` 再 `read_until(flag, skip_echo_of=cmd)` |
-| `check_alive(reboot_flag=..., prompt_flag=" #", ...)` | 有缓冲数据或能响应 Ctrl-C 即视为存活；超时则轮询等待 |
-| `clear()` | 清空读缓冲（保留 disconnect 用 sentinel） |
-| `send_interrupt(prompt_flag=..., timeout=...)` | 发 Ctrl-C 并等到含 `prompt_flag` 的提示行 |
-
-- 使用 `stream_read` / `stream_read_until` 可逐行迭代；`read` / `read_until` 为列表版。
-- `display=True` 时：本机发送回显为青色，匹配 flag 行为绿色，其余为灰色；板端折行会拼成一行再显示。
-
-## 特性
-
-- 后台线程读串口入队，主流程不阻塞
-- 不假定提示符左边格式（如 `~ #` / ` #` 均可），通过 `skip_echo_of` 区分命令回显与提示行
-- 超时在底层 `get(timeout=...)` 实现，可靠
-- 依赖：Python >= 3.7，pyserial >= 3.5，loguru >= 0.6.0