lifx-emulator 2.3.1__tar.gz → 2.4.0__tar.gz

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/CLAUDE.md

@@ -70,7 +70,7 @@ lifx-emulator --bind 192.168.1.100 --port 56700
 lifx-emulator --color 2 --multizone 1 --tile 1 --verbose
 
 # Create only specific device types
-lifx-emulator --color 0 --infrared 3 --hev 2
+lifx-emulator --color 0 --infrared 3 --hev 2 --switch 2
 
 # Mix product IDs with device types
 lifx-emulator --product 27 --color 2 --multizone 1
@@ -130,6 +130,7 @@ lifx-emulator --help
 - `--tile-count`: Tiles per device (uses product default if not specified)
 - `--tile-width`: Width of each tile in zones (uses product default if not specified)
 - `--tile-height`: Height of each tile in zones (uses product default if not specified)
+- `--switch`: Number of LIFX Switch devices (relays, no lighting, default: 0)
 - `--serial-prefix`: serial prefix (6 hex chars, default: d073d5)
 - `--serial-start`: Starting serial suffix (default: 1)
 - `--api`: Enable HTTP API server for monitoring and management (default: False)
@@ -521,7 +522,7 @@ delay = manager.get_response_delay(502, merged)  # 1.0s
 
 **DeviceState** (`src/lifx_emulator/devices/states.py`):
 - Dataclass holding all device state (color, power, zones, tiles, firmware version, etc.)
-- Capability flags: `has_color`, `has_infrared`, `has_multizone`, `has_matrix`, `has_hev`
+- Capability flags: `has_color`, `has_infrared`, `has_multizone`, `has_matrix`, `has_hev`, `has_relays`, `has_buttons`
 - Initialized differently per device type via factory functions
 - **TileFramebuffers**: Internal dataclass for storing non-visible framebuffers (1-7) per tile
   - Provides `get_framebuffer(fb_index, width, height)` for lazy initialization
@@ -562,6 +563,10 @@ delay = manager.get_response_delay(502, merged)  # 1.0s
   - Zone count uses product defaults from specs if not specified
 - `create_tile_device(tile_count=None)`: Tile chain (product=55)
   - Tile count and dimensions use product defaults from specs if not specified
+- `create_switch(product_id=70)`: LIFX Switch device (product=70)
+  - Has `has_relays=True` and `has_buttons=True` capabilities
+  - No lighting control (responds with StateUnhandled to Light/MultiZone/Tile packets)
+  - Supports all Device.* packets for basic device information
 - `create_device(product_id, zone_count=None, tile_count=None)`: Universal factory
   - Creates any device by product ID from the registry
   - Automatically uses product defaults from specs system
@@ -764,6 +769,18 @@ Matrix devices support 8 framebuffers (0-7) for advanced rendering:
 - Framebuffers are lazily initialized on first access
 - Non-visible framebuffers are persisted with device state
 
+### Switch Handling
+- LIFX Switch devices have `has_relays=True` and `has_buttons=True` capabilities
+- Switches do not support lighting operations (no color, brightness, or zone control)
+- **Capability-based packet filtering**: Switches automatically return `StateUnhandled` (packet 223) for:
+  - Light.* packets (types 101-149): GetColor, SetColor, SetWaveform, etc.
+  - MultiZone.* packets (types 501-512): GetColorZones, SetColorZones, etc.
+  - Tile.* packets (types 701-720): Get64, Set64, GetTileEffect, etc.
+- Switches handle Device.* packets (types 2-59) normally: GetVersion, GetLabel, EchoRequest, etc.
+- StateUnhandled response includes the `unhandled_type` field indicating which packet type was rejected
+- Acknowledgments (packet 45) are still sent if `ack_required=True` flag is set
+- **Note**: Button and relay protocol packets are not currently implemented (requires cloud/Matter infrastructure)
+
 ### Testing Scenarios
 Configure via ScenarioConfig in HierarchicalScenarioManager:
 - `drop_packets`: Dict mapping packet type to drop rate (0.0-1.0, where 1.0 = always drop)

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator
-Version: 2.3.1
+Version: 2.4.0
 Summary: LIFX Emulator for testing LIFX LAN protocol libraries
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/docs/changelog.md

@@ -2,6 +2,14 @@
 
 <!-- version list -->
 
+## v2.4.0 (2025-11-19)
+
+### Features
+
+- Implement LIFX Switch device emulation with StateUnhandled responses
+  ([`e2f9114`](https://github.com/Djelibeybi/lifx-emulator/commit/e2f911420db1d27d916247a9b3fdb50f31276b48))
+
+
 ## v2.3.1 (2025-11-18)
 
 ### Bug Fixes

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/docs/getting-started/cli.md

@@ -211,6 +211,16 @@ Height of each tile in zones. If not specified, uses product default (typically
 - **Default:** `None` (uses product defaults)
 - **Example:** `--tile-height 8`
 
+### `--switch <COUNT>`
+
+Number of LIFX Switch devices to emulate (relay-based switches with no lighting).
+
+- **Default:** `0`
+- **Product:** 70 (LIFX Switch)
+- **Example:** `--switch 2`
+
+Switch devices have `has_relays=True` and `has_buttons=True` capabilities but do not support Light, MultiZone, or Tile protocol packets. They respond with `StateUnhandled` (packet 223) to unsupported requests.
+
 ## serial Options
 
 ### `--serial-prefix <PREFIX>`
@@ -291,8 +301,8 @@ lifx-emulator --serial-prefix cafe00 --serial-start 100 --color 3
 ### Only Specific Types
 
 ```bash
-# No default devices, only infrared and HEV
-lifx-emulator --color 0 --infrared 3 --HEV 2
+# No default devices, only infrared, HEV, and switches
+lifx-emulator --color 0 --infrared 3 --HEV 2 --switch 2
 ```
 
 ### Discovery Testing

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/docs/guide/device-types.md

@@ -341,6 +341,82 @@ For large tiles (>64 zones), prepare all zones in a non-visible framebuffer, the
 See [Framebuffer Guide](framebuffers.md) for complete documentation and examples.
 
 
+## Switch Devices
+
+LIFX Switch devices are relay-based switches with no lighting capabilities. They respond with `StateUnhandled` (packet 223) to all lighting-related protocol requests.
+
+### Example Products
+
+- **LIFX Switch** (product IDs 70, 71, 89, 115, 116) - 2 relay switches
+
+### Capabilities
+
+- **Relays**: Physical relay switches for controlling external loads
+- **Buttons**: Physical buttons for manual control
+- **No lighting**: No color, brightness, or zone control
+- Basic device operations (GetVersion, GetLabel, EchoRequest, etc.)
+
+### Factory Function
+
+```python
+from lifx_emulator import create_switch
+
+# Create LIFX Switch (default product 70)
+switch = create_switch("d073d7000001")
+
+# Or specify a different switch product
+switch = create_switch("d073d7000002", product_id=89)
+```
+
+### Switch Behavior
+
+```python
+switch = create_switch("d073d7000001")
+
+# Check capabilities
+print(f"Has relays: {switch.state.has_relays}")  # True
+print(f"Has buttons: {switch.state.has_buttons}")  # True
+print(f"Has color: {switch.state.has_color}")  # False
+print(f"Has multizone: {switch.state.has_multizone}")  # False
+```
+
+### Packet Handling
+
+**Supported (Device.* packets 2-59):**
+- `GetVersion` (32) → `StateVersion` (33)
+- `GetLabel` (23) → `StateLabel` (25)
+- `SetLabel` (24)
+- `EchoRequest` (58) → `EchoResponse` (59)
+- All other Device.* packets
+
+**Rejected with StateUnhandled (223):**
+- **Light.* packets (101-149)**: GetColor, SetColor, GetPower, SetPower, etc.
+- **MultiZone.* packets (501-512)**: GetColorZones, SetColorZones, etc.
+- **Tile.* packets (701-720)**: Get64, Set64, GetTileEffect, etc.
+
+### StateUnhandled Response
+
+When a switch receives an unsupported packet type, it responds with:
+
+```python
+# Client sends Light.GetColor (101) to switch
+# Switch responds with:
+# - StateUnhandled (223) with unhandled_type=101
+# - Acknowledgement (45) if ack_required=True
+```
+
+The `StateUnhandled` packet includes the rejected packet type in the `unhandled_type` field, allowing clients to detect and handle unsupported operations gracefully.
+
+### Limitations
+
+**Note**: Button and relay control protocol packets are not currently implemented in the emulator.
+
+The switch emulation is primarily for testing client libraries' handling of:
+- Device capability detection
+- StateUnhandled response handling
+- Graceful degradation when lighting features are unavailable
+
+
 ## Using Generic create_device()
 
 All factory functions use `create_device()` internally. You can use it directly:

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-emulator"
-version = "2.3.1"
+version = "2.4.0"
 description = "LIFX Emulator for testing LIFX LAN protocol libraries"
 readme = "README.md"
 requires-python = ">=3.11"

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/__main__.py

@@ -21,6 +21,7 @@ from lifx_emulator.factories import (
     create_hev_light,
     create_infrared_light,
     create_multizone_light,
+    create_switch,
     create_tile_device,
 )
 from lifx_emulator.products.registry import get_registry
@@ -239,6 +240,7 @@ async def run(
     hev: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
     multizone: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
     tile: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
+    switch: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
     # Multizone Options
     multizone_zones: Annotated[
         int | None, cyclopts.Parameter(group=multizone_group)
@@ -284,6 +286,7 @@ async def run(
         multizone_extended: Enable extended multizone support (Beam).
             Set --no-multizone-extended for basic multizone (Z) devices.
         tile: Number of tile/matrix chain devices.
+        switch: Number of LIFX Switch devices (relays, no lighting).
         tile_count: Number of tiles per device. Uses product defaults if not
             specified (5 for Tile, 1 for Candle/Ceiling).
         tile_width: Width of each tile in zones. Uses product defaults if not
@@ -310,7 +313,7 @@ async def run(
             lifx-emulator --color 2 --multizone 1 --tile 1 --api --verbose
 
         Create only specific device types:
-            lifx-emulator --color 0 --infrared 3 --hev 2
+            lifx-emulator --color 0 --infrared 3 --hev 2 --switch 2
 
         Custom serial prefix:
             lifx-emulator --serial-prefix cafe00 --color 5
@@ -410,6 +413,7 @@ async def run(
                 and infrared == 0
                 and hev == 0
                 and multizone == 0
+                and switch == 0
             ):
                 color = 0
 
@@ -423,6 +427,7 @@ async def run(
             and hev == 0
             and multizone == 0
             and tile == 0
+            and switch == 0
         ):
             color = 0
 
@@ -467,13 +472,17 @@ async def run(
                 )
             )
 
+        # Create switch devices
+        for _ in range(switch):
+            devices.append(create_switch(get_serial(), storage=storage))
+
     if not devices:
         if persistent:
             logger.warning("No devices configured. Server will run with no devices.")
             logger.info("Use API (--api) or restart with device flags to add devices.")
         else:
             logger.error(
-                "No devices configured. Use --color, --multizone, --tile, "
+                "No devices configured. Use --color, --multizone, --tile, --switch, "
                 "etc. to add devices."
             )
             return

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/devices/device.py

@@ -215,6 +215,35 @@ class EmulatedLifxDevice:
         header.size = LIFX_HEADER_SIZE + payload_size
         return header
 
+    def _should_handle_packet(self, pkt_type: int) -> bool:
+        """Check if device should handle a packet type based on capabilities.
+
+        Args:
+            pkt_type: Packet type number
+
+        Returns:
+            True if device should handle, False if should return StateUnhandled
+        """
+        # Device.* packets are always handled (2-59)
+        if 2 <= pkt_type <= 59:
+            return True
+
+        # Light.* packets (101-149) require light capabilities
+        # Switches (devices with relays) don't support light operations
+        if 101 <= pkt_type <= 149:
+            return not self.state.has_relays
+
+        # MultiZone.* packets (501-512) require multizone capability
+        if 501 <= pkt_type <= 512:
+            return self.state.has_multizone
+
+        # Tile.* packets (701-720) require matrix capability
+        if 701 <= pkt_type <= 720:
+            return self.state.has_matrix
+
+        # Unknown packets - let handler decide
+        return True
+
     def process_packet(
         self, header: LifxHeader, packet: Any | None
     ) -> list[tuple[LifxHeader, Any]]:
@@ -229,6 +258,33 @@ class EmulatedLifxDevice:
             logger.info("Dropping packet type %s per scenario", header.pkt_type)
             return responses
 
+        # Check if device should handle this packet type (capability-based filtering)
+        if not self._should_handle_packet(header.pkt_type):
+            # Return StateUnhandled for unsupported packet types
+            state_unhandled = Device.StateUnhandled(unhandled_type=header.pkt_type)
+            unhandled_payload = state_unhandled.pack()
+            unhandled_header = self._create_response_header(
+                header.source,
+                header.sequence,
+                state_unhandled.PKT_TYPE,
+                len(unhandled_payload),
+            )
+            responses.append((unhandled_header, state_unhandled))
+
+            # Still send acknowledgment if requested
+            if header.ack_required:
+                ack_packet = Device.Acknowledgement()
+                ack_payload = ack_packet.pack()
+                ack_header = self._create_response_header(
+                    header.source,
+                    header.sequence,
+                    ack_packet.PKT_TYPE,
+                    len(ack_payload),
+                )
+                responses.append((ack_header, ack_packet))
+
+            return responses
+
         # Update uptime
         self.state.uptime_ns = self.get_uptime_ns()
 

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/devices/states.py

@@ -183,6 +183,8 @@ class DeviceState:
     has_extended_multizone: bool = False
     has_matrix: bool = False
     has_hev: bool = False
+    has_relays: bool = False
+    has_buttons: bool = False
 
     # Attribute routing map: maps attribute prefixes to state objects
     # This eliminates ~360 lines of property boilerplate
@@ -347,6 +349,8 @@ class DeviceState:
             "has_extended_multizone",
             "has_matrix",
             "has_hev",
+            "has_relays",
+            "has_buttons",
         } or name.startswith("_"):
             object.__setattr__(self, name, value)
             return

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/factories/__init__.py

@@ -15,6 +15,7 @@ from lifx_emulator.factories.factory import (
     create_hev_light,
     create_infrared_light,
     create_multizone_light,
+    create_switch,
     create_tile_device,
 )
 from lifx_emulator.factories.firmware_config import FirmwareConfig
@@ -32,6 +33,7 @@ __all__ = [
     "create_infrared_light",
     "create_hev_light",
     "create_multizone_light",
+    "create_switch",
     "create_tile_device",
     "create_color_temperature_light",
 ]

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/factories/builder.py

@@ -257,6 +257,8 @@ class DeviceBuilder:
             has_extended_multizone=has_extended_multizone,
             has_matrix=self._product_info.has_matrix,
             has_hev=self._product_info.has_hev,
+            has_relays=self._product_info.has_relays,
+            has_buttons=self._product_info.has_buttons,
         )
 
         # 10. Restore saved state if persistence enabled

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/factories/factory.py

@@ -141,6 +141,37 @@ def create_color_temperature_light(
     )  # LIFX Mini White to Warm
 
 
+def create_switch(
+    serial: str | None = None,
+    product_id: int = 70,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a LIFX Switch device.
+
+    Switches have has_relays and has_buttons capabilities but no lighting.
+    They respond with StateUnhandled (223) to Light, MultiZone, and Tile packets.
+
+    Args:
+        serial: Device serial number (auto-generated if None)
+        product_id: Switch product ID (default: 70 - LIFX Switch)
+        firmware_version: Optional firmware version (major, minor)
+        storage: Optional persistence backend
+        scenario_manager: Optional scenario manager for testing
+
+    Returns:
+        EmulatedLifxDevice configured as a switch
+    """
+    return create_device(
+        product_id,
+        serial=serial,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )
+
+
 def create_device(
     product_id: int,
     serial: str | None = None,

{lifx_emulator-2.3.1 → lifx_emulator-2.4.0}/src/lifx_emulator/products/generator.py

@@ -174,7 +174,6 @@ def generate_product_definitions(
     code_lines.append("PRODUCTS: dict[int, ProductInfo] = {")
 
     product_count = 0
-    skipped_count = 0
     for vendor_data in all_vendors:
         vendor_id = vendor_data.get("vid", 1)
         defaults = vendor_data.get("defaults", {})
@@ -186,11 +185,6 @@ def generate_product_definitions(
             name = product["name"]
             features = {**default_features, **product.get("features", {})}
 
-            # Skip switch products (devices with relays) - these are not lights
-            if features.get("relays"):
-                skipped_count += 1
-                continue
-
             # Build capabilities
             capabilities = _build_capabilities(features)
 
@@ -223,8 +217,6 @@ def generate_product_definitions(
     code_lines.append("")
 
     print(f"Generated {product_count} product definitions")
-    if skipped_count > 0:
-        print(f"Skipped {skipped_count} switch products (relays only)")
     return "\n".join(code_lines)
 
 
@@ -373,16 +365,17 @@ class ProductInfo:
         """Format product capabilities as a human-readable string.
 
         Returns:
-            Comma-separated capability string (e.g., "full color, infrared, multizone")
+            Comma-separated capability string (e.g., "color, infrared, multizone")
         """
         caps = []
 
-        # Determine base light type
+        if self.has_buttons:
+            caps.append("buttons")
+
         if self.has_relays:
-            # Devices with relays are switches, not lights
-            caps.append("switch")
+            caps.append("relays")
         elif self.has_color:
-            caps.append("full color")
+            caps.append("color")
         else:
             # Check temperature range to determine white light type
             if self.temperature_range:
@@ -409,9 +402,7 @@ class ProductInfo:
             caps.append("HEV")
         if self.has_chain:
             caps.append("chain")
-        if self.has_buttons and not self.has_relays:
-            # Only show buttons if not already identified as switch
-            caps.append("buttons")
+
 
         return ", ".join(caps) if caps else "unknown"
 
@@ -465,10 +456,6 @@ class ProductRegistry:
                 prod_features = product.get("features", {})
                 features: dict[str, Any] = {**default_features, **prod_features}
 
-                # Skip switch products (devices with relays) - these are not lights
-                if features.get("relays"):
-                    continue
-
                 # Build capabilities bitfield
                 capabilities = 0
                 if features.get("color"):
@@ -667,7 +654,7 @@ def _discover_new_products(
     products_data: dict[str, Any] | list[dict[str, Any]],
     existing_specs: dict[int, dict[str, Any]],
 ) -> list[dict[str, Any]]:
-    """Find new multizone or matrix products that need specs templates.
+    """Find new multizone, matrix, or switch products that need specs templates.
 
     Args:
         products_data: Parsed products.json data
@@ -691,21 +678,19 @@ def _discover_new_products(
             pid = product["pid"]
             features = {**default_features, **product.get("features", {})}
 
-            # Skip switch products (devices with relays) - these are not lights
-            if features.get("relays"):
-                continue
-
             # Check if this product needs specs template
             if pid not in existing_specs:
                 is_multizone = features.get("multizone", False)
                 is_matrix = features.get("matrix", False)
+                is_switch = features.get("relays", False)
 
-                if is_multizone or is_matrix:
+                if is_multizone or is_matrix or is_switch:
                     new_product = {
                         "pid": pid,
                         "name": product["name"],
                         "multizone": is_multizone,
                         "matrix": is_matrix,
+                        "switch": is_switch,
                         "extended_multizone": False,
                     }
 
@@ -732,7 +717,12 @@ def _add_product_templates(
     for product in new_products:
         product_name = product["name"].replace('"', '\\"')
 
-        if product["multizone"]:
+        if product["switch"]:
+            existing_specs[product["pid"]] = {
+                "relay_count": 2,
+                "notes": product_name,
+            }
+        elif product["multizone"]:
             existing_specs[product["pid"]] = {
                 "default_zone_count": 16,
                 "min_zone_count": 1,
@@ -752,28 +742,32 @@ def _add_product_templates(
 
 def _categorize_products(
     existing_specs: dict[int, dict[str, Any]],
-) -> tuple[list[int], list[int]]:
-    """Categorize products into multizone and matrix.
+) -> tuple[list[int], list[int], list[int]]:
+    """Categorize products into switch, multizone, and matrix.
 
     Args:
         existing_specs: Product specs dictionary
 
     Returns:
-        Tuple of (sorted_multizone_pids, sorted_matrix_pids)
+        Tuple of (sorted_switch_pids, sorted_multizone_pids, sorted_matrix_pids)
     """
+    switch_pids = []
     multizone_pids = []
     matrix_pids = []
 
     for pid, specs in existing_specs.items():
-        if "tile_width" in specs or "tile_height" in specs:
+        if "relay_count" in specs:
+            switch_pids.append(pid)
+        elif "tile_width" in specs or "tile_height" in specs:
             matrix_pids.append(pid)
         elif "default_zone_count" in specs:
             multizone_pids.append(pid)
 
+    switch_pids.sort()
     multizone_pids.sort()
     matrix_pids.sort()
 
-    return multizone_pids, matrix_pids
+    return switch_pids, multizone_pids, matrix_pids
 
 
 def _generate_yaml_header() -> list[str]:
@@ -833,6 +827,53 @@ def _generate_yaml_header() -> list[str]:
     ]
 
 
+def _generate_switch_section(
+    switch_pids: list[int], existing_specs: dict[int, dict[str, Any]]
+) -> list[str]:
+    """Generate YAML lines for switch products section.
+
+    Args:
+        switch_pids: Sorted list of switch product IDs
+        existing_specs: Product specs dictionary
+
+    Returns:
+        List of YAML lines
+    """
+    if not switch_pids:
+        return []
+
+    lines = [
+        "  # ========================================",
+        "  # Switch Products (Relays)",
+        "  # ========================================",
+        "",
+    ]
+
+    for pid in switch_pids:
+        specs = existing_specs[pid]
+        name = specs.get("notes", f"Product {pid}").split(" - ")[0]
+
+        lines.append(f"  {pid}:  # {name}")
+        lines.append(f"    relay_count: {specs['relay_count']}")
+
+        # Add firmware version if present
+        if "default_firmware_major" in specs and "default_firmware_minor" in specs:
+            lines.append(
+                f"    default_firmware_major: {specs['default_firmware_major']}"
+            )
+            lines.append(
+                f"    default_firmware_minor: {specs['default_firmware_minor']}"
+            )
+
+        notes = specs.get("notes", "")
+        if notes:
+            notes_escaped = notes.replace('"', '\\"')
+            lines.append(f'    notes: "{notes_escaped}"')
+        lines.append("")
+
+    return lines
+
+
 def _generate_multizone_section(
     multizone_pids: list[int], existing_specs: dict[int, dict[str, Any]]
 ) -> list[str]:
@@ -964,12 +1005,13 @@ def update_specs_file(
     _add_product_templates(new_products, existing_specs)
 
     # Categorize products and sort
-    multizone_pids, matrix_pids = _categorize_products(existing_specs)
+    switch_pids, multizone_pids, matrix_pids = _categorize_products(existing_specs)
 
     # Build YAML content
     lines = _generate_yaml_header()
     lines.extend(_generate_multizone_section(multizone_pids, existing_specs))
     lines.extend(_generate_matrix_section(matrix_pids, existing_specs))
+    lines.extend(_generate_switch_section(switch_pids, existing_specs))
 
     # Write the new file
     with open(specs_path, "w") as f: