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

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

@@ -1,3 +1,12 @@
+## v0.3.4 (2026-04-27)
+
+
+- fix: make serial read error reconnect configurable
+- fix: resolve data monitor review findings
+- feat: support add data monitor and callback to port
+- fix(port): propagate monitors and callbacks consistently
+- fix: pexpect buffer maxread limit and data cache overflow
+
 ## v0.3.3 (2026-04-21)
 
 

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

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

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

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

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

@@ -32,6 +32,7 @@ esptest/adapter/dut/mac_mixin.py
 esptest/adapter/dut/wrapper.py
 esptest/adapter/port/__init__.py
 esptest/adapter/port/base_port.py
+esptest/adapter/port/data_monitor_mixin.py
 esptest/adapter/port/serial_port.py
 esptest/adapter/port/shell_port.py
 esptest/common/__init__.py
@@ -44,8 +45,8 @@ esptest/common/parser.py
 esptest/common/shell.py
 esptest/common/timestamp.py
 esptest/config/__init__.py
-esptest/config/default_config.py
 esptest/config/env_config.py
+esptest/config/global_config.py
 esptest/db/__init__.py
 esptest/db/runners.py
 esptest/devices/__init__.py
@@ -88,14 +89,18 @@ esptest/utility/gen_esp32part.py
 esptest/utility/parse_bin_path.py
 example/jap_test.py
 example/restart_test.py
+example/use_data_monitor.py
 tests/__init__.py
 tests/conftest.py
 tests/test_EnvConfig.py
 tests/test_common.py
+tests/test_global_config.py
 tests/test_import.py
 tests/test_parse_expand_list.py
 tests/adapter/test_Dut.py
+tests/adapter/test_base_port.py
 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

{esp_test_utils-0.3.3 → esp_test_utils-0.3.4}/esptest/adapter/dut/dut_base.py

@@ -11,12 +11,14 @@ from esptool.loader import ESPLoader
 
 import esptest.common.compat_typing as t
 
+from ...common.data_monitor import DataMonitor
 from ...common.timestamp import timestamp_slug
 from ...interface.dut import DutInterface
 from ...interface.port import PortInterface
 from ...logger import get_logger
 from ...utility.parse_bin_path import ParseBinPath, get_baud_from_bin_path
 from ..port.base_port import BasePort, RawPort
+from ..port.data_monitor_mixin import DataMonitorMixin
 from ..port.serial_port import SerialPort
 
 logger = get_logger('dut')
@@ -131,16 +133,30 @@ class VariablesMixin:
             self._dynamic_variables.pop(name)
 
 
-class DutBase(VariablesMixin, DutInterface):  # pylint: disable=too-many-public-methods
+class _DutBase(DutInterface):
+    def __init__(self, *args: t.Any, **_kwargs: t.Any) -> None:  # pylint: disable=unused-argument
+        # kwargs are kept for BasePort creation and should not be forwarded
+        # to the end of MRO where object.__init__ rejects extra arguments.
+        super().__init__()
+
+
+class DutBase(VariablesMixin, DataMonitorMixin, _DutBase):  # pylint: disable=too-many-public-methods
     """A base Dut class"""
 
     BASE_PORT_PROXY_METHODS = list(PortInterface.__abstractmethods__)
 
     def __init__(self, *, dut_config: DutConfig, **kwargs: t.Any) -> None:
+        # pass extra parameters to base port
+        self._kwargs = kwargs
+        if dut_config.monitors:
+            self._kwargs['monitors'] = dut_config.monitors
+        if dut_config.rx_log_callback:
+            self._kwargs['rx_log_callback'] = dut_config.rx_log_callback
+        # kwargs are kept for BasePort creation and should not be forwarded
+        # to the end of MRO where object.__init__ rejects extra arguments.
         super().__init__(**kwargs)
         # args and kwargs may be used by mixins
         self._dut_config: DutConfig = dut_config
-        self._kwargs = kwargs
         self._raw_port: t.Optional[RawPort] = None
         self._base_port_proxy: t.Optional[BasePort] = None
         self._dut_logger: logging.Logger = self._create_dut_logger()
@@ -235,6 +251,31 @@ class DutBase(VariablesMixin, DutInterface):  # pylint: disable=too-many-public-
             return self._base_port_proxy.log_file
         return None
 
+    @property
+    def rx_log_callback(self) -> t.Optional[t.Callable[[str, bytes], None]]:
+        """Get Current dut log file."""
+        if self._base_port_proxy:
+            return self._base_port_proxy.rx_log_callback
+        return t.cast(t.Optional[t.Callable[[str, bytes], None]], self._kwargs.get('rx_log_callback', None))
+
+    def set_rx_log_callback(self, new_callback: t.Optional[t.Callable[[str, bytes], None]]) -> None:
+        self._kwargs['rx_log_callback'] = new_callback
+        if self._base_port_proxy:
+            self._base_port_proxy.set_rx_log_callback(new_callback)
+
+    @property
+    def monitors(self) -> t.List[DataMonitor]:
+        if self._base_port_proxy:
+            return self._base_port_proxy.monitors
+        return t.cast(t.List[DataMonitor], self._kwargs.setdefault('monitors', []))
+
+    @monitors.setter
+    def monitors(self, new_monitors: t.List[DataMonitor]) -> None:
+        synced_monitors = list(new_monitors)
+        self._kwargs['monitors'] = synced_monitors
+        if self._base_port_proxy:
+            self._base_port_proxy.monitors = synced_monitors
+
     @property
     def name(self) -> t.Any:
         return self.dut_config.name

{esp_test_utils-0.3.3 → esp_test_utils-0.3.4}/esptest/adapter/dut/esp_dut.py

@@ -34,11 +34,15 @@ class EspDut(_DefaultMixins, DutBase):
         if _config.opened_port:
             if isinstance(_config.opened_port, BasePort):
                 _base_port = _config.opened_port
+                if self._kwargs.get('monitors') is not None:
+                    _base_port.monitors = self._kwargs['monitors']
+                if self._kwargs.get('rx_log_callback'):
+                    _base_port.set_rx_log_callback(self._kwargs['rx_log_callback'])
                 self._close_base_port_when_exit = False
                 self._close_raw_port_when_exit = False
                 return _base_port
             if isinstance(_config.opened_port, RawPort):
-                _base_port = BasePort(_config.opened_port, name=_config.name, log_file=_config.log_file)
+                _base_port = BasePort(_config.opened_port, name=_config.name, log_file=_config.log_file, **self._kwargs)
                 self._close_raw_port_when_exit = False
                 return _base_port
             raise TypeError(f'Can not create dut from {type(_config.opened_port)}')
@@ -51,10 +55,10 @@ class EspDut(_DefaultMixins, DutBase):
             _esp._port.timeout = _config.serial_read_timeout  # pylint: disable=protected-access
             _esp.hard_reset()
             self._raw_port = _esp
-            return BasePort(EspSerial(self._raw_port), name=_config.name, log_file=_config.log_file)
+            return BasePort(EspSerial(self._raw_port), name=_config.name, log_file=_config.log_file, **self._kwargs)
         # create basic serial port
         self._raw_port = SerialExt(port=_device, baudrate=_config.baudrate, **(_config.serial_configs or {}))
-        return SerialPort(self._raw_port, name=_config.name, log_file=_config.log_file)
+        return SerialPort(self._raw_port, name=_config.name, log_file=_config.log_file, **self._kwargs)
 
     def close(self) -> None:
         if self._close_base_port_when_exit:

{esp_test_utils-0.3.3 → esp_test_utils-0.3.4}/esptest/adapter/port/base_port.py

@@ -8,15 +8,17 @@ import re
 import sys
 import threading
 import time
-from dataclasses import dataclass
 from typing import overload
 
 import esptest.common.compat_typing as t
 
 from ...common import timestamp_str, to_bytes, to_str
+from ...common.data_monitor import DataMonitor
 from ...common.decorators import deprecated
+from ...config.global_config import g
 from ...interface.port import PortInterface
 from ...logger import get_logger
+from .data_monitor_mixin import DataMonitorMixin
 
 if sys.platform == 'win32':
     import pexpect
@@ -32,6 +34,7 @@ else:
 
 logger = get_logger('port')
 NEVER_MATCHED_MAGIC_STRING = 'o6K,Q.(w+~yr~N9R'
+PEXPECT_DEFAULT_TIMEOUT = g.PORT_EXPECT_TIMEOUT
 
 
 class ExpectTimeout(TimeoutError):
@@ -77,21 +80,6 @@ class RawPort(metaclass=abc.ABCMeta):
 T = t.TypeVar('T', bound=RawPort)
 
 
-@dataclass
-class SpawnConfig:
-    name: str = ''  # mandatory
-    timeout: float = 30.0
-    read_interval: float = 0
-    # save rx log to log file
-    log_file: t.Optional[str] = None
-    # using logger.info for logs
-    logger: logging.Logger = logger
-    # callback  cb(data,name)
-    tx_callbacks: t.Optional[t.List[t.Callable[[bytes, str], None]]] = None
-    rx_callbacks: t.Optional[t.List[t.Callable[[bytes, str], None]]] = None
-    # TODO: monitors
-
-
 class PortSpawn(SpawnBase, t.Generic[T]):
     """Create a new class for pexpect with port read()/write() method.
 
@@ -110,7 +98,7 @@ class PortSpawn(SpawnBase, t.Generic[T]):
         raw_port: T,
         name: str = '',
         log_file: t.Optional[str] = None,
-        timeout: float = 30,
+        timeout: float = PEXPECT_DEFAULT_TIMEOUT,
         **kwargs: t.Any,
     ) -> None:
         """PortSpawn for pexpect
@@ -123,6 +111,7 @@ class PortSpawn(SpawnBase, t.Generic[T]):
         """
         super().__init__(timeout=timeout)
         assert isinstance(raw_port, RawPort)
+        self.maxread = kwargs.get('maxread', g.PORT_SPAWN_MAXREAD)
         self.name = name
         self._raw_port = raw_port
         if not self.name and hasattr(self.raw_port, 'name'):
@@ -138,10 +127,23 @@ class PortSpawn(SpawnBase, t.Generic[T]):
         # Create a new thread to read data from serial port
         self._read_queue: queue.Queue = queue.Queue()
         self._read_thread_stop_event = threading.Event()
+        # callbacks
+        self._rx_log_callback: t.Optional[t.Callable[[str, bytes], None]] = kwargs.get('rx_log_callback', None)
+        # monitors
+        self._monitors: t.Optional[t.List[DataMonitor]] = kwargs.get('monitors', None)
+        self._serial_error_reconnect_count_left = max(0, int(g.ALLOW_SERIAL_ERROR_RECONNECT_COUNT))
         self._read_thread = threading.Thread(target=self._read_incoming, name=f'Spawn_{self.name}')
         self._read_thread.daemon = True
         self._read_thread.start()
-        self.receive_callback: t.Optional[t.Callable[[str, t.AnyStr], None]] = None
+
+    @property
+    def receive_callback(self) -> t.Optional[t.Callable[[str, bytes], None]]:
+        return self._rx_log_callback
+
+    @receive_callback.setter
+    @deprecated('set receive_callback directly is deprecated, use rx_log_callback instead')
+    def receive_callback(self, new_callback: t.Optional[t.Callable[[str, bytes], None]]) -> None:
+        self._rx_log_callback = new_callback
 
     @property
     def raw_port(self) -> T:
@@ -189,6 +191,32 @@ class PortSpawn(SpawnBase, t.Generic[T]):
             else:
                 self.logger.debug(f'[{self.name}]: {to_str(data_to_write)}')
 
+    def _try_reconnect_after_error(self, err: Exception) -> bool:
+        if self._serial_error_reconnect_count_left <= 0:
+            return False
+        raw_port_close = getattr(self.raw_port, 'close', None)
+        raw_port_open = getattr(self.raw_port, 'open', None)
+        if not callable(raw_port_close) or not callable(raw_port_open):
+            self.logger.warning(f'Skip serial reconnect after serial error on {self.name}: raw port missing close/open')
+            return False
+        try:
+            self._serial_error_reconnect_count_left -= 1
+            raw_port_close()
+            # Keep a short gap to avoid immediate open/read race on some serial drivers.
+            time.sleep(0.1)
+            raw_port_open()
+            self.logger.warning(
+                f'{self.name} got serial error, reopened serial, '
+                f'reconnect_left={self._serial_error_reconnect_count_left}'
+            )
+            return True
+        except Exception as reconnect_err:  # pylint: disable=broad-except
+            self.logger.exception(
+                f'{self.name} failed to reconnect serial after error '
+                f'{type(err)}: {str(err)}, reconnect_error={type(reconnect_err)}: {str(reconnect_err)}'
+            )
+            return False
+
     def _read_incoming(self) -> None:
         """Running in a thread to read serial output and save to data cache."""
         self.logger.debug(f'Start serial {self.name} read thread.')
@@ -204,15 +232,23 @@ class PortSpawn(SpawnBase, t.Generic[T]):
                 # some port instances do not support changing read timeout, therefore use default timeout of the
                 new_data = self.raw_port.read_bytes(timeout=self.read_timeout)
             except Exception as e:  # pylint: disable=W0718
-                self._log(to_bytes(f'PortRead {type(e)}: {str(e)}'), 'read')
-                self._write_port_log(to_bytes(f'SerialException: {str(e)}'))
-                self.logger.exception(f'{self.name} reading thread stopped {type(e)}: {str(e)}')
-                return
+                self._log(to_bytes(f'PortReadError {type(e)}: {str(e)}'), 'read')
+                self.logger.exception(f'{self.name} port read error {type(e)}: {str(e)}')
+                time.sleep(0.01)  # avoid busy loop
+                if self._try_reconnect_after_error(e):
+                    self.logger.critical(f'{self.name} reconnected after error {type(e)}: {str(e)}')
+                    new_data = f'[PortException] reconnected after error {type(e)}: {str(e)}\n'.encode()
+                else:
+                    self._write_port_log(to_bytes(f'[PortException] {type(e)}: {str(e)}\n'))
+                    return
             if new_data:
                 self._read_queue.put(new_data)
-                if self.receive_callback and callable(self.receive_callback):
+                if self._rx_log_callback:
                     # https://stackoverflow.com/questions/69732212/pylint-self-xxx-is-not-callable
-                    self.receive_callback(self.name, new_data)  # pylint: disable=E1102
+                    self._rx_log_callback(self.name, new_data)  # pylint: disable=E1102
+                if self._monitors:
+                    for monitor in self._monitors:
+                        monitor.append_data(self.name, new_data)
             # the last line may be cached, to make the file more readable after adding timestamp
             # always check need write to file or not whether there's new data
             self._write_port_log(new_data)
@@ -254,6 +290,9 @@ class PortSpawn(SpawnBase, t.Generic[T]):
             except queue.Empty:
                 break
             time_left = t0 + timeout - time.time()
+        # clear older data cache if it is larger than 2x limit
+        if len(self._data_cache) >= g.DATA_CACHE_SIZE_LIMIT * 2:
+            self._data_cache = self._data_cache[-g.DATA_CACHE_SIZE_LIMIT :]
         # Returned data should not more than given size.
         if self._data_cache:
             ret_data = self._data_cache[:size]
@@ -274,7 +313,8 @@ class PortSpawn(SpawnBase, t.Generic[T]):
         self._read_thread_stop_event.set()
         self._read_thread.join()
         self._read_queue.empty()
-        self.receive_callback = None
+        self._rx_log_callback = None
+        self._monitors = []
         self._data_cache = b''
         self._line_cache = b''
 
@@ -300,7 +340,14 @@ def handle_expect_timeout(func: t.Callable) -> t.Callable:
     return wrap
 
 
-class BasePort(PortInterface, t.Generic[T]):
+class _BasePort(PortInterface):
+    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:  # pylint: disable=unused-argument
+        # kwargs are kept for BasePort creation and should not be forwarded
+        # to the end of MRO where object.__init__ rejects extra arguments.
+        super().__init__()
+
+
+class BasePort(DataMonitorMixin, _BasePort, t.Generic[T]):  # pylint: disable=too-many-public-methods
     """A class to simply port methods for all devices / shell / sockets to similar usage
 
     - Create receive thread and pexpect spawn process for data read/expect
@@ -313,7 +360,6 @@ class BasePort(PortInterface, t.Generic[T]):
         ExceptionPexpect,
     )
     INIT_START_REDIRECT_THREAD: bool = True
-    PEXPECT_DEFAULT_TIMEOUT: float = 30
 
     def __init__(
         self,
@@ -322,6 +368,7 @@ class BasePort(PortInterface, t.Generic[T]):
         log_file: str = '',
         **kwargs: t.Any,
     ) -> None:
+        super().__init__(**kwargs)
         self._raw_port = raw_port
         self._name = name
         self._log_file = log_file
@@ -332,7 +379,7 @@ class BasePort(PortInterface, t.Generic[T]):
             self._close_redirect_thread_when_exit = kwargs['close_redirect_thread_when_exit']
         # redirect thread (pexpect spawn)
         self.expect_timeout_exceptions = self.EXPECT_TIMEOUT_EXCEPTIONS
-        self.timeout = self.PEXPECT_DEFAULT_TIMEOUT
+        self.timeout = kwargs.get('timeout', PEXPECT_DEFAULT_TIMEOUT)
         self._pexpect_spawn: t.Optional[PortSpawn] = None
         # logger
         self._logger = self._get_logger()
@@ -408,6 +455,27 @@ class BasePort(PortInterface, t.Generic[T]):
             self._pexpect_spawn.log_file = new_log_file
         self._log_file = new_log_file
 
+    @property
+    def rx_log_callback(self) -> t.Optional[t.Callable[[str, bytes], None]]:
+        """Get Current dut log file."""
+        return t.cast(t.Optional[t.Callable[[str, bytes], None]], self._kwargs.get('rx_log_callback', None))
+
+    def set_rx_log_callback(self, new_callback: t.Optional[t.Callable[[str, bytes], None]]) -> None:
+        self._kwargs['rx_log_callback'] = new_callback
+        if self._pexpect_spawn:
+            self._pexpect_spawn._rx_log_callback = new_callback  # pylint: disable=protected-access
+
+    @property
+    def monitors(self) -> t.List[DataMonitor]:
+        return t.cast(t.List[DataMonitor], self._kwargs.setdefault('monitors', []))
+
+    @monitors.setter
+    def monitors(self, new_monitors: t.List[DataMonitor]) -> None:
+        synced_monitors = list(new_monitors)
+        self._kwargs['monitors'] = synced_monitors
+        if self._pexpect_spawn:
+            self._pexpect_spawn._monitors = synced_monitors  # pylint: disable=protected-access
+
     @property
     def spawn(self) -> t.Optional[PortSpawn]:
         """Allow the use of pexpect spawn enhancements, if pexpect process is available"""
@@ -419,7 +487,7 @@ class BasePort(PortInterface, t.Generic[T]):
             return
         self._init_log_file()
         self._pexpect_spawn = PortSpawn(
-            self.raw_port, self.name, self.log_file, self.PEXPECT_DEFAULT_TIMEOUT, **self._kwargs
+            self.raw_port, self.name, self.log_file, PEXPECT_DEFAULT_TIMEOUT, **self._kwargs
         )
 
     def stop_redirect_thread(self) -> bool:
@@ -455,13 +523,13 @@ class BasePort(PortInterface, t.Generic[T]):
         raise NotImplementedError()
 
     @overload
-    def expect(self, pattern: str, timeout: float = 30) -> None: ...
+    def expect(self, pattern: str, timeout: float = PEXPECT_DEFAULT_TIMEOUT) -> None: ...
     @overload
-    def expect(self, pattern: bytes, timeout: float = 30) -> None: ...
+    def expect(self, pattern: bytes, timeout: float = PEXPECT_DEFAULT_TIMEOUT) -> None: ...
     @overload
-    def expect(self, pattern: 're.Pattern[str]', timeout: float = 30) -> 're.Match[str]': ...
+    def expect(self, pattern: 're.Pattern[str]', timeout: float = PEXPECT_DEFAULT_TIMEOUT) -> '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 = PEXPECT_DEFAULT_TIMEOUT) -> 're.Match[bytes]': ...
 
     @handle_expect_timeout
     def expect(self, pattern, timeout=PEXPECT_DEFAULT_TIMEOUT):  # type: ignore
@@ -473,6 +541,12 @@ class BasePort(PortInterface, t.Generic[T]):
         If the pattern type is re.Pattern, this method will return a re.Match object if the pattern is matched.
         Can read all output data by pattern=re.compile('.+', re.DOTALL)
 
+        Note:
+            When matching very long data in a single read, pexpect may truncate the buffer
+            due to its ``maxread`` limit. If the expected pattern can
+            span a large chunk of output, increase ``maxread`` on the underlying pexpect
+            spawn accordingly.
+
         Args:
             pattern (t.Union[str, bytes, re.Pattern]): pattern to match
             timeout (int, optional): seconds of waiting for new data if match failed. Defaults to 30s.
@@ -518,18 +592,25 @@ class BasePort(PortInterface, t.Generic[T]):
         """
         buffer = b''
         if flush:
-            # pexpect may return empty bytes if b'(.*)' is used
-            try:
-                match = self.expect(re.compile(b'(.+)', re.DOTALL), timeout=0)
-                assert match
-                buffer = match.group(0)
-            except TimeoutError:
-                pass
+            while True:
+                new_data = b''
+                # pexpect may return empty bytes if b'(.*)' is used
+                try:
+                    match = self.expect(re.compile(b'(.+)', re.DOTALL), timeout=0)
+                    assert match
+                    new_data = match.group(0)
+                except TimeoutError:
+                    pass
+                if not new_data:
+                    break
+                buffer += new_data
         else:
-            # flush spawn buffer
+            # update spawn buffer
             assert self._pexpect_spawn
             self._pexpect_spawn.expect_exact(pexpect.TIMEOUT, timeout=0)
             buffer = to_bytes(self._pexpect_spawn.buffer)
+            if hasattr(self._pexpect_spawn, 'data_cache'):
+                buffer += to_bytes(self._pexpect_spawn.data_cache)
         assert isinstance(buffer, bytes)
         return buffer
 

esp_test_utils-0.3.4/esptest/adapter/port/data_monitor_mixin.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING
+
+import esptest.common.compat_typing as t
+
+from ...common.data_monitor import DataMonitor
+
+if TYPE_CHECKING:
+
+    class _SupportsMonitors(t.Protocol):
+        @property
+        def monitors(self) -> t.List[DataMonitor]: ...
+
+        @monitors.setter
+        def monitors(self, new_monitors: t.List[DataMonitor]) -> None: ...
+
+else:
+    _SupportsMonitors = object
+
+
+class DataMonitorMixin(_SupportsMonitors):
+    def add_monitor(self, monitor: DataMonitor) -> None:
+        new_monitors = list(self.monitors)
+        if monitor in new_monitors:
+            return
+        new_monitors.append(monitor)
+        self.monitors = new_monitors
+
+    def remove_monitor(self, monitor: DataMonitor) -> None:
+        new_monitors = list(self.monitors)
+        if monitor not in new_monitors:
+            return
+        new_monitors.remove(monitor)
+        self.monitors = new_monitors
+
+    def clear_monitors(self) -> None:
+        self.monitors = []

{esp_test_utils-0.3.3 → esp_test_utils-0.3.4}/esptest/adapter/port/serial_port.py

@@ -87,9 +87,9 @@ class SerialPortMixin(MixinBase):
         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:
+    def __init__(self, raw_port: t.Any, name: str, log_file: str = '', **kwargs: t.Any) -> None:
         self._add_mixin_by_type(raw_port)
-        super().__init__(raw_port, name, log_file)
+        super().__init__(raw_port, name, log_file, **kwargs)
         self._serial_config: t.Dict[str, t.Any] = {}
 
     def start_redirect_thread(self) -> None:

{esp_test_utils-0.3.3 → esp_test_utils-0.3.4}/esptest/adapter/port/shell_port.py

@@ -11,6 +11,7 @@ import psutil
 import esptest.common.compat_typing as t
 
 from ...common.shell import ensure_windows_env
+from ...config.global_config import g
 from ...logger import get_logger
 from .base_port import BasePort, RawPort
 
@@ -270,7 +271,8 @@ class PexpectPort(BasePort[InvalidRaw]):
         self._init_log_file()
         env = os.environ.copy()
         env['PYTHONUNBUFFERED'] = 'true'  # for python scripts, disable output buffering
-        self._pexpect_spawn = pexpect.spawn(self._cmd, maxread=8192, echo=False, env=env)  # type: ignore
+        maxread = self._kwargs.get('maxread', g.PORT_SPAWN_MAXREAD)
+        self._pexpect_spawn = pexpect.spawn(self._cmd, maxread=maxread, echo=False, env=env)  # type: ignore
         self._pexpect_spawn.logfile = self.log_file_f  # type: ignore
         # self._pexpect_spawn.delaybeforesend = 0.001