mpytool 2.3.6__tar.gz → 2.4.0__tar.gz

{mpytool-2.3.6 → mpytool-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.3.6
+Version: 2.4.0
 Summary: MPY tool - manage files on devices running MicroPython
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License-Expression: MIT
@@ -31,6 +31,8 @@ It is an alternative to the official [mpremote](https://docs.micropython.org/en/
   (CP2102, CH340)
 - **Multiple reset options** - soft, MCU, hardware (RTS),
   bootloader entry
+- **Wipe device** - erase the whole filesystem and machine-reset
+  for a clean slate (handy at the start of automated tests)
 - **General-purpose serial terminal** - `repl` and `monitor` work
   with any serial device
 - **Mount local directory** - VFS mount (read-only or read-write)
@@ -42,7 +44,7 @@ It is an alternative to the official [mpremote](https://docs.micropython.org/en/
 - **Raw-paste mode** - flow-controlled code execution with reduced
   RAM usage (API)
 - **Shell completion** - ZSH and Bash with remote path completion
-- **Network support** - connect over TCP
+- **Network support** - connect over TCP with optional SSL/TLS
 - **Full Unicode support** - handles Unicode in file names and content
 
 See [README_mpremote.md](README_mpremote.md) for detailed comparison with mpremote.
@@ -270,6 +272,30 @@ $ mpytool sleep 2            # sleep for 2 seconds (useful between commands)
 SLEEP 2.0s
 ```
 
+### Wipe device (erase all files + machine reset)
+```
+$ mpytool wipe               # delete everything from / then machine.reset()
+WIPE
+  rm /boot.py
+  rm /main.py
+  rm /lib
+  reset
+
+$ mpytool wipe -- ls         # wipe, reconnect, then list (now empty)
+WIPE
+  rm /main.py
+  reset, reconnected
+LS:
+```
+
+`wipe` erases the whole filesystem (recursive delete of `/`) and then does a
+full `machine.reset()` — a soft reset would leave open sockets, WiFi and
+mounted VFS alive, so machine reset is used for a true clean slate. It **never
+prompts** (mpytool has no interactive mode); `-y`/`--yes` is accepted as a
+no-op. When `wipe` is the last command it just resets and exits; when more
+commands follow it reconnects first (use `-t SECONDS` for the reconnect
+timeout). See [README_API.md](README_API.md) for `Mpy.wipe()`.
+
 ### Serial terminal and monitor (general purpose)
 ```
 $ mpytool repl                       # auto-detect port, 115200 baud
@@ -537,8 +563,12 @@ TREE: /
 
 ### Connect over network (TCP, default port 23)
 ```
-$ mpytool -a 192.168.1.100 ls
-$ mpytool -a 192.168.1.100:8266 tree
+$ mpytool -a 192.168.1.100 ls                          # plain TCP
+$ mpytool -a 192.168.1.100:8266 tree                   # custom port
+$ mpytool -a 192.168.1.100:8023 --ssl ls               # SSL/TLS connection
+$ mpytool -a 192.168.1.100:8023 --ssl-ca ca.pem ls     # SSL with custom CA
+$ mpytool -a 192.168.1.100:8023 --ssl-no-hostname ls   # SSL, skip hostname check
+$ mpytool -a 192.168.1.100:8023 --ssl-no-verify ls     # SSL, skip all verification
 ```
 
 ### Set baudrate (default 115200)

{mpytool-2.3.6 → mpytool-2.4.0}/README.md

@@ -16,6 +16,8 @@ It is an alternative to the official [mpremote](https://docs.micropython.org/en/
   (CP2102, CH340)
 - **Multiple reset options** - soft, MCU, hardware (RTS),
   bootloader entry
+- **Wipe device** - erase the whole filesystem and machine-reset
+  for a clean slate (handy at the start of automated tests)
 - **General-purpose serial terminal** - `repl` and `monitor` work
   with any serial device
 - **Mount local directory** - VFS mount (read-only or read-write)
@@ -27,7 +29,7 @@ It is an alternative to the official [mpremote](https://docs.micropython.org/en/
 - **Raw-paste mode** - flow-controlled code execution with reduced
   RAM usage (API)
 - **Shell completion** - ZSH and Bash with remote path completion
-- **Network support** - connect over TCP
+- **Network support** - connect over TCP with optional SSL/TLS
 - **Full Unicode support** - handles Unicode in file names and content
 
 See [README_mpremote.md](README_mpremote.md) for detailed comparison with mpremote.
@@ -255,6 +257,30 @@ $ mpytool sleep 2            # sleep for 2 seconds (useful between commands)
 SLEEP 2.0s
 ```
 
+### Wipe device (erase all files + machine reset)
+```
+$ mpytool wipe               # delete everything from / then machine.reset()
+WIPE
+  rm /boot.py
+  rm /main.py
+  rm /lib
+  reset
+
+$ mpytool wipe -- ls         # wipe, reconnect, then list (now empty)
+WIPE
+  rm /main.py
+  reset, reconnected
+LS:
+```
+
+`wipe` erases the whole filesystem (recursive delete of `/`) and then does a
+full `machine.reset()` — a soft reset would leave open sockets, WiFi and
+mounted VFS alive, so machine reset is used for a true clean slate. It **never
+prompts** (mpytool has no interactive mode); `-y`/`--yes` is accepted as a
+no-op. When `wipe` is the last command it just resets and exits; when more
+commands follow it reconnects first (use `-t SECONDS` for the reconnect
+timeout). See [README_API.md](README_API.md) for `Mpy.wipe()`.
+
 ### Serial terminal and monitor (general purpose)
 ```
 $ mpytool repl                       # auto-detect port, 115200 baud
@@ -522,8 +548,12 @@ TREE: /
 
 ### Connect over network (TCP, default port 23)
 ```
-$ mpytool -a 192.168.1.100 ls
-$ mpytool -a 192.168.1.100:8266 tree
+$ mpytool -a 192.168.1.100 ls                          # plain TCP
+$ mpytool -a 192.168.1.100:8266 tree                   # custom port
+$ mpytool -a 192.168.1.100:8023 --ssl ls               # SSL/TLS connection
+$ mpytool -a 192.168.1.100:8023 --ssl-ca ca.pem ls     # SSL with custom CA
+$ mpytool -a 192.168.1.100:8023 --ssl-no-hostname ls   # SSL, skip hostname check
+$ mpytool -a 192.168.1.100:8023 --ssl-no-verify ls     # SSL, skip all verification
 ```
 
 ### Set baudrate (default 115200)

{mpytool-2.3.6 → mpytool-2.4.0}/README_API.md

@@ -107,25 +107,44 @@ conn.reconnect(timeout=5)   # Reconnect after device reset (USB-CDC)
 
 ### ConnSocket
 
-TCP socket connection for network-connected devices.
+TCP socket connection for network-connected devices with optional SSL/TLS.
 
 ```python
-mpytool.ConnSocket(address, log=None)
+mpytool.ConnSocket(address, log=None, ssl=False, ssl_verify=True,
+    ssl_ca=None, ssl_check_hostname=True)
 ```
 
 **Parameters:**
 - `address` (str): Host address with optional port (e.g., `192.168.1.100` or `192.168.1.100:8266`)
 - `log`: Optional logger instance
+- `ssl` (bool): Enable SSL/TLS encryption (default: `False`)
+- `ssl_verify` (bool): Verify server certificate (default: `True`). Set to `False` for self-signed certs.
+- `ssl_ca` (str): Path to CA certificate file for custom certificate authorities
+- `ssl_check_hostname` (bool): Verify hostname matches certificate (default: `True`). Set to `False` when one cert is shared across multiple hosts.
 
 Default port is 23 if not specified.
 
-**Example:**
+**Examples:**
 ```python
+# Plain TCP
 conn = mpytool.ConnSocket(address='192.168.1.100:8266')
+
+# SSL with system CA
+conn = mpytool.ConnSocket(address='server:8023', ssl=True)
+
+# SSL with custom CA
+conn = mpytool.ConnSocket(address='server:8023', ssl=True, ssl_ca='ca.pem')
+
+# SSL, verify cert but skip hostname check
+conn = mpytool.ConnSocket(address='192.168.1.100:8023',
+    ssl=True, ssl_ca='ca.pem', ssl_check_hostname=False)
+
+# SSL without any verification (insecure)
+conn = mpytool.ConnSocket(address='server:8023', ssl=True, ssl_verify=False)
 ```
 
 **Raises:**
-- `ConnError`: If unable to connect
+- `ConnError`: If unable to connect or SSL handshake fails
 
 ### Common Connection Methods
 
@@ -873,7 +892,7 @@ Soft reset in raw REPL mode (clears RAM only, doesn't run boot.py/main.py).
 mpy.soft_reset_raw()
 ```
 
-#### machine_reset(reconnect=True)
+#### machine_reset(reconnect=True, timeout=None)
 
 MCU reset using `machine.reset()`.
 
@@ -883,6 +902,7 @@ mpy.machine_reset(reconnect=True)
 
 **Parameters:**
 - `reconnect` (bool): If True, attempt to reconnect after reset (for USB-CDC ports)
+- `timeout` (int): Reconnect timeout in seconds (None = default)
 
 #### hard_reset()
 
@@ -895,6 +915,34 @@ mpy.hard_reset()
 **Raises:**
 - `NotImplementedError`: If connection doesn't support hardware reset
 
+#### wipe(reconnect=True, timeout=None, on_delete=None)
+
+Erase all files from the filesystem root, then `machine.reset()` the device.
+
+Recursively deletes every entry in `/`, then performs a full machine reset so
+runtime state (open sockets, WiFi, mounted VFS) is dropped too — a soft reset
+would leave those alive. Intended for a clean slate, e.g. at the start of
+integration tests.
+
+```python
+# Clean slate at the start of a test
+mpy.wipe()
+
+# Wipe without waiting to reconnect
+mpy.wipe(reconnect=False)
+
+# Show what gets removed
+mpy.wipe(on_delete=lambda path: print(f"removing {path}"))
+```
+
+**Parameters:**
+- `reconnect` (bool): If True, wait for the device to come back after reset
+- `timeout` (int): Reconnect timeout in seconds (None = default)
+- `on_delete` (callable): Optional `callback(path)` invoked before each delete
+
+**Returns:**
+- `bool`: True if reconnected after reset, False otherwise
+
 ### Flash/Partition Methods
 
 #### partitions()

{mpytool-2.3.6 → mpytool-2.4.0}/completions/_mpytool

@@ -133,6 +133,10 @@ _mpytool() {
         '--port[serial port]:port:_mpytool_ports' \
         '-a[network address]:address:' \
         '--address[network address]:address:' \
+        '--ssl[use SSL/TLS]' \
+        '--ssl-no-verify[disable SSL certificate verification]' \
+        '--ssl-ca[CA certificate file]:file:_files' \
+        '--ssl-no-hostname[disable SSL hostname verification]' \
         '-b[baud rate]:baud:(9600 19200 38400 57600 115200 230400 460800 921600)' \
         '--baud[baud rate]:baud:(9600 19200 38400 57600 115200 230400 460800 921600)' \
         '-d[debug level]' \

{mpytool-2.3.6 → mpytool-2.4.0}/completions/mpytool.bash

@@ -170,6 +170,10 @@ _mpytool() {
         -a|--address)
             return
             ;;
+        --ssl-ca)
+            COMPREPLY=($(compgen -f -- "$cur"))
+            return
+            ;;
     esac
 
     # At command position

mpytool-2.4.0/mpytool/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.4.0'
+__version_tuple__ = version_tuple = (2, 4, 0)
+
+__commit_id__ = commit_id = 'gf2ecc3ebb'

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/conn.py

@@ -208,6 +208,13 @@ class Conn():
     def close(self):
         """Close connection"""
 
+    def discard_output(self):
+        """Discard buffered output not yet transmitted (no-op by default).
+
+        Serial connections override this; needed before closing a port with
+        undeliverable queued data, otherwise close() blocks waiting to drain.
+        """
+
     def hard_reset(self):
         """Hardware reset (only available on serial connections)"""
         raise NotImplementedError("Hardware reset not available on this connection")

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/conn_serial.py

@@ -46,6 +46,19 @@ class ConnSerial(_conn.Conn):
     def __del__(self):
         self.close()
 
+    def discard_output(self):
+        """Discard kernel TX buffer (data written but not yet transmitted).
+
+        Without this, closing the port blocks while the kernel waits to drain
+        output the device never consumed (e.g. keystrokes sent to a device not
+        reading its USB-CDC, after leaving the REPL).
+        """
+        if self._serial:
+            try:
+                self._serial.reset_output_buffer()
+            except OSError:
+                pass
+
     @property
     def fd(self):
         return self._serial.fd if self._serial else None

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/conn_socket.py

@@ -1,11 +1,14 @@
 """MicroPython tool: socket connector"""
 
 import socket as _socket
+import ssl as _ssl
 import mpytool.conn as _conn
 
 
 class ConnSocket(_conn.Conn):
-    def __init__(self, address, log=None):
+    def __init__(
+            self, address, log=None, ssl=False, ssl_verify=True,
+            ssl_ca=None, ssl_check_hostname=True):
         super().__init__(log)
         self._socket = None
         sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
@@ -16,14 +19,31 @@ class ConnSocket(_conn.Conn):
         else:
             host = address
             port = 23
+        proto = "ssl" if ssl else "tcp"
         if log:
-            log.info(f"Connecting to: {host}:{port}")
+            log.info(f"Connecting to: {host}:{port} [{proto}]")
         try:
             sock.connect((host, port))
         except _socket.timeout as err:
+            sock.close()
             raise _conn.ConnError(f"Timeout connecting to {host}:{port}") from err
         except _socket.error as err:
+            sock.close()
             raise _conn.ConnError(f"Cannot connect to {host}:{port}: {err}") from err
+        if ssl:
+            try:
+                context = _ssl.create_default_context()
+                if not ssl_verify:
+                    context.check_hostname = False
+                    context.verify_mode = _ssl.CERT_NONE
+                elif not ssl_check_hostname:
+                    context.check_hostname = False
+                if ssl_ca:
+                    context.load_verify_locations(ssl_ca)
+                sock = context.wrap_socket(sock, server_hostname=host)
+            except (_ssl.SSLError, OSError) as err:
+                sock.close()
+                raise _conn.ConnError(f"SSL error: {err}") from err
         sock.settimeout(None)
         sock.setblocking(False)
         self._socket = sock
@@ -51,8 +71,12 @@ class ConnSocket(_conn.Conn):
             if data:
                 self._log.debug("RX: %r", data)
                 return data
-        except BlockingIOError:
+            # recv() returned b'' = peer closed connection
+            raise _conn.ConnError("Connection closed")
+        except (BlockingIOError, _ssl.SSLWantReadError):
             pass
+        except _conn.ConnError:
+            raise
         except OSError as err:
             raise _conn.ConnError(f"Connection lost: {err}") from err
         return None
@@ -64,5 +88,7 @@ class ConnSocket(_conn.Conn):
         self._log.debug("TX: %r", data)
         try:
             return self._socket.send(data)
+        except _ssl.SSLWantWriteError:
+            return 0
         except OSError as err:
             raise _conn.ConnError(f"Connection lost: {err}") from err

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/mpy.py

@@ -1329,6 +1329,29 @@ def _mt_pfind(label):
             return True
         return False
 
+    def wipe(self, reconnect=True, timeout=None, on_delete=None):
+        """Erase all files from filesystem root, then machine-reset device
+
+        Deletes every entry in '/' recursively, then performs a full
+        machine.reset() so runtime state (open sockets, WiFi, mounted VFS,
+        etc.) is dropped too - a soft reset would leave those alive. Intended
+        for a clean slate, e.g. at the start of integration tests.
+
+        Arguments:
+            reconnect: if True, wait for the device to come back after reset
+            timeout: reconnect timeout in seconds (None = default)
+            on_delete: optional callback(path) invoked before each delete
+
+        Returns:
+            True if reconnected after reset, False otherwise
+        """
+        for name, _ in self.ls('/'):
+            path = '/' + name
+            if on_delete is not None:
+                on_delete(path)
+            self.delete(path)
+        return self.machine_reset(reconnect=reconnect, timeout=timeout)
+
     def machine_bootloader(self):
         """Enter bootloader using machine.bootloader()
 

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/mpytool.py

@@ -31,7 +31,7 @@ else:
 # Order of commands in help and completion
 _CMD_ORDER = [
     'ls', 'tree', 'cat', 'cp', 'mv', 'mkdir', 'rm', 'pwd', 'cd', 'path',
-    'stop', 'reset', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
+    'stop', 'reset', 'wipe', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
     'rtc', 'flash', 'mount', 'ln', 'speedtest', 'sleep', 'ports',
 ]
 
@@ -182,12 +182,17 @@ class MpyTool():
     def __init__(
             self, conn=None, log=None, verbose=None, exclude_dirs=None,
             force=False, compress=None, chunk_size=None,
-            port=None, address=None, baudrate=115200):
+            port=None, address=None, baudrate=115200,
+            ssl=False, ssl_verify=True, ssl_ca=None, ssl_check_hostname=True):
         # Connection can be provided directly or created lazily from parameters
         self._conn = conn
         self._port = port
         self._address = address
         self._baudrate = baudrate
+        self._ssl = ssl
+        self._ssl_verify = ssl_verify
+        self._ssl_ca = ssl_ca
+        self._ssl_check_hostname = ssl_check_hostname
         self._log = log if log is not None else _logger.SimpleColorLogger()
         self._verbose_out = verbose  # None = no verbose output (API mode)
         self._exclude_dirs = {'.*', '*.pyc', '__pycache__'}
@@ -226,9 +231,12 @@ class MpyTool():
                 self._log.verbose(f"Connected to {port_col} {desc}", level=2)
             elif self._address:
                 self._conn = _mpytool.ConnSocket(
-                    address=self._address, log=self._log)
+                    address=self._address, log=self._log,
+                    ssl=self._ssl, ssl_verify=self._ssl_verify,
+                    ssl_ca=self._ssl_ca, ssl_check_hostname=self._ssl_check_hostname)
+                proto = "ssl" if self._ssl else "socket"
                 self._log.verbose(
-                    f"Connected to {self._address} [socket]", level=2)
+                    f"Connected to {self._address} [{proto}]", level=2)
         return self._conn
 
     @property
@@ -465,6 +473,9 @@ class MpyTool():
         self.verbose("REPL (Ctrl+] to exit)", 1)
         terminal = _terminal.Terminal(self.conn, self._log)
         terminal.run()
+        # Drop keystrokes the device never consumed, so close() doesn't block
+        # waiting to drain the kernel TX buffer.
+        self.conn.discard_output()
         self._log.info('Exiting..')
 
     def cmd_ota(self, firmware_path):
@@ -759,6 +770,21 @@ class MpyTool():
             except (NotImplementedError, _mpytool.ConnError) as err:
                 raise _mpytool.MpyError(f"Bootloader reset failed: {err}")
 
+    def cmd_wipe(self, reconnect=True, timeout=None):
+        """Erase all files from root, then machine-reset the device"""
+        self.verbose("WIPE", 1)
+        try:
+            self.mpy.wipe(
+                reconnect=reconnect, timeout=timeout,
+                on_delete=lambda path: self.verbose(f"  rm {path}", 1))
+        except (_mpytool.ConnError, OSError) as err:
+            self.verbose(f"  reconnect failed: {err}", 1, color='red')
+            raise _mpytool.ConnError(f"Reconnect failed: {err}")
+        if reconnect:
+            self.verbose("  reset, reconnected", 1, color='green')
+        else:
+            self.verbose("  reset", 1)
+
     @command('ls', 'List files and directories on device.')
     @argument('path', nargs='?', default=':', metavar='remote',
         type=_normalize_path_arg, help='device path (default: CWD)')
@@ -911,6 +937,18 @@ class MpyTool():
         reconnect = has_more if mode in ('machine', 'rts') else True
         self.cmd_reset(mode=mode, reconnect=reconnect, timeout=args.timeout)
 
+    @command('wipe', 'Erase ALL files and machine-reset the device.')
+    @option('-y', '--yes', action='store_true',
+        help='no-op (wipe never prompts), accepted for convenience')
+    @option('-t', '--timeout', type=int,
+        help='reconnect timeout in seconds')
+    def _dispatch_wipe(self, commands, is_last_group):
+        args, commands[:] = _make_parser(
+            self._dispatch_wipe).parse_known_args(commands)
+        # Reconnect only if more work follows; pointless if wipe is last.
+        has_more = bool(commands) or not is_last_group
+        self.cmd_wipe(reconnect=has_more, timeout=args.timeout)
+
     @command('monitor', 'Monitor device output until program ends.')
     @option('-f', '--follow', action='store_true',
         help='follow output continuously (Ctrl-C to stop)')
@@ -1430,7 +1468,7 @@ class MpyTool():
 
     _COMMANDS = frozenset({
         'ls', 'tree', 'cat', 'mkdir', 'rm', 'pwd', 'cd', 'path',
-        'reset', 'stop', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
+        'reset', 'wipe', 'stop', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
         'rtc', 'flash', 'sleep', 'cp', 'mv', 'mount', 'ln', 'speedtest',
         'ports', '_paths', '_commands', '_options', '_args',
     })
@@ -1547,6 +1585,16 @@ def _build_main_parser():
         "-V", "--version", action='version', version=_VERSION_STR)
     parser.add_argument('-p', '--port', help="serial port")
     parser.add_argument('-a', '--address', help="network address")
+    parser.add_argument(
+        '--ssl', action='store_true', help='use SSL/TLS for network connection')
+    parser.add_argument(
+        '--ssl-no-verify', action='store_true',
+        help='disable SSL certificate verification (insecure)')
+    parser.add_argument(
+        '--ssl-ca', metavar='FILE', help='CA certificate file for SSL verification')
+    parser.add_argument(
+        '--ssl-no-hostname', action='store_true',
+        help='disable SSL hostname/IP verification (verify cert only)')
     parser.add_argument(
         '-b', '--baud', type=int, default=115200, help="baud rate")
     parser.add_argument(
@@ -1600,11 +1648,17 @@ def main():
         compress = False
     elif args.compress:
         compress = True
+    # SSL: --ssl-no-verify, --ssl-ca or --ssl-no-hostname implies --ssl
+    use_ssl = args.ssl or args.ssl_no_verify or args.ssl_ca or args.ssl_no_hostname
+    ssl_verify = not args.ssl_no_verify
+    ssl_check_hostname = not args.ssl_no_hostname
     # Create MpyTool with lazy connection initialization
     mpy_tool = MpyTool(
         log=log, verbose=log, exclude_dirs=args.exclude,
         force=args.force, compress=compress, chunk_size=args.chunk_size,
-        port=args.port, address=args.address, baudrate=args.baud)
+        port=args.port, address=args.address, baudrate=args.baud,
+        ssl=use_ssl, ssl_verify=ssl_verify, ssl_ca=args.ssl_ca,
+        ssl_check_hostname=ssl_check_hostname)
     command_groups = _utils.split_commands(args.commands)
     try:
         with_progress = args.verbose >= 1

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/terminal.py

@@ -16,6 +16,10 @@ class TerminalBase:
         self._log = log
         self._conn = conn
         self._running = None
+        # Pending keystrokes to send to device. Buffered here and flushed only
+        # when the connection fd is writable, so a blocking write (e.g. device
+        # not draining USB-CDC) never stalls the loop and breaks Ctrl+] exit.
+        self._tx_buf = bytearray()
 
     def _setup(self):
         """Set terminal to raw mode (platform-specific)"""
@@ -43,7 +47,17 @@ class TerminalBase:
             self._running = False
             return
         if data:
-            self._conn.write(data)
+            self._tx_buf += data
+
+    def _flush_tx(self):
+        """Send buffered keystrokes to device (blocking write).
+
+        Platforms that gate this on fd writability avoid blocking; the base
+        implementation is used where writability can't be polled.
+        """
+        if self._tx_buf:
+            self._conn.write(bytes(self._tx_buf))
+            del self._tx_buf[:]
 
     def _read_event_device(self):
         data = self._conn.read()

mpytool-2.4.0/mpytool/terminal_unix.py

@@ -0,0 +1,65 @@
+"""MicroPython tool: Unix terminal (tty/termios/select)"""
+
+import os as _os
+import sys as _sys
+import select as _select
+import tty as _tty
+import termios as _termios
+
+from mpytool.terminal import TerminalBase
+
+
+class Terminal(TerminalBase):
+
+    def __init__(self, conn, log):
+        super().__init__(conn, log)
+        self._stdin_fd = _sys.stdin.fileno()
+        self._orig_attr = _termios.tcgetattr(self._stdin_fd)
+
+    def __del__(self):
+        if self._orig_attr:
+            _termios.tcsetattr(
+                self._stdin_fd, _termios.TCSANOW, self._orig_attr)
+
+    def _setup(self):
+        _tty.setraw(self._stdin_fd)
+
+    def _restore(self):
+        if self._orig_attr:
+            _termios.tcsetattr(
+                self._stdin_fd, _termios.TCSANOW, self._orig_attr)
+            self._orig_attr = None
+
+    def read(self):
+        return _sys.stdin.buffer.raw.read(1)
+
+    def _flush_tx(self):
+        """Write a partial chunk without blocking.
+
+        Called only when the connection fd is writable, so os.write() writes
+        as much as fits and returns immediately; the rest stays buffered for
+        the next writable event.
+        """
+        if not self._tx_buf:
+            return
+        try:
+            count = _os.write(self._conn.fd, self._tx_buf)
+        except BlockingIOError:
+            return
+        if count:
+            self._log.debug('TX: %r', bytes(self._tx_buf[:count]))
+            del self._tx_buf[:count]
+
+    def _loop(self):
+        rd_fds = [self._stdin_fd, self._conn.fd]
+        while self._running:
+            # Only watch for writability while there is something to send,
+            # otherwise select() would busy-loop on the always-writable fd.
+            wr_fds = [self._conn.fd] if self._tx_buf else []
+            readable, writable, _ = _select.select(rd_fds, wr_fds, [], 1)
+            if self._stdin_fd in readable:
+                self._read_event_terminal()
+            if self._conn.fd in readable:
+                self._read_event_device()
+            if self._conn.fd in writable:
+                self._flush_tx()

{mpytool-2.3.6 → mpytool-2.4.0}/mpytool/terminal_win.py

@@ -81,6 +81,9 @@ class Terminal(TerminalBase):
             if _msvcrt.kbhit():
                 self._read_event_terminal()
                 activity = True
+            if self._tx_buf:
+                self._flush_tx()
+                activity = True
             if self._conn._has_data(0):
                 self._read_event_device()
                 activity = True