diff --git a/.coveragerc b/.coveragerc
index 6d4c8a667623d2d16b5105216c8c8b2edef4f7d1..a7438497affa805efe69a7927ad2c4d281ffd3c8 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -320,6 +320,8 @@ omit =
homeassistant/components/glances/sensor.py
homeassistant/components/gntp/notify.py
homeassistant/components/goalfeed/*
+ homeassistant/components/goalzero/__init__.py
+ homeassistant/components/goalzero/binary_sensor.py
homeassistant/components/google/*
homeassistant/components/google_cloud/tts.py
homeassistant/components/google_maps/device_tracker.py
diff --git a/CODEOWNERS b/CODEOWNERS
index cfaae6bc496b41e59a2a048b5b090b07a81ab1cf..c1064f4c60b203be4f7d8cc62dc8448036f60522 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -157,6 +157,7 @@ homeassistant/components/geonetnz_volcano/* @exxamalte
homeassistant/components/gios/* @bieniu
homeassistant/components/gitter/* @fabaff
homeassistant/components/glances/* @fabaff @engrbm87
+homeassistant/components/goalzero/* @tkdrob
homeassistant/components/gogogate2/* @vangorra
homeassistant/components/google_assistant/* @home-assistant/cloud
homeassistant/components/google_cloud/* @lufton
diff --git a/homeassistant/components/goalzero/__init__.py b/homeassistant/components/goalzero/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..892ee46982df6c29d0b3581268b0171e06e5d1de
--- /dev/null
+++ b/homeassistant/components/goalzero/__init__.py
@@ -0,0 +1,140 @@
+"""The Goal Zero Yeti integration."""
+import asyncio
+import logging
+
+from goalzero import Yeti, exceptions
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_NAME
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import (
+ CoordinatorEntity,
+ DataUpdateCoordinator,
+ UpdateFailed,
+)
+
+from .const import (
+ DATA_KEY_API,
+ DATA_KEY_COORDINATOR,
+ DEFAULT_NAME,
+ DOMAIN,
+ MIN_TIME_BETWEEN_UPDATES,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+GOALZERO_SCHEMA = vol.Schema(
+ vol.All(
+ {
+ vol.Required(CONF_HOST): cv.matches_regex(
+ r"\A(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2 \
+ [0-4][0-9]|[01]?[0-9][0-9]?)\Z"
+ ),
+ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+ },
+ )
+)
+
+CONFIG_SCHEMA = vol.Schema(
+ {DOMAIN: vol.Schema(vol.All(cv.ensure_list, [GOALZERO_SCHEMA]))},
+ extra=vol.ALLOW_EXTRA,
+)
+
+
+PLATFORMS = ["binary_sensor"]
+
+
+async def async_setup(hass: HomeAssistant, config):
+ """Set up the Goal Zero Yeti component."""
+
+ hass.data[DOMAIN] = {}
+
+ return True
+
+
+async def async_setup_entry(hass, entry):
+ """Set up Goal Zero Yeti from a config entry."""
+ name = entry.data[CONF_NAME]
+ host = entry.data[CONF_HOST]
+
+ _LOGGER.debug("Setting up %s integration with host %s", DOMAIN, host)
+
+ session = async_get_clientsession(hass)
+ api = Yeti(host, hass.loop, session)
+ try:
+ await api.get_state()
+ except exceptions.ConnectError as ex:
+ _LOGGER.warning("Failed to connect: %s", ex)
+ raise ConfigEntryNotReady from ex
+
+ async def async_update_data():
+ """Fetch data from API endpoint."""
+ try:
+ await api.get_state()
+ except exceptions.ConnectError as err:
+ _LOGGER.warning("Failed to update data from Yeti")
+ raise UpdateFailed(f"Failed to communicating with API: {err}") from err
+
+ coordinator = DataUpdateCoordinator(
+ hass,
+ _LOGGER,
+ name=name,
+ update_method=async_update_data,
+ update_interval=MIN_TIME_BETWEEN_UPDATES,
+ )
+ hass.data[DOMAIN][entry.entry_id] = {
+ DATA_KEY_API: api,
+ DATA_KEY_COORDINATOR: coordinator,
+ }
+
+ 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, entry: ConfigEntry):
+ """Unload a config entry."""
+ unload_ok = all(
+ await asyncio.gather(
+ *[
+ hass.config_entries.async_forward_entry_unload(entry, component)
+ for component in PLATFORMS
+ ]
+ )
+ )
+ if unload_ok:
+ hass.data[DOMAIN].pop(entry.entry_id)
+ return unload_ok
+
+
+class YetiEntity(CoordinatorEntity):
+ """Representation of a Goal Zero Yeti entity."""
+
+ def __init__(self, _api, coordinator, name, sensor_name, server_unique_id):
+ """Initialize a Goal Zero Yeti entity."""
+ super().__init__(coordinator)
+ self.api = _api
+ self._name = name
+ self._server_unique_id = server_unique_id
+ self._device_class = None
+
+ @property
+ def device_info(self):
+ """Return the device information of the entity."""
+ return {
+ "identifiers": {(DOMAIN, self._server_unique_id)},
+ "name": self._name,
+ "manufacturer": "Goal Zero",
+ }
+
+ @property
+ def device_class(self):
+ """Return the class of this device."""
+ return self._device_class
diff --git a/homeassistant/components/goalzero/binary_sensor.py b/homeassistant/components/goalzero/binary_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..25b370c459f4b8329a2b4c632989019d09458567
--- /dev/null
+++ b/homeassistant/components/goalzero/binary_sensor.py
@@ -0,0 +1,62 @@
+"""Support for Goal Zero Yeti Sensors."""
+from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.const import CONF_NAME
+
+from . import YetiEntity
+from .const import BINARY_SENSOR_DICT, DATA_KEY_API, DATA_KEY_COORDINATOR, DOMAIN
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(hass, entry, async_add_entities):
+ """Set up the Goal Zero Yeti sensor."""
+ name = entry.data[CONF_NAME]
+ goalzero_data = hass.data[DOMAIN][entry.entry_id]
+ sensors = [
+ YetiBinarySensor(
+ goalzero_data[DATA_KEY_API],
+ goalzero_data[DATA_KEY_COORDINATOR],
+ name,
+ sensor_name,
+ entry.entry_id,
+ )
+ for sensor_name in BINARY_SENSOR_DICT
+ ]
+ async_add_entities(sensors, True)
+
+
+class YetiBinarySensor(YetiEntity, BinarySensorEntity):
+ """Representation of a Goal Zero Yeti sensor."""
+
+ def __init__(self, api, coordinator, name, sensor_name, server_unique_id):
+ """Initialize a Goal Zero Yeti sensor."""
+ super().__init__(api, coordinator, name, sensor_name, server_unique_id)
+
+ self._condition = sensor_name
+
+ variable_info = BINARY_SENSOR_DICT[sensor_name]
+ self._condition_name = variable_info[0]
+ self._icon = variable_info[2]
+ self.api = api
+ self._device_class = variable_info[1]
+
+ @property
+ def name(self):
+ """Return the name of the sensor."""
+ return f"{self._name} {self._condition_name}"
+
+ @property
+ def unique_id(self):
+ """Return the unique id of the sensor."""
+ return f"{self._server_unique_id}/{self._condition_name}"
+
+ @property
+ def is_on(self):
+ """Return if the service is on."""
+ if self.api.data:
+ return self.api.data[self._condition] == 1
+
+ @property
+ def icon(self):
+ """Icon to use in the frontend, if any."""
+ return self._icon
diff --git a/homeassistant/components/goalzero/config_flow.py b/homeassistant/components/goalzero/config_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..31c1a51efebb8c7cd9718fb8a0dd8c39baf3c873
--- /dev/null
+++ b/homeassistant/components/goalzero/config_flow.py
@@ -0,0 +1,75 @@
+"""Config flow for Goal Zero Yeti integration."""
+import logging
+
+from goalzero import Yeti, exceptions
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_HOST, CONF_NAME
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DEFAULT_NAME, DOMAIN # pylint:disable=unused-import
+
+_LOGGER = logging.getLogger(__name__)
+
+DATA_SCHEMA = vol.Schema({"host": str, "name": str})
+
+
+class GoalZeroFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
+ """Handle a config flow for Goal Zero Yeti."""
+
+ VERSION = 1
+ CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
+
+ async def async_step_user(self, user_input=None):
+ """Handle a flow initiated by the user."""
+ errors = {}
+
+ if user_input is not None:
+ host = user_input[CONF_HOST]
+ name = user_input[CONF_NAME]
+
+ if await self._async_endpoint_existed(host):
+ return self.async_abort(reason="already_configured")
+
+ try:
+ await self._async_try_connect(host)
+ return self.async_create_entry(
+ title=name,
+ data={CONF_HOST: host, CONF_NAME: name},
+ )
+ except exceptions.ConnectError:
+ errors["base"] = "cannot_connect"
+ _LOGGER.exception("Error connecting to device at %s", host)
+ except exceptions.InvalidHost:
+ errors["base"] = "invalid_host"
+ _LOGGER.exception("Invalid data received from device at %s", host)
+ except Exception: # pylint: disable=broad-except
+ _LOGGER.exception("Unexpected exception")
+ errors["base"] = "unknown"
+
+ user_input = user_input or {}
+ return self.async_show_form(
+ step_id="user",
+ data_schema=vol.Schema(
+ {
+ vol.Required(
+ CONF_HOST, default=user_input.get(CONF_HOST) or ""
+ ): str,
+ vol.Optional(
+ CONF_NAME, default=user_input.get(CONF_NAME) or DEFAULT_NAME
+ ): str,
+ }
+ ),
+ errors=errors,
+ )
+
+ async def _async_endpoint_existed(self, endpoint):
+ for entry in self._async_current_entries():
+ if endpoint == entry.data.get(CONF_HOST):
+ return endpoint
+
+ async def _async_try_connect(self, host):
+ session = async_get_clientsession(self.hass)
+ api = Yeti(host, self.hass.loop, session)
+ await api.get_state()
diff --git a/homeassistant/components/goalzero/const.py b/homeassistant/components/goalzero/const.py
new file mode 100644
index 0000000000000000000000000000000000000000..3afa1e537c173d01f1076a67ee778d1b5da7f760
--- /dev/null
+++ b/homeassistant/components/goalzero/const.py
@@ -0,0 +1,28 @@
+"""Constants for the Goal Zero Yeti integration."""
+from datetime import timedelta
+
+from homeassistant.components.binary_sensor import (
+ DEVICE_CLASS_BATTERY_CHARGING,
+ DEVICE_CLASS_CONNECTIVITY,
+ DEVICE_CLASS_POWER,
+)
+
+DATA_KEY_COORDINATOR = "coordinator"
+DOMAIN = "goalzero"
+DEFAULT_NAME = "Yeti"
+DATA_KEY_API = "api"
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30)
+
+BINARY_SENSOR_DICT = {
+ "v12PortStatus": ["12V Port Status", DEVICE_CLASS_POWER, None],
+ "usbPortStatus": ["USB Port Status", DEVICE_CLASS_POWER, None],
+ "acPortStatus": ["AC Port Status", DEVICE_CLASS_POWER, None],
+ "backlight": ["Backlight", None, "mdi:clock-digital"],
+ "app_online": [
+ "App Online",
+ DEVICE_CLASS_CONNECTIVITY,
+ None,
+ ],
+ "isCharging": ["Charging", DEVICE_CLASS_BATTERY_CHARGING, None],
+}
diff --git a/homeassistant/components/goalzero/manifest.json b/homeassistant/components/goalzero/manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..803b8f7eaae01d07cd492613f7d1833613172fa7
--- /dev/null
+++ b/homeassistant/components/goalzero/manifest.json
@@ -0,0 +1,8 @@
+{
+ "domain": "goalzero",
+ "name": "Goal Zero Yeti",
+ "config_flow": true,
+ "documentation": "https://www.home-assistant.io/integrations/goalzero",
+ "requirements": ["goalzero==0.1.4"],
+ "codeowners": ["@tkdrob"]
+}
diff --git a/homeassistant/components/goalzero/strings.json b/homeassistant/components/goalzero/strings.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7a134c01ec8c6c5f051a76fa1c2acc35fdc9e20
--- /dev/null
+++ b/homeassistant/components/goalzero/strings.json
@@ -0,0 +1,22 @@
+{
+ "config": {
+ "step": {
+ "user": {
+ "title": "Goal Zero Yeti",
+ "description": "First, you need to download the Goal Zero app: https://www.goalzero.com/product-features/yeti-app/\n\nFollow the instructions to connect your Yeti to your Wifi network. Then get the host ip from your router. DHCP must be set up in your router settings for the device to ensure the host ip does not change. Refer to your router's user manual.",
+ "data": {
+ "host": "[%key:common::config_flow::data::host%]",
+ "name": "Name"
+ }
+ }
+ },
+ "error": {
+ "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+ "invalid_host": "This is not the Yeti you are looking for",
+ "unknown": "Unknown Error"
+ },
+ "abort": {
+ "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+ }
+ }
+}
diff --git a/homeassistant/components/goalzero/translations/en.json b/homeassistant/components/goalzero/translations/en.json
new file mode 100644
index 0000000000000000000000000000000000000000..412bef4c1d90bc43b895237be28322633c3e62a5
--- /dev/null
+++ b/homeassistant/components/goalzero/translations/en.json
@@ -0,0 +1,22 @@
+{
+ "config": {
+ "abort": {
+ "already_configured": "Already Configured"
+ },
+ "error": {
+ "cannot_connect": "Error connecting to host",
+ "invalid_host": "This is not a Yeti",
+ "unknown": "Unknown Error"
+ },
+ "step": {
+ "user": {
+ "data": {
+ "host": "Host",
+ "name": "Name"
+ },
+ "description": "First, you need to download the Goal Zero app: https://www.goalzero.com/product-features/yeti-app/\n\nFollow the instructions to connect your Yeti to your Wifi network. Then get the host ip from your router. DHCP must be set up in your router settings for the device to ensure the host ip does not change. Refer to your router's user manual.",
+ "title": "Goal Zero Yeti"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/homeassistant/generated/config_flows.py b/homeassistant/generated/config_flows.py
index 55e6bf2eafea7ee93dc206ab4fbedac30f4ac6c9..bfd3c340e6d882660643d459e192bc7cc0cb3214 100644
--- a/homeassistant/generated/config_flows.py
+++ b/homeassistant/generated/config_flows.py
@@ -68,6 +68,7 @@ FLOWS = [
"geonetnz_volcano",
"gios",
"glances",
+ "goalzero",
"gogogate2",
"gpslogger",
"griddy",
diff --git a/requirements_all.txt b/requirements_all.txt
index 76c59fcf7915e64a71ab4ff78b0e687b610685c5..f8fb22385f670cadf7f7c29a3a175fa8dae14f16 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -668,6 +668,9 @@ glances_api==0.2.0
# homeassistant.components.gntp
gntp==1.0.3
+# homeassistant.components.goalzero
+goalzero==0.1.4
+
# homeassistant.components.gogogate2
gogogate2-api==2.0.3
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 9e9899e039e013103df917dd0f29a516301200ff..c7b33625fc1308a93891e8b426a0b7c2ce67bc74 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -336,6 +336,9 @@ gios==0.1.4
# homeassistant.components.glances
glances_api==0.2.0
+# homeassistant.components.goalzero
+goalzero==0.1.4
+
# homeassistant.components.gogogate2
gogogate2-api==2.0.3
diff --git a/tests/components/goalzero/__init__.py b/tests/components/goalzero/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ba2a9127662c40e2395d0d964d541c7906fe461
--- /dev/null
+++ b/tests/components/goalzero/__init__.py
@@ -0,0 +1,35 @@
+"""Tests for the Goal Zero Yeti integration."""
+
+from homeassistant.const import CONF_HOST, CONF_NAME
+
+from tests.async_mock import AsyncMock, patch
+
+HOST = "1.2.3.4"
+NAME = "Yeti"
+
+CONF_DATA = {
+ CONF_HOST: HOST,
+ CONF_NAME: NAME,
+}
+
+CONF_CONFIG_FLOW = {
+ CONF_HOST: HOST,
+ CONF_NAME: NAME,
+}
+
+
+async def _create_mocked_yeti(raise_exception=False):
+ mocked_yeti = AsyncMock()
+ mocked_yeti.get_state = AsyncMock()
+ return mocked_yeti
+
+
+def _patch_init_yeti(mocked_yeti):
+ return patch("homeassistant.components.goalzero.Yeti", return_value=mocked_yeti)
+
+
+def _patch_config_flow_yeti(mocked_yeti):
+ return patch(
+ "homeassistant.components.goalzero.config_flow.Yeti",
+ return_value=mocked_yeti,
+ )
diff --git a/tests/components/goalzero/test_config_flow.py b/tests/components/goalzero/test_config_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a367c452c6f2d6496df0f08910ab3fe66149636
--- /dev/null
+++ b/tests/components/goalzero/test_config_flow.py
@@ -0,0 +1,120 @@
+"""Test Goal Zero Yeti config flow."""
+from goalzero import exceptions
+
+from homeassistant.components.goalzero.const import DOMAIN
+from homeassistant.config_entries import SOURCE_USER
+from homeassistant.data_entry_flow import (
+ RESULT_TYPE_ABORT,
+ RESULT_TYPE_CREATE_ENTRY,
+ RESULT_TYPE_FORM,
+)
+
+from . import (
+ CONF_CONFIG_FLOW,
+ CONF_DATA,
+ CONF_HOST,
+ CONF_NAME,
+ NAME,
+ _create_mocked_yeti,
+ _patch_config_flow_yeti,
+)
+
+from tests.async_mock import patch
+from tests.common import MockConfigEntry
+
+
+def _flow_next(hass, flow_id):
+ return next(
+ flow
+ for flow in hass.config_entries.flow.async_progress()
+ if flow["flow_id"] == flow_id
+ )
+
+
+def _patch_setup():
+ return patch(
+ "homeassistant.components.goalzero.async_setup_entry",
+ return_value=True,
+ )
+
+
+async def test_flow_user(hass):
+ """Test user initialized flow."""
+ mocked_yeti = await _create_mocked_yeti()
+ with _patch_config_flow_yeti(mocked_yeti), _patch_setup():
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": SOURCE_USER},
+ )
+ assert result["type"] == RESULT_TYPE_FORM
+ assert result["step_id"] == "user"
+ assert result["errors"] == {}
+ _flow_next(hass, result["flow_id"])
+
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"],
+ user_input=CONF_CONFIG_FLOW,
+ )
+ assert result["type"] == RESULT_TYPE_CREATE_ENTRY
+ assert result["title"] == NAME
+ assert result["data"] == CONF_DATA
+
+
+async def test_flow_user_already_configured(hass):
+ """Test user initialized flow with duplicate server."""
+ entry = MockConfigEntry(
+ domain=DOMAIN,
+ data={CONF_HOST: "1.2.3.4", CONF_NAME: "Yeti"},
+ )
+
+ entry.add_to_hass(hass)
+
+ service_info = {
+ "host": "1.2.3.4",
+ "name": "Yeti",
+ }
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN, context={"source": SOURCE_USER}, data=service_info
+ )
+
+ assert result["type"] == RESULT_TYPE_ABORT
+ assert result["reason"] == "already_configured"
+
+
+async def test_flow_user_cannot_connect(hass):
+ """Test user initialized flow with unreachable server."""
+ mocked_yeti = await _create_mocked_yeti(True)
+ with _patch_config_flow_yeti(mocked_yeti) as yetimock:
+ yetimock.side_effect = exceptions.ConnectError
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN, context={"source": SOURCE_USER}, data=CONF_CONFIG_FLOW
+ )
+ assert result["type"] == RESULT_TYPE_FORM
+ assert result["step_id"] == "user"
+ assert result["errors"] == {"base": "cannot_connect"}
+
+
+async def test_flow_user_invalid_host(hass):
+ """Test user initialized flow with invalid server."""
+ mocked_yeti = await _create_mocked_yeti(True)
+ with _patch_config_flow_yeti(mocked_yeti) as yetimock:
+ yetimock.side_effect = exceptions.InvalidHost
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN, context={"source": SOURCE_USER}, data=CONF_CONFIG_FLOW
+ )
+ assert result["type"] == RESULT_TYPE_FORM
+ assert result["step_id"] == "user"
+ assert result["errors"] == {"base": "invalid_host"}
+
+
+async def test_flow_user_unknown_error(hass):
+ """Test user initialized flow with unreachable server."""
+ mocked_yeti = await _create_mocked_yeti(True)
+ with _patch_config_flow_yeti(mocked_yeti) as yetimock:
+ yetimock.side_effect = Exception
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN, context={"source": SOURCE_USER}, data=CONF_CONFIG_FLOW
+ )
+ assert result["type"] == RESULT_TYPE_FORM
+ assert result["step_id"] == "user"
+ assert result["errors"] == {"base": "unknown"}