Instituto Geográfico Nacional Sismología (Earthquakes) Feed platform (#22696)

* wip

* added new requirements

* fixed tests

* improved test coverage

* added feed entry's title

* added manifest

* updated codeowners

* generated requirements

CODEOWNERS

@@ -102,6 +102,7 @@ homeassistant/components/http/* @home-assistant/core
 homeassistant/components/huawei_lte/* @scop
 homeassistant/components/huawei_router/* @abmantis
 homeassistant/components/hue/* @balloob
+homeassistant/components/ign_sismologia/* @exxamalte
 homeassistant/components/influxdb/* @fabaff
 homeassistant/components/input_boolean/* @home-assistant/core
 homeassistant/components/input_datetime/* @home-assistant/core

homeassistant/components/ign_sismologia/__init__.py

@@ -0,0 +1 @@
+"""The ign_sismologia component."""

homeassistant/components/ign_sismologia/geo_location.py

@@ -0,0 +1,232 @@
+"""Support for IGN Sismologia (Earthquakes) Feeds."""
+from datetime import timedelta
+import logging
+from typing import Optional
+
+import voluptuous as vol
+
+from homeassistant.components.geo_location import (
+    PLATFORM_SCHEMA, GeolocationEvent)
+from homeassistant.const import (
+    ATTR_ATTRIBUTION, CONF_LATITUDE, CONF_LONGITUDE,
+    CONF_RADIUS, CONF_SCAN_INTERVAL, EVENT_HOMEASSISTANT_START)
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.dispatcher import (
+    async_dispatcher_connect, dispatcher_send)
+from homeassistant.helpers.event import track_time_interval
+
+REQUIREMENTS = ['georss_ign_sismologia_client==0.2']
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_EXTERNAL_ID = 'external_id'
+ATTR_IMAGE_URL = 'image_url'
+ATTR_MAGNITUDE = 'magnitude'
+ATTR_PUBLICATION_DATE = 'publication_date'
+ATTR_REGION = 'region'
+ATTR_TITLE = 'title'
+
+CONF_MINIMUM_MAGNITUDE = 'minimum_magnitude'
+
+DEFAULT_MINIMUM_MAGNITUDE = 0.0
+DEFAULT_RADIUS_IN_KM = 50.0
+DEFAULT_UNIT_OF_MEASUREMENT = 'km'
+
+SCAN_INTERVAL = timedelta(minutes=5)
+
+SIGNAL_DELETE_ENTITY = 'ign_sismologia_delete_{}'
+SIGNAL_UPDATE_ENTITY = 'ign_sismologia_update_{}'
+
+SOURCE = 'ign_sismologia'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_LATITUDE): cv.latitude,
+    vol.Optional(CONF_LONGITUDE): cv.longitude,
+    vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS_IN_KM): vol.Coerce(float),
+    vol.Optional(CONF_MINIMUM_MAGNITUDE, default=DEFAULT_MINIMUM_MAGNITUDE):
+        vol.All(vol.Coerce(float), vol.Range(min=0))
+})
+
+
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Set up the IGN Sismologia Feed platform."""
+    scan_interval = config.get(CONF_SCAN_INTERVAL, SCAN_INTERVAL)
+    coordinates = (config.get(CONF_LATITUDE, hass.config.latitude),
+                   config.get(CONF_LONGITUDE, hass.config.longitude))
+    radius_in_km = config[CONF_RADIUS]
+    minimum_magnitude = config[CONF_MINIMUM_MAGNITUDE]
+    # Initialize the entity manager.
+    feed = IgnSismologiaFeedEntityManager(
+        hass, add_entities, scan_interval, coordinates, radius_in_km,
+        minimum_magnitude)
+
+    def start_feed_manager(event):
+        """Start feed manager."""
+        feed.startup()
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_feed_manager)
+
+
+class IgnSismologiaFeedEntityManager:
+    """Feed Entity Manager for IGN Sismologia GeoRSS feed."""
+
+    def __init__(self, hass, add_entities, scan_interval, coordinates,
+                 radius_in_km, minimum_magnitude):
+        """Initialize the Feed Entity Manager."""
+        from georss_ign_sismologia_client import IgnSismologiaFeedManager
+
+        self._hass = hass
+        self._feed_manager = IgnSismologiaFeedManager(
+            self._generate_entity, self._update_entity, self._remove_entity,
+            coordinates, filter_radius=radius_in_km,
+            filter_minimum_magnitude=minimum_magnitude)
+        self._add_entities = add_entities
+        self._scan_interval = scan_interval
+
+    def startup(self):
+        """Start up this manager."""
+        self._feed_manager.update()
+        self._init_regular_updates()
+
+    def _init_regular_updates(self):
+        """Schedule regular updates at the specified interval."""
+        track_time_interval(
+            self._hass, lambda now: self._feed_manager.update(),
+            self._scan_interval)
+
+    def get_entry(self, external_id):
+        """Get feed entry by external id."""
+        return self._feed_manager.feed_entries.get(external_id)
+
+    def _generate_entity(self, external_id):
+        """Generate new entity."""
+        new_entity = IgnSismologiaLocationEvent(self, external_id)
+        # Add new entities to HA.
+        self._add_entities([new_entity], True)
+
+    def _update_entity(self, external_id):
+        """Update entity."""
+        dispatcher_send(self._hass, SIGNAL_UPDATE_ENTITY.format(external_id))
+
+    def _remove_entity(self, external_id):
+        """Remove entity."""
+        dispatcher_send(self._hass, SIGNAL_DELETE_ENTITY.format(external_id))
+
+
+class IgnSismologiaLocationEvent(GeolocationEvent):
+    """This represents an external event with IGN Sismologia feed data."""
+
+    def __init__(self, feed_manager, external_id):
+        """Initialize entity with data from feed entry."""
+        self._feed_manager = feed_manager
+        self._external_id = external_id
+        self._title = None
+        self._distance = None
+        self._latitude = None
+        self._longitude = None
+        self._attribution = None
+        self._region = None
+        self._magnitude = None
+        self._publication_date = None
+        self._image_url = None
+        self._remove_signal_delete = None
+        self._remove_signal_update = None
+
+    async def async_added_to_hass(self):
+        """Call when entity is added to hass."""
+        self._remove_signal_delete = async_dispatcher_connect(
+            self.hass, SIGNAL_DELETE_ENTITY.format(self._external_id),
+            self._delete_callback)
+        self._remove_signal_update = async_dispatcher_connect(
+            self.hass, SIGNAL_UPDATE_ENTITY.format(self._external_id),
+            self._update_callback)
+
+    @callback
+    def _delete_callback(self):
+        """Remove this entity."""
+        self._remove_signal_delete()
+        self._remove_signal_update()
+        self.hass.async_create_task(self.async_remove())
+
+    @callback
+    def _update_callback(self):
+        """Call update method."""
+        self.async_schedule_update_ha_state(True)
+
+    @property
+    def should_poll(self):
+        """No polling needed for IGN Sismologia feed location events."""
+        return False
+
+    async def async_update(self):
+        """Update this entity from the data held in the feed manager."""
+        _LOGGER.debug("Updating %s", self._external_id)
+        feed_entry = self._feed_manager.get_entry(self._external_id)
+        if feed_entry:
+            self._update_from_feed(feed_entry)
+
+    def _update_from_feed(self, feed_entry):
+        """Update the internal state from the provided feed entry."""
+        self._title = feed_entry.title
+        self._distance = feed_entry.distance_to_home
+        self._latitude = feed_entry.coordinates[0]
+        self._longitude = feed_entry.coordinates[1]
+        self._attribution = feed_entry.attribution
+        self._region = feed_entry.region
+        self._magnitude = feed_entry.magnitude
+        self._publication_date = feed_entry.published
+        self._image_url = feed_entry.image_url
+
+    @property
+    def source(self) -> str:
+        """Return source value of this external event."""
+        return SOURCE
+
+    @property
+    def name(self) -> Optional[str]:
+        """Return the name of the entity."""
+        if self._magnitude and self._region:
+            return "M {:.1f} - {}".format(self._magnitude, self._region)
+        if self._magnitude:
+            return "M {:.1f}".format(self._magnitude)
+        if self._region:
+            return self._region
+        return self._title
+
+    @property
+    def distance(self) -> Optional[float]:
+        """Return distance value of this external event."""
+        return self._distance
+
+    @property
+    def latitude(self) -> Optional[float]:
+        """Return latitude value of this external event."""
+        return self._latitude
+
+    @property
+    def longitude(self) -> Optional[float]:
+        """Return longitude value of this external event."""
+        return self._longitude
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit of measurement."""
+        return DEFAULT_UNIT_OF_MEASUREMENT
+
+    @property
+    def device_state_attributes(self):
+        """Return the device state attributes."""
+        attributes = {}
+        for key, value in (
+                (ATTR_EXTERNAL_ID, self._external_id),
+                (ATTR_TITLE, self._title),
+                (ATTR_REGION, self._region),
+                (ATTR_MAGNITUDE, self._magnitude),
+                (ATTR_ATTRIBUTION, self._attribution),
+                (ATTR_PUBLICATION_DATE, self._publication_date),
+                (ATTR_IMAGE_URL, self._image_url)
+        ):
+            if value or isinstance(value, bool):
+                attributes[key] = value
+        return attributes

homeassistant/components/ign_sismologia/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "ign_sismologia",
+  "name": "IGN Sismologia",
+  "documentation": "https://www.home-assistant.io/components/ign_sismologia",
+  "requirements": [
+    "georss_ign_sismologia_client==0.2"
+  ],
+  "dependencies": [],
+  "codeowners": [
+    "@exxamalte"
+  ]
+}

requirements_all.txt

@@ -466,6 +466,9 @@ geojson_client==0.3
 # homeassistant.components.geo_rss_events
 georss_generic_client==0.2
 
+# homeassistant.components.ign_sismologia
+georss_ign_sismologia_client==0.2
+
 # homeassistant.components.gitter
 gitterpy==0.1.7
 

requirements_test_all.txt

@@ -111,6 +111,9 @@ geojson_client==0.3
 # homeassistant.components.geo_rss_events
 georss_generic_client==0.2
 
+# homeassistant.components.ign_sismologia
+georss_ign_sismologia_client==0.2
+
 # homeassistant.components.google
 google-api-python-client==1.6.4
 

script/gen_requirements_all.py

@@ -62,6 +62,7 @@ TEST_REQUIREMENTS = (
     'foobot_async',
     'geojson_client',
     'georss_generic_client',
+    'georss_ign_sismologia_client',
     'google-api-python-client',
     'gTTS-token',
     'ha-ffmpeg',

tests/components/ign_sismologia/__init__.py

@@ -0,0 +1 @@
+"""Tests for the ign_sismologia component."""

tests/components/ign_sismologia/test_geo_location.py

@@ -0,0 +1,191 @@
+"""The tests for the IGN Sismologia (Earthquakes) Feed platform."""
+import datetime
+from unittest.mock import patch, MagicMock, call
+
+from homeassistant.components import geo_location
+from homeassistant.components.geo_location import ATTR_SOURCE
+from homeassistant.components.ign_sismologia.geo_location import (
+    ATTR_EXTERNAL_ID, SCAN_INTERVAL, ATTR_REGION,
+    ATTR_MAGNITUDE, ATTR_IMAGE_URL, ATTR_PUBLICATION_DATE, ATTR_TITLE)
+from homeassistant.const import EVENT_HOMEASSISTANT_START, \
+    CONF_RADIUS, ATTR_LATITUDE, ATTR_LONGITUDE, ATTR_FRIENDLY_NAME, \
+    ATTR_UNIT_OF_MEASUREMENT, ATTR_ATTRIBUTION, CONF_LATITUDE, CONF_LONGITUDE
+from homeassistant.setup import async_setup_component
+from tests.common import assert_setup_component, async_fire_time_changed
+import homeassistant.util.dt as dt_util
+
+CONFIG = {
+    geo_location.DOMAIN: [
+        {
+            'platform': 'ign_sismologia',
+            CONF_RADIUS: 200
+        }
+    ]
+}
+
+CONFIG_WITH_CUSTOM_LOCATION = {
+    geo_location.DOMAIN: [
+        {
+            'platform': 'ign_sismologia',
+            CONF_RADIUS: 200,
+            CONF_LATITUDE: 40.4,
+            CONF_LONGITUDE: -3.7
+        }
+    ]
+}
+
+
+def _generate_mock_feed_entry(external_id, title, distance_to_home,
+                              coordinates, region=None,
+                              attribution=None, published=None,
+                              magnitude=None, image_url=None):
+    """Construct a mock feed entry for testing purposes."""
+    feed_entry = MagicMock()
+    feed_entry.external_id = external_id
+    feed_entry.title = title
+    feed_entry.distance_to_home = distance_to_home
+    feed_entry.coordinates = coordinates
+    feed_entry.region = region
+    feed_entry.attribution = attribution
+    feed_entry.published = published
+    feed_entry.magnitude = magnitude
+    feed_entry.image_url = image_url
+    return feed_entry
+
+
+async def test_setup(hass):
+    """Test the general setup of the platform."""
+    # Set up some mock feed entries for this test.
+    mock_entry_1 = _generate_mock_feed_entry(
+        '1234', 'Title 1', 15.5, (38.0, -3.0),
+        region='Region 1', attribution='Attribution 1',
+        published=datetime.datetime(2018, 9, 22, 8, 0,
+                                    tzinfo=datetime.timezone.utc),
+        magnitude=5.7, image_url='http://image.url/map.jpg')
+    mock_entry_2 = _generate_mock_feed_entry(
+        '2345', 'Title 2', 20.5, (38.1, -3.1), magnitude=4.6)
+    mock_entry_3 = _generate_mock_feed_entry(
+        '3456', 'Title 3', 25.5, (38.2, -3.2), region='Region 3')
+    mock_entry_4 = _generate_mock_feed_entry(
+        '4567', 'Title 4', 12.5, (38.3, -3.3))
+
+    # Patching 'utcnow' to gain more control over the timed update.
+    utcnow = dt_util.utcnow()
+    with patch('homeassistant.util.dt.utcnow', return_value=utcnow), \
+        patch('georss_ign_sismologia_client.'
+              'IgnSismologiaFeed') as mock_feed:
+        mock_feed.return_value.update.return_value = 'OK', [mock_entry_1,
+                                                            mock_entry_2,
+                                                            mock_entry_3]
+        with assert_setup_component(1, geo_location.DOMAIN):
+            assert await async_setup_component(
+                hass, geo_location.DOMAIN, CONFIG)
+            # Artificially trigger update.
+            hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+            # Collect events.
+            await hass.async_block_till_done()
+
+            all_states = hass.states.async_all()
+            assert len(all_states) == 3
+
+            state = hass.states.get("geo_location.m_5_7_region_1")
+            assert state is not None
+            assert state.name == "M 5.7 - Region 1"
+            assert state.attributes == {
+                ATTR_EXTERNAL_ID: "1234",
+                ATTR_LATITUDE: 38.0,
+                ATTR_LONGITUDE: -3.0,
+                ATTR_FRIENDLY_NAME: "M 5.7 - Region 1",
+                ATTR_TITLE: "Title 1",
+                ATTR_REGION: "Region 1",
+                ATTR_ATTRIBUTION: "Attribution 1",
+                ATTR_PUBLICATION_DATE:
+                    datetime.datetime(
+                        2018, 9, 22, 8, 0, tzinfo=datetime.timezone.utc),
+                ATTR_IMAGE_URL: 'http://image.url/map.jpg',
+                ATTR_MAGNITUDE: 5.7,
+                ATTR_UNIT_OF_MEASUREMENT: "km",
+                ATTR_SOURCE: 'ign_sismologia'}
+            assert float(state.state) == 15.5
+
+            state = hass.states.get("geo_location.m_4_6")
+            assert state is not None
+            assert state.name == "M 4.6"
+            assert state.attributes == {
+                ATTR_EXTERNAL_ID: "2345",
+                ATTR_LATITUDE: 38.1,
+                ATTR_LONGITUDE: -3.1,
+                ATTR_FRIENDLY_NAME: "M 4.6",
+                ATTR_TITLE: "Title 2",
+                ATTR_MAGNITUDE: 4.6,
+                ATTR_UNIT_OF_MEASUREMENT: "km",
+                ATTR_SOURCE: 'ign_sismologia'}
+            assert float(state.state) == 20.5
+
+            state = hass.states.get("geo_location.region_3")
+            assert state is not None
+            assert state.name == "Region 3"
+            assert state.attributes == {
+                ATTR_EXTERNAL_ID: "3456",
+                ATTR_LATITUDE: 38.2,
+                ATTR_LONGITUDE: -3.2,
+                ATTR_FRIENDLY_NAME: "Region 3",
+                ATTR_TITLE: "Title 3",
+                ATTR_REGION: "Region 3",
+                ATTR_UNIT_OF_MEASUREMENT: "km",
+                ATTR_SOURCE: 'ign_sismologia'}
+            assert float(state.state) == 25.5
+
+            # Simulate an update - one existing, one new entry,
+            # one outdated entry
+            mock_feed.return_value.update.return_value = 'OK', [
+                mock_entry_1, mock_entry_4, mock_entry_3]
+            async_fire_time_changed(hass, utcnow + SCAN_INTERVAL)
+            await hass.async_block_till_done()
+
+            all_states = hass.states.async_all()
+            assert len(all_states) == 3
+
+            # Simulate an update - empty data, but successful update,
+            # so no changes to entities.
+            mock_feed.return_value.update.return_value = 'OK_NO_DATA', None
+            async_fire_time_changed(hass, utcnow + 2 * SCAN_INTERVAL)
+            await hass.async_block_till_done()
+
+            all_states = hass.states.async_all()
+            assert len(all_states) == 3
+
+            # Simulate an update - empty data, removes all entities
+            mock_feed.return_value.update.return_value = 'ERROR', None
+            async_fire_time_changed(hass, utcnow + 3 * SCAN_INTERVAL)
+            await hass.async_block_till_done()
+
+            all_states = hass.states.async_all()
+            assert len(all_states) == 0
+
+
+async def test_setup_with_custom_location(hass):
+    """Test the setup with a custom location."""
+    # Set up some mock feed entries for this test.
+    mock_entry_1 = _generate_mock_feed_entry(
+        '1234', 'Title 1', 20.5, (38.1, -3.1))
+
+    with patch('georss_ign_sismologia_client.'
+               'IgnSismologiaFeed') as mock_feed:
+        mock_feed.return_value.update.return_value = 'OK', [mock_entry_1]
+
+        with assert_setup_component(1, geo_location.DOMAIN):
+            assert await async_setup_component(
+                hass, geo_location.DOMAIN, CONFIG_WITH_CUSTOM_LOCATION)
+
+            # Artificially trigger update.
+            hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+            # Collect events.
+            await hass.async_block_till_done()
+
+            all_states = hass.states.async_all()
+            assert len(all_states) == 1
+
+            assert mock_feed.call_args == call(
+                (40.4, -3.7), filter_minimum_magnitude=0.0,
+                filter_radius=200.0)