sdev 0.7.10__tar.gz → 0.7.12__tar.gz

{sdev-0.7.10/sdev.egg-info → sdev-0.7.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdev
-Version: 0.7.10
+Version: 0.7.12
 Summary: 串口控制器工具包
 Home-page: https://github.com/klrc/sdev
 Author: klrc

{sdev-0.7.10 → sdev-0.7.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdev"
-version = "0.7.10"
+version = "0.7.12"
 description = "串口控制器工具包"
 readme = "README.md"
 license = {text = "MIT"}

{sdev-0.7.10 → sdev-0.7.12}/sdev/cli/__init__.py

@@ -9,6 +9,8 @@ sdev CLI 入口：
 """
 
 import argparse
+import contextlib
+import fcntl
 import hashlib
 import itertools
 import json
@@ -43,6 +45,21 @@ def _sdev_cache_dir() -> str:
     return d
 
 
+@contextlib.contextmanager
+def _list_global_lock():
+    """
+    sdev list 进程级全局锁。
+    本工具不支持并发 list；这里用阻塞锁串行化，避免并发扫描互相干扰。
+    """
+    lock_path = os.path.join(_sdev_cache_dir(), "list.lock")
+    with open(lock_path, "w", encoding="utf-8") as f:
+        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+
 def _run_parallel_with_spinners(specs: List[Tuple[str, Any]]) -> List[Any]:
     """
     多行并行 spinner：
@@ -243,7 +260,7 @@ def _build_parser() -> argparse.ArgumentParser:
     list_p.add_argument(
         "scope_or_filter",
         nargs="?",
-        help="local=仅本地, remote=仅远程, 或第一个筛选条件（如 type=xc01）",
+        help="默认仅本地扫描；可显式传 local/remote，或直接给第一个筛选条件（如 type=xc01）",
     )
     list_p.add_argument(
         "-f",
@@ -453,187 +470,192 @@ def _ts() -> str:
 
 
 def _handle_list(args: argparse.Namespace) -> int:
-    extra_filters = list(getattr(args, "filters", None) or [])
-    scope_or_filter = getattr(args, "scope_or_filter", None)
-
-    scope: Optional[str]
-    initial_filter_parts: list[str] = []
-    if scope_or_filter in (None, "local", "remote"):
-        scope = scope_or_filter
-    else:
-        scope = None
-        initial_filter_parts.append(scope_or_filter)
-
-    filters = _parse_list_filters(initial_filter_parts + extra_filters)
-    fast = getattr(args, "fast", False)
-    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    scan_local = scope != "remote"
-    scan_remote = scope != "local"
-
-    # 本地与远程扫描分别封装为任务，由 spinner 展示进度。
-    def _scan_local_task(ports: List[str]) -> List[Dict[str, Any]]:
-        entries: List[Dict[str, Any]] = []
-        if not ports:
-            return entries
-
-        def _check_one(port: str) -> Tuple[str, Dict[str, Any]]:
-            r = check_port_alive_nonblock(port, baudrate=115200, timeout=1.5)
-            return (port, r)
-
-        alive_ports: List[str] = []
-        results: List[Tuple[str, Dict[str, Any]]] = []
-        fast_exit = False
-        ex = ThreadPoolExecutor(max_workers=max(len(ports), 1))
-        try:
-            futs = {ex.submit(_check_one, p): p for p in ports}
-            if fast:
-                for fut in as_completed(futs):
-                    port, r = fut.result()
-                    results.append((port, r))
-                    if r.get("available"):
-                        fast_exit = True
-                        alive_ports = [port]
-                        break
-            else:
-                for fut in as_completed(futs):
-                    results.append(fut.result())
-                results.sort(key=lambda x: x[0])
-                for port, r in results:
-                    if r.get("available"):
-                        alive_ports.append(port)
-        finally:
-            ex.shutdown(wait=not fast_exit)
-
-        def _model_one(port: str) -> Tuple[str, str]:
+    with _list_global_lock():
+        extra_filters = list(getattr(args, "filters", None) or [])
+        scope_or_filter = getattr(args, "scope_or_filter", None)
+
+        scope: Optional[str]
+        initial_filter_parts: list[str] = []
+        if scope_or_filter in ("local", "remote"):
+            scope = scope_or_filter
+        elif scope_or_filter is None:
+            # 默认不访问网络，仅扫描本地串口设备。
+            scope = "local"
+        else:
+            # 传入筛选条件时，依然沿用默认仅本地扫描。
+            scope = "local"
+            initial_filter_parts.append(scope_or_filter)
+
+        filters = _parse_list_filters(initial_filter_parts + extra_filters)
+        fast = getattr(args, "fast", False)
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        scan_local = scope != "remote"
+        scan_remote = scope != "local"
+
+        # 本地与远程扫描分别封装为任务，由 spinner 展示进度。
+        def _scan_local_task(ports: List[str]) -> List[Dict[str, Any]]:
+            entries: List[Dict[str, Any]] = []
+            if not ports:
+                return entries
+    
+            def _check_one(port: str) -> Tuple[str, Dict[str, Any]]:
+                r = check_port_alive_nonblock(port, baudrate=115200, timeout=1.5)
+                return (port, r)
+    
+            alive_ports: List[str] = []
+            results: List[Tuple[str, Dict[str, Any]]] = []
+            fast_exit = False
+            ex = ThreadPoolExecutor(max_workers=max(len(ports), 1))
             try:
-                with SerialNotebook(device=port, baudrate=115200) as nb:
-                    return (port, nb.get_model_type(timeout=2.0, verbose=False) or "unknown")
-            except Exception as e:
-                return (port, f"error: {e}")
-
-        if alive_ports:
-            model_results: List[Tuple[str, str]] = []
-            with ThreadPoolExecutor(max_workers=max(len(alive_ports), 1)) as ex2:
-                futs = {ex2.submit(_model_one, p): p for p in alive_ports}
-                for fut in as_completed(futs):
-                    model_results.append(fut.result())
-            model_results.sort(key=lambda x: x[0])
-            for port, device_type in model_results:
-                entries.append({
-                    "host": "localhost",
-                    "device": port,
-                    "device_id": _device_id("localhost", port),
-                    "device_type": device_type if not device_type.startswith("error:") else "unknown",
-                    "last_update": now,
-                })
-        return entries
-
-    def _scan_remote_task() -> List[Dict[str, Any]]:
-        entries: List[Dict[str, Any]] = []
-        hosts = get_remote_hosts()
-        # print(f"[debug] remote hosts found by discovery: {hosts}")
-        if not hosts:
-            return entries
-        for host, service_port in hosts:
-            # print(f"[debug] fetching boards from {host}:{service_port}...")
-            boards = fetch_boards_from_host(host, service_port, timeout=10.0)
-            # print(f"[debug] host {host} returned {len(boards)} boards")
-            for b in boards:
-                if not b.get("available"):
-                    continue
-                serial_dev = (b.get("device") or b.get("port") or "").strip()
-                if not serial_dev:
-                    continue
-                baud = int(b.get("baudrate") or 115200)
-                device_type = "unknown"
+                futs = {ex.submit(_check_one, p): p for p in ports}
+                if fast:
+                    for fut in as_completed(futs):
+                        port, r = fut.result()
+                        results.append((port, r))
+                        if r.get("available"):
+                            fast_exit = True
+                            alive_ports = [port]
+                            break
+                else:
+                    for fut in as_completed(futs):
+                        results.append(fut.result())
+                    results.sort(key=lambda x: x[0])
+                    for port, r in results:
+                        if r.get("available"):
+                            alive_ports.append(port)
+            finally:
+                ex.shutdown(wait=not fast_exit)
+    
+            def _model_one(port: str) -> Tuple[str, str]:
                 try:
-                    with SerialNotebook(device=serial_dev, baudrate=baud, host=host, port=service_port) as nb:
-                        device_type = nb.get_model_type(timeout=3.0, verbose=False) or "unknown"
+                    with SerialNotebook(device=port, baudrate=115200) as nb:
+                        return (port, nb.get_model_type(timeout=2.0, verbose=False) or "unknown")
                 except Exception as e:
-                    # 如果报错，说明连接或者握手阶段就出问题了
-                    # print(f"[debug] failed to get model type from {host}:{serial_dev}: {e}")
+                    return (port, f"error: {e}")
+    
+            if alive_ports:
+                model_results: List[Tuple[str, str]] = []
+                with ThreadPoolExecutor(max_workers=max(len(alive_ports), 1)) as ex2:
+                    futs = {ex2.submit(_model_one, p): p for p in alive_ports}
+                    for fut in as_completed(futs):
+                        model_results.append(fut.result())
+                model_results.sort(key=lambda x: x[0])
+                for port, device_type in model_results:
+                    entries.append({
+                        "host": "localhost",
+                        "device": port,
+                        "device_id": _device_id("localhost", port),
+                        "device_type": device_type if not device_type.startswith("error:") else "unknown",
+                        "last_update": now,
+                    })
+            return entries
+    
+        def _scan_remote_task() -> List[Dict[str, Any]]:
+            entries: List[Dict[str, Any]] = []
+            hosts = get_remote_hosts()
+            # print(f"[debug] remote hosts found by discovery: {hosts}")
+            if not hosts:
+                return entries
+            for host, service_port in hosts:
+                # print(f"[debug] fetching boards from {host}:{service_port}...")
+                boards = fetch_boards_from_host(host, service_port, timeout=10.0)
+                # print(f"[debug] host {host} returned {len(boards)} boards")
+                for b in boards:
+                    if not b.get("available"):
+                        continue
+                    serial_dev = (b.get("device") or b.get("port") or "").strip()
+                    if not serial_dev:
+                        continue
+                    baud = int(b.get("baudrate") or 115200)
                     device_type = "unknown"
-                entries.append({
-                    "host": host,
-                    "device": serial_dev,
-                    "device_id": _device_id(host, serial_dev),
-                    "device_type": device_type if not device_type.startswith("error:") else "unknown",
-                    "last_update": now,
-                })
-        return entries
-
-    specs: List[Tuple[str, Any]] = []
-    local_entries: List[Dict[str, Any]] = []
-    remote_entries: List[Dict[str, Any]] = []
-    idx_local: Optional[int] = None
-    idx_remote: Optional[int] = None
-
-    if scan_local and scan_remote:
-        ports = scan_serial_ports()
-        label = f"[main] scanning {len(ports)} local port(s) and discovering remote hosts..."
-        print(label)
-        # 本地和远程作为两个并行任务：
-        idx_local = 0
-        idx_remote = 1
-        specs.append(("[local] scanning local ports", lambda p=ports: _scan_local_task(p)))
-        specs.append(("[remote] discovering remote hosts", _scan_remote_task))
-    elif scan_local:
-        ports = scan_serial_ports()
-        label = f"[main] scanning {len(ports)} local port(s)..."
-        print(label)
-        idx_local = 0
-        specs.append(("[local] scanning local ports", lambda p=ports: _scan_local_task(p)))
-    else:
-        # 仅远程
-        print("[main] discovering remote hosts...")
-        idx_remote = 0
-        specs.append(("[remote] discovering remote hosts", _scan_remote_task))
-
-    if specs:
-        results = _run_parallel_with_spinners(specs)
-        if idx_local is not None:
-            local_entries = results[idx_local] or []
-        if idx_remote is not None:
-            remote_entries = results[idx_remote] or []
-
-    entries = list(local_entries) + list(remote_entries)
-
-    print("[main] all scanning finished.")
-
-    # 保存本次扫描到的全部设备到缓存，便于后续 sdev run / set default 解析 host/port
-    _write_list_cache(list(entries))
-
-    # 应用筛选（仅影响本次打印）
-    if "type" in filters:
-        entries = [e for e in entries if (e.get("device_type") or "").lower() == filters["type"].lower()]
-    if "host" in filters:
-        entries = [e for e in entries if (e.get("host") or "").lower() == filters["host"].lower()]
-
-    # 默认展示所有探测到的设备，即便型号识别为 unknown。
-    # entries = [e for e in entries if (e.get("device_type") or "").lower() != "unknown"]
-    if fast and len(entries) > 1:
-        entries = entries[:1]
-
-    # 表格输出
-    col_host = 14
-    col_port = 16
-    col_id = 10
-    col_type = 14
-    col_time = 20
-    header = f"{'HOST':<{col_host}} {'PORT':<{col_port}} {'DEVICE ID':<{col_id}} {'DEVICE TYPE':<{col_type}} {'LAST UPDATE':<{col_time}}"
-    sep = "-" * (col_host + col_port + col_id + col_type + col_time + 4)
-    print(header)
-    print(sep)
-    for e in entries:
-        print(
-            f"{e.get('host', ''):<{col_host}} "
-            f"{e.get('device', ''):<{col_port}} "
-            f"{e.get('device_id', ''):<{col_id}} "
-            f"{e.get('device_type', 'unknown'):<{col_type}} "
-            f"{e.get('last_update', ''):<{col_time}}"
-        )
-    return 0
+                    try:
+                        with SerialNotebook(device=serial_dev, baudrate=baud, host=host, port=service_port) as nb:
+                            device_type = nb.get_model_type(timeout=3.0, verbose=False) or "unknown"
+                    except Exception as e:
+                        # 如果报错，说明连接或者握手阶段就出问题了
+                        # print(f"[debug] failed to get model type from {host}:{serial_dev}: {e}")
+                        device_type = "unknown"
+                    entries.append({
+                        "host": host,
+                        "device": serial_dev,
+                        "device_id": _device_id(host, serial_dev),
+                        "device_type": device_type if not device_type.startswith("error:") else "unknown",
+                        "last_update": now,
+                    })
+            return entries
+
+        specs: List[Tuple[str, Any]] = []
+        local_entries: List[Dict[str, Any]] = []
+        remote_entries: List[Dict[str, Any]] = []
+        idx_local: Optional[int] = None
+        idx_remote: Optional[int] = None
+
+        if scan_local and scan_remote:
+            ports = scan_serial_ports()
+            label = f"[main] scanning {len(ports)} local port(s) and discovering remote hosts..."
+            print(label)
+            # 本地和远程作为两个并行任务：
+            idx_local = 0
+            idx_remote = 1
+            specs.append(("[local] scanning local ports", lambda p=ports: _scan_local_task(p)))
+            specs.append(("[remote] discovering remote hosts", _scan_remote_task))
+        elif scan_local:
+            ports = scan_serial_ports()
+            label = f"[main] scanning {len(ports)} local port(s)..."
+            print(label)
+            idx_local = 0
+            specs.append(("[local] scanning local ports", lambda p=ports: _scan_local_task(p)))
+        else:
+            # 仅远程
+            print("[main] discovering remote hosts...")
+            idx_remote = 0
+            specs.append(("[remote] discovering remote hosts", _scan_remote_task))
+
+        if specs:
+            results = _run_parallel_with_spinners(specs)
+            if idx_local is not None:
+                local_entries = results[idx_local] or []
+            if idx_remote is not None:
+                remote_entries = results[idx_remote] or []
+
+        entries = list(local_entries) + list(remote_entries)
+
+        print("[main] all scanning finished.")
+
+        # 保存本次扫描到的全部设备到缓存，便于后续 sdev run / set default 解析 host/port
+        _write_list_cache(list(entries))
+
+        # 应用筛选（仅影响本次打印）
+        if "type" in filters:
+            entries = [e for e in entries if (e.get("device_type") or "").lower() == filters["type"].lower()]
+        if "host" in filters:
+            entries = [e for e in entries if (e.get("host") or "").lower() == filters["host"].lower()]
+
+        # 默认展示所有探测到的设备，即便型号识别为 unknown。
+        # entries = [e for e in entries if (e.get("device_type") or "").lower() != "unknown"]
+        if fast and len(entries) > 1:
+            entries = entries[:1]
+
+        # 表格输出
+        col_host = 14
+        col_port = 16
+        col_id = 10
+        col_type = 14
+        col_time = 20
+        header = f"{'HOST':<{col_host}} {'PORT':<{col_port}} {'DEVICE ID':<{col_id}} {'DEVICE TYPE':<{col_type}} {'LAST UPDATE':<{col_time}}"
+        sep = "-" * (col_host + col_port + col_id + col_type + col_time + 4)
+        print(header)
+        print(sep)
+        for e in entries:
+            print(
+                f"{e.get('host', ''):<{col_host}} "
+                f"{e.get('device', ''):<{col_port}} "
+                f"{e.get('device_id', ''):<{col_id}} "
+                f"{e.get('device_type', 'unknown'):<{col_type}} "
+                f"{e.get('last_update', ''):<{col_time}}"
+            )
+        return 0
 
 
 def _handle_set(args: argparse.Namespace) -> int:

{sdev-0.7.10 → sdev-0.7.12}/sdev/modules/serial_notebook.py

@@ -1,8 +1,20 @@
-
 import sys
 import time
+from typing import Optional
+
 from loguru import logger
 
+
+def _normalize_device_tree_model(value: Optional[str]) -> Optional[str]:
+    """
+    规范化从 /proc/device-tree/model 读到的文本：去除 NUL 与首尾空白。
+    部分板卡会在型号末尾带 \\0，会导致 sdev list type=... 无法匹配。
+    """
+    if value is None:
+        return None
+    cleaned = value.replace("\x00", "").strip()
+    return cleaned or None
+
 from .serial_rw import SerialLine, CTRL_C
 
 GREY = "\033[90m"
@@ -230,7 +242,7 @@ class SerialNotebook():
                 verbose=verbose,
             )
             if lines and len(lines) >= 2:
-                return lines[-2].strip()
+                return _normalize_device_tree_model(lines[-2])
         except Exception:
             pass
         return None

{sdev-0.7.10 → sdev-0.7.12/sdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdev
-Version: 0.7.10
+Version: 0.7.12
 Summary: 串口控制器工具包
 Home-page: https://github.com/klrc/sdev
 Author: klrc

{sdev-0.7.10 → sdev-0.7.12}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="sdev",
-    version="0.7.10",
+    version="0.7.12",
     author="klrc",
     author_email="144069824@qq.com",
     description="串口控制器工具包",