diff --git a/platypush/plugins/smartthings/__init__.py b/platypush/plugins/smartthings/__init__.py
index c88f27830..49dd219b0 100644
--- a/platypush/plugins/smartthings/__init__.py
+++ b/platypush/plugins/smartthings/__init__.py
@@ -2,24 +2,31 @@ import asyncio
import aiohttp
from threading import RLock
-from typing import Optional, Dict, List, Set, Tuple, Type, Union, Iterable
+from typing import Optional, Dict, List, Tuple, Type, Union, Iterable
-import pysmartthings
+from pysmartthings import (
+ Attribute,
+ Capability,
+ Command,
+ Device,
+ DeviceStatus,
+ SmartThings,
+)
from platypush.entities import Entity, manages
-from platypush.entities.batteries import Battery
-from platypush.entities.devices import Device
+from platypush.entities.devices import Device as PDevice
from platypush.entities.dimmers import Dimmer
from platypush.entities.lights import Light
-from platypush.entities.motion import MotionSensor
from platypush.entities.sensors import Sensor
from platypush.entities.switches import Switch
from platypush.plugins import RunnablePlugin, action
from platypush.utils import camel_case_to_snake_case
+from ._mappers import device_mappers
-@manages(Device, Dimmer, Sensor, Switch, Light)
+
+@manages(PDevice, Dimmer, Sensor, Switch, Light)
class SmartthingsPlugin(RunnablePlugin):
"""
Plugin to interact with devices and locations registered to a Samsung SmartThings account.
@@ -55,6 +62,7 @@ class SmartthingsPlugin(RunnablePlugin):
self._rooms_by_id = {}
self._rooms_by_location_and_id = {}
self._rooms_by_location_and_name = {}
+ self._entities_by_id: Dict[str, Entity] = {}
async def _refresh_locations(self, api):
self._locations = await api.locations()
@@ -82,9 +90,8 @@ class SmartthingsPlugin(RunnablePlugin):
}
async def _refresh_info(self):
-
async with aiohttp.ClientSession(timeout=self._timeout) as session:
- api = pysmartthings.SmartThings(session, self._access_token)
+ api = SmartThings(session, self._access_token)
tasks = [
asyncio.ensure_future(self._refresh_locations(api)),
asyncio.ensure_future(self._refresh_devices(api)),
@@ -309,14 +316,21 @@ class SmartthingsPlugin(RunnablePlugin):
assert location, 'Location {} not found'.format(location_id or name)
return self._location_to_dict(location)
- def _get_device(self, device: str):
+ def _get_device(self, device: str) -> Device:
return self._get_devices(device)[0]
- def _get_found_and_missing_devs(
+ @staticmethod
+ def _to_device_and_property(device: str) -> Tuple[str, Optional[str]]:
+ tokens = device.split(':')
+ if len(tokens) > 1:
+ return tuple(tokens[:2])
+ return tokens[0], None
+
+ def _get_existing_and_missing_devices(
self, *devices: str
) -> Tuple[List[Device], List[str]]:
# Split the external_id:type indicators and always return the parent device
- devices = tuple(dev.split(':')[0] for dev in devices)
+ devices = tuple(self._to_device_and_property(dev)[0] for dev in devices)
found_devs = {
dev: self._devices_by_id.get(dev, self._devices_by_name.get(dev))
@@ -325,15 +339,14 @@ class SmartthingsPlugin(RunnablePlugin):
}
missing_devs = {dev for dev in devices if dev not in found_devs}
-
return list(found_devs.values()), list(missing_devs) # type: ignore
- def _get_devices(self, *devices: str):
- devs, missing_devs = self._get_found_and_missing_devs(*devices)
+ def _get_devices(self, *devices: str) -> List[Device]:
+ devs, missing_devs = self._get_existing_and_missing_devices(*devices)
if missing_devs:
self.refresh_info()
- devs, missing_devs = self._get_found_and_missing_devs(*devices)
+ devs, missing_devs = self._get_existing_and_missing_devices(*devices)
assert not missing_devs, f'Devices not found: {missing_devs}'
return devs
@@ -375,7 +388,7 @@ class SmartthingsPlugin(RunnablePlugin):
args: Optional[list],
):
async with aiohttp.ClientSession(timeout=self._timeout) as session:
- api = pysmartthings.SmartThings(session, self._access_token)
+ api = SmartThings(session, self._access_token)
device = await api.device(device_id)
ret = await device.command(
component_id=component_id,
@@ -384,11 +397,13 @@ class SmartthingsPlugin(RunnablePlugin):
args=args,
)
- assert (
- ret
- ), 'The command {capability}={command} failed on device {device}'.format(
- capability=capability, command=command, device=device_id
- )
+ assert (
+ ret
+ ), 'The command {capability}={command} failed on device {device}'.format(
+ capability=capability, command=command, device=device_id
+ )
+
+ await self._get_device_status(api, device_id, publish_entities=True)
@action
def execute(
@@ -423,7 +438,7 @@ class SmartthingsPlugin(RunnablePlugin):
:param component_id: ID of the component to execute the command on (default: ``main``, i.e. the device itself).
:param args: Command extra arguments, as a list.
"""
- device = self._get_device(device)
+ dev = self._get_device(device)
with self._execute_lock:
loop = asyncio.new_event_loop()
@@ -431,7 +446,7 @@ class SmartthingsPlugin(RunnablePlugin):
asyncio.set_event_loop(loop)
loop.run_until_complete(
self._execute(
- device_id=device.device_id,
+ device_id=dev.device_id,
capability=capability,
command=command,
component_id=component_id,
@@ -442,110 +457,17 @@ class SmartthingsPlugin(RunnablePlugin):
loop.stop()
@staticmethod
- def _get_capabilities(device) -> Set[str]:
- if isinstance(device, dict):
- return set(device.get('capabilities', []))
- return set(device.capabilities)
-
- @staticmethod
- def _to_entity(entity_type: Type[Entity], device, **kwargs) -> Entity:
+ def _to_entity(
+ device: Device, property: str, entity_type: Type[Entity], **kwargs
+ ) -> Entity:
return entity_type(
- id=device.device_id + ':' + entity_type.__name__.lower(),
+ id=f'{device.device_id}:{property}',
name=entity_type.__name__,
**kwargs,
)
- @classmethod
- def _get_lights(cls, device) -> Iterable[Light]:
- # TODO double-check conversion values here according to the docs
- if not (
- {'colorControl', 'colorTemperature'}.intersection(
- cls._get_capabilities(device)
- )
- ):
- return []
-
- light_attrs = {}
- if 'switch' in device.capabilities:
- light_attrs['on'] = device.status.switch
- if getattr(device.status, 'level', None) is not None:
- light_attrs['brightness'] = device.status.level
- light_attrs['brightness_min'] = 0
- light_attrs['brightness_max'] = 100
- if 'colorTemperature' in device.capabilities:
- # Color temperature range on SmartThings is expressed in Kelvin
- light_attrs['temperature_min'] = 2000
- light_attrs['temperature_max'] = 6500
- if device.status.color_temperature >= light_attrs['temperature_min']:
- light_attrs['temperature'] = (
- light_attrs['temperature_max'] - light_attrs['temperature_min']
- ) / 2
- if getattr(device.status, 'hue', None) is not None:
- light_attrs['hue'] = device.status.hue
- light_attrs['hue_min'] = 0
- light_attrs['hue_max'] = 100
- if getattr(device.status, 'saturation', None) is not None:
- light_attrs['saturation'] = device.status.saturation
- light_attrs['saturation_min'] = 0
- light_attrs['saturation_max'] = 100
-
- return [cls._to_entity(Light, device, **light_attrs)]
-
- @classmethod
- def _get_switches(cls, device) -> Iterable[Switch]:
- if 'switch' not in cls._get_capabilities(device):
- return []
-
- return [
- cls._to_entity(
- Switch,
- device,
- state=device.status.switch,
- )
- ]
-
- @classmethod
- def _get_dimmers(cls, device: pysmartthings.Device) -> Iterable[Dimmer]:
- if 'switchLevel' not in cls._get_capabilities(device):
- return []
-
- kwargs = cls._get_status_attr_info(device, 'level')
- return [
- cls._to_entity(
- Dimmer, device, value=device.status.level, min=0, max=100, **kwargs
- )
- ]
-
- @classmethod
- def _get_sensors(cls, device) -> Iterable[Sensor]:
- sensors = []
-
- if 'motionSensor' in cls._get_capabilities(device):
- kwargs = cls._get_status_attr_info(device, 'motion')
- sensors.append(
- cls._to_entity(
- MotionSensor,
- device,
- value=device.status.motion,
- **kwargs,
- )
- )
-
- if 'battery' in cls._get_capabilities(device):
- kwargs = cls._get_status_attr_info(device, 'battery')
- sensors.append(
- cls._to_entity(
- Battery,
- device,
- value=device.status.attributes['battery'].value,
- **kwargs,
- )
- )
-
- return sensors
-
@staticmethod
- def _get_status_attr_info(device: pysmartthings.Device, attr: str) -> dict:
+ def _get_status_attr_info(device: Device, attr: str) -> dict:
status = device.status.attributes.get(attr)
info = {}
if status:
@@ -558,6 +480,76 @@ class SmartthingsPlugin(RunnablePlugin):
return info
+ @classmethod
+ def _get_supported_entities(
+ cls,
+ device: Device,
+ entity_type: Optional[Type[Entity]] = None,
+ entity_value_attr: str = 'value',
+ **default_entity_args,
+ ) -> List[Entity]:
+ mappers = [
+ m
+ for m in device_mappers
+ if (entity_type is None or issubclass(m.entity_type, entity_type))
+ and m.capability in device.capabilities
+ ]
+
+ return [
+ cls._to_entity(
+ device,
+ property=m.attribute,
+ entity_type=m.entity_type,
+ **{entity_value_attr: m.get_value(device)},
+ **default_entity_args,
+ **cls._get_status_attr_info(device, m.attribute),
+ )
+ for m in mappers
+ ]
+
+ @classmethod
+ def _get_lights(cls, device: Device) -> Iterable[Light]:
+ if not (
+ {Capability.color_control, Capability.color_temperature}.intersection(
+ device.capabilities
+ )
+ ):
+ return []
+
+ light_attrs = {}
+ if Capability.switch in device.capabilities:
+ light_attrs['on'] = device.status.switch
+ if Capability.switch_level in device.capabilities:
+ light_attrs['brightness'] = device.status.level
+ light_attrs['brightness_min'] = 0
+ light_attrs['brightness_max'] = 100
+ if Capability.color_temperature in device.capabilities:
+ light_attrs['temperature'] = device.status.color_temperature
+ light_attrs['temperature_min'] = 1
+ light_attrs['temperature_max'] = 30000
+ if getattr(device.status, 'hue', None) is not None:
+ light_attrs['hue'] = device.status.hue
+ light_attrs['hue_min'] = 0
+ light_attrs['hue_max'] = 100
+ if getattr(device.status, 'saturation', None) is not None:
+ light_attrs['saturation'] = device.status.saturation
+ light_attrs['saturation_min'] = 0
+ light_attrs['saturation_max'] = 100
+
+ return [cls._to_entity(device, 'light', Light, **light_attrs)]
+
+ @classmethod
+ def _get_switches(cls, device: Device) -> Iterable[Switch]:
+ return cls._get_supported_entities(device, Switch, entity_value_attr='state')
+
+ @classmethod
+ def _get_dimmers(cls, device: Device) -> Iterable[Dimmer]:
+ return cls._get_supported_entities(device, Dimmer, min=0, max=100)
+
+ @classmethod
+ def _get_sensors(cls, device) -> Iterable[Sensor]:
+ return cls._get_supported_entities(device, Sensor)
+
def transform_entities(self, entities):
compatible_entities = []
@@ -582,6 +574,8 @@ class SmartthingsPlugin(RunnablePlugin):
compatible_entities += device_entities
+ self._entities_by_id.update({e.id: e for e in compatible_entities})
+
return super().transform_entities(compatible_entities) # type: ignore
async def _get_device_status(
@@ -640,7 +634,7 @@ class SmartthingsPlugin(RunnablePlugin):
), 'Could not find the following devices: {}'.format(list(missing_device_ids))
async with aiohttp.ClientSession(timeout=self._timeout) as session:
- api = pysmartthings.SmartThings(session, self._access_token)
+ api = SmartThings(session, self._access_token)
status_tasks = [
asyncio.ensure_future(
self._get_device_status(
@@ -701,69 +695,50 @@ class SmartthingsPlugin(RunnablePlugin):
finally:
loop.stop()
+ def _set_switch(self, device: str, value: Optional[bool] = None):
+ device, property = self._to_device_and_property(device)
+ if not property:
+ property = Attribute.switch
+
+ if value is None:
+ # Toggle case
+ dev = self._get_device(device)
+ assert hasattr(
+ dev.status, property
+ ), f'No such property on device "{dev.label}": "{property}"'
+
+ device = dev.device_id
+ value = getattr(dev.status, property) is not True
+
+ return self.set_value(device, property, value)
+
@action
- def on(self, device: str, *_, **__) -> dict:
+ def on(self, device: str, *_, **__):
"""
Turn on a device with ``switch`` capability.
:param device: Device name or ID.
- :return: Device status
"""
- self.execute(device, 'switch', 'on')
- return self.status(device).output[0] # type: ignore
+ return self._set_switch(device, True)
@action
- def off(self, device: str, *_, **__) -> dict:
+ def off(self, device: str, *_, **__):
"""
Turn off a device with ``switch`` capability.
:param device: Device name or ID.
- :return: Device status
"""
- self.execute(device, 'switch', 'off')
- return self.status(device).output[0] # type: ignore
+ return self._set_switch(device, False)
@action
- def toggle(self, device: str, *args, **__) -> dict:
+ def toggle(self, device: str, *_, **__):
"""
Toggle a device with ``switch`` capability.
:param device: Device name or ID.
:return: Device status
"""
- device = self._get_device(device)
- device_id = device.device_id
-
- async def _toggle():
- async with aiohttp.ClientSession(timeout=self._timeout) as session:
- api = pysmartthings.SmartThings(session, self._access_token)
- dev = await api.device(device_id)
- assert (
- 'switch' in dev.capabilities
- ), 'The device {} has no switch capability'.format(dev.label)
-
- await dev.status.refresh()
- state = 'off' if dev.status.switch else 'on'
- ret = await dev.command(
- component_id='main', capability='switch', command=state, args=args
- )
-
- assert ret, 'The command switch={state} failed on device {device}'.format(
- state=state, device=dev.label
- )
-
- with self._refresh_lock:
- loop = asyncio.new_event_loop()
- loop.run_until_complete(_toggle())
- updated_device = loop.run_until_complete(self._refresh_status([device_id]))[
- 0
- ]
-
- return {
- 'id': device_id,
- 'name': updated_device['name'],
- 'on': updated_device['switch'],
- }
+ return self._set_switch(device)
@action
def set_level(self, device: str, level: int, **kwargs):
@@ -775,7 +750,44 @@ class SmartthingsPlugin(RunnablePlugin):
:param level: Level, usually a percentage value between 0 and 1.
:param kwarsg: Extra arguments that should be passed to :meth:`.execute`.
"""
- self.execute(device, 'switchLevel', 'setLevel', args=[int(level)], **kwargs)
+ return self.set_value(device, Capability.switch_level, level, **kwargs)
+
+ def _set_value(
+ self, device: str, property: Optional[str] = None, data=None, **kwargs
+ ):
+ if not property:
+ device, property = self._to_device_and_property(device)
+
+ assert property, 'No property name specified'
+ assert data is not None, 'No value specified'
+ entity_id = f'{device}:{property}'
+ entity = self._entities_by_id.get(entity_id)
+ assert entity, f'No such entity ID: {entity_id}'
+
+ mapper = next(
+ iter([m for m in device_mappers if m.attribute == property]), None
+ )
+
+ assert mapper, f'No mappers found to set {property}={data} on device "{device}"'
+
+ assert (
+ mapper.set_command
+ ), f'The property "{property}" on the device "{device}" cannot be set'
+ command = (
+ mapper.set_command(data)
+ if callable(mapper.set_command)
+ else mapper.set_command
+ )
+
+ self.execute(
+ device,
+ mapper.capability,
+ command,
+ args=mapper.set_value_args(data),
+ **kwargs,
+ )
+
+ return self.status(device)
@action
def set_value(
@@ -785,21 +797,17 @@ class SmartthingsPlugin(RunnablePlugin):
Set the value of a device. It is compatible with the generic
``set_value`` method required by entities.
- :param device: Device ID or device+property name string in the format ``device_id:property``.
+ :param device: Device ID or device+property name string in the format
+ ``device_id:property``.
:param property: Name of the property to be set. If not specified here
then it should be specified on the ``device`` level.
:param data: Value to be set.
"""
- device_tokens = device.split(':')
- if len(device_tokens) > 1:
- device, property = device_tokens[:2]
- assert property, 'No property name specified'
-
- if property.startswith('dimmer'):
- assert data is not None, 'No value specified'
- self.execute(device, 'switchLevel', 'setLevel', args=[int(data)], **kwargs)
- elif property.startswith('switch'):
- self.execute(device, 'switch', 'on' if data else 'off', **kwargs)
+ try:
+ return self._set_value(device, property, data, **kwargs)
+ except Exception as e:
+ self.logger.exception(e)
+ raise AssertionError(e)
@action
def set_lights(
@@ -819,26 +827,41 @@ class SmartthingsPlugin(RunnablePlugin):
for light in lights:
try:
if on is not None:
- self.execute(light, 'switch', 'on' if on else 'off')
+ self.execute(
+ light, Capability.switch, Command.on if on else Command.off
+ )
if brightness is not None:
self.execute(
- light, 'switchLevel', 'setLevel', args=[brightness]
+ light,
+ Capability.switch_level,
+ Command.set_level,
+ args=[brightness],
)
if hue is not None:
- self.execute(light, 'colorControl', 'setHue', args=[hue])
+ self.execute(
+ light, Capability.color_control, Command.set_hue, args=[hue]
+ )
if saturation is not None:
self.execute(
- light, 'colorControl', 'setSaturation', args=[saturation]
+ light,
+ Capability.color_control,
+ Command.set_saturation,
+ args=[saturation],
)
if temperature is not None:
self.execute(
light,
- 'colorTemperature',
- 'setColorTemperature',
+ Capability.color_temperature,
+ Command.set_color_temperature,
args=[temperature],
)
if hex is not None:
- self.execute(light, 'colorControl', 'setColor', args=[hex])
+ self.execute(
+ light,
+ Capability.color_control,
+ Command.set_color,
+ args=[hex],
+ )
except Exception as e:
self.logger.error('Could not set attributes on %s: %s', light, e)
err = e
@@ -847,20 +870,30 @@ class SmartthingsPlugin(RunnablePlugin):
raise err
@staticmethod
- def _device_status_to_dict(status: pysmartthings.DeviceStatus) -> dict:
+ def _device_status_to_dict(status: DeviceStatus) -> dict:
status_dict = {}
- for attr in status.attributes.keys():
+ for attr in status.attributes:
attr = camel_case_to_snake_case(attr)
- if hasattr(status, attr):
- status_dict[attr] = getattr(status, attr)
+ try:
+ if hasattr(status, attr):
+ status_dict[attr] = getattr(status, attr)
+ except Exception:
+ # Ignore exceptions if retrieving status attributes that don't
+ # apply to this device
+ continue
return status_dict
def _get_devices_status_dict(self) -> Dict[str, dict]:
- return {
- device_id: self._device_status_to_dict(device.status)
- for device_id, device in self._devices_by_id.items()
- }
+ return dict(
+ filter(
+ lambda d: bool(d[1]),
+ [
+ (device_id, self._device_status_to_dict(device.status))
+ for device_id, device in self._devices_by_id.items()
+ ],
+ )
+ )
@staticmethod
def _has_status_changed(status: dict, new_status: dict) -> bool:
@@ -876,10 +909,21 @@ class SmartthingsPlugin(RunnablePlugin):
return False
def main(self):
+ def refresh_status_safe():
+ try:
+ return self.status(publish_entities=False)
+ except Exception as e:
+ self.logger.exception(e)
+ self.logger.error(f'Could not refresh the status: {e}')
+ self.wait_stop(3 * (self.poll_interval or 5))
+
while not self.should_stop():
updated_devices = {}
devices = self._get_devices_status_dict()
- self.status(publish_entities=False)
+ status = refresh_status_safe()
+ if not status:
+ continue
+
new_devices = self._get_devices_status_dict()
updated_devices = {
@@ -889,8 +933,9 @@ class SmartthingsPlugin(RunnablePlugin):
}
self.publish_entities(updated_devices.values()) # type: ignore
- devices = new_devices
+ devices.update(new_devices)
self.wait_stop(self.poll_interval)
+ refresh_status_safe()
# vim:sw=4:ts=4:et:
diff --git a/platypush/plugins/smartthings/_mappers.py b/platypush/plugins/smartthings/_mappers.py
new file mode 100644
index 000000000..1b5c51424
--- /dev/null
+++ b/platypush/plugins/smartthings/_mappers.py
@@ -0,0 +1,99 @@
+from typing import Any, Callable, List, Optional, Type, Union
+
+from pysmartthings import Attribute, Capability, Command, Device
+
+from platypush.entities import Entity
+
+from platypush.entities.audio import Muted, Volume
+from platypush.entities.batteries import Battery
+from platypush.entities.dimmers import Dimmer
+from platypush.entities.motion import MotionSensor
+from platypush.entities.switches import Switch
+
+
+class DeviceMapper:
+ """
+ The purpose of these objects is to map the capabilities of SmartThings
+ devices to native Platypush entities.
+ """
+
+ def __init__(
+ self,
+ entity_type: Type[Entity],
+ capability: str,
+ attribute: str,
+ value_type: Type,
+ set_command: Optional[Union[str, Callable[[Any], List[Any]]]] = None,
+ get_value: Optional[Callable[[Device], Any]] = None,
+ set_value_args: Optional[Callable[..., Any]] = None,
+ ):
+ self.entity_type = entity_type
+ self.capability = capability
+ self.set_command = set_command
+ self.attribute = attribute
+ self.value_type = value_type
+ self.get_value = get_value if get_value else self._default_get_value
+
+ self.set_value_args = (
+ set_value_args if set_value_args else self._default_set_value_args
+ )
+
+ def _default_get_value(self, device: Device) -> Any:
+ if hasattr(device.status, self.attribute):
+ value = getattr(device.status, self.attribute)
+ else:
+ value = device.status.attributes[self.attribute].value
+
+ return self.value_type(value)
+
+ def _default_set_value_args(self, *values: Any) -> List[Any]:
+ return [self.value_type(v) for v in values]
+
+
+device_mappers: List[DeviceMapper] = [
+ DeviceMapper(
+ entity_type=Volume,
+ capability=Capability.audio_volume,
+ attribute=Attribute.volume,
+ value_type=int,
+ set_command=Command.set_volume,
+ ),
+ DeviceMapper(
+ entity_type=Muted,
+ capability=Capability.audio_mute,
+ attribute=Attribute.mute,
+ value_type=bool,
+ set_command=lambda value: Command.mute if value else Command.unmute,
+ set_value_args=lambda *_: [],
+ ),
+ DeviceMapper(
+ entity_type=MotionSensor,
+ capability=Capability.motion_sensor,
+ attribute=Attribute.motion,
+ value_type=bool,
+ ),
+ DeviceMapper(
+ entity_type=Battery,
+ capability=Capability.battery,
+ attribute=Attribute.battery,
+ value_type=int,
+ ),
+ DeviceMapper(
+ entity_type=Dimmer,
+ capability=Capability.switch_level,
+ attribute=Attribute.level,
+ value_type=int,
+ set_command=Command.set_level,
+ ),
+ DeviceMapper(
+ entity_type=Switch,
+ capability=Capability.switch,
+ attribute=Attribute.switch,
+ value_type=bool,
+ set_command=lambda value: Command.on if value else Command.off,
+ set_value_args=lambda *_: [],
+ ),
+]
+
+
+# vim:sw=4:ts=4:et: