remotedesktop 0.10.0__tar.gz → 0.12.0__tar.gz

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.10.0
+Version: 0.12.0
 Summary: Remote desktop client/server for Windows computers on the same LAN, with autodiscovery. Provides screen, keyboard, mouse, and clipboard sharing without RDP or Microsoft authentication.
 Author-email: James Abel <j@abel.co>
 License-Expression: MIT

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/src/remotedesktop/__init__.py

@@ -1,3 +1,3 @@
 """Remote desktop client/server for Windows computers on the same LAN."""
 
-__version__ = "0.10.0"
+__version__ = "0.12.0"

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/src/remotedesktop/client.py

@@ -110,7 +110,10 @@ class ClientWindow(QMainWindow):
             InventoryTab(self.inventory, "Forget server", self._forget_server),
             "Servers on LAN",
         )
-        tabs.addTab(PerformanceTab(self.performance), "Performance")
+        tabs.addTab(
+            PerformanceTab(self.performance, local="client", remote="server"),
+            "Performance",
+        )
         self.setCentralWidget(tabs)
 
         self.discovery_panel = DiscoveryPanel(self)

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/src/remotedesktop/performance.py

@@ -30,13 +30,14 @@ All timing uses time.monotonic(), injectable as `clock=` for tests.
 
 import itertools
 import logging
+import math
 import time
 from collections import deque
 from collections.abc import Callable
 from typing import Protocol
 
 from PySide6.QtCore import QObject, QPointF, QTimer, Qt, Signal
-from PySide6.QtGui import QColor, QPainter, QPaintEvent, QPolygonF, QShowEvent
+from PySide6.QtGui import QColor, QPainter, QPaintEvent, QPen, QPolygonF, QShowEvent
 from PySide6.QtWidgets import QVBoxLayout, QWidget
 
 _log = logging.getLogger("remotedesktop.performance")
@@ -58,6 +59,7 @@ DEFAULT_INTERVAL_MS = 1000
 DEFAULT_DEAD_AFTER_SECONDS = 10.0
 _PING_PRUNE_SECONDS = 30.0
 _HEARTBEAT_TICKS = 10  # one debug-log line per this many samples
+_GRID_DIVISIONS = 4  # grid cells per axis, i.e. 5 ticks including both ends
 
 
 class MetricSeries:
@@ -270,6 +272,30 @@ def format_ms(ms: float) -> str:
     return f"{ms:.1f} ms"
 
 
+def rate_unit(bytes_per_second: float) -> float:
+    """The divisor format_rate will display this value in (B/KB/MB per s),
+    so axis ticks can be computed in the displayed unit and land on round
+    numbers there."""
+    if bytes_per_second >= 1024 * 1024:
+        return 1024.0 * 1024.0
+    if bytes_per_second >= 1024:
+        return 1024.0
+    return 1.0
+
+
+def nice_ceiling(value: float) -> float:
+    """Smallest 1/2/5 x 10^k that is >= value, so axis ticks land on round
+    numbers instead of the raw data maximum."""
+    if value <= 0:
+        return 1.0
+    exponent = math.floor(math.log10(value))
+    for multiplier in (1.0, 2.0, 5.0, 10.0):
+        candidate = multiplier * 10.0**exponent
+        if candidate >= value:
+            return candidate
+    raise AssertionError("unreachable: 10 * 10**floor(log10(v)) >= v")
+
+
 class GraphWidget(QWidget):
     """A rolling line graph over the monitor's window, painted with QPainter.
 
@@ -284,6 +310,7 @@ class GraphWidget(QWidget):
         monitor: PerformanceMonitor,
         format_value: Callable[[float], str],
         *,
+        tick_unit: Callable[[float], float] = lambda _value: 1.0,
         clock: Callable[[], float] = time.monotonic,
         parent: QWidget | None = None,
     ) -> None:
@@ -292,8 +319,12 @@ class GraphWidget(QWidget):
         self._series = series
         self._monitor = monitor
         self._format_value = format_value
+        # Maps the data maximum to the unit format_value displays it in, so
+        # the axis ceiling is a round number of that unit (100 KB/s, not the
+        # 97.7 KB/s that a round number of bytes/s would render as).
+        self._tick_unit = tick_unit
         self._clock = clock
-        self.setMinimumSize(300, 120)
+        self.setMinimumSize(300, 140)  # room for the axis-label rows
 
     def paintEvent(self, event: QPaintEvent) -> None:
         painter = QPainter(self)
@@ -313,12 +344,52 @@ class GraphWidget(QWidget):
                 self.rect(), Qt.AlignmentFlag.AlignCenter, "no data"
             )
             return
-        y_max = max(
+        raw_max = max(
             (value for _l, _c, samples in data for _t, value in samples), default=1.0
         )
-        y_max = max(y_max, 1.0)
+        unit = self._tick_unit(raw_max)
+        y_max = unit * nice_ceiling(raw_max / unit)
+
+        # Y tick labels (with units, via the formatter) size the left margin;
+        # the bottom leaves a row for X tick labels and one for the legend.
+        metrics = painter.fontMetrics()
+        y_ticks = [y_max * i / _GRID_DIVISIONS for i in range(_GRID_DIVISIONS + 1)]
+        y_labels = [self._format_value(v) for v in y_ticks]
+        left = 8 + max(metrics.horizontalAdvance(t) for t in y_labels) + 6
+        graph = self.rect().adjusted(left, 24, -12, -(2 * metrics.height() + 12))
+
+        grid_color = palette.color(palette.ColorRole.Mid)
+        grid_pen = QPen(grid_color, 0, Qt.PenStyle.DotLine)
+        text_color = palette.color(palette.ColorRole.Text)
+        for value, label in zip(y_ticks, y_labels):
+            y = graph.bottom() - graph.height() * (value / y_max)
+            painter.setPen(grid_pen)
+            painter.drawLine(graph.left(), round(y), graph.right(), round(y))
+            painter.setPen(text_color)
+            painter.drawText(
+                graph.left() - 6 - metrics.horizontalAdvance(label),
+                round(y) + metrics.ascent() // 2 - 1,
+                label,
+            )
+        x_label_baseline = graph.bottom() + metrics.ascent() + 4
+        for i in range(_GRID_DIVISIONS + 1):
+            seconds_ago = window * (1 - i / _GRID_DIVISIONS)
+            x = graph.left() + graph.width() * i / _GRID_DIVISIONS
+            painter.setPen(grid_pen)
+            painter.drawLine(round(x), graph.top(), round(x), graph.bottom())
+            label = f"{seconds_ago:g}"
+            width = metrics.horizontalAdvance(label)
+            # Center on the tick, but keep the edge labels inside the graph.
+            text_x = min(max(x - width / 2, graph.left()), graph.right() - width)
+            painter.setPen(text_color)
+            painter.drawText(round(text_x), x_label_baseline, label)
+        caption = "seconds ago"
+        painter.drawText(
+            self.rect().right() - 8 - metrics.horizontalAdvance(caption),
+            self.rect().bottom() - 6,
+            caption,
+        )
 
-        graph = self.rect().adjusted(8, 24, -8, -20)
         for label, color, samples in data:
             if not samples:
                 continue
@@ -336,14 +407,8 @@ class GraphWidget(QWidget):
             latest = samples[-1][1] if samples else None
             text = f"{label} {self._format_value(latest)}" if latest is not None else f"{label} —"
             painter.setPen(color)
-            painter.drawText(x, self.rect().bottom() - 6, text)
-            x += painter.fontMetrics().horizontalAdvance(text) + 16
-        painter.setPen(palette.color(palette.ColorRole.Text))
-        painter.drawText(
-            self.rect().right() - 8 - painter.fontMetrics().horizontalAdvance(self._format_value(y_max)),
-            16,
-            self._format_value(y_max),
-        )
+            painter.drawText(round(x), self.rect().bottom() - 6, text)
+            x += metrics.horizontalAdvance(text) + 16
 
 
 class PerformanceTab(QWidget):
@@ -353,7 +418,14 @@ class PerformanceTab(QWidget):
     monitor regardless, but a background tab schedules zero paint work.
     """
 
-    def __init__(self, monitor: PerformanceMonitor, parent: QWidget | None = None) -> None:
+    def __init__(
+        self,
+        monitor: PerformanceMonitor,
+        *,
+        local: str = "client",
+        remote: str = "server",
+        parent: QWidget | None = None,
+    ) -> None:
         super().__init__(parent)
         self._monitor = monitor
         self.bandwidth_graph = GraphWidget(
@@ -364,12 +436,16 @@ class PerformanceTab(QWidget):
             ],
             monitor,
             format_rate,
+            tick_unit=rate_unit,
         )
+        # Each line is named for the side that sent the ping, so the same
+        # line has the same name in both apps ("client → server" is the
+        # client-measured round trip on either end).
         self.ping_graph = GraphWidget(
             "Round-trip time",
             [
-                ("this side", QColor("#ff9800"), monitor.rtt_ms),
-                ("peer", QColor("#9c27b0"), monitor.peer_rtt_ms),
+                (f"{local} → {remote}", QColor("#ff9800"), monitor.rtt_ms),
+                (f"{remote} → {local}", QColor("#9c27b0"), monitor.peer_rtt_ms),
             ],
             monitor,
             format_ms,

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/src/remotedesktop/server.py

@@ -108,7 +108,10 @@ class ServerWindow(QMainWindow):
             InventoryTab(self.inventory, "Revoke access", self._revoke_client),
             "Clients on LAN",
         )
-        tabs.addTab(PerformanceTab(self.performance), "Performance")
+        tabs.addTab(
+            PerformanceTab(self.performance, local="server", remote="client"),
+            "Performance",
+        )
         tabs.addTab(log_tab, "Connection log")
         tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
         self.setCentralWidget(tabs)

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/src/remotedesktop/viewer.py

@@ -145,6 +145,14 @@ class ViewerWidget(QWidget):
             self._pressed_keys.discard(vk)
         self.inputEvent.emit({"action": "key", "vk": vk, "pressed": pressed})
 
+    def focusNextPrevChild(self, next: bool) -> bool:
+        # Qt consumes Tab/Shift+Tab for focus traversal before keyPressEvent
+        # ever runs; declining here makes them arrive as ordinary key events
+        # so they reach the remote desktop instead of moving local focus.
+        if self._frame is not None:
+            return False
+        return super().focusNextPrevChild(next)
+
     def keyPressEvent(self, event: QKeyEvent) -> None:
         self._key_event(event, True)
 

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/tests/test_input.py

@@ -207,6 +207,25 @@ def test_viewer_forwards_wheel_and_key_release(qapp):
     assert events[-1]["pressed"] is False
 
 
+def test_tab_key_is_forwarded_not_used_for_focus_traversal(qapp):
+    viewer = ViewerWidget()
+    viewer.resize(400, 400)
+    viewer.show_frame(QImage(200, 100, QImage.Format.Format_RGB32))
+    events: list[dict] = []
+    viewer.inputEvent.connect(events.append)
+    # Send Tab through the real event path: QWidget.event() offers it to
+    # focusNextPrevChild before keyPressEvent, which is what ate Tab.
+    tab = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_Tab, Qt.KeyboardModifier.NoModifier, 0, 0x09, 0)
+    qapp.sendEvent(viewer, tab)
+    assert events == [{"action": "key", "vk": 0x09, "pressed": True}]
+    # Shift+Tab arrives as Backtab and must be forwarded the same way.
+    backtab = QKeyEvent(
+        QEvent.Type.KeyPress, Qt.Key.Key_Backtab, Qt.KeyboardModifier.ShiftModifier, 0, 0x09, 0
+    )
+    qapp.sendEvent(viewer, backtab)
+    assert events[-1] == {"action": "key", "vk": 0x09, "pressed": True}
+
+
 def test_release_when_frame_vanished_mid_drag(qapp):
     viewer = ViewerWidget()
     viewer.resize(400, 400)

{remotedesktop-0.10.0 → remotedesktop-0.12.0}/tests/test_performance.py

@@ -12,6 +12,8 @@ from remotedesktop.performance import (
     MetricSeries,
     PerformanceMonitor,
     PerformanceTab,
+    nice_ceiling,
+    rate_unit,
 )
 from remotedesktop.protocol import MessageStream
 from remotedesktop.sharing import ShareClient, ShareServer
@@ -325,11 +327,52 @@ def test_share_client_drops_the_connection_on_lost_signal(qapp, tmp_path):
     assert any("Connection lost" in s and "10 s" in s for s in statuses)
 
 
+def test_nice_ceiling_rounds_up_to_1_2_5():
+    assert nice_ceiling(0.0) == 1.0
+    assert nice_ceiling(-3.0) == 1.0
+    assert nice_ceiling(0.7) == 1.0
+    assert nice_ceiling(1.0) == 1.0
+    assert nice_ceiling(1.5) == 2.0
+    assert nice_ceiling(3.0) == 5.0
+    assert nice_ceiling(42.0) == 50.0
+    assert nice_ceiling(50.0) == 50.0
+    assert nice_ceiling(99.0) == 100.0
+    assert nice_ceiling(2049.0) == 5000.0
+    assert nice_ceiling(0.03) == pytest.approx(0.05)
+
+
+def test_rate_unit_matches_format_rate_unit():
+    assert rate_unit(500.0) == 1.0
+    assert rate_unit(2048.0) == 1024.0
+    assert rate_unit(3 * 1024 * 1024) == 1024.0 * 1024.0
+    # A round tick count in the displayed unit: 70000 B/s displays in KB/s,
+    # and the resulting ceiling is 100 KB/s exactly.
+    unit = rate_unit(70000.0)
+    assert unit * nice_ceiling(70000.0 / unit) == 100.0 * 1024.0
+
+
+def test_rtt_lines_are_named_for_the_side_that_pings(qapp):
+    monitor = PerformanceMonitor()
+    client_tab = PerformanceTab(monitor, local="client", remote="server")
+    server_tab = PerformanceTab(monitor, local="server", remote="client")
+    # This side's own measurement (rtt_ms) is listed first; the same physical
+    # measurement carries the same name in both apps.
+    assert [label for label, _c, series in client_tab.ping_graph._series] == [
+        "client → server",
+        "server → client",
+    ]
+    assert [label for label, _c, series in server_tab.ping_graph._series] == [
+        "server → client",
+        "client → server",
+    ]
+
+
 def test_graph_widgets_render_headless(qapp):
     seeded = PerformanceMonitor()
     seeded.send_bps.add(100.0)
     seeded.send_bps.add(2048.0)
     seeded.recv_bps.add(50.0)
+    seeded.rtt_ms.add(12.5)  # exercises the RTT graph's grid/axes path too
     for monitor in (seeded, PerformanceMonitor()):  # data and "no data" paths
         tab = PerformanceTab(monitor)
         tab.resize(400, 300)