mpytool 1.2.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

mpytool/__init__.py

@@ -2,5 +2,7 @@
 
 from mpytool.conn import ConnError, Timeout
 from mpytool.conn_serial import ConnSerial
+from mpytool.conn_socket import ConnSocket
 from mpytool.mpy_comm import MpyError, CmdError
 from mpytool.mpy import Mpy
+from mpytool.logger import SimpleColorLogger

mpytool/conn.py

@@ -1,5 +1,8 @@
 """MicroPython tool: abstract connector"""
 
+import time as _time
+import select as _select
+
 
 class ConnError(Exception):
     """General connection error"""
@@ -12,27 +15,115 @@ class Timeout(ConnError):
 class Conn():
     def __init__(self, log=None):
         self._log = log
+        self._buffer = bytearray(b'')
 
     @property
     def fd(self):
-        """Return file descriptor
-        """
+        """Return file descriptor for select()"""
         return None
 
-    def read(self):
-        """Read available data from device
-        """
+    def _has_data(self, timeout=0):
+        """Check if data is available to read using select()"""
+        fd = self.fd
+        if fd is None:
+            return False
+        readable, _, _ = _select.select([fd], [], [], timeout)
+        return bool(readable)
+
+    def _read_available(self):
+        """Read available data from device (must be implemented by subclass)"""
+        raise NotImplementedError
 
-    def write(self, data, chunk_size=128, delay=0.01):
-        """Write to device
+    def _write_raw(self, data):
+        """Write data to device, return bytes written (must be implemented by subclass)"""
+        raise NotImplementedError
+
+    def _read_to_buffer(self, wait_timeout=0):
+        """Read available data into buffer
+
+        Arguments:
+            wait_timeout: how long to wait for data (0 = non-blocking)
         """
+        if self._has_data(wait_timeout):
+            data = self._read_available()
+            if data:
+                self._buffer += data
+                return True
+        return False
+
+    def flush(self):
+        """Flush and return buffer contents"""
+        buffer = bytes(self._buffer)
+        del self._buffer[:]
+        return buffer
+
+    def read(self):
+        """Read available data from device"""
+        if self._has_data():
+            return self._read_available()
+        return None
+
+    def read_bytes(self, count, timeout=1):
+        """Read exactly count bytes from device"""
+        start_time = _time.time()
+        while len(self._buffer) < count:
+            if self._read_to_buffer(wait_timeout=0.001):
+                start_time = _time.time()
+            if timeout is not None and start_time + timeout < _time.time():
+                if self._buffer:
+                    raise Timeout(
+                        f"During timeout received: {bytes(self._buffer)}")
+                raise Timeout("No data received")
+        data = bytes(self._buffer[:count])
+        del self._buffer[:count]
+        if self._log:
+            self._log.debug("rd: %s", data)
+        return data
+
+    def write(self, data):
+        """Write data to device"""
+        if self._log:
+            self._log.debug("wr: %s", bytes(data))
+        while data:
+            count = self._write_raw(data)
+            data = data[count:]
 
     def read_until(self, end, timeout=1):
-        """Read until
-        """
-        return ''
+        """Read until end marker is found"""
+        if self._log:
+            self._log.debug("wait for %s", end)
+        start_time = _time.time()
+        while True:
+            # Use select() with 1ms timeout instead of sleep - wakes immediately on data
+            if self._read_to_buffer(wait_timeout=0.001):
+                start_time = _time.time()  # reset timeout on data received
+            if end in self._buffer:
+                break
+            if timeout is not None and start_time + timeout < _time.time():
+                if self._buffer:
+                    raise Timeout(
+                        f"During timeout received: {bytes(self._buffer)}")
+                raise Timeout("No data received")
+        index = self._buffer.index(end)
+        data = self._buffer[:index]
+        del self._buffer[:index + len(end)]
+        if self._log:
+            self._log.debug("rd: %s", bytes(data + end))
+        return data
 
     def read_line(self, timeout=None):
-        """Read signle line"""
+        """Read single line"""
         line = self.read_until(b'\n', timeout)
         return line.strip(b'\r')
+
+    def hard_reset(self):
+        """Hardware reset (only available on serial connections)"""
+        raise NotImplementedError("Hardware reset not available on this connection")
+
+    def reset_to_bootloader(self):
+        """Reset into bootloader mode (only available on serial connections)"""
+        raise NotImplementedError("Reset to bootloader not available on this connection")
+
+    def reconnect(self, timeout=None):
+        """Reconnect after device reset (only available on serial connections)"""
+        raise NotImplementedError("Reconnect not available on this connection")

mpytool/conn_serial.py

@@ -6,62 +6,106 @@ import mpytool.conn as _conn
 
 
 class ConnSerial(_conn.Conn):
+    RECONNECT_TIMEOUT = 5  # seconds
+
     def __init__(self, log=None, **serial_config):
         super().__init__(log)
-        self._serial = _serial.Serial(**serial_config)
-        self._buffer = bytearray(b'')
+        self._serial_config = serial_config
+        try:
+            self._serial = _serial.Serial(**serial_config)
+        except _serial.serialutil.SerialException as err:
+            self._serial = None
+            raise _conn.ConnError(
+                f"Error opening serial port {serial_config['port']}") from err
 
     def __del__(self):
         if self._serial:
             self._serial.close()
 
-    def _read_to_buffer(self):
-        in_waiting = self._serial.in_waiting
-        if in_waiting > 0:
-            self._buffer += self._serial.read(in_waiting)
-            return True
-        return False
-
     @property
     def fd(self):
-        return self._serial.fd
+        return self._serial.fd if self._serial else None
 
-    def read(self):
-        self._read_to_buffer()
-        if self._buffer:
-            data = self._buffer[:]
-            del self._buffer[:]
-            return data
+    def _read_available(self):
+        """Read available data from serial port"""
+        in_waiting = self._serial.in_waiting
+        if in_waiting > 0:
+            return self._serial.read(in_waiting)
         return None
 
-    def write(self, data, chunk_size=128, delay=0.01):
-        if self._log:
-            self._log.debug(f"wr: {data}")
-        while data:
-            chunk = data[:chunk_size]
-            count = self._serial.write(chunk)
-            data = data[count:]
-            _time.sleep(delay)
+    def _write_raw(self, data):
+        """Write data to serial port"""
+        return self._serial.write(data)
+
+    def _is_usb_cdc(self):
+        """Check if this is a USB-CDC port (native USB on ESP32-S/C)"""
+        port = self._serial.port or ''
+        return 'ACM' in port or 'usbmodem' in port
+
+    def hard_reset(self):
+        """Hardware reset using DTR/RTS signals"""
+        self._serial.setDTR(False)  # GPIO0 high (normal boot)
+        self._serial.setRTS(True)   # Assert reset
+        _time.sleep(0.1)
+        self._serial.setRTS(False)  # Release reset
+
+    def reconnect(self, timeout=None):
+        """Close and reopen serial port (for USB-CDC reconnect after reset)"""
+        if timeout is None:
+            timeout = self.RECONNECT_TIMEOUT
+        port = self._serial_config.get('port', 'unknown')
+        if self._serial:
+            try:
+                self._serial.close()
+            except (OSError, _serial.serialutil.SerialException):
+                pass  # Port may already be gone
+            self._serial = None
+        start = _time.time()
+        while _time.time() - start < timeout:
+            try:
+                self._serial = _serial.Serial(**self._serial_config)
+                del self._buffer[:]  # Clear any stale data
+                _time.sleep(0.5)  # Wait for device to stabilize
+                # Verify connection is stable
+                _ = self._serial.in_waiting
+                return True
+            except (_serial.serialutil.SerialException, OSError):
+                if self._serial:
+                    try:
+                        self._serial.close()
+                    except (OSError, _serial.serialutil.SerialException):
+                        pass
+                    self._serial = None
+                _time.sleep(0.1)
+        raise _conn.ConnError(f"Could not reconnect to {port} within {timeout}s")
+
+    def reset_to_bootloader(self):
+        """Reset into bootloader mode (auto-detects USB-CDC vs USB-UART)"""
+        if self._is_usb_cdc():
+            self._reset_to_bootloader_usb_jtag()
+        else:
+            self._reset_to_bootloader_classic()
+
+    def _reset_to_bootloader_usb_jtag(self):
+        """Bootloader reset for USB-JTAG-Serial (esptool sequence)"""
+        self._serial.setRTS(False)
+        self._serial.setDTR(False)
+        _time.sleep(0.1)
+        self._serial.setDTR(True)
+        self._serial.setRTS(True)
+        _time.sleep(0.1)
+        self._serial.setDTR(False)
+        self._serial.setRTS(True)
+        _time.sleep(0.1)
+        self._serial.setDTR(False)
+        self._serial.setRTS(False)
 
-    def read_until(self, end, timeout=1):
-        if self._log:
-            self._log.debug(f'wait for {end}')
-        start_time = _time.time()
-        while True:
-            if self._read_to_buffer():
-                start_time = _time.time()
-            if end in self._buffer:
-                break
-            if timeout is not None and start_time + timeout < _time.time():
-                if self._buffer:
-                    raise _conn.Timeout(
-                        f"During timeout received: {bytes(self._buffer)}")
-                raise _conn.Timeout("No data received")
-            _time.sleep(.01)
-        index = self._buffer.index(end)
-        data = self._buffer[:index]
-        del self._buffer[:index + len(end)]
-        # data, self._buffer = self._buffer.split(end, 1)
-        if self._log:
-            self._log.debug(f"rd: {data + end}")
-        return data
+    def _reset_to_bootloader_classic(self):
+        """Bootloader reset for USB-UART (classic DTR/RTS circuit)"""
+        self._serial.setDTR(False)  # GPIO0 high
+        self._serial.setRTS(True)   # Assert reset
+        _time.sleep(0.1)
+        self._serial.setDTR(True)   # GPIO0 low (bootloader)
+        self._serial.setRTS(False)  # Release reset
+        _time.sleep(0.05)
+        self._serial.setDTR(False)  # GPIO0 high

mpytool/conn_socket.py

@@ -0,0 +1,53 @@
+"""MicroPython tool: socket connector"""
+
+import socket as _socket
+import mpytool.conn as _conn
+
+
+class ConnSocket(_conn.Conn):
+    def __init__(self, address, log=None):
+        super().__init__(log)
+        self._socket = None
+        sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
+        sock.settimeout(5)
+        if ':' in address:
+            host, port = address.split(':')
+            port = int(port)
+        else:
+            host = address
+            port = 23
+        if log:
+            log.info(f"Connecting to: {host}:{port}")
+        try:
+            sock.connect((host, port))
+        except _socket.timeout as err:
+            raise _conn.ConnError(f"Timeout connecting to {host}:{port}") from err
+        except _socket.error as err:
+            raise _conn.ConnError(f"Cannot connect to {host}:{port}: {err}") from err
+        sock.settimeout(None)
+        sock.setblocking(False)
+        self._socket = sock
+        if log:
+            log.info("connected")
+
+    def __del__(self):
+        if self._socket:
+            self._socket.close()
+
+    @property
+    def fd(self):
+        return self._socket.fileno() if self._socket else None
+
+    def _read_available(self):
+        """Read available data from socket"""
+        try:
+            data = self._socket.recv(4096)
+            if data:
+                return data
+        except BlockingIOError:
+            pass
+        return None
+
+    def _write_raw(self, data):
+        """Write data to socket"""
+        return self._socket.send(data)

mpytool/logger.py

@@ -0,0 +1,87 @@
+"""Simple color logger for mpytool"""
+
+import os as _os
+import sys as _sys
+
+
+class SimpleColorLogger():
+    # ANSI color codes
+    _RESET = '\033[0m'
+    _BOLD_RED = '\033[1;31m'
+    _BOLD_YELLOW = '\033[1;33m'
+    _BOLD_MAGENTA = '\033[1;35m'
+    _BOLD_BLUE = '\033[1;34m'
+    _BOLD_GREEN = '\033[1;32m'
+    _BOLD_CYAN = '\033[1;36m'
+    _CLEAR_LINE = '\033[K'
+
+    # Color names for verbose()
+    COLORS = {
+        'red': _BOLD_RED,
+        'yellow': _BOLD_YELLOW,
+        'magenta': _BOLD_MAGENTA,
+        'blue': _BOLD_BLUE,
+        'green': _BOLD_GREEN,
+        'cyan': _BOLD_CYAN,
+    }
+
+    def __init__(self, loglevel=1, verbose_level=0):
+        self._loglevel = loglevel
+        self._verbose_level = verbose_level
+        self._is_tty = (
+            _sys.stderr.isatty()
+            and _os.environ.get('NO_COLOR') is None
+            and _os.environ.get('TERM') != 'dumb'
+            and _os.environ.get('CI') is None
+        )
+
+    def log(self, msg):
+        print(msg, file=_sys.stderr)
+
+    def error(self, msg, *args):
+        if args:
+            msg = msg % args
+        if self._loglevel >= 1:
+            if self._is_tty:
+                self.log(f"{self._BOLD_RED}{msg}{self._RESET}")
+            else:
+                self.log(f"E: {msg}")
+
+    def warning(self, msg, *args):
+        if args:
+            msg = msg % args
+        if self._loglevel >= 2:
+            if self._is_tty:
+                self.log(f"{self._BOLD_YELLOW}{msg}{self._RESET}")
+            else:
+                self.log(f"W: {msg}")
+
+    def info(self, msg, *args):
+        if args:
+            msg = msg % args
+        if self._loglevel >= 3:
+            if self._is_tty:
+                self.log(f"{self._BOLD_MAGENTA}{msg}{self._RESET}")
+            else:
+                self.log(f"I: {msg}")
+
+    def debug(self, msg, *args):
+        if args:
+            msg = msg % args
+        if self._loglevel >= 4:
+            if self._is_tty:
+                self.log(f"{self._BOLD_BLUE}{msg}{self._RESET}")
+            else:
+                self.log(f"D: {msg}")
+
+    def verbose(self, msg, level=1, color='green', end='\n', overwrite=False):
+        """Print verbose message if verbose_level >= level"""
+        if self._verbose_level < level:
+            return
+        # Skip progress updates (overwrite without newline) in non-TTY mode
+        if overwrite and not self._is_tty and end != '\n':
+            return
+        color_code = self.COLORS.get(color, self._BOLD_GREEN) if self._is_tty else ''
+        reset_code = self._RESET if self._is_tty else ''
+        clear = f'\r{self._CLEAR_LINE}' if self._is_tty and overwrite else ''
+        print(f"{clear}{color_code}{msg}{reset_code}", end=end, file=_sys.stderr, flush=True)