Bump version to 0.2.6 with UI improvements and options flow

- Fix sonance amp type key to sonance6 (matches pyxantech)
- Add descriptive amp type labels showing all supported models
  (MRC88, MX88, MRAUDIO8X8, DAX66, WS66i, etc.)
- Switch amp type selector from dropdown to radio buttons
- Fix DAX88 default sources to show all 8 inputs
- Add options flow to edit zones, sources, connection, and
  polling interval after initial setup
- Implement optimistic updates for instant UI feedback on
  power, volume, mute, and source changes

Co-Authored-By: SageOx <ox@sageox.ai>

Author: rsnodgrass

custom_components/xantech/config_flow.py

@@ -94,7 +94,7 @@ async def async_step_user(
                     ): SelectSelector(
                         SelectSelectorConfig(
                             options=SUPPORTED_AMP_TYPES,
-                            mode=SelectSelectorMode.DROPDOWN,
+                            mode=SelectSelectorMode.LIST,
                             translation_key='amp_type',
                         )
                     ),
@@ -165,7 +165,9 @@ async def async_step_sources(
                     data=self._data,
                 )
 
-        default_sources = '1: TV\n2: Streaming\n3: Turntable\n4: CD Player'
+        default_sources = self._get_default_sources_text(
+            self._data.get(CONF_AMP_TYPE, DEFAULT_AMP_TYPE)
+        )
 
         return self.async_show_form(
             step_id='sources',
@@ -241,6 +243,17 @@ def _get_default_zones_text(self, amp_type: str) -> str:
             '14: Office\n15: Patio\n16: Dining Room'
         )
 
+    def _get_default_sources_text(self, amp_type: str) -> str:
+        """Get default sources text for an amplifier type."""
+        # 8-source amps: xantech8, dax88
+        if amp_type in ('xantech8', 'dax88'):
+            return (
+                '1: TV\n2: Streaming\n3: Turntable\n4: CD Player\n'
+                '5: Auxiliary\n6: Tuner\n7: Phono\n8: Media Server'
+            )
+        # 6-source amps: monoprice6, zpr68-10, sonance6
+        return '1: TV\n2: Streaming\n3: Turntable\n4: CD Player\n5: Auxiliary\n6: Tuner'
+
     @staticmethod
     @callback
     def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
@@ -256,10 +269,53 @@ def __init__(self, config_entry: ConfigEntry) -> None:
         self.config_entry = config_entry
 
     async def async_step_init(
+        self,
+        user_input: dict[str, Any] | None = None,  # noqa: ARG002
+    ) -> ConfigFlowResult:
+        """Show menu of configuration options."""
+        return self.async_show_menu(
+            step_id='init',
+            menu_options=['polling', 'connection', 'zones', 'sources'],
+        )
+
+    async def async_step_connection(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Configure connection settings."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            new_port = user_input.get(CONF_PORT, '')
+            if not new_port:
+                errors['base'] = 'cannot_connect'
+            else:
+                # update config entry data with new port
+                new_data = {**self.config_entry.data, CONF_PORT: new_port}
+                self.hass.config_entries.async_update_entry(
+                    self.config_entry, data=new_data
+                )
+                return self.async_create_entry(title='', data=self.config_entry.options)
+
+        current_port = self.config_entry.data.get(CONF_PORT, '/dev/ttyUSB0')
+
+        return self.async_show_form(
+            step_id='connection',
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PORT, default=current_port): TextSelector(
+                        TextSelectorConfig(type=TextSelectorType.TEXT)
+                    ),
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_polling(
         self,
         user_input: dict[str, Any] | None = None,
     ) -> ConfigFlowResult:
-        """Manage the options."""
+        """Configure polling interval."""
         if user_input is not None:
             return self.async_create_entry(title='', data=user_input)
 
@@ -268,7 +324,7 @@ async def async_step_init(
         )
 
         return self.async_show_form(
-            step_id='init',
+            step_id='polling',
             data_schema=vol.Schema(
                 {
                     vol.Optional(
@@ -286,3 +342,135 @@ async def async_step_init(
                 }
             ),
         )
+
+    async def async_step_zones(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Configure zones."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            zones_text = user_input.get('zones_config', '')
+            zones = self._parse_zones_config(zones_text)
+
+            if not zones:
+                errors['base'] = 'invalid_zones'
+            else:
+                # update config entry data with new zones
+                new_data = {**self.config_entry.data, CONF_ZONES: zones}
+                self.hass.config_entries.async_update_entry(
+                    self.config_entry, data=new_data
+                )
+                return self.async_create_entry(title='', data=self.config_entry.options)
+
+        # convert current zones dict back to text
+        current_zones = self.config_entry.data.get(CONF_ZONES, {})
+        zones_text = self._zones_to_text(current_zones)
+
+        return self.async_show_form(
+            step_id='zones',
+            data_schema=vol.Schema(
+                {
+                    vol.Required('zones_config', default=zones_text): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.TEXT,
+                            multiline=True,
+                        )
+                    ),
+                }
+            ),
+            errors=errors,
+            description_placeholders={
+                'example': '11: Living Room\n12: Kitchen\n13: Bedroom',
+            },
+        )
+
+    async def async_step_sources(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Configure sources."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            sources_text = user_input.get('sources_config', '')
+            sources = self._parse_sources_config(sources_text)
+
+            if not sources:
+                errors['base'] = 'invalid_sources'
+            else:
+                # update config entry data with new sources
+                new_data = {**self.config_entry.data, CONF_SOURCES: sources}
+                self.hass.config_entries.async_update_entry(
+                    self.config_entry, data=new_data
+                )
+                return self.async_create_entry(title='', data=self.config_entry.options)
+
+        # convert current sources dict back to text
+        current_sources = self.config_entry.data.get(CONF_SOURCES, {})
+        sources_text = self._sources_to_text(current_sources)
+
+        return self.async_show_form(
+            step_id='sources',
+            data_schema=vol.Schema(
+                {
+                    vol.Required('sources_config', default=sources_text): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.TEXT,
+                            multiline=True,
+                        )
+                    ),
+                }
+            ),
+            errors=errors,
+            description_placeholders={
+                'example': '1: Sonos\n2: Turntable\n3: TV',
+            },
+        )
+
+    def _parse_zones_config(self, text: str) -> dict[int, dict[str, str]]:
+        """Parse zone configuration text into structured dict."""
+        zones: dict[int, dict[str, str]] = {}
+        for line in text.strip().split('\n'):
+            line = line.strip()
+            if not line or ':' not in line:
+                continue
+            try:
+                zone_id_str, name = line.split(':', 1)
+                zone_id = int(zone_id_str.strip())
+                zones[zone_id] = {'name': name.strip()}
+            except ValueError:
+                continue
+        return zones
+
+    def _parse_sources_config(self, text: str) -> dict[int, dict[str, str]]:
+        """Parse source configuration text into structured dict."""
+        sources: dict[int, dict[str, str]] = {}
+        for line in text.strip().split('\n'):
+            line = line.strip()
+            if not line or ':' not in line:
+                continue
+            try:
+                source_id_str, name = line.split(':', 1)
+                source_id = int(source_id_str.strip())
+                sources[source_id] = {'name': name.strip()}
+            except ValueError:
+                continue
+        return sources
+
+    def _zones_to_text(self, zones: dict[int, dict[str, str]]) -> str:
+        """Convert zones dict back to text format."""
+        lines = []
+        for zone_id in sorted(zones.keys()):
+            name = zones[zone_id].get('name', f'Zone {zone_id}')
+            lines.append(f'{zone_id}: {name}')
+        return '\n'.join(lines)
+
+    def _sources_to_text(self, sources: dict[int, dict[str, str]]) -> str:
+        """Convert sources dict back to text format."""
+        lines = []
+        for source_id in sorted(sources.keys()):
+            name = sources[source_id].get('name', f'Source {source_id}')
+            lines.append(f'{source_id}: {name}')
+        return '\n'.join(lines)

custom_components/xantech/const.py

@@ -24,18 +24,23 @@
 DEFAULT_SCAN_INTERVAL: Final = 30
 
 # Amplifier types supported by pyxantech
+# xantech8: MX88, MX88ai, MRC88, MRC88m, MRAUDIO8X8, MRAUDIO8X8m
 AMP_TYPE_XANTECH8: Final = 'xantech8'
+# monoprice6: Monoprice MPR-SG6Z, Dayton Audio DAX66, Soundavo WS66i
 AMP_TYPE_MONOPRICE6: Final = 'monoprice6'
+# dax88: Dayton Audio DAX88 (6+2 zone)
 AMP_TYPE_DAX88: Final = 'dax88'
+# zpr68-10: Xantech ZPR68-10 controller
 AMP_TYPE_ZPR68: Final = 'zpr68-10'
-AMP_TYPE_SONANCE: Final = 'sonance'
+# sonance6: Sonance C4630 SE (6-zone), 875D MKII (4-zone)
+AMP_TYPE_SONANCE6: Final = 'sonance6'
 
 SUPPORTED_AMP_TYPES: Final[list[str]] = [
     AMP_TYPE_XANTECH8,
     AMP_TYPE_MONOPRICE6,
     AMP_TYPE_DAX88,
     AMP_TYPE_ZPR68,
-    AMP_TYPE_SONANCE,
+    AMP_TYPE_SONANCE6,
 ]
 
 # Max volume level for amps

custom_components/xantech/manifest.json

@@ -1,7 +1,7 @@
 {
     "domain": "xantech",
     "name": "Xantech Multi-Zone Audio",
-    "version": "0.2.5",
+    "version": "0.2.6",
     "documentation": "https://github.com/rsnodgrass/hass-xantech",
     "issue_tracker": "https://github.com/rsnodgrass/hass-xantech/issues",
     "requirements": ["pyxantech>=0.10.3"],