Adds facebox

homeassistant/components/image_processing/facebox.py

@@ -0,0 +1,110 @@
+"""
+Component that will perform facial detection and identification via facebox.
+
+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 encode_image(image):
+    """base64 encode an image stream."""
+    base64_img = base64.b64encode(image).decode('ascii')
+    return {"base64": base64_img}
+
+
+def get_matched_faces(faces):
+    """Return the name and rounded confidence of matched faces."""
+    return {face['name']: round(face['confidence'], 2)
+            for face in faces if face['matched']}
+
+
+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=encode_image(image),
+                timeout=9
+                ).json()
+        except requests.exceptions.ConnectionError:
+            _LOGGER.error("ConnectionError: Is %s running?", CLASSIFIER)
+            response['success'] = False
+
+        if response['success']:
+            faces = response['faces']
+            total = response['facesCount']
+            self.process_faces(faces, total)
+            self._matched = get_matched_faces(faces)
+
+        else:
+            self.total_faces = None
+            self.faces = []
+            self._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,73 @@
+"""The tests for the facebox component."""
+from unittest.mock import patch
+
+import pytest
+import requests_mock
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID, 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_JSON = {"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'
+        }
+    }
+
+
+@pytest.fixture
+def mock_image():
+    """Return a mock camera image."""
+    with patch('homeassistant.components.camera.demo.DemoCamera.camera_image',
+               return_value=b'Test') as image:
+        yield image
+
+
+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, mock_image):
+    """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, json=MOCK_JSON)
+        data = {ATTR_ENTITY_ID: VALID_ENTITY_ID}
+        await hass.services.async_call(ip.DOMAIN,
+                                       ip.SERVICE_SCAN,
+                                       service_data=data)
+        await hass.async_block_till_done()
+
+    state = hass.states.get(VALID_ENTITY_ID)
+    assert state.state == '1'
+    assert state.attributes.get('matched_faces') == {'John Lennon': 0.58}