Release v2.0.0

custom_components/ha_text_ai/config_flow.py

@@ -4,10 +4,11 @@ from typing import Any, Dict, Optional
 
 import voluptuous as vol
 from homeassistant import config_entries
-from homeassistant.const import CONF_API_KEY
+from homeassistant.const import CONF_API_KEY, CONF_NAME
 from homeassistant.core import callback
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers import selector
 
 from .const import (
     DOMAIN,
@@ -42,145 +43,144 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize flow."""
-        super().__init__()
-        self.provider = None
-
-    def _show_provider_selection(self) -> FlowResult:
-        """Show the provider selection form."""
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema({
-                vol.Required("provider"): vol.In(API_PROVIDERS),
-            }),
-        )
-
-    def _show_provider_config(self, provider: str) -> FlowResult:
-        """Show the configuration form for the selected provider."""
-        default_endpoint = (
-            DEFAULT_OPENAI_ENDPOINT if provider == API_PROVIDER_OPENAI
-            else DEFAULT_ANTHROPIC_ENDPOINT
-        )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema({
-                vol.Required("name", default=f"HA Text AI {len(self._async_current_entries()) + 1}"): str,
-                vol.Required(CONF_API_PROVIDER): vol.In([provider]),
-                vol.Required(CONF_API_KEY): str,
-                vol.Required(CONF_MODEL, default=DEFAULT_MODEL): str,
-                vol.Optional(CONF_API_ENDPOINT, default=default_endpoint): str,
-                vol.Optional(CONF_TEMPERATURE, default=DEFAULT_TEMPERATURE): vol.All(
-                    vol.Coerce(float),
-                    vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
-                ),
-                vol.Optional(CONF_MAX_TOKENS, default=DEFAULT_MAX_TOKENS): vol.All(
-                    vol.Coerce(int),
-                    vol.Range(min=MIN_MAX_TOKENS, max=MAX_MAX_TOKENS)
-                ),
-                vol.Optional(CONF_REQUEST_INTERVAL, default=DEFAULT_REQUEST_INTERVAL): vol.All(
-                    vol.Coerce(float),
-                    vol.Range(min=MIN_REQUEST_INTERVAL)
-                ),
-            })
-        )
+        self._errors = {}
+        self._data = {}
+        self._provider = None
 
     async def async_step_user(self, user_input: Optional[Dict[str, Any]] = None) -> FlowResult:
         """Handle the initial step."""
         if user_input is None:
-            return self._show_provider_selection()
+            return self.async_show_form(
+                step_id="user",
+                data_schema=vol.Schema({
+                    vol.Required(CONF_API_PROVIDER): selector.SelectSelector(
+                        selector.SelectSelectorConfig(
+                            options=API_PROVIDERS,
+                            translation_key="api_provider"
+                        )
+                    ),
+                })
+            )
 
-        if "provider" in user_input:
-            self.provider = user_input["provider"]
-            return self._show_provider_config(self.provider)
+        self._provider = user_input[CONF_API_PROVIDER]
+        return await self.async_step_provider()
 
-        return await self._process_configuration(user_input)
+    async def async_step_provider(self, user_input: Optional[Dict[str, Any]] = None) -> FlowResult:
+        """Handle provider configuration step."""
+        if user_input is None:
+            default_endpoint = (
+                DEFAULT_OPENAI_ENDPOINT if self._provider == API_PROVIDER_OPENAI
+                else DEFAULT_ANTHROPIC_ENDPOINT
+            )
 
-    async def _process_configuration(self, user_input):
-        """Validate and process user configuration."""
-        errors = {}
+            suggested_name = f"HA Text AI {len(self._async_current_entries()) + 1}"
 
+            return self.async_show_form(
+                step_id="provider",
+                data_schema=vol.Schema({
+                    vol.Required(CONF_NAME, default=suggested_name): str,
+                    vol.Required(CONF_API_KEY): str,
+                    vol.Required(CONF_MODEL, default=DEFAULT_MODEL): str,
+                    vol.Required(CONF_API_ENDPOINT, default=default_endpoint): str,
+                    vol.Optional(CONF_TEMPERATURE, default=DEFAULT_TEMPERATURE): vol.All(
+                        vol.Coerce(float),
+                        vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
+                    ),
+                    vol.Optional(CONF_MAX_TOKENS, default=DEFAULT_MAX_TOKENS): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=MIN_MAX_TOKENS, max=MAX_MAX_TOKENS)
+                    ),
+                    vol.Optional(CONF_REQUEST_INTERVAL, default=DEFAULT_REQUEST_INTERVAL): vol.All(
+                        vol.Coerce(float),
+                        vol.Range(min=MIN_REQUEST_INTERVAL)
+                    ),
+                }),
+                errors=self._errors
+            )
+
+        # Проверка уникальности имени
+        instance_name = user_input[CONF_NAME]
+        await self._async_validate_name(instance_name)
+        if self._errors:
+            return await self.async_step_provider()
+
+        # Проверка API подключения
+        if not await self._async_validate_api(user_input):
+            return await self.async_step_provider()
+
+        # Создание записи конфигурации
+        return await self._create_entry(user_input)
+
+    async def _async_validate_name(self, name: str) -> bool:
+        """Validate that the name is unique."""
+        for entry in self._async_current_entries():
+            if entry.data.get(CONF_NAME) == name:
+                self._errors["name"] = "name_exists"
+                return False
+        return True
+
+    async def _async_validate_api(self, user_input: Dict[str, Any]) -> bool:
+        """Validate API connection."""
         try:
-            # Создаем уникальный идентификатор, включающий имя экземпляра
-            instance_name = user_input.get("name", f"HA Text AI {len(self._async_current_entries()) + 1}")
-            unique_id = f"{DOMAIN}_{instance_name}_{user_input[CONF_API_PROVIDER]}"
-
-            # Нормализуем уникальный идентификатор
-            unique_id = unique_id.lower().replace(" ", "_")
-
-            await self.async_set_unique_id(unique_id)
-            self._abort_if_unique_id_configured()
-
-            # Проверяем подключение к API
             session = async_get_clientsession(self.hass)
             headers = self._get_api_headers(user_input)
+            endpoint = user_input[CONF_API_ENDPOINT].rstrip('/')
 
-            try:
-                async with session.get(
-                    f"{user_input[CONF_API_ENDPOINT]}/models",
-                    headers=headers
-                ) as response:
-                    if response.status not in [200, 404]:
-                        errors["base"] = "cannot_connect"
-            except Exception as e:
-                _LOGGER.error(f"Connection test failed: {e}")
-                errors["base"] = "cannot_connect"
+            check_url = (
+                f"{endpoint}/v1/models" if self._provider == API_PROVIDER_ANTHROPIC
+                else f"{endpoint}/models"
+            )
 
-            if not errors:
-                return self.async_create_entry(
-                    title=instance_name,
-                    data={
-                        "name": instance_name,
-                        **user_input,
-                        "unique_id": unique_id  # Сохраняем уникальный идентификатор в данных
-                    }
-                )
+            async with session.get(check_url, headers=headers) as response:
+                if response.status == 401:
+                    self._errors["base"] = "invalid_auth"
+                    return False
+                elif response.status not in [200, 404]:
+                    self._errors["base"] = "cannot_connect"
+                    return False
+                return True
 
-        except Exception as e:
-            _LOGGER.error(f"Unexpected error: {e}")
-            errors["base"] = "unknown"
+        except Exception as err:
+            _LOGGER.error("API validation error: %s", str(err))
+            self._errors["base"] = "cannot_connect"
+            return False
 
-        return self._show_configuration_form(user_input, errors)
-
-    def _get_api_headers(self, user_input):
+    def _get_api_headers(self, user_input: Dict[str, Any]) -> Dict[str, str]:
         """Get API headers based on provider."""
-        if user_input[CONF_API_PROVIDER] == API_PROVIDER_ANTHROPIC:
+        api_key = user_input[CONF_API_KEY]
+
+        if self._provider == API_PROVIDER_ANTHROPIC:
             return {
-                "x-api-key": user_input[CONF_API_KEY],
-                "anthropic-version": "2023-06-01"
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+                "Content-Type": "application/json"
             }
         return {
-            "Authorization": f"Bearer {user_input[CONF_API_KEY]}",
+            "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json"
         }
 
-    def _show_configuration_form(self, user_input, errors=None):
-        """Show the configuration form to edit location data."""
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema({
-                vol.Required("name", default=user_input.get("name", f"HA Text AI {len(self._async_current_entries()) + 1}")): str,
-                vol.Required(CONF_API_PROVIDER): vol.In([user_input[CONF_API_PROVIDER]]),
-                vol.Required(CONF_API_KEY): str,
-                vol.Required(CONF_MODEL, default=user_input.get(CONF_MODEL, DEFAULT_MODEL)): str,
-                vol.Optional(CONF_API_ENDPOINT, default=user_input.get(CONF_API_ENDPOINT,
-                    DEFAULT_OPENAI_ENDPOINT if user_input[CONF_API_PROVIDER] == API_PROVIDER_OPENAI
-                    else DEFAULT_ANTHROPIC_ENDPOINT)): str,
-                vol.Optional(CONF_TEMPERATURE, default=user_input.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)): vol.All(
-                    vol.Coerce(float),
-                    vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
-                ),
-                vol.Optional(CONF_MAX_TOKENS, default=user_input.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS)): vol.All(
-                    vol.Coerce(int),
-                    vol.Range(min=MIN_MAX_TOKENS, max=MAX_MAX_TOKENS)
-                ),
-                vol.Optional(CONF_REQUEST_INTERVAL, default=user_input.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL)): vol.All(
-                    vol.Coerce(float),
-                    vol.Range(min=MIN_REQUEST_INTERVAL)
-                ),
-            }),
-            errors=errors or {}
+    async def _create_entry(self, user_input: Dict[str, Any]) -> FlowResult:
+        """Create the config entry."""
+        instance_name = user_input[CONF_NAME]
+        unique_id = f"{DOMAIN}_{instance_name}_{self._provider}".lower().replace(" ", "_")
+
+        return self.async_create_entry(
+            title=instance_name,
+            data={
+                CONF_API_PROVIDER: self._provider,
+                CONF_NAME: instance_name,
+                **user_input,
+                "unique_id": unique_id
+            }
         )
 
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: config_entries.ConfigEntry) -> config_entries.OptionsFlow:
+        """Get the options flow for this handler."""
+        return OptionsFlowHandler(config_entry)
+
 
 class OptionsFlowHandler(config_entries.OptionsFlow):
     """Handle options flow."""
@@ -194,11 +194,15 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
         if user_input is not None:
             return self.async_create_entry(title="", data=user_input)
 
-        current_data = self.config_entry.data
+        current_data = {**self.config_entry.data, **self.config_entry.options}
 
         return self.async_show_form(
             step_id="init",
             data_schema=vol.Schema({
+                vol.Optional(
+                    CONF_MODEL,
+                    default=current_data.get(CONF_MODEL, DEFAULT_MODEL)
+                ): str,
                 vol.Optional(
                     CONF_TEMPERATURE,
                     default=current_data.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)