fix(instrument): silence get_idn warning on virtual instruments

``Instrument.get_idn`` calls ``self.ask("*IDN?")`` which in turn invokes
``ask_raw``. The base ``Instrument`` class leaves ``ask_raw`` as a stub that
raises ``NotImplementedError``; virtual instruments that do not override it
therefore always produced a warning on every call to ``get_idn``. This is
noisy in practice, for example when a virtual instrument is registered in a
station and the station queries its IDN.

Treat ``NotImplementedError`` specifically as the expected signal that the
instrument is virtual and return the default ``None`` dict without a warning.
All other exceptions are still surfaced via ``self.log.warning`` so genuine
communication failures remain visible.

Adds focused regression tests covering both the silenced virtual-instrument
path and the still-noisy unexpected-error path.

Closes #4611

Signed-off-by: Asish Kumar <officialasishkumar@gmail.com>

Author: officialasishkumar

docs/changes/newsfragments/4611.improved

@@ -0,0 +1,4 @@
+Calling :meth:`~qcodes.instrument.Instrument.get_idn` on a virtual instrument that
+does not implement ``ask_raw`` no longer logs a spurious warning. Only
+``NotImplementedError`` is treated as an expected virtual-instrument signal;
+unrelated errors during ``*IDN?`` handling are still reported as warnings.

src/qcodes/instrument/instrument.py

@@ -91,6 +91,10 @@ def get_idn(self) -> dict[str, str | None]:
         semicolon and colon are also common separators so we accept them here
         as well.
 
+        Virtual instruments that do not define ``ask_raw`` will produce a dict
+        with ``None`` entries (and ``name`` as the model) without emitting a
+        warning, since the absence of real hardware communication is expected.
+
         Returns:
             A dict containing vendor, model, serial, and firmware.
 
@@ -109,6 +113,11 @@ def get_idn(self) -> dict[str, str | None]:
             # in case parts at the end are missing, fill in None
             if len(idparts) < 4:
                 idparts += [None] * (4 - len(idparts))
+        except NotImplementedError:
+            # Virtual instruments inherit from Instrument without overriding
+            # ``ask_raw``; treat this as an expected condition rather than a
+            # misconfiguration, so the user does not see a spurious warning.
+            idparts = [None, self.name, None, None]
         except Exception:
             self.log.warning(
                 f"Error getting or interpreting *IDN?: {idstr!r}", exc_info=True

tests/test_instrument.py

@@ -256,6 +256,59 @@ def test_get_idn(testdummy: DummyInstrument) -> None:
     assert testdummy.get_idn() == idn
 
 
+def test_get_idn_on_virtual_instrument_does_not_warn(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Virtual instruments that inherit from ``Instrument`` without overriding
+    ``ask_raw`` must not log a warning when ``get_idn`` is called; the missing
+    hardware communication layer is expected. The returned dict should still be
+    structurally valid.
+    """
+
+    class VirtualInstrument(Instrument):
+        """A bare virtual instrument with no ``ask_raw`` implementation."""
+
+    virtual = VirtualInstrument(name="virtual_no_ask")
+    try:
+        with caplog.at_level("WARNING"):
+            idn = virtual.get_idn()
+        assert idn == {
+            "vendor": None,
+            "model": "virtual_no_ask",
+            "serial": None,
+            "firmware": None,
+        }
+        assert "Error getting or interpreting *IDN?" not in caplog.text
+    finally:
+        virtual.close()
+
+
+def test_get_idn_still_warns_on_other_errors(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Unexpected errors in ``*IDN?`` handling should still be surfaced via a
+    warning so real misbehaviour is not silenced by the virtual-instrument
+    short-circuit."""
+
+    class BrokenInstrument(Instrument):
+        def ask_raw(self, cmd: str) -> str:
+            raise RuntimeError("communication failure")
+
+    broken = BrokenInstrument(name="broken_ask")
+    try:
+        with caplog.at_level("WARNING"):
+            idn = broken.get_idn()
+        assert idn == {
+            "vendor": None,
+            "model": "broken_ask",
+            "serial": None,
+            "firmware": None,
+        }
+        assert "Error getting or interpreting *IDN?" in caplog.text
+    finally:
+        broken.close()
+
+
 def test_repr(testdummy: DummyInstrument) -> None:
     assert repr(testdummy) == "<DummyInstrument: testdummy>"