esp-test-utils 0.3.0__tar.gz → 0.3.2__tar.gz

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/.gitignore

@@ -8,6 +8,7 @@ __pycache__/
 htmlcov/
 /.coverage
 /.coverage.*
+/coverage.xml
 gl-codequality.json
 
 /build/

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/.gitlab-ci.yml

@@ -30,20 +30,87 @@ pre-commit-check:
 # ------------------------------------------------------------------------------------------------------
 # Pytest
 # ------------------------------------------------------------------------------------------------------
-pytest-check:
+pytest-linux:
   stage: test
   needs: []
+  image: ${IMG}
   before_script:
     - pip install -e '.[test]'
   script:
-    - pytest --junitxml=reports/junit.xml --cov=esptest --cov-report=term --cov-report xml:reports/coverage.xml
-  coverage: '/TOTAL.*\s+(\d+)\%/'
+    # - pytest --junitxml=reports/junit.xml --cov=esptest --cov-report=term --cov-report xml:reports/coverage.xml
+    - if [ "$IMG" = "python:3.11-bookworm" ]; then pip install pyecharts; fi  # test with pyecharts installed
+    - export COVERAGE_FILE=.coverage.${CI_JOB_ID}
+    - pytest --junitxml=reports/junit.xml --cov=esptest --cov-report=term
+  # coverage: '/TOTAL.*\s+(\d+)\%/'
   artifacts:
     paths:
-      - reports/
+      # - reports/
       - '.coverage*'
     reports:
       junit: reports/junit.xml
+    expire_in: 2 days
+  parallel:
+    matrix:
+      - IMG: "python:3.7-bullseye"
+      - IMG: "python:3.11-bookworm"
+      - IMG: "python:3.14-trixie"
+  tags:
+    - host_test
+
+pytest-win32:
+  stage: test
+  needs:
+    - job: pytest-linux
+      artifacts: false
+  before_script:
+    - pymanager exec -V:$env:PYTHON_VER -m venv venv
+    - 'venv\Scripts\Activate.ps1'
+    - python -V
+    - pip install '.[test]'
+  script:
+    # - pytest --junitxml=reports/junit.xml --cov=esptest --cov-report=term --cov-report xml:reports/coverage.xml
+    - $env:COVERAGE_FILE = ".coverage.$env:CI_JOB_ID"
+    - pytest --junitxml=reports/junit.xml --cov=esptest --cov-report=term
+  # coverage: '/TOTAL.*\s+(\d+)\%/'
+  artifacts:
+    paths:
+      # - reports/
+      - '.coverage*'
+    reports:
+      junit: reports/junit.xml
+    expire_in: 2 days
+  parallel:
+    matrix:
+      - PYTHON_VER: "3.7"
+      - PYTHON_VER: "3.11"
+      - PYTHON_VER: "3.14"
+  tags:
+    - windows
+    - pymanager
+
+pytest-coverage:
+  stage: test
+  needs:
+    - job: pytest-linux
+      artifacts: true
+    - job: pytest-win32
+      artifacts: false # Do not merge coverage from win32
+  before_script:
+    - pip install coverage
+  script:
+    - coverage combine .coverage*
+    - coverage report
+    - coverage xml
+    - coverage html
+  coverage: '/TOTAL.*\s+(\d+)\%/'
+  artifacts:
+    paths:
+      - htmlcov/
+      - '.coverage'
+      - coverage.xml
+    # reports:
+    #   coverage: 'coverage.xml'
+    expire_in: 1 week
   tags:
     - host_test
 

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/CHANGELOG.md

@@ -1,3 +1,18 @@
+## v0.3.2 (2026-03-19)
+
+
+- feat: add downbin with configs
+- feat: add secure boot match check
+- fix: parse partition for read-only dir
+- change: add debug logs for downbin
+
+## v0.3.1 (2026-01-16)
+
+
+- feat: add diff values for pyecharts
+- feat: add secure boot check
+- fix: pass pytest on windows
+
 ## v0.3.0 (2025-12-10)
 
 

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esp-test-utils
-Version: 0.3.0
+Version: 0.3.2
 Summary: ESP Test Utils
 Author-email: Chen Yudong <chenyudong@espressif.com>
 License:                              Apache License

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/docs/conf.py

@@ -20,6 +20,9 @@ extensions = [
     'sphinx.ext.napoleon',
 ]
 
+# Use type hints from signature in parameter descriptions (avoids duplicating complex types in docstrings)
+autodoc_typehints = 'description'
+
 templates_path = ['_templates']
 exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esp_test_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esp-test-utils
-Version: 0.3.0
+Version: 0.3.2
 Summary: ESP Test Utils
 Author-email: Chen Yudong <chenyudong@espressif.com>
 License:                              Apache License

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esp_test_utils.egg-info/SOURCES.txt

@@ -107,6 +107,7 @@ 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/tools/test_download_bin.py
 tests/tools/test_download_file.py
 tests/tools/test_pip_check.py
 tests/utility/test_parse_bin_path.py

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esptest/adapter/dut/dut_base.py

@@ -258,9 +258,9 @@ class DutBase(VariablesMixin, DutInterface):  # pylint: disable=too-many-public-
     @overload
     def expect(self, pattern: bytes, timeout: float = 30) -> None: ...
     @overload
-    def expect(self, pattern: re.Pattern[str], timeout: float = 30) -> re.Match[str]: ...
+    def expect(self, pattern: 're.Pattern[str]', timeout: float = 30) -> 're.Match[str]': ...
     @overload
-    def expect(self, pattern: re.Pattern[bytes], timeout: float = 30) -> re.Match[bytes]: ...
+    def expect(self, pattern: 're.Pattern[bytes]', timeout: float = 30) -> 're.Match[bytes]': ...
 
     def expect(self, pattern, timeout=30):  # type: ignore
         if self._base_port_proxy:

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esptest/adapter/dut/wrapper.py

@@ -6,7 +6,7 @@ from ...common.generator import get_next_index
 from ...interface.dut import DutInterface
 from ...logger import get_logger
 from ..port.base_port import RawPort
-from ..port.serial_port import SerialExt, SerialPort
+from ..port.serial_port import SerialExt, SerialPort, serial_add_mixin
 from .create_dut import create_dut
 from .dut_base import DutBase, DutConfig
 from .esp_dut import EspDut
@@ -62,6 +62,11 @@ def dut_wrapper(dut, name='', log_file='', wrap_cls=None):  # type: ignore
         dut.__class__ = SerialExt
         dut_config = DutConfig(opened_port=dut, name=_name, log_file=log_file)
         wrap_dut = wrap_cls(dut_config=dut_config)
+    elif isinstance(dut, serial.SerialBase):
+        _name = name or dut.port.split('/')[-1]
+        dut.__class__ = serial_add_mixin(dut.__class__)
+        dut_config = DutConfig(opened_port=dut, name=_name, log_file=log_file)
+        wrap_dut = wrap_cls(dut_config=dut_config)
     elif isinstance(dut, RawPort):
         _name = name
         if not _name:

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esptest/adapter/port/base_port.py

@@ -5,13 +5,12 @@ import logging
 import os
 import queue
 import re
+import sys
 import threading
 import time
 from dataclasses import dataclass
 from typing import overload
 
-import pexpect.spawnbase
-
 import esptest.common.compat_typing as t
 
 from ...common import timestamp_str, to_bytes, to_str
@@ -19,6 +18,18 @@ from ...common.decorators import deprecated
 from ...interface.port import PortInterface
 from ...logger import get_logger
 
+if sys.platform == 'win32':
+    import pexpect
+    from pexpect.exceptions import ExceptionPexpect
+    from pexpect.spawnbase import SpawnBase
+    # from wexpect import SpawnPipe as SpawnBase
+    # from wexpect import ExceptionPexpect
+else:
+    import pexpect
+    from pexpect.exceptions import ExceptionPexpect
+    from pexpect.spawnbase import SpawnBase
+
+
 logger = get_logger('port')
 NEVER_MATCHED_MAGIC_STRING = 'o6K,Q.(w+~yr~N9R'
 
@@ -81,7 +92,7 @@ class SpawnConfig:
     # TODO: monitors
 
 
-class PortSpawn(pexpect.spawnbase.SpawnBase, t.Generic[T]):
+class PortSpawn(SpawnBase, t.Generic[T]):
     """Create a new class for pexpect with port read()/write() method.
 
     There's some reason that we can not use pyserial with pexpect.fdpexpect directly:
@@ -268,6 +279,27 @@ class PortSpawn(pexpect.spawnbase.SpawnBase, t.Generic[T]):
         self._line_cache = b''
 
 
+def handle_expect_timeout(func: t.Callable) -> t.Callable:
+    """Raise same type exception ExpectTimeout for ports from different frameworks"""
+
+    @functools.wraps(func)
+    def wrap(obj: 'BasePort', *args, **kwargs):  # type: ignore
+        try:
+            result = func(obj, *args, **kwargs)
+        except obj.expect_timeout_exceptions as e:
+            data_in_buffer = ''
+            try:
+                if obj._pexpect_spawn:  # pylint: disable=protected-access
+                    data_in_buffer = obj._pexpect_spawn.before  # pylint: disable=protected-access
+            except AttributeError:
+                pass  # ignore
+            obj.logger.debug(f'ExpectTimeout: {str(e)}, data_in_buffer={repr(data_in_buffer)}')
+            raise ExpectTimeout(str(e), data_in_buffer=data_in_buffer) from e
+        return result
+
+    return wrap
+
+
 class BasePort(PortInterface, t.Generic[T]):
     """A class to simply port methods for all devices / shell / sockets to similar usage
 
@@ -278,7 +310,7 @@ class BasePort(PortInterface, t.Generic[T]):
 
     EXPECT_TIMEOUT_EXCEPTIONS: t.Tuple[t.Type[Exception], ...] = (
         TimeoutError,
-        pexpect.exceptions.ExceptionPexpect,
+        ExceptionPexpect,
     )
     INIT_START_REDIRECT_THREAD: bool = True
     PEXPECT_DEFAULT_TIMEOUT: float = 30
@@ -406,25 +438,6 @@ class BasePort(PortInterface, t.Generic[T]):
         if stopped:
             self.start_redirect_thread()
 
-    @staticmethod
-    def handle_expect_timeout(func: t.Callable) -> t.Callable:
-        """Raise same type exception ExpectTimeout for ports from different frameworks"""
-
-        @functools.wraps(func)
-        def wrap(self, *args, **kwargs):  # type: ignore
-            try:
-                result = func(self, *args, **kwargs)
-            except self.expect_timeout_exceptions as e:
-                try:
-                    data_in_buffer = self._pexpect_spawn.before  # pylint: disable=protected-access
-                except AttributeError:
-                    data_in_buffer = ''
-                self.logger.debug(f'ExpectTimeout: {str(e)}, data_in_buffer={repr(data_in_buffer)}')
-                raise ExpectTimeout(str(e), data_in_buffer=data_in_buffer) from e
-            return result
-
-        return wrap
-
     def write(self, data: t.AnyStr) -> None:
         if self._pexpect_spawn:
             return self._pexpect_spawn.write(data)
@@ -446,9 +459,9 @@ class BasePort(PortInterface, t.Generic[T]):
     @overload
     def expect(self, pattern: bytes, timeout: float = 30) -> None: ...
     @overload
-    def expect(self, pattern: re.Pattern[str], timeout: float = 30) -> re.Match[str]: ...
+    def expect(self, pattern: 're.Pattern[str]', timeout: float = 30) -> 're.Match[str]': ...
     @overload
-    def expect(self, pattern: re.Pattern[bytes], timeout: float = 30) -> re.Match[bytes]: ...
+    def expect(self, pattern: 're.Pattern[bytes]', timeout: float = 30) -> 're.Match[bytes]': ...
 
     @handle_expect_timeout
     def expect(self, pattern, timeout=PEXPECT_DEFAULT_TIMEOUT):  # type: ignore

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esptest/adapter/port/serial_port.py

@@ -1,28 +1,43 @@
 import time
-from typing import TYPE_CHECKING, Any, AnyStr, Dict, Optional, TypeAlias
+from typing import TYPE_CHECKING
 
 import serial
-from serial import Serial
+from serial import Serial, SerialBase
+
+import esptest.common.compat_typing as t
 
 from ...common import to_bytes
 from ...logger import get_logger
 from .base_port import BasePort
 
 if TYPE_CHECKING:
-    MixinBase: TypeAlias = 'BasePort'
+    MixinBase: t.TypeAlias = 'BasePort'
 else:
     MixinBase = object
 
 logger = get_logger('ser_port')
 
 
-class SerialExt(Serial):
-    """Add RawPort methods to serial.Serial"""
+class SerialBaseProtocol(t.Protocol):
+    @property
+    def port(self) -> t.Optional[str]: ...
+
+    @property
+    def baudrate(self) -> t.Optional[int]: ...
+
+    @property
+    def timeout(self) -> t.Optional[float]: ...
+
+    def read(self, size: int = 1) -> bytes: ...
+
+    def write(self, data: t.AnyStr) -> int: ...
 
+
+class SerMixin(SerialBaseProtocol):
     @property
     def read_timeout(self) -> float:
         # For PortSpawn
-        return super().timeout or 0.001  # type: ignore
+        return self.timeout or 0.001  # type: ignore
 
     def read_bytes(self, timeout: float = 0.001) -> bytes:
         # For PortSpawn
@@ -30,25 +45,52 @@ class SerialExt(Serial):
         assert self.timeout >= 0.001
         if timeout > self.timeout:
             time.sleep(timeout - self.timeout)
-        return super().read(1024)  # type: ignore
+        return self.read(1024)  # type: ignore
 
-    def write_bytes(self, data: AnyStr) -> None:
+    def write_bytes(self, data: t.AnyStr) -> int:
         # For PortSpawn
-        super().write(to_bytes(data))
+        self.write(to_bytes(data))
+        return len(to_bytes(data))
 
     def __str__(self) -> str:
-        """SerialPort<device=xxx,baudrate=xxx,timeout=xxx>"""
-        return f'SerialPort<device={self.port},baudrate={self.baudrate},timeout={self.timeout}>'
+        """SerialExt<device=xxx,baudrate=xxx,timeout=xxx>"""
+        return f'SerialExt<device={self.port},baudrate={self.baudrate},timeout={self.timeout}>'
+
+
+class SerialExt(Serial, SerMixin):
+    """Add RawPort methods to serial.Serial"""
+
+
+def serial_add_mixin(cls: t.Type[t.Any]) -> t.Type[t.Any]:
+    """动态为类添加 SerMixin"""
+    # 创建一个新的类，继承自原始类和 SerMixin
+    # 基类顺序与 SerialExt(Serial, SerMixin) 保持一致
+    return type(f'{cls.__name__}Ext', (cls, SerMixin), {})
 
 
 class SerialPortMixin(MixinBase):
     """Add RawPort methods to serial.Serial"""
 
-    def __init__(self, raw_port: Any, name: str, log_file: str = '') -> None:
-        if isinstance(raw_port, Serial):
+    @staticmethod
+    def _add_mixin_by_type(raw_port: t.Any) -> None:
+        """根据原始类型添加对应的 mixin"""
+        if raw_port is None:
+            return
+        original_type = type(raw_port)
+        # If the original type already includes SerMixin, do nothing.
+        # This prevents repeatedly nesting mixin classes when the serial
+        # object is reassigned and _add_mixin_by_type is called multiple times.
+        if issubclass(original_type, SerMixin):
+            return
+        if issubclass(original_type, Serial):
             raw_port.__class__ = SerialExt
+        elif issubclass(original_type, SerialBase):
+            raw_port.__class__ = serial_add_mixin(original_type)
+
+    def __init__(self, raw_port: t.Any, name: str, log_file: str = '') -> None:
+        self._add_mixin_by_type(raw_port)
         super().__init__(raw_port, name, log_file)
-        self._serial_config: Dict[str, Any] = {}
+        self._serial_config: t.Dict[str, t.Any] = {}
 
     def start_redirect_thread(self) -> None:
         if not self.serial:
@@ -72,12 +114,12 @@ class SerialPortMixin(MixinBase):
         super().start_redirect_thread()
 
     @property
-    def serial(self) -> Optional[SerialExt]:
+    def serial(self) -> t.Optional[SerialExt]:
         """Get Current serial instance."""
         return self._raw_port  # type: ignore
 
     @serial.setter
-    def serial(self, serial_instance: Optional[Serial]) -> None:
+    def serial(self, serial_instance: t.Optional[Serial]) -> None:
         """Set serial instance, will close and clean up the old serial resources"""
         if self._raw_port:
             # Close pexpect proc
@@ -87,7 +129,7 @@ class SerialPortMixin(MixinBase):
             #     self._port.close()
         if serial_instance:
             self._raw_port = serial_instance
-            self._raw_port.__class__ = SerialExt
+            self._add_mixin_by_type(serial_instance)
             self.start_redirect_thread()
 
     def close(self) -> None:
@@ -107,7 +149,7 @@ class SerialPort(SerialPortMixin, BasePort):
     This class using serial with pexpect.
     """
 
-    def __init__(self, dut: Serial, name: str, log_file: str = '', **kwargs: Any) -> None:
+    def __init__(self, dut: Serial, name: str, log_file: str = '', **kwargs: t.Any) -> None:
         if not dut:
             self.INIT_START_REDIRECT_THREAD = False  # pylint: disable=invalid-name
         super().__init__(dut, name, log_file, **kwargs)

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esptest/adapter/port/shell_port.py

@@ -1,47 +1,101 @@
+import io
 import os
+import queue
 import subprocess
+import sys
+import threading
 import time
 
-import pexpect
 import psutil
 
 import esptest.common.compat_typing as t
 
+from ...common.shell import ensure_windows_env
 from ...logger import get_logger
 from .base_port import BasePort, RawPort
 
 logger = get_logger('shell_port')
 
 
+if sys.platform == 'win32':
+    # windows does not support pexpect.spawn
+    # import wexpect as pexpect  # pexpect.spawn
+    import pexpect  # pexpect.spawn
+
+    DEFAULT_SHELL = 'cmd.exe'
+    ensure_windows_env()
+else:
+    import pexpect
+
+    DEFAULT_SHELL = '/bin/bash'
+
+
 class ShellRaw(RawPort):
     """A subprocess Raw Port class that supports shell read, write
 
     is a subclass of RawPort
     """
 
-    def __init__(self, cmd: str = '/bin/bash', env: t.Optional[t.Dict[str, str]] = None) -> None:
+    def __init__(self, cmd: t.Union[str, t.List[str]] = '', env: t.Optional[t.Dict[str, str]] = None) -> None:
+        ensure_windows_env()
         self.env = env or os.environ.copy()
         self.env['PYTHONUNBUFFERED'] = 'true'  # for python scripts, disable output buffering
-        self.cmd = cmd
+        self.cmd = cmd or DEFAULT_SHELL
         self.proc: t.Optional[subprocess.Popen] = None
         self.read_timeout = 0.002  # default read_timeout
+        # For Windows: use a thread and queue for non-blocking reads
+        self._read_queue: t.Optional[queue.Queue] = None
+        self._read_thread: t.Optional[threading.Thread] = None
+        self._read_thread_stop = threading.Event()
         self.open()
 
     def open(self) -> None:
         if not self.proc:
             self.proc = subprocess.Popen(  # pylint: disable=consider-using-with
                 self.cmd,
-                shell=True,
+                shell=bool(not isinstance(self.cmd, list)),
                 env=self.env,
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
             )
             # Set stdout to non-blocking
-            os.set_blocking(self.proc.stdout.fileno(), False)  # type: ignore
+            if sys.platform != 'win32':
+                os.set_blocking(self.proc.stdout.fileno(), False)  # type: ignore
+            else:
+                # Windows: subprocess pipes are blocking by default and cannot be set to non-blocking
+                # Use a background thread to read from the pipe
+                self._read_queue = queue.Queue()
+                self._read_thread_stop.clear()
+                self._read_thread = threading.Thread(target=self._read_stdout_thread, daemon=True)
+                self._read_thread.start()
+
+    def _read_stdout_thread(self) -> None:
+        """Background thread to read from stdout on Windows (where pipes are blocking)."""
+        if not self.proc or not self._read_queue:
+            return
+        try:
+            while not self._read_thread_stop.is_set():
+                try:
+                    # Read line by line to avoid blocking too long on Windows
+                    data = self.proc.stdout.readline()  # type: ignore
+                    if data:
+                        self._read_queue.put(data)
+                    elif self.proc.poll() is not None:
+                        # Process has ended
+                        break
+                except (OSError, ValueError):
+                    break
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error(f'Error in read_stdout_thread {type(e)}: {str(e)}')
 
     def close(self) -> None:
         """Close subprocess."""
+        # Stop the read thread on Windows
+        if self._read_thread_stop:
+            self._read_thread_stop.set()
+        if self._read_thread:
+            self._read_thread.join(timeout=0.1)
         if self.proc:
             if self.proc.pid:
                 try:
@@ -84,10 +138,34 @@ class ShellRaw(RawPort):
 
     def read_bytes_nonblocking(self, size: int = -1) -> bytes:
         """non-blocking read bytes"""
-        if self.proc:
+        if not self.proc:
+            return b''
+        if sys.platform != 'win32':
             self.proc.stdout.flush()  # type: ignore
             return self.proc.stdout.read(size)  # type: ignore
-        return b''
+        # Windows: read from the queue
+        try:
+            if not self._read_queue:
+                return b''
+            # On Windows, use the queue from the background thread
+            data = b''
+            while True:
+                try:
+                    self.proc.stdout.flush()  # type: ignore
+                    chunk = self._read_queue.get_nowait()
+                    data += chunk
+                    # If we have enough data and size is specified, stop reading
+                    if size > 0 and len(data) >= size:  # pylint: disable=chained-comparison
+                        break
+                except queue.Empty:
+                    break
+            # Return the requested amount or all available data
+            if size > 0:
+                return data[:size]
+            return data
+        except (OSError, ValueError) as e:
+            logger.error(f'Error in read_bytes_nonblocking {type(e)}: {str(e)}')
+            raise
 
 
 class ShellPort(BasePort[ShellRaw]):
@@ -96,7 +174,7 @@ class ShellPort(BasePort[ShellRaw]):
     def __init__(
         self,
         cmd: str = '/bin/bash',
-        env: t.Optional[dict[str, str]] = None,
+        env: t.Optional[t.Dict[str, str]] = None,
         name: str = '',
         log_file: str = '',
         **kwargs: t.Any,
@@ -130,10 +208,17 @@ class PexpectPort(BasePort[InvalidRaw]):
         log_file: str = '',
         **kwargs: t.Any,
     ) -> None:
+        if sys.platform == 'win32':
+            raise NotImplementedError('PexpectPort is not supported on Windows now.')
         self._cmd = cmd
         raw_port = InvalidRaw()
         self._pexpect_spawn: t.Optional[pexpect.spawn] = None  # change type
-        self.log_file_f = open(log_file, 'wb') if log_file else None  # pylint: disable=consider-using-with
+        self.log_file_f: t.Optional[io.BufferedWriter] = None
+        if log_file:
+            os.makedirs(os.path.dirname(log_file) or '.', exist_ok=True)
+            self.log_file_f = open(log_file, 'wb')  # pylint: disable=consider-using-with
+        else:
+            self.log_file_f = None
         super().__init__(raw_port, name, log_file, **kwargs)
 
     @property
@@ -152,13 +237,17 @@ class PexpectPort(BasePort[InvalidRaw]):
             if self._pexpect_spawn:
                 self._pexpect_spawn.logfile = None  # type: ignore
             self.log_file_f.close()
+        if new_log_file:
+            os.makedirs(os.path.dirname(new_log_file) or '.', exist_ok=True)
+            self.log_file_f = open(new_log_file, 'wb')  # pylint: disable=consider-using-with
+        else:
+            self.log_file_f = None
         if self._pexpect_spawn:
-            self.log_file_f = open(new_log_file, 'wb') if new_log_file else None  # pylint: disable=consider-using-with
             self._pexpect_spawn.logfile = self.log_file_f  # type: ignore
         self._log_file = new_log_file
 
     @property
-    def spawn(self) -> t.Optional[pexpect.spawn]:  # type: ignore
+    def spawn(self) -> 't.Optional[pexpect.spawn]':  # type: ignore
         """Allow the use of pexpect spawn enhancements, if pexpect process is available"""
         return self._pexpect_spawn
 

{esp_test_utils-0.3.0 → esp_test_utils-0.3.2}/esptest/common/compat_typing.py

@@ -1,6 +1,6 @@
 # pylint: disable=unused-import
-# flake8: noqa: F401
-# ruff: noqa: F401
+# flake8: noqa: F401,F404
+# ruff: noqa: F401,F404
 import sys
 from typing import (
     IO,
@@ -15,7 +15,7 @@ from typing import (
     Iterator,
     List,
     Optional,
-    Protocol,
+    Sequence,
     Set,
     Tuple,
     Type,
@@ -25,6 +25,12 @@ from typing import (
     overload,
 )
 
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from typing_extensions import Protocol
+
+
 if sys.version_info >= (3, 9):
     from contextlib import AbstractContextManager as ContextManager
 else: