init

fix action

Action commit

Created package file

minor updates

Add binary_sensor

Updated package file

Updated package file

Fix BinarySensor Class name

Add more descriptions

Updated package file

Move stuff

Updated package file

add binary_sensor to resources.json

Updated package file

Add configuration

Updated package file

Remove switch

Adds CONTRIBUTING

Fix broken link

Remove refrences

Fix links

fix broken actions

Update actions

Updated package file

Updated package file

Black format

Fix config issues

Updated package file

Fix icon for binary_sensor

Add switch platform

Update README.md (#1)

* Update README.md

* Update README.md

Update CONTRIBUTING.md (#2)

Update __init__.py (#3)

* Update __init__.py

* Set enabled default to `True`

Update const.py (#4)

cleanup badges/add style (#5)

* shield that supports styling

* badge cleanup

* Change discord ID

Correct typo

Create manifest.json (#12)

Fixes https://github.com/custom-components/blueprint/issues/10

Move manifest to correct dir

Fixes #9 by renaming the file

Updates, updates, more updates, worst commit messge ever!

revert

Update main.workflow

Delete resources.json

Create example.yaml

Update README.md

Summer update 😎

Adds info about devcontainer

Adds pylint

Add translation example

remove stalebot

Adds integrationhelper

adds requirements.txt

Adds "tabnine.tabnine-vscode" to devcontainer

Add support for config_flow configuration

Add config_flow "docs"

Update README.md

use https for pip install ha@dev (#15)

Typo on README.md (#18)

Fix various typos in comments (#19)

Add hassfest action (#22)

* Add hassfest action

* Fix manifest issue

Spring cleaning ☀️ (#23)

* Spring cleaning

* Actions

* Fix branches

* Changes for config_flow

Show how to only allow one instance

Adds HACS validation action (#24)

Update postCreateCommand

Update tasks

Minor updates (#26)

* link correction in README.md and info.md

* Add READMME.md for .devcontainer

* Add automation.yaml file in the configuration

* Complete CONTRIBUTING.md

Improve README for container dev and library update. (#27)

Feature/setup cfg (#28)

* Add setup.cfg

* Run black and isort.

* Add blueprint to first party.

* Make const import consistent.

Move translation files

Fixes #32

Use CoordinatorEntity (#33)

Co-authored-by: Joakim Sørensen <hi@ludeeus.dev>

Fixed typos (#34)

Fix directory name for translations and link to the documentation (#36)

Fix info.md (#40)

Use debian based devcontainer (#44)

Remove sampleclient (#45)

Rename [blueprint|Blueprint] -> [integration_blueprint|Integration blueprint] (#47)

Change HACS action (#39)

Fix wrong path for link (#48)

For an unknown reason the link was pointing to a one of my repository.
Probably a too quick copy/paste.

Add french translation and strings improvements (#49)

Reusing work done on strings.json done in #37

Add example tests (#50)

Prepare and explain how to step by step debugging (#51)

Add version

Fix testing by bumping pytest-homeassistant-custom-component (#54)

Fix typo in api.py (#55)

passeword -> password

Fix a typo in the readme (#56)

Update .gitignore to include .idea (#57)

Update .gitignore to include .idea for those using Py Charm

Add iot_class to manifest

Use `enable_custom_integrations` fixture by default (#58)

Fix typo (#59)

retain user input after an error (#52)

Update README.md

Closes #61

remove async_timeout.timeout loop arg (#65)

Correct name "Blueprint" ->"Integration blueprint" (#64)

change entity.py to use extra_state_attributes (#66)

custom_components/__init__.py

@@ -0,0 +1 @@
+"""Custom components module."""

custom_components/integration_blueprint/__init__.py

@@ -0,0 +1,109 @@
+"""
+Custom integration to integrate integration_blueprint with Home Assistant.
+
+For more details about this integration, please refer to
+https://github.com/custom-components/integration_blueprint
+"""
+import asyncio
+from datetime import timedelta
+import logging
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import Config, HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .api import IntegrationBlueprintApiClient
+
+from .const import (
+    CONF_PASSWORD,
+    CONF_USERNAME,
+    DOMAIN,
+    PLATFORMS,
+    STARTUP_MESSAGE,
+)
+
+SCAN_INTERVAL = timedelta(seconds=30)
+
+_LOGGER: logging.Logger = logging.getLogger(__package__)
+
+
+async def async_setup(hass: HomeAssistant, config: Config):
+    """Set up this integration using YAML is not supported."""
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
+    """Set up this integration using UI."""
+    if hass.data.get(DOMAIN) is None:
+        hass.data.setdefault(DOMAIN, {})
+        _LOGGER.info(STARTUP_MESSAGE)
+
+    username = entry.data.get(CONF_USERNAME)
+    password = entry.data.get(CONF_PASSWORD)
+
+    session = async_get_clientsession(hass)
+    client = IntegrationBlueprintApiClient(username, password, session)
+
+    coordinator = BlueprintDataUpdateCoordinator(hass, client=client)
+    await coordinator.async_refresh()
+
+    if not coordinator.last_update_success:
+        raise ConfigEntryNotReady
+
+    hass.data[DOMAIN][entry.entry_id] = coordinator
+
+    for platform in PLATFORMS:
+        if entry.options.get(platform, True):
+            coordinator.platforms.append(platform)
+            hass.async_add_job(
+                hass.config_entries.async_forward_entry_setup(entry, platform)
+            )
+
+    entry.add_update_listener(async_reload_entry)
+    return True
+
+
+class BlueprintDataUpdateCoordinator(DataUpdateCoordinator):
+    """Class to manage fetching data from the API."""
+
+    def __init__(
+        self, hass: HomeAssistant, client: IntegrationBlueprintApiClient
+    ) -> None:
+        """Initialize."""
+        self.api = client
+        self.platforms = []
+
+        super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=SCAN_INTERVAL)
+
+    async def _async_update_data(self):
+        """Update data via library."""
+        try:
+            return await self.api.async_get_data()
+        except Exception as exception:
+            raise UpdateFailed() from exception
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Handle removal of an entry."""
+    coordinator = hass.data[DOMAIN][entry.entry_id]
+    unloaded = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(entry, platform)
+                for platform in PLATFORMS
+                if platform in coordinator.platforms
+            ]
+        )
+    )
+    if unloaded:
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unloaded
+
+
+async def async_reload_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Reload config entry."""
+    await async_unload_entry(hass, entry)
+    await async_setup_entry(hass, entry)

custom_components/integration_blueprint/api.py

@@ -0,0 +1,75 @@
+"""Sample API Client."""
+import logging
+import asyncio
+import socket
+from typing import Optional
+import aiohttp
+import async_timeout
+
+TIMEOUT = 10
+
+
+_LOGGER: logging.Logger = logging.getLogger(__package__)
+
+HEADERS = {"Content-type": "application/json; charset=UTF-8"}
+
+
+class IntegrationBlueprintApiClient:
+    def __init__(
+        self, username: str, password: str, session: aiohttp.ClientSession
+    ) -> None:
+        """Sample API Client."""
+        self._username = username
+        self._password = password
+        self._session = session
+
+    async def async_get_data(self) -> dict:
+        """Get data from the API."""
+        url = "https://jsonplaceholder.typicode.com/posts/1"
+        return await self.api_wrapper("get", url)
+
+    async def async_set_title(self, value: str) -> None:
+        """Get data from the API."""
+        url = "https://jsonplaceholder.typicode.com/posts/1"
+        await self.api_wrapper("patch", url, data={"title": value}, headers=HEADERS)
+
+    async def api_wrapper(
+        self, method: str, url: str, data: dict = {}, headers: dict = {}
+    ) -> dict:
+        """Get information from the API."""
+        try:
+            async with async_timeout.timeout(TIMEOUT):
+                if method == "get":
+                    response = await self._session.get(url, headers=headers)
+                    return await response.json()
+
+                elif method == "put":
+                    await self._session.put(url, headers=headers, json=data)
+
+                elif method == "patch":
+                    await self._session.patch(url, headers=headers, json=data)
+
+                elif method == "post":
+                    await self._session.post(url, headers=headers, json=data)
+
+        except asyncio.TimeoutError as exception:
+            _LOGGER.error(
+                "Timeout error fetching information from %s - %s",
+                url,
+                exception,
+            )
+
+        except (KeyError, TypeError) as exception:
+            _LOGGER.error(
+                "Error parsing information from %s - %s",
+                url,
+                exception,
+            )
+        except (aiohttp.ClientError, socket.gaierror) as exception:
+            _LOGGER.error(
+                "Error fetching information from %s - %s",
+                url,
+                exception,
+            )
+        except Exception as exception:  # pylint: disable=broad-except
+            _LOGGER.error("Something really wrong happened! - %s", exception)

custom_components/integration_blueprint/binary_sensor.py

@@ -0,0 +1,35 @@
+"""Binary sensor platform for integration_blueprint."""
+from homeassistant.components.binary_sensor import BinarySensorEntity
+
+from .const import (
+    BINARY_SENSOR,
+    BINARY_SENSOR_DEVICE_CLASS,
+    DEFAULT_NAME,
+    DOMAIN,
+)
+from .entity import IntegrationBlueprintEntity
+
+
+async def async_setup_entry(hass, entry, async_add_devices):
+    """Setup binary_sensor platform."""
+    coordinator = hass.data[DOMAIN][entry.entry_id]
+    async_add_devices([IntegrationBlueprintBinarySensor(coordinator, entry)])
+
+
+class IntegrationBlueprintBinarySensor(IntegrationBlueprintEntity, BinarySensorEntity):
+    """integration_blueprint binary_sensor class."""
+
+    @property
+    def name(self):
+        """Return the name of the binary_sensor."""
+        return f"{DEFAULT_NAME}_{BINARY_SENSOR}"
+
+    @property
+    def device_class(self):
+        """Return the class of this binary_sensor."""
+        return BINARY_SENSOR_DEVICE_CLASS
+
+    @property
+    def is_on(self):
+        """Return true if the binary_sensor is on."""
+        return self.coordinator.data.get("title", "") == "foo"

custom_components/integration_blueprint/config_flow.py

@@ -0,0 +1,116 @@
+"""Adds config flow for Blueprint."""
+from homeassistant import config_entries
+from homeassistant.core import callback
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
+import voluptuous as vol
+
+from .api import IntegrationBlueprintApiClient
+from .const import (
+    CONF_PASSWORD,
+    CONF_USERNAME,
+    DOMAIN,
+    PLATFORMS,
+)
+
+
+class BlueprintFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
+    """Config flow for Blueprint."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
+
+    def __init__(self):
+        """Initialize."""
+        self._errors = {}
+
+    async def async_step_user(self, user_input=None):
+        """Handle a flow initialized by the user."""
+        self._errors = {}
+
+        # Uncomment the next 2 lines if only a single instance of the integration is allowed:
+        # 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[CONF_USERNAME], user_input[CONF_PASSWORD]
+            )
+            if valid:
+                return self.async_create_entry(
+                    title=user_input[CONF_USERNAME], data=user_input
+                )
+            else:
+                self._errors["base"] = "auth"
+
+            return await self._show_config_form(user_input)
+
+        user_input = {}
+        # Provide defaults for form
+        user_input[CONF_USERNAME] = ""
+        user_input[CONF_PASSWORD] = ""
+
+        return await self._show_config_form(user_input)
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry):
+        return BlueprintOptionsFlowHandler(config_entry)
+
+    async def _show_config_form(self, user_input):  # pylint: disable=unused-argument
+        """Show the configuration form to edit location data."""
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_USERNAME, default=user_input[CONF_USERNAME]): str,
+                    vol.Required(CONF_PASSWORD, default=user_input[CONF_PASSWORD]): str,
+                }
+            ),
+            errors=self._errors,
+        )
+
+    async def _test_credentials(self, username, password):
+        """Return true if credentials is valid."""
+        try:
+            session = async_create_clientsession(self.hass)
+            client = IntegrationBlueprintApiClient(username, password, session)
+            await client.async_get_data()
+            return True
+        except Exception:  # pylint: disable=broad-except
+            pass
+        return False
+
+
+class BlueprintOptionsFlowHandler(config_entries.OptionsFlow):
+    """Blueprint config flow options handler."""
+
+    def __init__(self, config_entry):
+        """Initialize HACS options flow."""
+        self.config_entry = config_entry
+        self.options = dict(config_entry.options)
+
+    async def async_step_init(self, user_input=None):  # pylint: disable=unused-argument
+        """Manage the options."""
+        return await self.async_step_user()
+
+    async def async_step_user(self, user_input=None):
+        """Handle a flow initialized by the user."""
+        if user_input is not None:
+            self.options.update(user_input)
+            return await self._update_options()
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(x, default=self.options.get(x, True)): bool
+                    for x in sorted(PLATFORMS)
+                }
+            ),
+        )
+
+    async def _update_options(self):
+        """Update config entry options."""
+        return self.async_create_entry(
+            title=self.config_entry.data.get(CONF_USERNAME), data=self.options
+        )

custom_components/integration_blueprint/const.py

@@ -0,0 +1,40 @@
+"""Constants for integration_blueprint."""
+# Base component constants
+NAME = "Integration blueprint"
+DOMAIN = "integration_blueprint"
+DOMAIN_DATA = f"{DOMAIN}_data"
+VERSION = "0.0.1"
+ATTRIBUTION = "Data provided by http://jsonplaceholder.typicode.com/"
+ISSUE_URL = "https://github.com/custom-components/integration_blueprint/issues"
+
+# Icons
+ICON = "mdi:format-quote-close"
+
+# Device classes
+BINARY_SENSOR_DEVICE_CLASS = "connectivity"
+
+# Platforms
+BINARY_SENSOR = "binary_sensor"
+SENSOR = "sensor"
+SWITCH = "switch"
+PLATFORMS = [BINARY_SENSOR, SENSOR, SWITCH]
+
+
+# Configuration and options
+CONF_ENABLED = "enabled"
+CONF_USERNAME = "username"
+CONF_PASSWORD = "password"
+
+# Defaults
+DEFAULT_NAME = DOMAIN
+
+
+STARTUP_MESSAGE = f"""
+-------------------------------------------------------------------
+{NAME}
+Version: {VERSION}
+This is a custom integration!
+If you have any issues with this you need to open an issue here:
+{ISSUE_URL}
+-------------------------------------------------------------------
+"""

custom_components/integration_blueprint/entity.py

@@ -0,0 +1,33 @@
+"""BlueprintEntity class"""
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, NAME, VERSION, ATTRIBUTION
+
+
+class IntegrationBlueprintEntity(CoordinatorEntity):
+    def __init__(self, coordinator, config_entry):
+        super().__init__(coordinator)
+        self.config_entry = config_entry
+
+    @property
+    def unique_id(self):
+        """Return a unique ID to use for this entity."""
+        return self.config_entry.entry_id
+
+    @property
+    def device_info(self):
+        return {
+            "identifiers": {(DOMAIN, self.unique_id)},
+            "name": NAME,
+            "model": VERSION,
+            "manufacturer": NAME,
+        }
+
+    @property
+    def extra_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            "attribution": ATTRIBUTION,
+            "id": str(self.coordinator.data.get("id")),
+            "integration": DOMAIN,
+        }

custom_components/integration_blueprint/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "integration_blueprint",
+  "name": "Integration blueprint",
+  "documentation": "https://github.com/custom-components/integration_blueprint",
+  "iot_class": "cloud_polling",
+  "issue_tracker": "https://github.com/custom-components/integration_blueprint/issues",
+  "version": "0.0.0",
+  "config_flow": true,
+  "codeowners": [
+    "@ludeeus"
+  ]
+}

custom_components/integration_blueprint/sensor.py

@@ -0,0 +1,28 @@
+"""Sensor platform for integration_blueprint."""
+from .const import DEFAULT_NAME, DOMAIN, ICON, SENSOR
+from .entity import IntegrationBlueprintEntity
+
+
+async def async_setup_entry(hass, entry, async_add_devices):
+    """Setup sensor platform."""
+    coordinator = hass.data[DOMAIN][entry.entry_id]
+    async_add_devices([IntegrationBlueprintSensor(coordinator, entry)])
+
+
+class IntegrationBlueprintSensor(IntegrationBlueprintEntity):
+    """integration_blueprint Sensor class."""
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return f"{DEFAULT_NAME}_{SENSOR}"
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self.coordinator.data.get("body")
+
+    @property
+    def icon(self):
+        """Return the icon of the sensor."""
+        return ICON

custom_components/integration_blueprint/switch.py

@@ -0,0 +1,40 @@
+"""Switch platform for integration_blueprint."""
+from homeassistant.components.switch import SwitchEntity
+
+from .const import DEFAULT_NAME, DOMAIN, ICON, SWITCH
+from .entity import IntegrationBlueprintEntity
+
+
+async def async_setup_entry(hass, entry, async_add_devices):
+    """Setup sensor platform."""
+    coordinator = hass.data[DOMAIN][entry.entry_id]
+    async_add_devices([IntegrationBlueprintBinarySwitch(coordinator, entry)])
+
+
+class IntegrationBlueprintBinarySwitch(IntegrationBlueprintEntity, SwitchEntity):
+    """integration_blueprint switch class."""
+
+    async def async_turn_on(self, **kwargs):  # pylint: disable=unused-argument
+        """Turn on the switch."""
+        await self.coordinator.api.async_set_title("bar")
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs):  # pylint: disable=unused-argument
+        """Turn off the switch."""
+        await self.coordinator.api.async_set_title("foo")
+        await self.coordinator.async_request_refresh()
+
+    @property
+    def name(self):
+        """Return the name of the switch."""
+        return f"{DEFAULT_NAME}_{SWITCH}"
+
+    @property
+    def icon(self):
+        """Return the icon of this switch."""
+        return ICON
+
+    @property
+    def is_on(self):
+        """Return true if the switch is on."""
+        return self.coordinator.data.get("title", "") == "foo"

custom_components/integration_blueprint/translations/en.json

@@ -0,0 +1,31 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Blueprint",
+                "description": "If you need help with the configuration have a look here: https://github.com/custom-components/integration_blueprint",
+                "data": {
+                    "username": "Username",
+                    "password": "Password"
+                }
+            }
+        },
+        "error": {
+            "auth": "Username/Password is wrong."
+        },
+        "abort": {
+            "single_instance_allowed": "Only a single instance is allowed."
+        }
+    },
+    "options": {
+        "step": {
+            "user": {
+                "data": {
+                    "binary_sensor": "Binary sensor enabled",
+                    "sensor": "Sensor enabled",
+                    "switch": "Switch enabled"
+                }
+            }
+        }
+    }
+}

custom_components/integration_blueprint/translations/fr.json

@@ -0,0 +1,31 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Blueprint",
+                "description": "Si vous avez besoin d'aide pour la configuration, regardez ici: https://github.com/custom-components/integration_blueprint",
+                "data": {
+                    "username": "Identifiant",
+                    "password": "Mot de Passe"
+                }
+            }
+        },
+        "error": {
+            "auth": "Identifiant ou mot de passe erroné."
+        },
+        "abort": {
+            "single_instance_allowed": "Une seule instance est autorisée."
+        }
+    },
+    "options": {
+        "step": {
+            "user": {
+                "data": {
+                    "binary_sensor": "Capteur binaire activé",
+                    "sensor": "Capteur activé",
+                    "switch": "Interrupteur activé"
+                }
+            }
+        }
+    }
+}

custom_components/integration_blueprint/translations/nb.json

@@ -0,0 +1,31 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Blueprint",
+                "description": "Hvis du trenger hjep til konfigurasjon ta en titt her: https://github.com/custom-components/integration_blueprint",
+                "data": {
+                    "username": "Brukernavn",
+                    "password": "Passord"
+                }
+            }
+        },
+        "error": {
+            "auth": "Brukernavn/Passord er feil."
+        },
+        "abort": {
+            "single_instance_allowed": "Denne integrasjonen kan kun konfigureres en gang."
+        }
+    },
+    "options": {
+        "step": {
+            "user": {
+                "data": {
+                    "binary_sensor": "Binær sensor aktivert",
+                    "sensor": "Sensor aktivert",
+                    "switch": "Bryter aktivert"
+                }
+            }
+        }
+    }
+}