Pre core

.github/workflows/hassfest.yml

@@ -0,0 +1,23 @@
+name: Validate with hassfest
+
+on:
+
+  push:
+
+  pull_request:
+
+  schedule:
+
+    - cron:  '0 0 * * *'
+
+jobs:
+
+  validate:
+
+    runs-on: "ubuntu-latest"
+
+    steps:
+
+        - uses: "actions/checkout@v3"
+
+        - uses: "home-assistant/actions/hassfest@master"

README.md

@@ -1,5 +1,15 @@
-# QNAP NAP Integration
+# QNAP Integration Re-write with Config-Flow
 
-This is a complete re-write of the Core QNAP integration, adding config_flow and unique_ID. Using this custom componant for development and testing before creating a PR and adding to Core.
+This is a complete re-write of the Core QNAP integration, adding config_flow and unique_ID. Using this custom componant will override the built-in QNAP integration.
+This integration has been submitted and accepted as a PR to Home Assistant Core. I will leave this custom_integration open, active, and in sync with the core version so I can continue to develop on it. Here are some upcoming features (that are not submitted to core).
+* Folder entites
+* Firmware update entity
+* auto-discovery of device
 
-## Looking for contributers, testers, and ideas...
+## Installation
+
+Due to this repository overriding an existing core integration, it will need to be added as a custom repository. Goto HACS - Custom Integrations - three dots at the top - Custom Repositories.
+Paste: https://github.com/disforw/qnap
+
+
+NOTE: All folder and drive entities will be disabled by default. You will need to go to the entities you want and enable them manually.

custom_components/qnap/__init__.py

@@ -1,97 +1,34 @@
 """The qnap component."""
-from datetime import timedelta
-import logging
+from __future__ import annotations
 
-from qnapstats import QNAPStats
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import PlatformNotReady
 
-from homeassistant import config_entries
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.helpers import config_per_platform
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from .const import DOMAIN
+from .coordinator import QnapCoordinator
 
-from .const import DEFAULT_PORT, DEFAULT_TIMEOUT, DOMAIN, PLATFORMS
+PLATFORMS: list[Platform] = [
+    Platform.SENSOR,
+]
 
-UPDATE_INTERVAL = timedelta(minutes=1)
 
-_LOGGER = logging.getLogger(__name__)
-
-
-async def async_setup(hass, config):
-    """Set up the qnap environment."""
-    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": config_entries.SOURCE_IMPORT},
-                data=p_config,
-            )
-        )
-
-    return True
-
-
-async def async_setup_entry(hass, config_entry):
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Set the config entry up."""
-    host = config_entry.data[CONF_HOST]
-    protocol = "https" if config_entry.data.get(CONF_SSL) else "http"
-    api = QNAPStats(
-        host=f"{protocol}://{host}",
-        port=config_entry.data.get(CONF_PORT, DEFAULT_PORT),
-        username=config_entry.data[CONF_USERNAME],
-        password=config_entry.data[CONF_PASSWORD],
-        verify_ssl=config_entry.data.get(CONF_VERIFY_SSL),
-        timeout=DEFAULT_TIMEOUT,
-    )
-
-    async def async_update_data():
-        datas = {}
-        datas["system_stats"] = await hass.async_add_executor_job(api.get_system_stats)
-        datas["system_health"] = await hass.async_add_executor_job(api.get_system_health)
-        datas["smart_drive_health"] = await hass.async_add_executor_job(api.get_smart_disk_health)
-        datas["volumes"] = await hass.async_add_executor_job(api.get_volumes)
-        datas["bandwidth"] = await hass.async_add_executor_job(api.get_bandwidth)
-        return datas
-
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        name="sensor",
-        update_method=async_update_data,
-        update_interval=UPDATE_INTERVAL,
-    )
-
+    hass.data.setdefault(DOMAIN, {})
+    coordinator = QnapCoordinator(hass, config_entry)
     # Fetch initial data so we have data when entities subscribe
     await coordinator.async_config_entry_first_refresh()
-
     hass.data[DOMAIN][config_entry.entry_id] = coordinator
-
-    for component in PLATFORMS:
-        hass.async_create_task(
-            hass.config_entries.async_forward_entry_setup(config_entry, component)
-        )
-
+    await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass, config_entry):
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(
+    if unload_ok := await hass.config_entries.async_unload_platforms(
         config_entry, PLATFORMS
-    )
-    if unload_ok:
+    ):
         hass.data[DOMAIN].pop(config_entry.entry_id)
     return unload_ok

custom_components/qnap/config_flow.py

@@ -1,12 +1,14 @@
 """Config flow to configure qnap component."""
+from __future__ import annotations
+
 import logging
+from typing import Any
 
 from qnapstats import QNAPStats
 from requests.exceptions import ConnectTimeout
 import voluptuous as vol
 
 from homeassistant import config_entries
-from homeassistant.components.persistent_notification import create as notify_create
 from homeassistant.const import (
     CONF_HOST,
     CONF_PASSWORD,
@@ -15,17 +17,24 @@
     CONF_USERNAME,
     CONF_VERIFY_SSL,
 )
+from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers import config_validation as cv
 
-from .const import DEFAULT_PORT, DEFAULT_TIMEOUT, DOMAIN
+from .const import (
+    DEFAULT_PORT,
+    DEFAULT_SSL,
+    DEFAULT_TIMEOUT,
+    DEFAULT_VERIFY_SSL,
+    DOMAIN,
+)
 
 DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST): cv.string,
         vol.Required(CONF_USERNAME): cv.string,
         vol.Required(CONF_PASSWORD): cv.string,
-        vol.Optional(CONF_SSL, default=False): cv.boolean,
-        vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean,
+        vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
+        vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean,
         vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
     }
 )
@@ -38,27 +47,28 @@ class QnapConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    def __init__(self):
-        """Initialize."""
-        self.is_imported = False
-
     async def async_step_import(self, import_info):
         """Set the config entry up from yaml."""
-        self.is_imported = True
         return await self.async_step_user(import_info)
 
-    async def async_step_user(self, user_input=None):
+    async def async_step_user(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> FlowResult:
         """Handle a flow initialized by the user."""
         errors = {}
         if user_input is not None:
+            user_input.setdefault(CONF_SSL, DEFAULT_SSL)
+            user_input.setdefault(CONF_VERIFY_SSL, DEFAULT_VERIFY_SSL)
+            user_input.setdefault(CONF_PORT, DEFAULT_PORT)
             host = user_input[CONF_HOST]
-            protocol = "https" if user_input.get(CONF_SSL, False) else "http"
+            protocol = "https" if user_input[CONF_SSL] else "http"
             api = QNAPStats(
                 host=f"{protocol}://{host}",
-                port=user_input.get(CONF_PORT, DEFAULT_PORT),
+                port=user_input[CONF_PORT],
                 username=user_input[CONF_USERNAME],
                 password=user_input[CONF_PASSWORD],
-                verify_ssl=user_input.get(CONF_VERIFY_SSL, True),
+                verify_ssl=user_input[CONF_VERIFY_SSL],
                 timeout=DEFAULT_TIMEOUT,
             )
             try:
@@ -75,11 +85,6 @@ async def async_step_user(self, user_input=None):
                 await self.async_set_unique_id(unique_id)
                 self._abort_if_unique_id_configured()
                 title = stats["system"]["name"].capitalize()
-                if self.is_imported:
-                    _LOGGER.warning(
-                        "The import of the QNAP configuration was successful. \
-                        Please remove the platform from the YAML configuration file"
-                    )
                 return self.async_create_entry(title=title, data=user_input)
 
         return self.async_show_form(