ConfigFlowHandler and OptionsFlowHandler - managing the same parameter

PeteRage · December 11, 2021, 12:50pm

I have a simple use case. In the configuration of the integration, there are some parameters that I want the user to configure - for example “scan rate” - that I also want to allow them to change later. To allow parameters to be changed later you implement an Options flow

So in both the ConfigFlow and OptionsFlow I have this parameter and hence it gets presented to them both during the initial configuration and later on - when pressing “Configure” on the existing integration. This is good.

However, the OptionsFlow stores the configuration under the “options” key in core.config.entries; while the ConfigFlow stores it under the “data” key. So I end up with two sets of config values for scan rate (data[“scan_rate”] and options[“scan_rate”]. While I could sort through this when the integration loads, it does not seem ideal.

Anyone solve this already? Examples?

An option would be to have my configflow chain into the optionsflow during initial configuration? Is this possible?

anon63427907 · December 11, 2021, 10:49pm

That seems like a common problem.

You are right about options vs config flow. Maybe you can keep data duplicated across config and options, have priority on options over config.

Or, you can update config entry using this: kia_uvo/custom_components/kia_uvo at 62ee535ae871bb044163d09ec0562e53db9c51f5 · fuatakgun/kia_uvo · GitHubinit.py#L190

PeteRage · December 12, 2021, 12:15am

Thank you that is helpful. It looks like I should be able to update the config using that API - I’ll give that a try and let you know how it goes.

PeteRage · December 13, 2021, 5:31pm

I was able to get this working. Thanks for your recommendations and the code sample. Here’s the formula:

Step 1 - in the OptionsFlowHandler load the schema defaults from your config_entry.data. This then populates the Options form with the config data

            return self.async_show_form(
                step_id="init",
                data_schema=vol.Schema(
                    {
                        vol.Optional(
                            CONF_APP_ID, default=self.config_entry.data[CONF_APP_ID]
                        ): cv.string,
                        vol.Optional(
                            CONF_CREATE_SENSORS,
                            default=self.config_entry.data[CONF_CREATE_SENSORS],
                        ): cv.boolean,

Step 2: On save of the form. Store it as config data, and store no options

        if user_input is not None:
            if CONF_HOST in self.config_entry.data:
                user_input[CONF_HOST] = self.config_entry.data[CONF_HOST]
            if CONF_EMAIL in self.config_entry.data:
                user_input[CONF_EMAIL] = self.config_entry.data[CONF_EMAIL]
            self.hass.config_entries.async_update_entry(
                self.config_entry, data=user_input, options=self.config_entry.options
            )
            return self.async_create_entry(title="", data={})

A couple of notes. First, in my case the Options being configured are a subset of the config data; hence the first step is to copy the other config data in (in this example email and host) - otherwise it will be erased. Second, by returning data={} no data will get written into options (or more likely options gets set to {}), this way there is only one set of data in config.

HAEdwin · October 25, 2022, 4:21pm

I have run into the same issue and being a noob Python programmer it’s driving me nuts. But I do want to understand and well I don’t find it easy to use (building the config flow).

From what I understand is that the configflow runs when you add the integration and the optionsflow when you want to change the configuration from the added integration. The optionsflow stores the options in options and the configflow in data. Does someone have a simple example on how to either use only the options or the data part?

PeteRage · October 25, 2022, 6:33pm

Look here:

The configflow, imo, is poorly documented and very opaque. That said it does work.

HAEdwin · October 25, 2022, 8:30pm

Thanks for you swift reply, your repository is allready way to complex to use. I hope to find a simpler configflow this way. I agree on the way the documentation is written, it should be kept simple without extra’s, just the basics.

PeteRage · October 25, 2022, 8:44pm

It is a complex application. Either way, the config flow presents the parameters in the initial integration configuration AND allows a subset of these to be edited in Options. They all then get saved back into the configuration section with options remaining empty. You will see the key elements where the Options config flow gets loaded from Config and saved back into config.

HAEdwin · October 31, 2022, 8:11pm

I see, just copy the options to data and on return empty the options.

self.hass.config_entries.async_update_entry(
                self.config_entry, data=user_input, options=self.config_entry.options
            )

Thanks for this solution!

PeteRage · November 3, 2022, 1:40pm

Yep, that’s the magic!

ThermIQ · November 26, 2022, 12:52pm

Thanks, that solved a two day debug mystery for me. I wish the Config flow/Options flow documentation actually showed them to be two completely different aspects of component config and the examples doesn’t really make it clear either.

alexdelprete · January 10, 2023, 10:55pm

Pete, you almost saved me from more hours of troubleshooting, I was getting crazy because it was exactly what I needed to implement in my component, I didn’t want to duplicate data from config to options, I wanted to be able to let users edit a subset of config data through the Options Flow.

Now the good news is that I’m able to edit data and saving it in config correctly, the bad news is that the options form is not picking up the labels I configured in en.json, and I can’t understand why.

This is the main config form of a first configuration:

This is the options form when I click configure (data is saved correctly, but I don’t see any labels):

Any help is greatly appreciated, you can find the source of config_flow.py and en.json in my repo.

Thanks a lot.

PeteRage · January 10, 2023, 11:44pm

It may be that the HASS language is not set to en in your dev environment. Check the .storage/core.config file.

I also have a strings.json in the same directory as the code. I believe when no language is specified it uses those. GitHub - PeteRager/lennoxs30: Home Assistant Lennox S30 / E30 / M30 integration

You can also try copying the .en file to strings.json and see if that fixes it.

alexdelprete · January 11, 2023, 12:01am

But for the config labels it works…I simply duplicated the config lines to options section in the en.json file.

Anyway, I checked core.config: "language": "en"

I also copied en.json to strings.json in source dir, but no luck.

Any other idea? I bet it’s some stupid thing in the en.json file…but I can’t see it…it looks good to me.

alexdelprete · January 11, 2023, 11:31am

This morning I restarted HA and it seems to be working fine now, who knows why it didn’t pick-up the labels yesterday. Anyway, seems to be ok now. Thanks a lot @PeteRage, your findings should be in the documentation. It was so hard understanding how to be able to edit a proper working Config Flow, but I guess it’s because I’m not a developer.

Always thankful for this great community.

alexdelprete · January 11, 2023, 11:35am

@PeteRage I forgot to ask one thing: when I save the config, in order to have the integration pick-up the new values, I need to reload it. Is there a way to reload it programmatically when the user clicks submit?

PeteRage · January 11, 2023, 5:14pm

There may be, but i don’t know how to do it.

alexdelprete · January 11, 2023, 9:11pm

Thanks anyway Pete.

anon63427907 · January 12, 2023, 6:39am

Reloading it @alexdelprete

github.com

fuatakgun/eufy_security/blob/43a3d0736b22a0d184af05028aa7a8a7219cafaa/custom_components/eufy_security/config_flow.py#L83

    
      
                  mfa_input = user_input[ConfigField.mfa_input.name]

                  await coordinator.set_mfa_and_connect(mfa_input)

              else:

                  captcha_id = coordinator.config.captcha_id

                  captcha_input = user_input[ConfigField.captcha_input.name]

                  coordinator.config.captcha_id = None

                  coordinator.config.captcha_img = None

                  await coordinator.set_captcha_and_connect(captcha_id, captcha_input)

          

              if self._async_current_entries():

                  await self.hass.config_entries.async_reload(self.context["entry_id"])

          

          if self._async_current_entries():

              return self.async_abort(reason="single_instance_allowed")

          

          if user_input is not None:

              valid = await self._test_credentials(user_input[ConfigField.host.name], user_input[ConfigField.port.name])

              if valid:

                  return self.async_create_entry(title=user_input[ConfigField.host.name], data=user_input)

              self._errors["base"] = "auth"

              return await self._show_config_form(user_input)

alexdelprete · January 12, 2023, 10:29pm

thank you so much.

questions:

Since I have to reload in the Option Flow, where in reality I’m editing config entries, can I use that function also there or it only works in the context of Config Flow?
I found another example that has a structure more similar to my component, with the difference that it’s used in ConfigFlow. So the idea is to put these two in my option flow, after I update the config items in async_step_init. Do you think it’s ok?

class ABBPowerOnePVISunSpecOptionsFlow(config_entries.OptionsFlow):
    """Config flow options handler"""

    VERSION = 1

    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize option flow instance"""
        self.config_entry = config_entry
        self.data_schema=vol.Schema(
            {
                vol.Required(
                    CONF_PORT,
                    default=self.config_entry.data[CONF_PORT],
                ): vol.Coerce(int),
                vol.Required(
                    CONF_SLAVE_ID,
                    default=self.config_entry.data[CONF_SLAVE_ID],
                ): vol.Coerce(int),
                vol.Required(
                    CONF_BASE_ADDR,
                    default=self.config_entry.data[CONF_BASE_ADDR],
                ): vol.Coerce(int),
                vol.Required(
                    CONF_SCAN_INTERVAL,
                    default=self.config_entry.data[CONF_SCAN_INTERVAL],
                ): vol.All(vol.Coerce(int), vol.Range(min=5, max=900)),
            }
        )
    async def async_step_init(self, user_input=None):  # pylint: disable=unused-argument
        """Manage the options"""

        if user_input is not None:
            # complete non-edited entries before update (ht @PeteRage)
            if CONF_NAME in self.config_entry.data:
                user_input[CONF_NAME] = self.config_entry.data[CONF_NAME]
            if CONF_HOST in self.config_entry.data:
                user_input[CONF_HOST] = self.config_entry.data[CONF_HOST]

            # write updated config entries (ht @PeteRage / @anon63427907)
            self.hass.config_entries.async_update_entry(
                self.config_entry, data=user_input, options=self.config_entry.options
            )
            # reload updated config entries (ht @anon63427907)
            await self.hass.config_entries.async_reload(self.config_entry.entry_id)
            self.async_abort(reason="configuration updated")

            # write empty options entries (ht @PeteRage / @anon63427907)
            return self.async_create_entry(title="", data={})

        return self.async_show_form(step_id="init", data_schema=self.data_schema)