Convert qbittorrent to config flow

.coveragerc

@@ -839,6 +839,7 @@ omit =
     homeassistant/components/pvoutput/sensor.py
     homeassistant/components/pyload/sensor.py
     homeassistant/components/qbittorrent/sensor.py
+    homeassistant/components/qbittorrent/client.py
     homeassistant/components/qnap/sensor.py
     homeassistant/components/qrcode/image_processing.py
     homeassistant/components/quantum_gateway/device_tracker.py

homeassistant/components/qbittorrent/__init__.py

@@ -1 +1,85 @@
 """The qbittorrent component."""
+import asyncio
+import logging
+
+from qbittorrent.client import LoginRequired
+from requests.exceptions import RequestException
+
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import config_per_platform
+
+from .client import create_client
+from .const import DATA_KEY_CLIENT, DATA_KEY_NAME, DOMAIN
+
+PLATFORMS = ["sensor"]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup(hass: HomeAssistant, config: dict):
+    """Set up the Qbittorrent component."""
+    hass.data.setdefault(DOMAIN, {})
+
+    # Import configuration from sensor platform
+    config_platform = config_per_platform(config, "sensor")
+    for p_type, p_config in config_platform:
+        if p_type != DOMAIN:
+            continue
+
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": SOURCE_IMPORT},
+                data=p_config,
+            )
+        )
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
+    """Set up Qbittorrent from a config entry."""
+    name = "Qbittorrent"
+    try:
+        client = await hass.async_add_executor_job(
+            create_client,
+            entry.data[CONF_URL],
+            entry.data[CONF_USERNAME],
+            entry.data[CONF_PASSWORD],
+        )
+    except LoginRequired:
+        _LOGGER.error("Invalid authentication")
+        return False
+
+    except RequestException as err:
+        _LOGGER.error("Connection failed")
+        raise ConfigEntryNotReady from err
+
+    hass.data[DOMAIN][entry.data[CONF_URL]] = {
+        DATA_KEY_CLIENT: client,
+        DATA_KEY_NAME: name,
+    }
+    for platform in PLATFORMS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(entry, platform)
+        )
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Unload Qbittorrent Entry from config_entry."""
+
+    unload_ok = all(
+        await asyncio.gather(
+            *(
+                hass.config_entries.async_forward_entry_unload(config_entry, platform)
+                for platform in PLATFORMS
+            )
+        )
+    )
+
+    return unload_ok

homeassistant/components/qbittorrent/client.py

@@ -0,0 +1,19 @@
+"""Some common functions used in the qbittorrent components."""
+from qbittorrent.client import Client
+
+
+def get_main_data_client(client: Client):
+    """Get the main data from the Qtorrent client."""
+    return client.sync_main_data()
+
+
+def create_client(url, username, password):
+    """Create the Qtorrent client."""
+    client = Client(url)
+    client.login(username, password)
+    return client
+
+
+def retrieve_torrentdata(client: Client, torrentfilter):
+    """Retrieve torrent data from the Qtorrent client with specific filters."""
+    return client.torrents(filter=torrentfilter)

homeassistant/components/qbittorrent/config_flow.py

@@ -0,0 +1,116 @@
+"""Config flow for qBittorrent integration."""
+import logging
+
+from qbittorrent.client import LoginRequired
+from requests.exceptions import RequestException
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME
+
+from .client import create_client
+from .const import DOMAIN  # pylint:disable=unused-import
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def validate_input(hass, data):
+    """Validate user or import input."""
+    errors = {}
+    try:
+        await hass.async_add_executor_job(
+            create_client,
+            data[CONF_URL],
+            data[CONF_USERNAME],
+            data[CONF_PASSWORD],
+        )
+    except LoginRequired:
+        errors["base"] = "invalid_auth"
+
+    except RequestException as err:
+        errors["base"] = "cannot_connect"
+        _LOGGER.error("Connection failed - %s", err)
+    return errors
+
+
+class QBittorrentConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for qbittorrent."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
+
+    def __init__(self):
+        """Initialize qbittorrent config flow."""
+        self._data = None
+        self._title = None
+
+    async def async_step_import(self, device_config):
+        """Import a configuration.yaml config."""
+        data = {}
+
+        data[CONF_URL] = device_config.get(CONF_URL)
+        data[CONF_USERNAME] = device_config.get(CONF_USERNAME)
+        data[CONF_PASSWORD] = device_config.get(CONF_PASSWORD)
+
+        errors = await validate_input(self.hass, data)
+        if not errors:
+            self._data = data
+            self._title = data[CONF_URL]
+            return await self.async_step_import_confirm()
+
+        return self.async_abort(reason=errors["base"])
+
+    async def async_step_import_confirm(self, user_input=None):
+        """Confirm the user wants to import the config entry."""
+        if user_input is None:
+            return self.async_show_form(
+                step_id="import_confirm",
+                description_placeholders={"id": self._title},
+            )
+
+        await self.async_set_unique_id(self._data[CONF_URL])
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(
+            title=self._data[CONF_URL],
+            data={
+                CONF_USERNAME: self._data[CONF_USERNAME],
+                CONF_PASSWORD: self._data[CONF_PASSWORD],
+                CONF_URL: self._data[CONF_URL],
+            },
+        )
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+        if user_input is not None:
+            await self.async_set_unique_id(user_input[CONF_URL])
+            self._abort_if_unique_id_configured()
+
+            _LOGGER.debug(
+                "Configuring user: %s - Password hidden", user_input[CONF_USERNAME]
+            )
+
+            errors = await validate_input(self.hass, user_input)
+
+            if not errors:
+                return self.async_create_entry(
+                    title=user_input[CONF_URL],
+                    data={
+                        CONF_USERNAME: user_input[CONF_USERNAME],
+                        CONF_PASSWORD: user_input[CONF_PASSWORD],
+                        CONF_URL: user_input[CONF_URL],
+                    },
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_URL): str,
+                    vol.Required(CONF_USERNAME): str,
+                    vol.Required(CONF_PASSWORD): str,
+                }
+            ),
+            errors=errors,
+        )

homeassistant/components/qbittorrent/const.py

@@ -0,0 +1,25 @@
+"""Added constants for the qbittorrent component."""
+
+SENSOR_TYPE_CURRENT_STATUS = "current_status"
+SENSOR_TYPE_DOWNLOAD_SPEED = "download_speed"
+SENSOR_TYPE_UPLOAD_SPEED = "upload_speed"
+SENSOR_TYPE_TOTAL_TORRENTS = "total_torrents"
+SENSOR_TYPE_ACTIVE_TORRENTS = "active_torrents"
+SENSOR_TYPE_INACTIVE_TORRENTS = "inactive_torrents"
+SENSOR_TYPE_DOWNLOADING_TORRENTS = "downloading_torrents"
+SENSOR_TYPE_SEEDING_TORRENTS = "seeding_torrents"
+SENSOR_TYPE_RESUMED_TORRENTS = "resumed_torrents"
+SENSOR_TYPE_PAUSED_TORRENTS = "paused_torrents"
+SENSOR_TYPE_COMPLETED_TORRENTS = "completed_torrents"
+
+DEFAULT_NAME = "qbittorrent"
+TRIM_SIZE = 35
+CONF_CATEGORIES = "categories"
+
+DOMAIN = DEFAULT_NAME
+
+DATA_KEY_CLIENT = "client"
+DATA_KEY_NAME = "name"
+
+SERVICE_ADD_DOWNLOAD = "add_download"
+SERVICE_REMOVE_DOWNLOAD = "remove_download"

homeassistant/components/qbittorrent/manifest.json

@@ -1,6 +1,7 @@
 {
   "domain": "qbittorrent",
   "name": "qBittorrent",
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/qbittorrent",
   "requirements": ["python-qbittorrent==0.4.2"],
   "codeowners": ["@geoffreylagaisse"],