fix(network): persist ethernet off in the wired profile, move numpad dot left of zero

Author: gmmcosta15

BlocksScreen/lib/network/worker.py

@@ -437,24 +437,38 @@ async def _detect_interfaces(self) -> None:
             if not self._primary_wifi_path:
                 logger.warning("No Wi-Fi interface detected; ethernet-only mode")
 
+    async def _set_wired_profiles_autoconnect(self, enabled: bool) -> None:
+        """Persist autoconnect on every wired profile; Device.Autoconnect dies on NM restart."""
+        try:
+            paths = await self._nm_settings().list_connections()
+            for path, settings in await self._gather_settings(list(paths)):
+                conn = settings.get("connection", {})
+                if conn.get("type", (None, ""))[1] != "802-3-ethernet":
+                    continue
+                if bool(conn.get("autoconnect", ("b", True))[1]) == enabled:
+                    continue
+                props = {k: dict(v) for k, v in settings.items()}
+                props["connection"]["autoconnect"] = ("b", enabled)
+                props["connection"].pop("timestamp", None)
+                await self._conn_settings(path).update(props)
+                logger.info("Wired profile %s autoconnect -> %s", path, enabled)
+        except Exception as exc:
+            logger.warning("Wired profile autoconnect (%s) failed: %s", enabled, exc)
+
     async def _ensure_wired_autoconnect(self) -> None:
-        """Re-arm wired autoconnect; NM's Disconnect() latches it off for good.
+        """Re-arm wired autoconnect on both the device and the saved profiles.
 
-        Called only when the user asks for ethernet, so the latch keeps meaning
-        "user turned it off" everywhere else.  Best-effort: never propagates.
+        Called only when the user asks for ethernet, so autoconnect staying off
+        keeps meaning "user turned it off".  Best-effort: never propagates.
         """
         if not self._primary_wired_path:
             return
+        await self._set_wired_profiles_autoconnect(True)
         try:
             wired = self._generic(self._primary_wired_path)
-            state = await wired.state
-            auto = bool(await wired.autoconnect)
-            logger.debug(
-                "wired autoconnect check: state=%s autoconnect=%s", state, auto
-            )
-            if not auto:
+            if not await wired.autoconnect:
                 await wired.autoconnect.set_async(True)
-                logger.info("Re-armed wired autoconnect (was off, state=%s)", state)
+                logger.info("Re-armed wired device autoconnect")
         except Exception as exc:
             logger.warning("Wired autoconnect re-arm failed (non-fatal): %s", exc)
 
@@ -2139,8 +2153,9 @@ async def _async_disconnect_ethernet(self) -> None:
                 await asyncio.sleep(0.5)
                 if not await self._is_ethernet_connected():
                     break
-            # NM latches Device.Autoconnect off here; _ensure_wired_autoconnect re-arms it.
-            logger.info("Ethernet disconnected (autoconnect now latched off by NM)")
+            # Device.Autoconnect dies with NM; the profile flag is what survives.
+            await self._set_wired_profiles_autoconnect(False)
+            logger.info("Ethernet disconnected (wired profiles autoconnect off)")
         except Exception as exc:
             logger.error("Failed to disconnect ethernet: %s", exc)
 

BlocksScreen/lib/panels/widgets/keyboardPage.py

@@ -396,15 +396,15 @@ def _setup_numpad(self) -> None:
             grid.addWidget(btn, idx // 3, idx % 3)
             self._numpad_digits.append(btn)
 
+        # Bottom row keeps the digit grid: "." left, "0" centred under 8/5/2.
         zero = self._create_numpad_button("0", "np_0")
         zero.setProperty("position", "down")
-        grid.addWidget(zero, 3, 0, 1, 2)
+        grid.addWidget(zero, 3, 1)
         self._numpad_digits.append(zero)
 
-        # Bottom row is "0 ." like a phone pad; the right column is delete/enter.
         self.np_dot = self._create_numpad_button(".", "np_dot")
-        self.np_dot.setProperty("position", "right")
-        grid.addWidget(self.np_dot, 3, 2)
+        self.np_dot.setProperty("position", "left")
+        grid.addWidget(self.np_dot, 3, 0)
 
         self.np_delete = self._create_numpad_icon(
             "np_delete", ":/dialog/media/btn_icons/no.svg"

tests/network/test_worker_unit.py

@@ -2142,6 +2142,71 @@ def test_calls_state_and_connectivity(self, qapp):
         w._async_load_saved_networks.assert_awaited_once()
 
 
+class TestWiredProfilesAutoconnect:
+    """Device.Autoconnect dies on NM restart; only the profile flag persists."""
+
+    @staticmethod
+    def _wire_profiles(w, conn_type="802-3-ethernet", autoconnect=True):
+        nm_settings_proxy = AsyncProxyMock(
+            list_connections=AsyncMock(return_value=["/conn/eth"])
+        )
+        w._nm_settings = _ProxyFactory(nm_settings_proxy)
+        settings = {
+            "connection": {
+                "type": ("s", conn_type),
+                "autoconnect": ("b", autoconnect),
+                "timestamp": ("t", 123),
+            },
+            "ipv4": {"method": ("s", "auto")},
+        }
+        w._gather_settings = AsyncMock(return_value=[("/conn/eth", settings)])
+        conn_proxy = AsyncProxyMock(update=AsyncMock())
+        w._conn_settings = lambda path: conn_proxy
+        return conn_proxy
+
+    @pytest.mark.asyncio
+    async def test_disables_wired_profile(self, qapp):
+        w = _make_worker(qapp)
+        conn = self._wire_profiles(w, autoconnect=True)
+        await w._set_wired_profiles_autoconnect(False)
+        props = conn.update.await_args[0][0]
+        assert props["connection"]["autoconnect"] == ("b", False)
+
+    @pytest.mark.asyncio
+    async def test_strips_timestamp_nm_will_not_accept(self, qapp):
+        w = _make_worker(qapp)
+        conn = self._wire_profiles(w, autoconnect=True)
+        await w._set_wired_profiles_autoconnect(False)
+        assert "timestamp" not in conn.update.await_args[0][0]["connection"]
+
+    @pytest.mark.asyncio
+    async def test_reenables_wired_profile(self, qapp):
+        w = _make_worker(qapp)
+        conn = self._wire_profiles(w, autoconnect=False)
+        await w._set_wired_profiles_autoconnect(True)
+        assert conn.update.await_args[0][0]["connection"]["autoconnect"] == ("b", True)
+
+    @pytest.mark.asyncio
+    async def test_skips_when_already_correct(self, qapp):
+        w = _make_worker(qapp)
+        conn = self._wire_profiles(w, autoconnect=True)
+        await w._set_wired_profiles_autoconnect(True)
+        conn.update.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_ignores_non_ethernet_profiles(self, qapp):
+        w = _make_worker(qapp)
+        conn = self._wire_profiles(w, conn_type="802-11-wireless", autoconnect=True)
+        await w._set_wired_profiles_autoconnect(False)
+        conn.update.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_exception_is_non_fatal(self, qapp):
+        w = _make_worker(qapp)
+        w._nm_settings = MagicMock(side_effect=RuntimeError("boom"))
+        await w._set_wired_profiles_autoconnect(False)  # must not raise
+
+
 class TestEnsureWiredAutoconnect:
     def test_no_wired_device_returns_early(self, qapp):
         w = _make(qapp, wired=False)
@@ -2164,6 +2229,13 @@ def test_autoconnect_on_is_left_alone(self, qapp):
         _run(w._ensure_wired_autoconnect())
         wired.autoconnect.set_async.assert_not_awaited()
 
+    def test_profiles_are_rearmed_too(self, qapp):
+        w = _make(qapp)
+        w._set_wired_profiles_autoconnect = AsyncMock()
+        _wire(w, wired_proxy=AsyncProxyMock(state=30, autoconnect=False))
+        _run(w._ensure_wired_autoconnect())
+        w._set_wired_profiles_autoconnect.assert_awaited_once_with(True)
+
     def test_exception_is_non_fatal(self, qapp):
         w = _make(qapp)
         w._generic = MagicMock(side_effect=RuntimeError("boom"))
@@ -2276,6 +2348,17 @@ def test_calls_disconnect(self, qapp):
         wired.disconnect.assert_awaited_once()
         w._deactivate_all_vlans.assert_awaited_once()
 
+    def test_persists_choice_in_the_profile(self, qapp):
+        w = _make(qapp)
+        wired = AsyncProxyMock()
+        wired.disconnect = AsyncMock()
+        _wire(w, wired_proxy=wired)
+        w._is_ethernet_connected = AsyncMock(return_value=False)
+        w._deactivate_all_vlans = AsyncMock()
+        w._set_wired_profiles_autoconnect = AsyncMock()
+        _run(w._async_disconnect_ethernet())
+        w._set_wired_profiles_autoconnect.assert_awaited_once_with(False)
+
 
 class TestConnectEthernetAsync:
     def test_no_wired_path_emits_error(self, qapp):