python-netgear-switch-library 0.0.post323__tar.gz → 0.0.post325__tar.gz

{python_netgear_switch_library-0.0.post323 → python_netgear_switch_library-0.0.post325}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-netgear-switch-library
-Version: 0.0.post323
+Version: 0.0.post325
 Summary: Python library and CLI to query and control Netgear switches over SNMP, NSDP and HTTP.
 Author-email: Tim Ansell <me@mith.ro>
 License-Expression: Apache-2.0
@@ -18,6 +18,7 @@ Requires-Dist: pyserial>=3.5; extra == 'docs'
 Requires-Dist: pysnmp>=7.0; extra == 'docs'
 Requires-Dist: sphinx-argparse>=0.5; extra == 'docs'
 Requires-Dist: sphinx-copybutton>=0.5.2; extra == 'docs'
+Requires-Dist: sphinx-design>=0.6; extra == 'docs'
 Requires-Dist: sphinx>=8.1; extra == 'docs'
 Provides-Extra: http
 Requires-Dist: httpx>=0.27; extra == 'http'
@@ -37,6 +38,19 @@ Description-Content-Type: text/markdown
 Query and control all your Netgear switches — SNMP (managed), NSDP and HTTP
 web-UI (Plus) — behind one model-driven Python API and the `ngsw` CLI.
 
+> [!WARNING]
+> **This library and its documentation were written by an AI.** Every line of
+> code, every test and every documentation page was generated by a language
+> model, with a human directing and reviewing the work.
+>
+> The device behaviour in it is *measured* — protocol details and firmware
+> quirks come from captured traffic and live runs against the real switches,
+> recorded with the host and firmware they were seen on — and the support tables
+> are generated from the code rather than written by hand. But an AI is
+> perfectly capable of confident, fluent error, and nothing here has had
+> independent human review at scale. Verify anything that matters to you against
+> the source or your own hardware, and please report what you find.
+
 **Documentation: <https://python-netgear-switch-library.readthedocs.io/>** — API
 reference, the complete `ngsw` CLI reference, the virtual-switch guide (how to
 test your own tools against a mock), and generated

{python_netgear_switch_library-0.0.post323 → python_netgear_switch_library-0.0.post325}/README.md

@@ -3,6 +3,19 @@
 Query and control all your Netgear switches — SNMP (managed), NSDP and HTTP
 web-UI (Plus) — behind one model-driven Python API and the `ngsw` CLI.
 
+> [!WARNING]
+> **This library and its documentation were written by an AI.** Every line of
+> code, every test and every documentation page was generated by a language
+> model, with a human directing and reviewing the work.
+>
+> The device behaviour in it is *measured* — protocol details and firmware
+> quirks come from captured traffic and live runs against the real switches,
+> recorded with the host and firmware they were seen on — and the support tables
+> are generated from the code rather than written by hand. But an AI is
+> perfectly capable of confident, fluent error, and nothing here has had
+> independent human review at scale. Verify anything that matters to you against
+> the source or your own hardware, and please report what you find.
+
 **Documentation: <https://python-netgear-switch-library.readthedocs.io/>** — API
 reference, the complete `ngsw` CLI reference, the virtual-switch guide (how to
 test your own tools against a mock), and generated

{python_netgear_switch_library-0.0.post323 → python_netgear_switch_library-0.0.post325}/docs/_ext/support_tables.py

@@ -29,9 +29,11 @@ Directives
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
 
 from docutils.parsers.rst import directives
+from sphinx.util import logging
 from sphinx.util.docutils import SphinxDirective
 
 from netgear_switch.capabilities import (
@@ -49,6 +51,8 @@ if TYPE_CHECKING:
     from docutils import nodes
     from sphinx.application import Sphinx
 
+logger = logging.getLogger(__name__)
+
 #: Compact per-backend labels used inside grid cells. The CLI backends share a
 #: label because they are one command surface reached over three transports
 #: (see ``src/netgear_switch/registry.py``'s ``Backend``).
@@ -65,6 +69,24 @@ _YES = "✓"  # check mark
 _NO = "—"  # em dash
 
 
+def matrix_models() -> tuple[str, ...]:
+    """The models the generated tables cover.
+
+    A model registered from a specification sheet with **no device access**
+    (``SwitchModel.verified is False``) is deliberately excluded. Listing one in
+    a support matrix would assert per-model, per-backend behaviour that nobody
+    has ever observed on that hardware -- the exact difference between a
+    measurement and an inference this project refuses to blur. They are named in
+    prose instead, so their existence is not hidden either.
+    """
+    return tuple(key for key, model in MODELS.items() if model.verified)
+
+
+def unverified_models() -> tuple[str, ...]:
+    """Registered models with no capture behind them, excluded from the tables."""
+    return tuple(key for key, model in MODELS.items() if not model.verified)
+
+
 def _rst_escape(text: str) -> str:
     """Neutralise inline reST markup in generated cell text."""
     for char in ("\\", "*", "`", "|", "_"):
@@ -114,7 +136,8 @@ class ModelTable(_GeneratedTable):
         for alias, canonical in MODEL_ALIASES.items():
             aliases.setdefault(canonical, []).append(alias)
         rows = []
-        for key, model in MODELS.items():
+        for key in matrix_models():
+            model = MODELS[key]
             also = aliases.get(key)
             name = f"``{key}``"
             if also:
@@ -159,7 +182,8 @@ class ProtocolTable(_GeneratedTable):
 
     def body(self) -> str:
         rows = []
-        for key, model in MODELS.items():
+        for key in matrix_models():
+            model = MODELS[key]
             cells = [_YES if b in model.backends else _NO for b in self._COLUMNS]
             rows.append([f"``{key}``", *cells])
         return _list_table(
@@ -185,7 +209,7 @@ class OperationTable(_GeneratedTable):
         raise self.error(f"ngsw-operation-table: unknown kind {kind!r}")
 
     def body(self) -> str:
-        keys = list(MODELS)
+        keys = list(matrix_models())
         rows = []
         for op in self._operations():
             cells = []
@@ -251,7 +275,7 @@ class SupportGaps(_GeneratedTable):
 
     def body(self) -> str:
         rows = []
-        for key in MODELS:
+        for key in matrix_models():
             backends = backends_for(key)
             if len(backends) < 2:
                 continue
@@ -282,10 +306,240 @@ class SupportGaps(_GeneratedTable):
         )
 
 
+_BACKEND_BY_NAME = {b.name: b for b in Backend}
+
+#: CLI is one command surface over three transports, so a "CLI" column means
+#: whichever of SSH/TELNET/CONSOLE a model actually registers.
+_CLI = (Backend.SSH, Backend.TELNET, Backend.CONSOLE)
+
+
+def _named_backends(name: str) -> tuple[Backend, ...]:
+    key = name.strip().upper()
+    if key == "CLI":
+        return _CLI
+    try:
+        return (_BACKEND_BY_NAME[key],)
+    except KeyError:
+        raise ValueError(f"unknown backend: {name!r}") from None
+
+
+def _models_with(backends: tuple[Backend, ...]) -> tuple[str, ...]:
+    return tuple(
+        key
+        for key in matrix_models()
+        if any(b in MODELS[key].backends for b in backends)
+    )
+
+
+class BackendModelTable(_GeneratedTable):
+    """Which models expose one backend, and how they are reached."""
+
+    required_arguments = 1
+
+    def body(self) -> str:
+        backends = _named_backends(self.arguments[0])
+        rows = []
+        for key in _models_with(backends):
+            model = MODELS[key]
+            reached = ", ".join(
+                b.name for b in backends_for(model) if b in backends
+            )
+            rows.append(
+                [
+                    # Absolute doc path: this table is included from
+                    # docs/protocols/, so a relative target would resolve there.
+                    f":doc:`{key} </models/{key}>`",
+                    _rst_escape(model.display_name),
+                    model.switch_class.value.replace("_", " "),
+                    str(model.port_count),
+                    reached,
+                ]
+            )
+        if not rows:
+            return "No registered model exposes this backend.\n"
+        return _list_table(
+            "",
+            ["Model", "Product", "Class", "Ports", "Reached over"],
+            rows,
+            widths="16 24 18 10 32",
+        )
+
+
+class BackendOperationTable(_GeneratedTable):
+    """Operation x model grid for ONE backend: what it can do, where."""
+
+    required_arguments = 1
+
+    def body(self) -> str:
+        backends = _named_backends(self.arguments[0])
+        keys = _models_with(backends)
+        if not keys:
+            return "No registered model exposes this backend.\n"
+        rows = []
+        notes: list[str] = []
+        seen: dict[str, int] = {}
+        label = self.arguments[0].strip().upper()
+        for op in (*READ_OPERATIONS, *WRITE_OPERATIONS):
+            cells = []
+            for key in keys:
+                backend = next(
+                    (b for b in backends_for(key) if b in backends), None
+                )
+                if backend is None:  # pragma: no cover - filtered by _models_with
+                    cells.append(_NO)
+                    continue
+                cap = support(key, backend, op)
+                if cap.supported:
+                    cells.append(_YES)
+                    continue
+                reason = _rst_escape(cap.reason)
+                index = seen.get(reason)
+                if index is None:
+                    index = len(notes) + 1
+                    seen[reason] = index
+                    notes.append(reason)
+                cells.append(f"{_NO} [{label}-{index}]_")
+            rows.append([f":py:meth:`~netgear_switch.SyncSwitch.{op.name}`", *cells])
+        table = _list_table("", ["Operation", *keys], rows)
+        if not notes:
+            return table
+        citations = "\n".join(
+            f".. [{label}-{i}] {text}" for i, text in enumerate(notes, 1)
+        )
+        return f"{table}\n{citations}\n"
+
+
+class ModelFacts(_GeneratedTable):
+    """The registry record for one model, as a field list."""
+
+    required_arguments = 1
+
+    def body(self) -> str:
+        model = get_model(self.arguments[0])
+        aliases = sorted(k for k, v in MODEL_ALIASES.items() if v == model.key)
+        vendor = model.snmp_vendor_base or "none (standard MIBs only)"
+        dialect = {
+            "qbridge": "Q-BRIDGE static PortLists (read-modify-write)",
+            "fastpath_switchport": "FASTPATH vendor switchport table",
+        }.get(model.snmp_vlan_write, model.snmp_vlan_write)
+        rows = [
+            ["Registry key", f"``{model.key}``"],
+            ["Product name", _rst_escape(model.display_name)],
+            ["Class", model.switch_class.value.replace("_", " ")],
+            ["Ports", str(model.port_count)],
+            ["PoE (PSE) ports", str(model.poe_port_count)],
+            [
+                "Backends",
+                ", ".join(f"``{b.name}``" for b in backends_for(model)),
+            ],
+            ["SNMP vendor subtree", f"``{vendor}``"],
+        ]
+        if Backend.SNMP in model.backends:
+            rows.append(["VLAN write dialect", dialect])
+            if model.snmp_vlan_split_membership_writes:
+                rows.append(
+                    [
+                        "VLAN write quirk",
+                        "egress and untagged PortLists must travel in "
+                        "SEPARATE PDUs, egress first",
+                    ]
+                )
+        if aliases:
+            rows.append(
+                ["Aliases", ", ".join(f"``{a}``" for a in aliases)]
+            )
+        rows.append(
+            [
+                "MAC/FDB table",
+                "yes" if model.has_mac_table else "no",
+            ]
+        )
+        return _list_table("", ["Field", "Value"], rows, widths="30 70")
+
+
+class ModelPhoto(_GeneratedTable):
+    """Render a photo of the switch, if one has been added to the repository.
+
+    Photos live at ``docs/_static/models/<key>.<ext>``. Nothing is emitted when
+    the file is absent -- a missing photo must not render as a broken image --
+    and every gap is reported once at the end of the build.
+    """
+
+    required_arguments = 1
+    option_spec: ClassVar[dict[str, Any]] = {"alt": directives.unchanged}
+
+    _EXTENSIONS = (".jpg", ".jpeg", ".png", ".webp")
+
+    def body(self) -> str:
+        key = self.arguments[0]
+        model = get_model(key)
+        static = Path(str(self.env.srcdir)) / "_static" / "models"
+        for ext in self._EXTENSIONS:
+            if (static / f"{key}{ext}").is_file():
+                alt = self.options.get("alt", f"{model.display_name} switch")
+                return (
+                    f".. figure:: /_static/models/{key}{ext}\n"
+                    f"   :alt: {alt}\n"
+                    "   :align: center\n"
+                    "   :class: ngsw-model-photo\n\n"
+                    f"   {_rst_escape(model.display_name)}\n"
+                )
+        MISSING_PHOTOS.add(key)
+        return ""
+
+
+#: Models whose photo slot was empty during this build; reported at the end.
+MISSING_PHOTOS: set[str] = set()
+
+
+class UnverifiedNote(_GeneratedTable):
+    """Name the models the tables leave out, and say why."""
+
+    def body(self) -> str:
+        keys = unverified_models()
+        if not keys:
+            return ""
+        listed = ", ".join(f"``{k}`` ({MODELS[k].display_name})" for k in keys)
+        return (
+            ".. note::\n\n"
+            f"   The registry also carries {listed}, which the tables above "
+            "deliberately leave out.\n"
+            "   No device of either kind has ever been reachable from this "
+            "project, so there is no\n"
+            "   capture, no live run, and nothing measured to report. They are "
+            "registered only so a\n"
+            "   caller can construct a facade for them; treat every one of "
+            "their fields as a\n"
+            "   specification-sheet guess until a real capture exists.\n"
+        )
+
+
+def _report_missing_photos(app: Sphinx, exception: Exception | None) -> None:
+    """Say which model pages have no photo yet, rather than failing the build.
+
+    A photo is content the repository may simply not have; the build must not
+    break over it, but the gap should be visible instead of silently invisible.
+    """
+    if exception is not None or not MISSING_PHOTOS:
+        return
+    logger.info(
+        "ngsw: no photo for %d model(s): %s "
+        "(add docs/_static/models/<key>.jpg to fill the slot)",
+        len(MISSING_PHOTOS),
+        ", ".join(sorted(MISSING_PHOTOS)),
+    )
+
+
 def setup(app: Sphinx) -> dict[str, Any]:
+    app.add_directive("ngsw-unverified-note", UnverifiedNote)
     app.add_directive("ngsw-model-table", ModelTable)
     app.add_directive("ngsw-protocol-table", ProtocolTable)
     app.add_directive("ngsw-operation-table", OperationTable)
     app.add_directive("ngsw-model-support", ModelSupportTable)
+    app.add_directive("ngsw-model-facts", ModelFacts)
+    app.add_directive("ngsw-model-photo", ModelPhoto)
+    app.add_directive("ngsw-backend-models", BackendModelTable)
+    app.add_directive("ngsw-backend-operations", BackendOperationTable)
     app.add_directive("ngsw-support-gaps", SupportGaps)
+    app.connect("build-finished", _report_missing_photos)
     return {"version": "1.0", "parallel_read_safe": True, "parallel_write_safe": True}

{python_netgear_switch_library-0.0.post323 → python_netgear_switch_library-0.0.post325}/docs/conf.py

@@ -54,6 +54,9 @@ extensions = [
     "sphinx.ext.intersphinx",
     "sphinx.ext.extlinks",
     "sphinx_copybutton",
+    # Synchronised tab sets: every API example is shown in both synchronous and
+    # asynchronous form, and picking one switches every example on the page.
+    "sphinx_design",
     "sphinxarg.ext",
     # Local: see docs/_ext/.
     "filelinks",
@@ -135,6 +138,14 @@ html_theme_options = {
     "source_repository": f"{GITHUB_REPO}/",
     "source_branch": filelinks_ref,
     "source_directory": "docs/",
+    # Shown at the top of EVERY page. This library and this documentation were
+    # written by an AI; a reader deserves to know that before they trust a
+    # sentence of it, not only if they happen to land on the front page.
+    "announcement": (
+        "This library and its documentation were written by an AI. "
+        '<a href="/en/latest/#ai-generated">What that means, and what was '
+        "actually verified against hardware</a>."
+    ),
 }
 
 copybutton_prompt_text = r"\$ |>>> |\.\.\. "

{python_netgear_switch_library-0.0.post323 → python_netgear_switch_library-0.0.post325}/docs/fake/testing.rst

@@ -54,21 +54,53 @@ Testing code that uses this library
 Inject a client pointed at the mock. Everything above the transport — dispatch,
 parsing, model rules — is the same code that runs against hardware.
 
-.. code-block:: python
+.. tab-set::
 
-   from netgear_switch import SyncSwitch, get_model
-   from netgear_switch.transport.sync.snmp_netsnmp_cli import NetsnmpCliClient
-   from netgear_switch.virtual.server import VirtualSwitch
+   .. tab-item:: Sync
+      :sync: sync
+
+      .. code-block:: python
+
+         from netgear_switch import SyncSwitch, get_model
+         from netgear_switch.transport.sync.snmp_netsnmp_cli import NetsnmpCliClient
+         from netgear_switch.virtual.server import VirtualSwitch
+
+
+         def test_reports_link_state() -> None:
+             with VirtualSwitch(model="gsm7252ps") as mock:
+                 switch = SyncSwitch(
+                     get_model("gsm7252ps"),
+                     host=mock.host,
+                     snmp_client=NetsnmpCliClient(
+                         f"{mock.host}:{mock.port}", "public"
+                     ),
+                 )
+                 assert switch.get_ports()[0].link_up
+
+   .. tab-item:: Async
+      :sync: async
+
+      .. code-block:: python
+
+         import pytest
+
+         from netgear_switch import AsyncSwitch, get_model
+         from netgear_switch.transport.aio.snmp_pysnmp import PysnmpClient
+         from netgear_switch.virtual.server import VirtualSwitch
 
 
-   def test_reports_link_state() -> None:
-       with VirtualSwitch(model="gsm7252ps") as mock:
-           switch = SyncSwitch(
-               get_model("gsm7252ps"),
-               host=mock.host,
-               snmp_client=NetsnmpCliClient(f"{mock.host}:{mock.port}", "public"),
-           )
-           assert switch.get_ports()[0].link_up
+         @pytest.mark.asyncio
+         async def test_reports_link_state() -> None:
+             with VirtualSwitch(model="gsm7252ps") as mock:
+                 switch = AsyncSwitch(
+                     get_model("gsm7252ps"),
+                     host=mock.host,
+                     snmp_client=PysnmpClient(mock.host, "public", port=mock.port),
+                 )
+                 try:
+                     assert (await switch.get_ports())[0].link_up
+                 finally:
+                     await switch.aclose()
 
 .. code-block:: text
 
@@ -84,14 +116,19 @@ Every backend takes an injected client:
    * - Backend
      - Constructor argument
    * - SNMP
-     - ``snmp_client=NetsnmpCliClient(f"{host}:{port}", community)``, and
-       ``snmp_write_client=`` for writes
+     - sync: ``snmp_client=NetsnmpCliClient(f"{host}:{port}", community)``;
+       async: ``snmp_client=PysnmpClient(host, community, port=mock.port)``.
+       Add ``snmp_write_client=`` for writes.
    * - NSDP
-     - ``nsdp_client=UdpNsdpClient(host, client_port=0, server_port=mock.port)``
+     - sync: ``nsdp_client=UdpNsdpClient(host, client_port=0, server_port=mock.port)``;
+       async: the same arguments to ``AsyncUdpNsdpClient``.
    * - HTTP
-     - ``http_client=HttpClient(f"{host}:{http_port}", password, http_spec(model))``
+     - sync: ``http_client=HttpClient(f"{host}:{http_port}", password, http_spec(model))``;
+       async: the same arguments to ``AsyncHttpClient``.
    * - CLI
-     - ``cli_client=mock.cli_session()``
+     - ``cli_client=mock.cli_session()`` — **synchronous only**. The CLI
+       transports block, so :py:class:`~netgear_switch.AsyncSwitch` has no CLI
+       backend and takes no ``cli_client``.
 
 All four at once
 ----------------
@@ -274,7 +311,7 @@ with the wrong model:
            host=mock.host,
            snmp_client=NetsnmpCliClient(f"{mock.host}:{mock.port}", "public"),
        )
-       print(switch.identify())
+       print(switch.identify())          # await switch.identify() on AsyncSwitch
 
 .. code-block:: text
 

{python_netgear_switch_library-0.0.post323 → python_netgear_switch_library-0.0.post325}/docs/guide/concepts.rst

@@ -64,10 +64,23 @@ gaps that remain.
 Dispatch: exactly one backend, every time
 -----------------------------------------
 
-.. code-block:: python
+.. tab-set::
 
-   switch.get_vlans()                        # the model's default backend
-   switch.get_vlans(backend=Backend.HTTP)    # exactly HTTP, or an error
+   .. tab-item:: Sync
+      :sync: sync
+
+      .. code-block:: python
+
+         switch.get_vlans()                      # the model's default backend
+         switch.get_vlans(backend=Backend.HTTP)  # exactly HTTP, or an error
+
+   .. tab-item:: Async
+      :sync: async
+
+      .. code-block:: python
+
+         await switch.get_vlans()                      # the model's default backend
+         await switch.get_vlans(backend=Backend.HTTP)  # exactly HTTP, or an error
 
 When you **name** a backend, that backend runs. If the model does not have it,
 you get `UnsupportedCapabilityError` immediately. If it has it but cannot serve
@@ -106,12 +119,27 @@ Choosing a default per facade
 
 Pass ``backend=`` to the constructor to change the default for every call:
 
-.. code-block:: python
+.. tab-set::
+
+   .. tab-item:: Sync
+      :sync: sync
+
+      .. code-block:: python
+
+         web_only = SyncSwitch(
+             get_model("gsm7252ps"), host="10.1.5.22",
+             http_password="...", backend=Backend.HTTP,
+         )
 
-   web_only = SyncSwitch(
-       get_model("gsm7252ps"), host="10.1.5.22",
-       http_password="...", backend=Backend.HTTP,
-   )
+   .. tab-item:: Async
+      :sync: async
+
+      .. code-block:: python
+
+         web_only = AsyncSwitch(
+             get_model("gsm7252ps"), host="10.1.5.22",
+             http_password="...", backend=Backend.HTTP,
+         )
 
 Per-call ``backend=`` still overrides it.
 
@@ -121,11 +149,13 @@ Verification status
 This project distinguishes what has been *measured* from what has been
 *assumed*, and the distinction is visible in the API.
 
-``SwitchModel.verified``
-    ``False`` marks a model registered from a specification sheet with no device
-    capture behind it — currently ``m7300`` and ``xs748t``. Standard-MIB reads
-    should work; vendor-specific reads are unverified. These models are labelled
-    in :doc:`../models/index` and never treated as evidence of anything.
+`SwitchModel.verified`
+    ``False`` marks a model registered from a specification sheet, with no
+    device of that kind ever reachable from this project. Such a model is
+    **excluded from every support table** — see :doc:`../models/index` —
+    because putting it in a matrix would assert per-backend behaviour nobody has
+    observed. It stays in the registry only so a caller can construct a facade
+    for it, and nothing here treats it as evidence of anything.
 
 ``HttpModelSpec.reads_verified``, ``CliModelSpec.reads_verified`` / ``writes_verified``
     Per-model, per-backend flags recording whether that backend's output has
@@ -173,8 +203,29 @@ see :doc:`../models/support`.
 Synchronous and asynchronous
 ----------------------------
 
-`SyncSwitch` and `AsyncSwitch` expose the same operations with the same
+:py:class:`~netgear_switch.SyncSwitch` and
+:py:class:`~netgear_switch.AsyncSwitch` expose the same operations with the same
 arguments and the same semantics. They share the model registry, the parsers and
 the backend-resolution seam in ``src/netgear_switch/_dispatch.py``; only the
 transports differ. ``tests/test_facade_equivalence.py`` asserts they stay in
 step.
+
+.. important::
+
+   **One backend is synchronous-only: the CLI.** All three CLI transports —
+   SSH, telnet and the serial console — are blocking, and none has an async
+   twin, so :py:class:`~netgear_switch.AsyncSwitch` has no CLI backend at all.
+   Asking for one raises rather than quietly blocking the event loop::
+
+      UnsupportedCapabilityError: model 'gsm7252ps' CLI reads are not available
+      via the async facade (CLI is synchronous ...)
+
+   That also rules out
+   :py:meth:`~netgear_switch.SyncSwitch.upload_certificate_scp` on the async
+   facade, since the operation is CLI-based by nature. Use
+   :py:class:`~netgear_switch.SyncSwitch` for those, or wrap the call in
+   :py:func:`asyncio.to_thread`.
+
+   **The support tables in** :doc:`../models/support` **describe the
+   synchronous facade.** Every SNMP, NSDP and HTTP entry holds for both; the CLI
+   columns apply to :py:class:`~netgear_switch.SyncSwitch` only.