replx 1.22.2__tar.gz → 1.25.0__tar.gz

replx-1.25.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: replx
+Version: 1.25.0
+Summary: replx is a fast, modern MicroPython CLI: turbo REPL, robust file sync (put/get), project install, mpy-cross integration, and smart port discovery.
+Author-email: "chanmin.park" <devcamp@planxlab.com>
+License-Expression: MIT
+Project-URL: Homepage, https://planxlab.com
+Project-URL: Repository, https://github.com/PlanXLab/replx
+Project-URL: Issues, https://github.com/PlanXLab/replx/issues
+Keywords: micropython,repl,serial,pyserial,typer,mpy-cross,deploy,gpio,i2c,spi,uart,pwm,adc,i2s,ws2812
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: System :: Hardware :: Universal Serial Bus (USB)
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.4.2
+Requires-Dist: typer>=0.27.0
+Requires-Dist: rich>=13.0
+Requires-Dist: pyserial>=3.5
+Requires-Dist: mpy-cross>=1.27.0
+Requires-Dist: psutil>=7.2.2
+Dynamic: license-file
+
+# replx
+
+[![PyPI version](https://badge.fury.io/py/replx.svg)](https://pypi.org/project/replx/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**A cross-platform command-line toolkit for MicroPython development.** replx runs a shared local agent so multiple terminals can work with multiple boards while reusing connections and session state.
+
+## Features
+
+- Works on Windows, Linux, and macOS.
+- Connect to multiple boards from multiple terminals, with per-session foreground and background devices.
+- Discover boards, configure a workspace default, and set up VS Code MicroPython support.
+- Run scripts and snippets, use the interactive REPL, and sync files and directories.
+- Search and install packages with `mip` or `pkg`; compile `.py` files to `.mpy`.
+- Work with GPIO, PWM, ADC, UART, SPI, I2C, I2S, BLE, and WS2812 devices (availability depends on board and firmware).
+- Use MicroPython raw-paste for code submissions of 4 KiB or larger when supported; batched file uploads keep the standard raw path for throughput.
+
+## Install
+
+```sh
+python -m pip install replx
+```
+
+This installs both `replx` and the `rx` command.
+
+## Quick start
+
+```sh
+replx scan
+replx COM4 setup
+replx status
+replx -c "print('Hello from MicroPython')"
+replx run main.py
+replx repl
+```
+
+Replace `COM4` with the board's serial port, such as `/dev/ttyUSB0` on Linux or `/dev/cu.usbmodem14101` on macOS. After `setup`, the configured board can usually be targeted without repeating the port; specify a port when working with another board.
+
+## Documentation
+
+This PyPI page is a short overview and quick start. See the [full command reference and user manual on GitHub](https://github.com/PlanXLab/replx) for connection/session behavior, commands, options, examples, and troubleshooting.
+
+- [GitHub repository](https://github.com/PlanXLab/replx)
+- [Report an issue](https://github.com/PlanXLab/replx/issues)
+- [Website](https://planxlab.com)

replx-1.25.0/README.md

@@ -0,0 +1,46 @@
+# replx
+
+[![PyPI version](https://badge.fury.io/py/replx.svg)](https://pypi.org/project/replx/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**A cross-platform command-line toolkit for MicroPython development.** replx runs a shared local agent so multiple terminals can work with multiple boards while reusing connections and session state.
+
+## Features
+
+- Works on Windows, Linux, and macOS.
+- Connect to multiple boards from multiple terminals, with per-session foreground and background devices.
+- Discover boards, configure a workspace default, and set up VS Code MicroPython support.
+- Run scripts and snippets, use the interactive REPL, and sync files and directories.
+- Search and install packages with `mip` or `pkg`; compile `.py` files to `.mpy`.
+- Work with GPIO, PWM, ADC, UART, SPI, I2C, I2S, BLE, and WS2812 devices (availability depends on board and firmware).
+- Use MicroPython raw-paste for code submissions of 4 KiB or larger when supported; batched file uploads keep the standard raw path for throughput.
+
+## Install
+
+```sh
+python -m pip install replx
+```
+
+This installs both `replx` and the `rx` command.
+
+## Quick start
+
+```sh
+replx scan
+replx COM4 setup
+replx status
+replx -c "print('Hello from MicroPython')"
+replx run main.py
+replx repl
+```
+
+Replace `COM4` with the board's serial port, such as `/dev/ttyUSB0` on Linux or `/dev/cu.usbmodem14101` on macOS. After `setup`, the configured board can usually be targeted without repeating the port; specify a port when working with another board.
+
+## Documentation
+
+This PyPI page is a short overview and quick start. See the [full command reference and user manual on GitHub](https://github.com/PlanXLab/replx) for connection/session behavior, commands, options, examples, and troubleshooting.
+
+- [GitHub repository](https://github.com/PlanXLab/replx)
+- [Report an issue](https://github.com/PlanXLab/replx/issues)
+- [Website](https://planxlab.com)

{replx-1.22.2 → replx-1.25.0}/pyproject.toml

@@ -34,7 +34,7 @@ dependencies = [
 [project.optional-dependencies]
 
 [project.urls]
-Homepage = "https://github.com/PlanXLab/replx"
+Homepage = "https://planxlab.com"
 Repository = "https://github.com/PlanXLab/replx"
 Issues = "https://github.com/PlanXLab/replx/issues"
 

{replx-1.22.2 → replx-1.25.0}/replx/__init__.py

@@ -1,5 +1,5 @@
 __all__ = ["__version__", "get_version", "__description__"]
-__version__ = "1.22.2"
+__version__ = "1.25.0"
 __description__ = "Fast, modern MicroPython CLI with REPL, file sync, install, and smart port detection."
 __author__ = "PlanX Lab Development Team"
 

{replx-1.22.2 → replx-1.25.0}/replx/cli/agent/__init__.py

@@ -1,6 +1,7 @@
 
+from importlib import import_module
+
 from .protocol import AgentProtocol
-from .client import AgentClient, get_session_id, get_cached_session_id, clear_session_cache
 
 __all__ = [
     'AgentProtocol',
@@ -14,8 +15,14 @@ __all__ = [
 
 
 def __getattr__(name):
-    # The server stack pulls in ``replx.terminal`` (~150ms) plus all command
-    # handlers; CLI clients never need it. Defer until something actually asks.
+    if name in {
+        'AgentClient',
+        'get_session_id',
+        'get_cached_session_id',
+        'clear_session_cache',
+    }:
+        return getattr(import_module('.client', __name__), name)
+
     if name == 'AgentServer':
         from .server import AgentServer
 

{replx-1.22.2 → replx-1.25.0}/replx/cli/agent/protocol.py

@@ -9,6 +9,7 @@ from replx.utils.constants import MAX_PAYLOAD_SIZE
 
 _MAGIC = b'RPLX'
 _VERSION = 1
+_HEADER = struct.Struct('!4sBI')
 
 _seq_lock = threading.Lock()
 _seq_counter = int(time.time() * 1000000) & 0xFFFFFFFE  # even start
@@ -24,38 +25,32 @@ def _next_seq() -> int:
 class AgentProtocol:
     @staticmethod
     def encode_message(msg: Dict[str, Any]) -> bytes:
-        payload = json.dumps(msg).encode('utf-8')
+        payload = json.dumps(msg, separators=(',', ':')).encode('utf-8')
 
         if len(payload) > MAX_PAYLOAD_SIZE:
             raise ValueError(f"Message too large: {len(payload)} bytes")
 
-        header = (
-            _MAGIC +
-            struct.pack('!B', _VERSION) +
-            struct.pack('!I', len(payload))
-        )
+        header = _HEADER.pack(_MAGIC, _VERSION, len(payload))
 
         return header + payload
 
     @staticmethod
     def decode_message(data: bytes) -> Optional[Dict[str, Any]]:
-        if len(data) < 9:
+        if len(data) < _HEADER.size:
             return None
 
-        if data[:4] != _MAGIC:
+        magic, version, length = _HEADER.unpack_from(data)
+        if magic != _MAGIC:
             return None
 
-        version = struct.unpack('!B', data[4:5])[0]
         if version != _VERSION:
             return None
 
-        length = struct.unpack('!I', data[5:9])[0]
-
-        if len(data) < 9 + length:
+        payload_end = _HEADER.size + length
+        if len(data) < payload_end:
             return None
 
-        payload = data[9:9+length]
-        return json.loads(payload.decode('utf-8'))
+        return json.loads(data[_HEADER.size:payload_end])
 
     @staticmethod
     def create_request(command: str, seq: int = None, ppid: int = None, port: str = None, **args) -> Dict[str, Any]:

{replx-1.22.2 → replx-1.25.0}/replx/cli/agent/server/connection_manager.py

@@ -2,9 +2,10 @@ import re
 import sys
 import time
 import threading
+from collections import deque
 from concurrent.futures import Future as ConcurrentFuture
 from dataclasses import dataclass, field
-from typing import Optional, Dict, Any, List, Tuple
+from typing import Optional, Dict, Any, Deque, List, Tuple
 
 from replx.protocol import ReplProtocol, create_storage
 from replx.utils import parse_device_banner, canon_port as _shared_canon_port
@@ -58,7 +59,7 @@ class InteractiveSessionState:
     seq: int = 0
     client_addr: Optional[tuple] = None
     echo: bool = True
-    input_queue: List[Any] = field(default_factory=list)
+    input_queue: Deque[bytes] = field(default_factory=deque)
     stop_requested: bool = False
     thread: Optional[threading.Thread] = None
     error: Optional[str] = None
@@ -71,7 +72,7 @@ class InteractiveSessionState:
             self.seq = seq
             self.client_addr = client_addr
             self.echo = echo
-            self.input_queue = []
+            self.input_queue.clear()
             self.stop_requested = False
             self.error = None
 
@@ -82,7 +83,7 @@ class InteractiveSessionState:
             self.ppid = None
             self.seq = 0
             self.client_addr = None
-            self.input_queue = []
+            self.input_queue.clear()
             self.stop_requested = False
             thread_to_join = self.thread
             self.thread = None
@@ -104,14 +105,14 @@ class ReplSessionState:
     ppid: Optional[int] = None
     reader_future: Optional[ConcurrentFuture] = None
     reader_thread: Optional[threading.Thread] = None
-    output_buffer: bytes = b""
+    output_buffer: bytearray = field(default_factory=bytearray)
     buffer_lock: threading.Lock = field(default_factory=threading.Lock)
 
     def start(self, ppid: int):
         self.active = True
         self.ppid = ppid
         with self.buffer_lock:
-            self.output_buffer = b""
+            self.output_buffer.clear()
 
     def stop(self):
         self.active = False
@@ -123,7 +124,7 @@ class ReplSessionState:
             self.reader_thread.join(timeout=1)
             self.reader_thread = None
         with self.buffer_lock:
-            self.output_buffer = b""
+            self.output_buffer.clear()
 
     def is_owner(self, ppid: int) -> bool:
         if ppid is None:
@@ -134,13 +135,13 @@ class ReplSessionState:
 
     def append_output(self, data: bytes):
         with self.buffer_lock:
-            self.output_buffer += data
+            self.output_buffer.extend(data)
 
     def read_output(self) -> bytes:
         with self.buffer_lock:
             data = self.output_buffer
-            self.output_buffer = b""
-            return data
+            self.output_buffer = bytearray()
+        return bytes(data)
 
 @dataclass
 class BoardConnection:

{replx-1.22.2 → replx-1.25.0}/replx/cli/agent/server/core.py

@@ -617,10 +617,14 @@ class AgentServer(
         self._cache_response(client_addr, seq, encoded)
         self._safe_send(encoded, client_addr)
 
-    def _handle_request(self, data: bytes, client_addr: tuple):
+    def _handle_request(self, request: bytes | dict, client_addr: tuple):
         msg = None
         try:
-            msg = AgentProtocol.decode_message(data)
+            msg = (
+                AgentProtocol.decode_message(request)
+                if isinstance(request, bytes)
+                else request
+            )
             if not msg:
                 print(f"Invalid message from {client_addr}", file=sys.stderr)
                 return

{replx-1.22.2 → replx-1.25.0}/replx/cli/agent/server/handlers/exec.py

@@ -360,7 +360,7 @@ class ExecCommandsMixin:
                     input_data = None
                     with conn.interactive.lock:
                         if conn.interactive.input_queue:
-                            input_data = conn.interactive.input_queue.pop(0)
+                            input_data = conn.interactive.input_queue.popleft()
                     
                     if input_data:
                         try:

{replx-1.22.2 → replx-1.25.0}/replx/cli/agent/server/udp.py

@@ -17,6 +17,8 @@ FAST_COMMANDS: frozenset[str] = frozenset({
     'repl_read',
 })
 
+_RESPONSE_CACHE_MAX_BYTES = 16 * 1024 * 1024
+
 
 class AgentDatagramProtocol(asyncio.DatagramProtocol):
     __slots__ = ('_server',)
@@ -44,7 +46,8 @@ class AgentDatagramProtocol(asyncio.DatagramProtocol):
             if command in FAST_COMMANDS
             else server._slow_executor
         )
-        executor.submit(server._handle_request, data, addr)
+        request = msg if isinstance(msg, dict) else data
+        executor.submit(server._handle_request, request, addr)
 
     def error_received(self, exc: Exception) -> None:
         if self._server.running:
@@ -59,6 +62,7 @@ class UdpReliabilityMixin:
         self,
         *,
         response_cache_max: int = 512,
+        response_cache_max_bytes: int = _RESPONSE_CACHE_MAX_BYTES,
         last_seq_max: int = 256,
     ) -> None:
         self.last_seq: dict = {}
@@ -69,9 +73,10 @@ class UdpReliabilityMixin:
         self._send_lock = threading.Lock()
 
         self._response_cache: dict[tuple, bytes] = {}
-        self._response_cache_order: list[tuple] = []
+        self._response_cache_bytes = 0
         self._response_cache_lock = threading.Lock()
         self._RESPONSE_CACHE_MAX = response_cache_max
+        self._RESPONSE_CACHE_MAX_BYTES = response_cache_max_bytes
 
         self._stream_ack_events: dict[tuple, threading.Event] = {}
         self._stream_ack_lock = threading.Lock()
@@ -92,17 +97,20 @@ class UdpReliabilityMixin:
             return
         key = (client_addr, seq)
         with self._response_cache_lock:
-            if key in self._response_cache:
-                try:
-                    self._response_cache_order.remove(key)
-                except ValueError:
-                    pass
-            else:
-                if len(self._response_cache_order) >= self._RESPONSE_CACHE_MAX:
-                    oldest = self._response_cache_order.pop(0)
-                    self._response_cache.pop(oldest, None)
+            previous = self._response_cache.pop(key, None)
+            if previous is not None:
+                self._response_cache_bytes -= len(previous)
             self._response_cache[key] = data
-            self._response_cache_order.append(key)
+            self._response_cache_bytes += len(data)
+
+            # Dict insertion order provides the FIFO index without a second list.
+            while (
+                len(self._response_cache) > self._RESPONSE_CACHE_MAX
+                or self._response_cache_bytes > self._RESPONSE_CACHE_MAX_BYTES
+            ):
+                oldest = next(iter(self._response_cache))
+                evicted = self._response_cache.pop(oldest)
+                self._response_cache_bytes -= len(evicted)
 
     def _lookup_response(self, client_addr: tuple, seq: int) -> Optional[bytes]:
         with self._response_cache_lock:

{replx-1.22.2 → replx-1.25.0}/replx/cli/commands/exec.py

@@ -1536,7 +1536,7 @@ Start a live MicroPython session where you can type code line by line.
                     break
         else:
             while True:
-                char = getch()
+                char = _repl_getch()
                 
                 if char == b'\x00' or not char:
                     continue

{replx-1.22.2 → replx-1.25.0}/replx/protocol/repl.py

@@ -6,8 +6,6 @@ import threading
 from contextlib import contextmanager
 from typing import Callable, Optional
 
-import typer
-
 from replx.utils.exceptions import ProtocolError, TransportError
 from replx.utils.constants import (
     CTRL_A, CTRL_B, CTRL_C, CTRL_D, CTRL_E,
@@ -27,6 +25,8 @@ from replx.terminal import (
     getch, putch, getch_nonblock,
 )
 
+_RAW_PASTE_MIN_COMMAND_SIZE = 4 * 1024
+
 
 class ReplProtocol:
     _active_instance = None
@@ -133,7 +133,7 @@ class ReplProtocol:
     
     def _read_ex(self, min_num_bytes:int, ending:bytes, timeout:int=5,
                 data_consumer:Optional[Callable[[bytes], None]]=None) -> bytes:
-        start = time.time()
+        start = time.monotonic()
         deadline = (start + timeout) if timeout > 0 else None
         
         streaming_mode = (timeout == 0 and data_consumer is not None)
@@ -265,18 +265,18 @@ class ReplProtocol:
                             self._rx_pushback[:] = tail + self._rx_pushback
                         return _get_result()
 
-            last_activity = time.time()
-            last_keepalive = time.time()
+            last_activity = time.monotonic()
+            last_keepalive = time.monotonic()
             keepalive_interval = 30.0
 
             while True:
                 if self._stop_event.is_set():
                     break
                 
-                if deadline is not None and time.time() >= deadline:
+                if deadline is not None and time.monotonic() >= deadline:
                     break
                 
-                now = time.time()
+                now = time.monotonic()
                 if streaming_mode and (now - last_keepalive) >= keepalive_interval:
                     try:
                         if hasattr(self.transport, 'keep_alive'):
@@ -294,7 +294,7 @@ class ReplProtocol:
                     chunk = _read_some(want)
                     if chunk:
                         pos = _feed_chunk(chunk)
-                        last_activity = time.time()
+                        last_activity = time.monotonic()
                         if pos >= 0:
                             tail = chunk[pos:]
                             if tail:
@@ -307,7 +307,7 @@ class ReplProtocol:
 
                     if timeout > 0:
                         idle_limit = max(timeout * 2, 10)
-                        if (time.time() - last_activity) > idle_limit:
+                        if (time.monotonic() - last_activity) > idle_limit:
                             break
 
             return _get_result()
@@ -434,10 +434,10 @@ class ReplProtocol:
         try:
             self.transport.write(RAW_PASTE_INIT)
             
-            start = time.time()
+            start = time.monotonic()
             timeout = 0.5
             response = b''
-            while len(response) < 2 and (time.time() - start) < timeout:
+            while len(response) < 2 and (time.monotonic() - start) < timeout:
                 waiting = self.transport.in_waiting()
                 if waiting > 0:
                     response += self._read(min(2 - len(response), waiting))
@@ -449,14 +449,16 @@ class ReplProtocol:
                 return False
             
             if response == RAW_PASTE_SUPPORTED:
-                init_bytes = self._read(3)
-                if len(init_bytes) >= 2:
-                    self._raw_paste_window_size = struct.unpack('<H', init_bytes[:2])[0]
-                    self._raw_paste_supported = True
-                    return True
-                else:
-                    self._raw_paste_supported = False
-                    return False
+                window_bytes = self._read(2)
+                if len(window_bytes) == 2:
+                    window_size = struct.unpack('<H', window_bytes)[0]
+                    if window_size > 0:
+                        self._raw_paste_window_size = window_size
+                        self._raw_paste_supported = True
+                        return True
+
+                self._raw_paste_supported = False
+                return False
                     
             elif response == RAW_PASTE_NOT_SUPPORTED:
                 self._raw_paste_supported = False
@@ -513,13 +515,13 @@ class ReplProtocol:
             pass
 
     def _exec_raw_paste(self, command: bytes, data_consumer: Optional[Callable[[bytes], None]] = None) -> tuple[bytes, bytes]:
-        remaining_window = self._raw_paste_window_size * 2
+        remaining_window = self._raw_paste_window_size
         bytes_sent = 0
         command_len = len(command)
         aborted = False
         
         while bytes_sent < command_len:
-            while remaining_window <= 0:
+            while remaining_window <= 0 or self.transport.in_waiting() > 0:
                 fc_byte = self._read(1)
                 if fc_byte == RAW_PASTE_WINDOW_INC:
                     remaining_window += self._raw_paste_window_size
@@ -527,27 +529,19 @@ class ReplProtocol:
                     self.transport.write(CTRL_D)
                     aborted = True
                     break
-            
+                elif fc_byte:
+                    raise ProtocolError(
+                        f"Unexpected raw-paste flow-control byte: {fc_byte!r}"
+                    )
+
             if aborted:
                 break
-            
+
             chunk_size = min(remaining_window, command_len - bytes_sent)
             chunk = command[bytes_sent:bytes_sent + chunk_size]
             self.transport.write(chunk)
             bytes_sent += chunk_size
             remaining_window -= chunk_size
-            
-            while self.transport.in_waiting() > 0:
-                fc_byte = self._read(1)
-                if fc_byte == RAW_PASTE_WINDOW_INC:
-                    remaining_window += self._raw_paste_window_size
-                elif fc_byte == RAW_PASTE_END_DATA:
-                    self.transport.write(CTRL_D)
-                    aborted = True
-                    break
-            
-            if aborted:
-                break
         
         if not aborted and bytes_sent == command_len:
             self.transport.write(CTRL_D)
@@ -570,7 +564,7 @@ class ReplProtocol:
 
     def _exec(self, command:str|bytes, interactive:bool=False, echo:bool=False, detach:bool=False, 
               data_consumer:Optional[Callable[[bytes], None]]=None,
-              force_raw_paste:bool=False) -> bytes:
+              force_raw_paste:Optional[bool]=None) -> bytes:
         self._stop_event.clear()
         self._reset_error_filter()
         
@@ -591,7 +585,7 @@ class ReplProtocol:
 
     def _exec_command(self, command: bytes, interactive: bool, echo: bool, detach: bool,
                       data_consumer: Optional[Callable[[bytes], None]],
-                      force_raw_paste: bool) -> bytes:
+                      force_raw_paste: Optional[bool]) -> bytes:
         data_err = b''
         if data_consumer is None and interactive:
             data_consumer = self._create_data_consumer()
@@ -603,7 +597,10 @@ class ReplProtocol:
 
         command_len = len(command)
 
-        use_raw_paste = force_raw_paste and self._enter_raw_paste_mode()
+        prefer_raw_paste = force_raw_paste
+        if prefer_raw_paste is None:
+            prefer_raw_paste = command_len >= _RAW_PASTE_MIN_COMMAND_SIZE
+        use_raw_paste = prefer_raw_paste and self._enter_raw_paste_mode()
         
         if use_raw_paste:
             try:
@@ -630,7 +627,7 @@ class ReplProtocol:
         current_buffer_size = self._DEVICE_CHUNK_SIZES
         bytes_sent = 0
         
-        start_time = time.time()
+        start_time = time.monotonic()
         
         while bytes_sent < command_len:
             chunk_end = min(bytes_sent + current_buffer_size, command_len)
@@ -644,7 +641,7 @@ class ReplProtocol:
         
         self.transport.write(EOF_MARKER)
         
-        transfer_time = time.time() - start_time
+        transfer_time = time.monotonic() - start_time
         timeout = max(5, int(transfer_time * 2))
         
         data = self._read_ex(1, OK_RESPONSE, timeout=timeout)
@@ -742,8 +739,8 @@ class ReplProtocol:
         return data_consumer
 
     def _drain_eof(self, max_ms:int=200):
-        deadline = time.time() + max_ms / 1000
-        while time.time() < deadline:
+        deadline = time.monotonic() + max_ms / 1000
+        while time.monotonic() < deadline:
             waiting = self.transport.in_waiting()
             if waiting:
                 _ = self._read(waiting) 
@@ -826,6 +823,8 @@ class ReplProtocol:
     
     def run(self, local, interactive:bool=False, echo:bool=False):
         if not interactive and echo:
+            import typer
+
             raise typer.BadParameter("Option chaining error: -n and -e can only be used once, not multiple times.")
         
         with open(local, "rb") as f:
@@ -900,8 +899,8 @@ class ReplProtocol:
             return
         time.sleep(0.1)
         
-        drain_timeout = time.time() + 0.5
-        while time.time() < drain_timeout:
+        drain_timeout = time.monotonic() + 0.5
+        while time.monotonic() < drain_timeout:
             if self.transport.in_waiting() > 0:
                 self.transport.read(self.transport.in_waiting())
                 time.sleep(0.02)
@@ -917,8 +916,8 @@ class ReplProtocol:
             print('')
             return
         
-        prompt_timeout = time.time() + 1.0
-        while time.time() < prompt_timeout:
+        prompt_timeout = time.monotonic() + 1.0
+        while time.monotonic() < prompt_timeout:
             time.sleep(0.05)
             if self._repl_prompt_detected:
                 break

{replx-1.22.2 → replx-1.25.0}/replx/protocol/storage.py

@@ -750,7 +750,8 @@ if chunk:
                                 return
 
                             code = ";\n".join(batch_src_lines)
-                            self.repl._exec(code)
+                            # Keep bulk file batches on raw REPL to avoid per-window flow-control overhead.
+                            self.repl._exec(code, force_raw_paste=False)
                             batch_src_lines = []
                             batch_bytes = 0
                             

{replx-1.22.2 → replx-1.25.0}/replx/terminal.py

@@ -199,7 +199,7 @@ else:
     _FD = sys.stdin.fileno()
 
     _terminal_state = threading.local()
-    _terminal_lock = threading.Lock()
+    _terminal_lock = threading.RLock()
 
     def _get_terminal_state():
         if not hasattr(_terminal_state, 'old_settings'):
@@ -501,4 +501,3 @@ class LineModeTerminal:
         self._scroll_bottom = self._rows - 1
         lmt_set_scroll_region(self._scroll_top, self._scroll_bottom)
         self._draw_input()
-