esp-test-utils 0.3.4__tar.gz → 0.4.0__tar.gz

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/.pre-commit-config.yaml

@@ -35,7 +35,6 @@ repos:
       - 'types-psutil'
       - 'types-PyYAML'
       - 'typing_extensions'
-      - 'sqlalchemy'
 
   - repo: https://github.com/espressif/conventional-precommit-linter
     rev: v1.10.0

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/CHANGELOG.md

@@ -1,3 +1,15 @@
+## v0.4.0 (2026-05-14)
+
+
+- feat: add fetch repo script
+- feat: add script to control relay power on
+- feat: add nvs dump args and reuse partition lookup
+- fix: remove database / sqlalchemy from esptest
+- feat: support download partition
+- feat: add check serial port in use
+- feat: add copy_bin cli options and option behavior tests
+- fix: correct copy_bin zip output and add regression test
+
 ## v0.3.4 (2026-04-27)
 
 

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esp-test-utils
-Version: 0.3.4
+Version: 0.4.0
 Summary: ESP Test Utils
 Author-email: Chen Yudong <chenyudong@espressif.com>
 License:                              Apache License
@@ -232,7 +232,6 @@ Requires-Dist: pyudev
 Requires-Dist: esptool
 Requires-Dist: packaging
 Requires-Dist: rich
-Requires-Dist: sqlalchemy
 Requires-Dist: typing_extensions; python_version < "3.11"
 Provides-Extra: idfci
 Requires-Dist: pyecharts; extra == "idfci"

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/esp_test_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esp-test-utils
-Version: 0.3.4
+Version: 0.4.0
 Summary: ESP Test Utils
 Author-email: Chen Yudong <chenyudong@espressif.com>
 License:                              Apache License
@@ -232,7 +232,6 @@ Requires-Dist: pyudev
 Requires-Dist: esptool
 Requires-Dist: packaging
 Requires-Dist: rich
-Requires-Dist: sqlalchemy
 Requires-Dist: typing_extensions; python_version < "3.11"
 Provides-Extra: idfci
 Requires-Dist: pyecharts; extra == "idfci"

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/esp_test_utils.egg-info/SOURCES.txt

@@ -47,8 +47,6 @@ esptest/common/timestamp.py
 esptest/config/__init__.py
 esptest/config/env_config.py
 esptest/config/global_config.py
-esptest/db/__init__.py
-esptest/db/runners.py
 esptest/devices/__init__.py
 esptest/devices/attenuator.py
 esptest/devices/esp_serial.py
@@ -75,8 +73,10 @@ esptest/network/mac.py
 esptest/network/netif.py
 esptest/network/nic.py
 esptest/scripts/downbin.py
+esptest/scripts/fetch_repo.py
 esptest/scripts/list_ports.py
 esptest/scripts/monitor.py
+esptest/scripts/relay.py
 esptest/scripts/set_att.py
 esptest/testcase/__init__.py
 esptest/testcase/result.py
@@ -103,7 +103,6 @@ tests/adapter/test_shell_port.py
 tests/basic/test_data_monitor.py
 tests/basic/test_decorators.py
 tests/basic/test_network.py
-tests/db/test_db_runners.py
 tests/devices/test_switch.py
 tests/esp_console/conftest.py
 tests/esp_console/test_WifiCmd.py
@@ -116,7 +115,10 @@ tests/iperf_utility/_files/dut_iperf_rx1.log
 tests/iperf_utility/_files/dut_iperf_rx2.log
 tests/iperf_utility/_files/pc_iperf_rx.log
 tests/iperf_utility/_files/pc_iperf_rx2.log
+tests/scripts/test_fetch_repo.py
+tests/scripts/test_relay_script.py
 tests/testcase/test_result.py
+tests/tools/test_copy_bin.py
 tests/tools/test_download_bin.py
 tests/tools/test_download_file.py
 tests/tools/test_pip_check.py

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/esp_test_utils.egg-info/entry_points.txt

@@ -1,7 +1,9 @@
 [console_scripts]
 esp-copybin = esptest.tools.copy_bin:main
 esp-downbin = esptest.scripts.downbin:main
+esp-fetch-repo = esptest.scripts.fetch_repo:main
 esp-listports = esptest.scripts.list_ports:main
 esp-monitor = esptest.scripts.monitor:main
 esp-pipcheck = esptest.tools.pip_check:main
+esp-relay = esptest.scripts.relay:main
 esp-setatt = esptest.scripts.set_att:main

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/esp_test_utils.egg-info/requires.txt

@@ -7,7 +7,6 @@ pyudev
 esptool
 packaging
 rich
-sqlalchemy
 
 [:python_version < "3.11"]
 typing_extensions

esp_test_utils-0.4.0/esptest/devices/serial_tools.py

@@ -0,0 +1,82 @@
+import shutil
+import subprocess
+from functools import lru_cache
+from typing import List
+
+import serial.tools.list_ports
+from serial.tools.list_ports_common import ListPortInfo
+
+from ..logger import get_logger
+
+logger = get_logger('devices')
+
+
+@lru_cache()
+def get_all_serial_ports(user: str = 'default', include_links: bool = False) -> List[ListPortInfo]:
+    """list_ports could spend a very long time if there are many ports"""
+    # pylint: disable=unused-argument
+    # disable unused argument user was only used by lru_cache
+    # remove /dev/ttyS0  {location: None, pid: None, hwid: PNP0501, subsystem:pnp, serial_number: None}
+    return [p for p in serial.tools.list_ports.comports(include_links=include_links) if p.device and p.location]
+
+
+def compute_serial_port(port: str, strict: bool = False) -> str:
+    """Get the real serial port device from device, port name or usb location
+
+    Args:
+        port (str): device, port name or usb location
+        strict (bool, optional): raise Exception if not found locally.
+
+    Returns:
+        str: port device. return the given input port
+    """
+    ports = get_all_serial_ports(include_links=True)
+    for p in ports:
+        if port in [p.name, p.device, p.location]:
+            assert isinstance(p.device, str)
+            return p.device
+    if strict:
+        raise serial.SerialException(f'Can not compute {port}')
+    logger.warning(f'Can not compute port {port}, is it exist?')
+    return port
+
+
+def is_serial_port_in_use(port: str) -> bool:
+    """Return whether the serial device is likely open in another process.
+
+    Resolves ``port`` with :func:`compute_serial_port`, then prefers ``fuser(1)``
+    (``fuser -s`` on the device path: exit 0 means some process is using the
+    file). If ``fuser`` is unavailable, fails, or returns an unexpected exit
+    code, falls back to ``lsof(8)`` (exit 0 means holders were found).
+
+    If neither tool is available or both fail, raise OSError (occupancy unknown; callers may still open the port).
+    """
+    device = compute_serial_port(port)
+
+    check_commands = {
+        'fuser': {
+            'cmd': ['fuser', '-s', device],
+            'return_code': 0,
+        },
+        'lsof': {
+            'cmd': ['lsof', device],
+            'return_code': 0,
+        },
+    }
+
+    for cmd, cmd_info in check_commands.items():
+        if shutil.which(cmd):
+            try:
+                _cmd: List[str] = cmd_info['cmd']  # type: ignore
+                proc = subprocess.run(
+                    _cmd,
+                    check=False,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+            except OSError as e:
+                raise OSError(f'Failed to run {cmd} on {device}') from e
+            if proc.returncode == cmd_info['return_code']:
+                return True
+            return False
+    raise OSError(f'Failed to check if serial port {device} is in use')

esp_test_utils-0.4.0/esptest/scripts/fetch_repo.py

@@ -0,0 +1,90 @@
+#! /usr/bin/env python3
+
+import argparse
+import logging
+import os
+import shutil
+import subprocess
+from typing import Any, List, Optional
+
+
+def run_cmd(cmd: List[str], **kwargs: Any) -> None:
+    logging.debug(f'Running command: {" ".join(cmd)}')
+    subprocess.run(cmd, check=True, **kwargs)
+
+
+def check_git_repo(repo_path: str) -> None:
+    if not os.path.isdir(repo_path):
+        return
+
+    git_dir = os.path.join(repo_path, '.git')
+    if not os.path.isdir(git_dir):
+        # path is not a git repository, remove it
+        shutil.rmtree(repo_path)
+        return
+
+    try:
+        run_cmd(['git', '-C', repo_path, 'rev-parse', '--git-dir'])
+    except subprocess.CalledProcessError:
+        logging.error(f'Git repo {repo_path} corrupted, removing...')
+        shutil.rmtree(repo_path)
+
+
+def fetch_repo(url: str, path: str, ref: str, depth: Optional[int] = None) -> None:
+    check_git_repo(path)
+
+    # ref not set, clone default branch
+    if not ref:
+        if os.path.isdir(path):
+            # path is a git repository, but no ref provided
+            logging.warning(f'Path {path} already exists, but no ref provided, skipping fetch...')
+            return
+        # clone repo from remote url with default branch
+        clone_args = ['git', 'clone', url, path]
+        if depth:
+            clone_args.extend(['--depth', str(depth)])
+        run_cmd(clone_args)
+        return
+
+    # fetch specific ref
+    if not os.path.isdir(path):
+        os.makedirs(path, exist_ok=True)
+        init_args = ['git', '-C', path, 'init']
+        run_cmd(init_args)
+
+    # path is a git repository, configure remote origin url and fetch
+    # ref may be a branch, tag or commit hash.
+    # always checkout to new branch with FETCH_HEAD
+    run_cmd(['git', '-C', path, 'config', 'remote.origin.url', url])
+    # refspec = f'refs/heads/{ref}:refs/remotes/origin/{ref}'
+    fetch_args = ['git', '-C', path, 'fetch', 'origin', ref]
+    if depth:
+        fetch_args.extend(['--depth', str(depth)])
+    run_cmd(fetch_args)
+    run_cmd(['git', '-C', path, 'checkout', '-f', '-B', ref, 'FETCH_HEAD'])
+    run_cmd(['git', '-C', path, 'reset', '--hard'])
+    run_cmd(['git', '-C', path, 'clean', '-ffdx'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def parse_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='Fetch git repository to local path')
+    parser.add_argument('--url', required=True, help='Git repository URL')
+    parser.add_argument('--path', required=True, help='Local repository path')
+    parser.add_argument(
+        '--ref',
+        help='Branch/ref to clone/checkout (e.g. origin/master or chip/foo)',
+    )
+    parser.add_argument('--depth', type=int, default=0, help='Shallow fetch/clone depth, 0 means full history')
+    return parser.parse_args(argv)
+
+
+def main(argv: Optional[List[str]] = None) -> None:
+    args = parse_args(argv)
+    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')
+    depth = args.depth if args.depth > 0 else 0
+    logging.info(f'Fetching git repository {args.url} to {args.path} with ref {args.ref}, depth={depth}')
+    fetch_repo(args.url, args.path, args.ref, depth=depth)
+
+
+if __name__ == '__main__':
+    main()

esp_test_utils-0.4.0/esptest/scripts/relay.py

@@ -0,0 +1,116 @@
+import argparse
+import logging
+import re
+import subprocess
+import sys
+import time
+from typing import Optional
+
+import serial
+
+from esptest.devices.serial_tools import compute_serial_port, get_all_serial_ports
+
+# Channel 1: open / close (checksum = low 8 bits of sum of preceding bytes)
+CHANNEL1_OPEN_HEX = 'A0 01 01 A2'
+CHANNEL1_CLOSE_HEX = 'A0 01 00 A1'
+
+
+# QinHeng CH340 serial converter (USB ID 1a86:7523)
+VID_CH340 = 0x1A86
+PID_CH340 = 0x7523
+
+
+def get_relay_device(port: str = '') -> Optional[str]:
+    if port:
+        return compute_serial_port(port, strict=True)
+    # find the first CH340 device
+    for p in get_all_serial_ports():
+        if p.vid == VID_CH340 and p.pid == PID_CH340:
+            return str(p.device)
+    raise ValueError('No CH340 (1a86:7523) found; connect the USB serial adapter and retry.')
+
+
+def get_battery_level_pct() -> Optional[int]:
+    """Run ``adb shell dumpsys battery`` and return SoC 0–100, or None on failure."""
+    try:
+        r = subprocess.run(
+            ['adb', 'shell', 'dumpsys', 'battery'],
+            capture_output=True,
+            text=True,
+            timeout=15,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if r.returncode != 0:
+        return None
+    m = re.search(r'level:\s*(\d+)', r.stdout, re.I)
+    if not m:
+        return None
+    return int(m.group(1))
+
+
+class RelayControl:
+    def __init__(
+        self,
+        port: str,
+        open_cmd: str = CHANNEL1_OPEN_HEX,
+        close_cmd: str = CHANNEL1_CLOSE_HEX,
+    ):
+        self.port = get_relay_device(port)
+        assert self.port, f'Failed to get relay device: {port}'
+        self.open_cmd = bytes.fromhex(open_cmd)
+        self.close_cmd = bytes.fromhex(close_cmd)
+
+    def open(self) -> None:
+        logging.info(f'opening relay on {self.port}: sending {self.open_cmd.hex()}')
+        with serial.Serial(self.port, baudrate=9600, timeout=0.01) as ser:
+            ser.write(self.open_cmd)
+        time.sleep(0.1)
+
+    def close(self) -> None:
+        logging.info(f'closing relay on {self.port}: sending {self.close_cmd.hex()}')
+        with serial.Serial(self.port, baudrate=9600, timeout=0.01) as ser:
+            ser.write(self.close_cmd)
+        time.sleep(0.1)
+
+    def check_phone(self) -> None:
+        logging.info(f'checking phone on {self.port}')
+        self.open()
+        time.sleep(2)
+        level = get_battery_level_pct()
+        if level is None:
+            logging.error('adb battery: could not read level (no device or no level: in dumpsys)')
+            sys.exit(1)
+        if level >= 80:
+            logging.info(f'battery level {level} is greater than or equal to 80, closing relay')
+            self.close()
+        else:
+            logging.info(f'battery level {level} is less than 80, keeping relay open')
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')
+    args = argparse.ArgumentParser(description='Relay control')
+    args.add_argument('action', choices=['open', 'close', 'check-phone'], help='Action to perform')
+    args.add_argument('--port', type=str, help='Serial port')
+    args.add_argument('--open-cmd', type=str, default=CHANNEL1_OPEN_HEX, help='open device command')
+    args.add_argument('--close-cmd', type=str, default=CHANNEL1_CLOSE_HEX, help='close device command')
+
+    args = args.parse_args()
+
+    relay_control = RelayControl(args.port, args.open_cmd, args.close_cmd)
+    if args.action == 'open':
+        relay_control.open()
+    elif args.action == 'close':
+        relay_control.close()
+    elif args.action == 'check-phone':
+        relay_control.check_phone()
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logging.exception(f'{type(e)}: {e}')
+        sys.exit(1)

{esp_test_utils-0.3.4 → esp_test_utils-0.4.0}/esptest/tools/copy_bin.py

@@ -3,6 +3,7 @@ import logging
 import os
 import shutil
 import subprocess
+import tempfile
 from pathlib import Path
 from typing import List, Optional
 
@@ -24,6 +25,7 @@ class BuildFilesPatterns:
         'partition_table/*.bin',
         'partition_table/*.csv',
         'flasher_args.json',
+        'flash_args',
         'flash_project_args',
         'config/sdkconfig.json',
         'sdkconfig',
@@ -35,12 +37,17 @@ class BuildFilesPatterns:
         'bootloader/*.elf',
         '*.map',
         '*.elf',
+        'dependencies.lock',
+        'build_log.txt',
+        'size.json',
     ]
 
 
 def copy_bin_to_new_path(
     from_dir: str,
-    to_dir: str,
+    to_path: str,
+    *,
+    zip_output: bool = False,
     force: bool = True,
     copy_elf: bool = True,
     extra_files: Optional[List[str]] = None,
@@ -49,41 +56,50 @@ def copy_bin_to_new_path(
 
     Args:
         from_dir (str): the app build directory. eg: ./build/
-        to_dir (str): Destination directory to save the bin files.
+        to_path (str): Destination directory or zip file to save the bin files.
+        zip_output (bool, optional): Zip the destination directory. Defaults to False.
         force (bool, optional): Delete the destination dir if it is already exists. Defaults to True.
         copy_elf (bool, optional): Copy elf and map files as well. Defaults to True.
         extra_files (Optional[List[str]], optional): . Defaults to None.
     """
     from_path = Path(from_dir).resolve().absolute()
-    to_path = Path(to_dir).resolve().absolute()
-    logger.debug(f'Copying bin files from {from_path} to {to_path}')
+    to_path_obj = Path(to_path).resolve().absolute()
     assert from_path.is_dir()
-    if force and to_path.is_dir():
-        logger.debug(f'Removing existing destination directory {to_path}')
-        shutil.rmtree(str(to_path))
-    assert not to_path.exists()
-    to_path.mkdir(parents=True)
-
-    all_patterns = BuildFilesPatterns.BIN_FILES
+    if force and to_path_obj.exists():
+        logger.info(f'Removing existing destination directory or file {to_path_obj}')
+        if to_path_obj.is_dir():
+            shutil.rmtree(str(to_path_obj))
+        else:
+            to_path_obj.unlink()
+    if zip_output:
+        assert to_path_obj.suffix == '.zip'
+        to_path_obj.parent.mkdir(parents=True, exist_ok=True)
+        to_dir = Path(tempfile.mkdtemp())
+    else:
+        to_dir = to_path_obj
+        to_dir.mkdir(parents=True, exist_ok=True)
+    logger.debug(f'Copying bin files from {from_path} to {to_path_obj}')
+
+    all_patterns = BuildFilesPatterns.BIN_FILES[:]
     if copy_elf:
         all_patterns.extend(BuildFilesPatterns.MAP_AND_ELF_FILES)
     if extra_files:
         all_patterns.extend(extra_files)
 
-    for pattern in BuildFilesPatterns.BIN_FILES:
+    for pattern in all_patterns:
         for _file in from_path.glob(pattern):
             assert _file.is_file()
             relative_path = _file.relative_to(from_path)
-            to_file = to_path / relative_path
+            to_file = to_dir / relative_path
             if not to_file.parent.is_dir():
                 to_file.parent.mkdir(parents=True)
             logging.debug(f'Copying file {relative_path}')
-            shutil.copy(_file, to_path / relative_path)
+            shutil.copy(_file, to_dir / relative_path)
 
     # parse 'partition-table.bin'
     if IDF_PATH:
-        part_csv = Path(to_path) / 'partition_table' / 'partition-table.csv'
-        part_bin = Path(to_path) / 'partition_table' / 'partition-table.bin'
+        part_csv = Path(to_dir) / 'partition_table' / 'partition-table.csv'
+        part_bin = Path(to_dir) / 'partition_table' / 'partition-table.bin'
         parttool = Path(IDF_PATH) / 'components' / 'partition_table' / 'gen_esp32part.py'
         if not part_csv.is_file() and part_bin.is_file():
             assert parttool.is_file(), 'Can not find gen_esp32part.py'
@@ -92,16 +108,55 @@ def copy_bin_to_new_path(
                 subprocess.check_call(_cmd, shell=False)
             except subprocess.SubprocessError as e:
                 logger.error(f'Failed to gen partition-table.csv: {str(e)}')
+    # zip the destination directory
+    if zip_output:
+        shutil.make_archive(str(to_path_obj.with_suffix('')), 'zip', root_dir=str(to_dir))
+        shutil.rmtree(str(to_dir))
 
 
 def main() -> None:
     logging.basicConfig(level=logging.DEBUG)
     parser = argparse.ArgumentParser(description='Copy bin files')
     parser.add_argument('from_dir', type=str, help='source directory of build bin files')
-    parser.add_argument('to_dir', type=str, help='destination directory')
+    parser.add_argument('to_path', type=str, help='destination directory or zip file')
+    parser.add_argument(
+        '--zip',
+        action='store_true',
+        help='zip destination, and to_path should end with .zip',
+    )
+    parser.add_argument(
+        '--no-force',
+        dest='force',
+        action='store_false',
+        help='do not remove existing destination directory or file',
+    )
+    parser.set_defaults(force=True)
+    parser.add_argument(
+        '--no-copy-elf',
+        dest='copy_elf',
+        action='store_false',
+        help='do not copy elf/map files',
+    )
+    parser.set_defaults(copy_elf=True)
+    parser.add_argument(
+        '--extra-files',
+        metavar='PATTERN',
+        action='append',
+        nargs='+',
+        default=[],
+        help='extra glob patterns to copy, can be used multiple times',
+    )
     args = parser.parse_args()
-
-    copy_bin_to_new_path(args.from_dir, args.to_dir)
+    extra_files = [pattern for item in args.extra_files for pattern in item] or None
+
+    copy_bin_to_new_path(
+        args.from_dir,
+        args.to_path,
+        zip_output=args.zip,
+        force=args.force,
+        copy_elf=args.copy_elf,
+        extra_files=extra_files,
+    )
 
 
 if __name__ == '__main__':