Adds facebox

homeassistant/components/image_processing/facebox.py

@@ -0,0 +1,109 @@
+"""
+Component that will perform facial detection and identification via a local
+facebox classifier.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/image_processing.facebox
+"""
+import base64
+import logging
+
+import requests
+import voluptuous as vol
+
+from homeassistant.core import split_entity_id
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.image_processing import (
+    PLATFORM_SCHEMA, ImageProcessingFaceEntity, CONF_SOURCE, CONF_ENTITY_ID,
+    CONF_NAME)
+from homeassistant.const import (CONF_IP_ADDRESS, CONF_PORT)
+
+_LOGGER = logging.getLogger(__name__)
+
+CLASSIFIER = 'facebox'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_IP_ADDRESS): cv.string,
+    vol.Required(CONF_PORT): cv.port,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the classifier."""
+    entities = []
+    for camera in config[CONF_SOURCE]:
+        entities.append(FaceClassifyEntity(
+            config[CONF_IP_ADDRESS],
+            config[CONF_PORT],
+            camera[CONF_ENTITY_ID],
+            camera.get(CONF_NAME)
+        ))
+    add_devices(entities)
+
+
+class FaceClassifyEntity(ImageProcessingFaceEntity):
+    """Perform a face classification."""
+
+    def __init__(self, ip, port, camera_entity, name=None):
+        """Init with the API key and model id"""
+        super().__init__()
+        self._url = "http://{}:{}/{}/check".format(ip, port, CLASSIFIER)
+        self._camera = camera_entity
+        if name:
+            self._name = name
+        else:
+            camera_name = split_entity_id(camera_entity)[1]
+            self._name = "{} {}".format(
+                CLASSIFIER, camera_name)
+        self._matched = {}
+
+    def process_image(self, image):
+        """Process an image."""
+        response = {}
+        try:
+            response = requests.post(
+                self._url,
+                json=self.encode_image(image),
+                timeout=9
+                ).json()
+        except requests.exceptions.ConnectionError:
+            _LOGGER.error("ConnectionError: Is {} running?".format(CLASSIFIER))
+            response['success'] = False
+
+        if response['success']:
+            faces = response['faces']
+            total = response['facesCount']
+            self.process_faces(faces, total)
+            self._matched = self.get_matched_faces(faces)
+
+        else:
+            self.total_faces = None
+            self.faces = []
+            self._matched = {}
+
+    def encode_image(self, image):
+        """base64 encode an image stream."""
+        base64_img = base64.b64encode(image).decode('ascii')
+        return {"base64": base64_img}
+
+    def get_matched_faces(self, faces):
+        """Return the name and rounded confidence of matched faces."""
+        return {face['name']: round(face['confidence'], 2)
+                for face in faces if face['matched']}
+
+    @property
+    def camera_entity(self):
+        """Return camera entity id from process pictures."""
+        return self._camera
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def device_state_attributes(self):
+        """Return the classifier attributes."""
+        return {
+            'matched_faces': self._matched,
+            }

tests/components/image_processing/test_facebox.py

@@ -0,0 +1,57 @@
+"""The tests for the facebox component."""
+import requests_mock
+
+from homeassistant.const import (CONF_IP_ADDRESS, CONF_PORT)
+from homeassistant.setup import async_setup_component
+import homeassistant.components.image_processing as ip
+
+MOCK_IP = '192.168.0.1'
+MOCK_PORT = '8080'
+
+MOCK_RESPONSE = """
+{"facesCount": 1,
+"success": True,
+"faces":[{'confidence': 0.5812028911604818,
+            'id': 'john.jpg',
+            'matched': True,
+            'name': 'John Lennon',
+            'rect': {'height': 75, 'left': 63, 'top': 262, 'width': 74}
+            }]
+"""
+
+VALID_ENTITY_ID = 'image_processing.facebox_demo_camera'
+VALID_CONFIG = {
+    ip.DOMAIN: {
+        'platform': 'facebox',
+        CONF_IP_ADDRESS: MOCK_IP,
+        CONF_PORT: MOCK_PORT,
+        ip.CONF_SOURCE: {
+            ip.CONF_ENTITY_ID: 'camera.demo_camera'}
+        },
+    'camera': {
+        'platform': 'demo'
+        }
+    }
+
+
+async def test_setup_platform(hass):
+    """Setup platform with one entity."""
+
+    await async_setup_component(hass, ip.DOMAIN, VALID_CONFIG)
+    assert hass.states.get(VALID_ENTITY_ID)
+
+
+async def test_process_image(hass):
+    """Test processing of an image."""
+
+    await async_setup_component(hass, ip.DOMAIN, VALID_CONFIG)
+    assert hass.states.get(VALID_ENTITY_ID)
+
+    with requests_mock.Mocker() as mock_req:
+        url = "http://{}:{}/facebox/check".format(MOCK_IP, MOCK_PORT)
+        mock_req.post(url, text=MOCK_RESPONSE)
+        ip.scan(hass, entity_id=VALID_ENTITY_ID)
+        hass.block_till_done()
+
+    state = hass.states.get(VALID_ENTITY_ID)
+    assert state.state == '1'