refactor: Simplify segment mode configuration - remove global setting

- Remove global segment_mode option from options flow
- Use per-device segment mode configuration only with SEGMENT_MODE_INDIVIDUAL default
- Add friendly labels for per-device segment mode dropdowns
- Simplify light.py and __init__.py to use per-device-only mode resolution
- Remove unused imports and debug logging references
- Update strings.json and translations/en.json accordingly

This simplifies the UI by removing redundant global setting and focusing on per-device configuration when needed.

Author: Tom Lasswell

custom_components/govee/__init__.py

@@ -25,13 +25,11 @@
     CONF_ENABLE_SEGMENTS,
     CONF_PASSWORD,
     CONF_POLL_INTERVAL,
-    CONF_SEGMENT_MODE,
     DEFAULT_ENABLE_DIY_SCENES,
     DEFAULT_ENABLE_GROUPS,
     DEFAULT_ENABLE_SCENES,
     DEFAULT_ENABLE_SEGMENTS,
     DEFAULT_POLL_INTERVAL,
-    DEFAULT_SEGMENT_MODE,
     DOMAIN,
     KEY_IOT_CREDENTIALS,
     KEY_IOT_LOGIN_FAILED,
@@ -261,16 +259,14 @@ async def _async_cleanup_orphaned_entities(
 
     # Get current options
     options = entry.options
-    global_segment_mode = options.get(CONF_SEGMENT_MODE, DEFAULT_SEGMENT_MODE)
     device_modes = options.get("segment_mode_by_device", {})
     # For backward compatibility, check old enable_segments boolean
     enable_segments_old = options.get(CONF_ENABLE_SEGMENTS, DEFAULT_ENABLE_SEGMENTS)
     enable_scenes = options.get(CONF_ENABLE_SCENES, DEFAULT_ENABLE_SCENES)
     enable_diy_scenes = options.get(CONF_ENABLE_DIY_SCENES, DEFAULT_ENABLE_DIY_SCENES)
 
     _LOGGER.debug(
-        "Orphan cleanup: global_segment_mode=%s, device_modes=%s, enable_scenes=%s, enable_diy_scenes=%s",
-        global_segment_mode,
+        "Orphan cleanup: device_modes=%s, enable_scenes=%s, enable_diy_scenes=%s",
         len(device_modes),
         enable_scenes,
         enable_diy_scenes,
@@ -302,8 +298,8 @@ async def _async_cleanup_orphaned_entities(
 
         # Check feature toggles first
         if device_id:
-            # Get per-device mode, fallback to global
-            segment_mode = device_modes.get(device_id, global_segment_mode)
+            # Get per-device mode (default to individual)
+            segment_mode = device_modes.get(device_id, SEGMENT_MODE_INDIVIDUAL)
             suffix = unique_id[len(device_id) :]
 
             # Use explicit suffix matching to avoid false positives

custom_components/govee/config_flow.py

@@ -488,13 +488,6 @@ async def async_step_init(
                             CONF_ENABLE_DIY_SCENES, DEFAULT_ENABLE_DIY_SCENES
                         ),
                     ): bool,
-                    vol.Optional(
-                        CONF_SEGMENT_MODE,
-                        default=options.get(
-                            CONF_SEGMENT_MODE,
-                            SEGMENT_MODE_INDIVIDUAL if options.get(CONF_ENABLE_SEGMENTS, DEFAULT_ENABLE_SEGMENTS) else SEGMENT_MODE_DISABLED,
-                        ),
-                    ): vol.In([SEGMENT_MODE_DISABLED, SEGMENT_MODE_GROUPED, SEGMENT_MODE_INDIVIDUAL]),
                 }
             ),
         )
@@ -567,15 +560,21 @@ async def async_step_configure_device_modes(
         schema_dict: dict[vol.Marker, vol.Schema] = {}
 
         current_device_modes = self._config_entry.options.get("segment_mode_by_device", {})
-        global_mode = self._global_options.get(CONF_SEGMENT_MODE, DEFAULT_SEGMENT_MODE)
+
+        # Friendly labels for segment modes
+        mode_options = {
+            SEGMENT_MODE_DISABLED: "Disabled (hide segment entities)",
+            SEGMENT_MODE_GROUPED: "Grouped (control all together)",
+            SEGMENT_MODE_INDIVIDUAL: "Individual (separate control per segment)",
+        }
 
         for device_id in self._selected_devices:
             device = coordinator.devices.get(device_id)
             if not device:
                 continue
 
-            # Get current mode for this device
-            default_mode = current_device_modes.get(device_id, global_mode)
+            # Get current mode for this device (default to individual)
+            default_mode = current_device_modes.get(device_id, SEGMENT_MODE_INDIVIDUAL)
 
             # Create field key and label for this device
             field_key = f"segment_mode_{device_id}"
@@ -585,7 +584,7 @@ async def async_step_configure_device_modes(
                 field_key,
                 description=device_label,
                 default=default_mode,
-            )] = vol.In([SEGMENT_MODE_DISABLED, SEGMENT_MODE_GROUPED, SEGMENT_MODE_INDIVIDUAL])
+            )] = vol.In(mode_options)
 
         _LOGGER.debug("Showing per-device configuration form for %d devices", len(self._selected_devices))
 

custom_components/govee/light.py

@@ -26,8 +26,6 @@
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from .const import (
-    CONF_SEGMENT_MODE,
-    DEFAULT_SEGMENT_MODE,
     SEGMENT_MODE_DISABLED,
     SEGMENT_MODE_GROUPED,
     SEGMENT_MODE_INDIVIDUAL,
@@ -61,25 +59,23 @@ async def async_setup_entry(
 
     entities: list[LightEntity] = []
 
-    # Get per-device and global segment modes
+    # Get per-device segment modes
     device_modes = entry.options.get("segment_mode_by_device", {})
-    global_segment_mode = entry.options.get(CONF_SEGMENT_MODE, DEFAULT_SEGMENT_MODE)
 
     for device in coordinator.devices.values():
         # Only create light entities for devices with power control (not fans)
         if device.supports_power and not device.is_fan:
             entities.append(GoveeLightEntity(coordinator, device))
 
-        # Create segment entities for RGBIC devices based on per-device or global mode
+        # Create segment entities for RGBIC devices based on per-device mode
         if device.supports_segments and device.segment_count > 0:
-            # Get per-device mode, fallback to global
-            segment_mode = device_modes.get(device.device_id, global_segment_mode)
+            # Use per-device mode if set, otherwise default to individual
+            segment_mode = device_modes.get(device.device_id, SEGMENT_MODE_INDIVIDUAL)
 
             _LOGGER.debug(
-                "Segment check for %s: device_mode=%s, global_mode=%s, supports_segments=%s, segment_count=%d",
+                "Segment check for %s: device_mode=%s, supports_segments=%s, segment_count=%d",
                 device.name,
-                device_modes.get(device.device_id, "not set"),
-                global_segment_mode,
+                device_modes.get(device.device_id, "default (individual)"),
                 device.supports_segments,
                 device.segment_count,
             )

custom_components/govee/manifest.json

@@ -16,6 +16,6 @@
     "cryptography>=41.0.0"
   ],
   "ssdp": [],
-  "version": "2026.2.5",
+  "version": "2026.2.6",
   "zeroconf": []
 }

custom_components/govee/strings.json

@@ -68,21 +68,11 @@
           "poll_interval": "Polling interval (seconds)",
           "enable_groups": "Enable group devices",
           "enable_scenes": "Enable scene selector",
-          "enable_diy_scenes": "Enable DIY scene selector",
-          "segment_mode": "Segment control mode"
+          "enable_diy_scenes": "Enable DIY scene selector"
         }
       }
     }
   },
-  "selector": {
-    "segment_mode": {
-      "options": {
-        "disabled": "Disabled (no segment entities)",
-        "grouped": "Grouped (single control for all segments)",
-        "individual": "Individual (separate control for each segment)"
-      }
-    }
-  },
   "entity": {
     "light": {
       "govee_light": {

custom_components/govee/translations/en.json

@@ -68,8 +68,7 @@
           "poll_interval": "Polling interval (seconds)",
           "enable_groups": "Enable group devices",
           "enable_scenes": "Enable scene selector",
-          "enable_diy_scenes": "Enable DIY scene selector",
-          "enable_segments": "Enable segment entities"
+          "enable_diy_scenes": "Enable DIY scene selector"
         }
       }
     }