class TestFritzhomeDeviceButton(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_button_fritzdect440(self):
self.mock.side_effect = [
Helper.response("button/device_button_fritzdect440"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345 0000001")
assert_true(device.present)
eq_(device.alert_state, None)
assert_true(device.has_temperature_sensor)
assert_true(device.has_button)
assert_false(device.battery_low)
eq_(device.battery_level, 100)
assert_false(device.tx_busy)
button = device.get_button_by_ain("12345 0000001-1")
eq_(button.name, "Taster Wohnzimmer: Oben rechts")
eq_(button.last_pressed, 1608557681)
button = device.get_button_by_ain("12345 0000001-2")
eq_(button.name, "Taster Wohnzimmer: Unten rechts")
eq_(button.last_pressed, 1608557682)
class TestFritzhomeDeviceTemperature(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_get_temperature(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7"),
"245",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_temperature(), 24.5)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "gettemperature",
"sid": None
},
)
class TestFritzhomeDeviceAlarm(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_device_alert_on(self):
self.mock.side_effect = [
Helper.response("alarm/device_alert_on"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("05333 0077045-1")
assert_true(device.present)
eq_(device.alert_state, True)
def test_device_alert_off(self):
self.mock.side_effect = [
Helper.response("alarm/device_alert_off"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("05333 0077045-2")
assert_true(device.present)
eq_(device.alert_state, False)
def test_device_alert_no_alertstate(self):
self.mock.side_effect = [
Helper.response("alarm/device_alert_no_alertstate"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("05333 0077045-3")
assert_true(device.present)
eq_(device.alert_state, None)
def test_magenta_smoke_alarm(self):
self.mock.side_effect = [
Helper.response("alarm/device_magenta_smoke_alarm"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("11324 0244498-1")
assert_true(device.present)
eq_(device.alert_state, None)
class TestFritzhomeDevicePowermeter(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_get_switch_power(self):
self.mock.side_effect = [
Helper.response("powermeter/device_list"),
"18000",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
eq_(device.get_switch_power(), 18000)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchpower",
"sid": None
},
)
def test_get_switch_energy(self):
self.mock.side_effect = [
Helper.response("powermeter/device_list"),
"2000",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
eq_(device.get_switch_energy(), 2000)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchenergy",
"sid": None
},
)
class TestFritzhomeDeviceSwitch(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_get_switch_state(self):
self.mock.side_effect = [
Helper.response("switch/device_list"),
"1",
"0",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
assert_true(device.get_switch_state())
assert_false(device.get_switch_state())
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"ain": u"08761 0000434", "switchcmd": "getswitchstate", "sid": None},
)
def test_set_switch_state_toggle(self):
self.mock.side_effect = [
Helper.response("switch/device_list"),
"1",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
device.set_switch_state_toggle()
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"ain": u"08761 0000434", "switchcmd": "setswitchtoggle", "sid": None},
)
def test_set_switch_state_on(self):
self.mock.side_effect = [
Helper.response("switch/device_list"),
"1",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
device.set_switch_state_on()
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"ain": u"08761 0000434", "switchcmd": "setswitchon", "sid": None},
)
def test_set_switch_state_off(self):
self.mock.side_effect = [
Helper.response("switch/device_list"),
"1",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
device.set_switch_state_off()
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"ain": u"08761 0000434", "switchcmd": "setswitchoff", "sid": None},
)
class TestFritzhomeDeviceThermostat(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_device_hkr_fw_03_50(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fw_03_50"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
assert_true(device.present)
eq_(device.device_lock, None)
eq_(device.lock, None)
eq_(device.error_code, None)
eq_(device.battery_low, None)
def test_device_hkr_fw_03_54(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fw_03_54"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("23456")
assert_true(device.present)
def test_get_target_temperature(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7"),
"38",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_target_temperature(), 19.0)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "gethkrtsoll",
"sid": None
},
)
def test_get_eco_temperature(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7"),
"40",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_eco_temperature(), 20.0)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "gethkrabsenk",
"sid": None
},
)
def test_get_comfort_temperature(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7"),
"41",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_comfort_temperature(), 20.5)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "gethkrkomfort",
"sid": None
},
)
def test_hkr_without_temperature_values(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_no_temp_values"),
]
element = self.fritz.get_device_element("11960 0071472")
device = FritzhomeDevice(node=element)
eq_(device.ain, "11960 0071472")
eq_(device.offset, None)
eq_(device.temperature, None)
def test_hkr_get_state_on(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_on"),
Helper.response("thermostat/device_hkr_state_on"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "on")
def test_hkr_get_state_off(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_off"),
Helper.response("thermostat/device_hkr_state_off"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "off")
def test_hkr_get_state_eco(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_eco"),
Helper.response("thermostat/device_hkr_state_eco"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "eco")
def test_hkr_get_state_comfort(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_comfort"),
Helper.response("thermostat/device_hkr_state_comfort"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "comfort")
def test_hkr_get_state_manual(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_manual"),
Helper.response("thermostat/device_hkr_state_manual"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "manual")
def test_hkr_set_state_on(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_manual"),
Helper.response("thermostat/device_hkr_state_manual"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
device.set_hkr_state("on")
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "sethkrtsoll",
"param": 254,
"sid": None
},
)
def test_hkr_set_state_off(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_state_manual"),
Helper.response("thermostat/device_hkr_state_manual"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
device.set_hkr_state("off")
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "sethkrtsoll",
"param": 253,
"sid": None
},
)
def test_hkr_battery_level(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.battery_level, 70)
def test_hkr_window_open(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.window_open, False)
def test_hkr_summer_active(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.summer_active, True)
def test_hkr_holiday_active(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.holiday_active, False)
def test_hkr_nextchange_endperiod(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.nextchange_endperiod, 1538341200)
def test_hkr_nextchange_temperature(self):
self.mock.side_effect = [
Helper.response("thermostat/device_hkr_fritzos_7")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.nextchange_temperature, 21.0)
class TestFritzhomeDeviceBase(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_device_init(self):
self.mock.side_effect = [Helper.response("base/device_list")]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
eq_(device.ain, "08761 0000434")
eq_(device.fw_version, "03.33")
assert_true(device.present)
assert_true(device.has_switch)
assert_true(device.has_temperature_sensor)
assert_true(device.has_powermeter)
def test_device_init_present_false(self):
self.mock.side_effect = [
Helper.response("base/device_not_present"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("11960 0089208")
eq_(device.ain, "11960 0089208")
assert_false(device.present)
def test_device_init_no_devicelock_element(self):
self.mock.side_effect = [
Helper.response("base/device_no_devicelock_element"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0373130")
eq_(device.ain, "08761 0373130")
assert_true(device.present)
def test_device_umlaut(self):
self.mock.side_effect = [
Helper.response("base/device_with_umlaut_in_name"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0373130")
eq_(device.ain, "08761 0373130")
eq_(device.name, u"äöü")
def test_device_update(self):
self.mock.side_effect = [
Helper.response("thermostat/device_list_battery_ok"),
Helper.response("thermostat/device_list_battery_low"),
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("11959 0171328")
assert_false(device.battery_low)
device.update()
assert_true(device.battery_low)
def test_get_device_present(self):
self.mock.side_effect = [
Helper.response("base/device_list"),
"1",
"0",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("08761 0000434")
assert_true(device.get_present())
assert_false(device.get_present())
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchpresent",
"sid": None
},
)
class TestDevice(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome('10.0.0.1', 'user', 'pass')
self.fritz._request = self.mock
def test_device_init(self):
self.mock.side_effect = [
device_list_xml,
]
device = self.fritz.get_device_by_ain('08761 0000434')
eq_(device.ain, '08761 0000434')
eq_(device.fw_version, '03.33')
assert_true(device.present)
assert_true(device.has_switch)
assert_true(device.has_temperature_sensor)
assert_true(device.has_powermeter)
def test_device_init_present_false(self):
self.mock.side_effect = [
device_not_present_xml,
]
device = self.fritz.get_device_by_ain('11960 0089208')
eq_(device.ain, '11960 0089208')
assert_false(device.present)
def test_device_init_no_devicelock_element(self):
self.mock.side_effect = [
device_no_devicelock_element_xml,
]
device = self.fritz.get_device_by_ain('08761 0373130')
eq_(device.ain, '08761 0373130')
assert_true(device.present)
def test_device_umlaut(self):
self.mock.side_effect = [
device_with_umlaut_in_name_xml,
]
device = self.fritz.get_device_by_ain('08761 0373130')
eq_(device.ain, '08761 0373130')
eq_(device.name, u'äöü')
def test_device_hkr_fw_03_50(self):
self.mock.side_effect = [
device_hkr_fw_03_50_xml,
]
device = self.fritz.get_device_by_ain('12345')
assert_true(device.present)
eq_(device.device_lock, None)
eq_(device.lock, None)
eq_(device.error_code, None)
eq_(device.battery_low, None)
def test_device_hkr_fw_03_54(self):
self.mock.side_effect = [
device_hkr_fw_03_54_xml,
]
device = self.fritz.get_device_by_ain('23456')
assert_true(device.present)
def test_device_alert_on(self):
self.mock.side_effect = [
device_alert_on_xml,
]
device = self.fritz.get_device_by_ain('05333 0077045-1')
assert_true(device.present)
eq_(device.alert_state, True)
def test_device_alert_off(self):
self.mock.side_effect = [
device_alert_off_xml,
]
device = self.fritz.get_device_by_ain('05333 0077045-2')
assert_true(device.present)
eq_(device.alert_state, False)
def test_device_alert_no_alertstate(self):
self.mock.side_effect = [
device_alert_no_alertstate_xml,
]
device = self.fritz.get_device_by_ain('05333 0077045-3')
assert_true(device.present)
eq_(device.alert_state, None)
def test_device_update(self):
self.mock.side_effect = [
device_list_battery_ok_xml,
device_list_battery_low_xml,
]
device = self.fritz.get_device_by_ain('11959 0171328')
assert_false(device.battery_low)
device.update()
assert_true(device.battery_low)
def test_get_device_present(self):
self.mock.side_effect = ['1', '0']
device = get_switch_test_device()
device._fritz._request = self.mock
assert_true(device.get_present())
assert_false(device.get_present())
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'getswitchpresent',
'sid': None
})
def test_get_switch_state(self):
self.mock.side_effect = ['1', '0']
device = get_switch_test_device()
device._fritz._request = self.mock
assert_true(device.get_switch_state())
assert_false(device.get_switch_state())
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'getswitchstate',
'sid': None
})
def test_set_switch_state(self):
device = get_switch_test_device()
device._fritz._request = self.mock
device.set_switch_state_on()
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'setswitchon',
'sid': None
})
device.set_switch_state_off()
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'setswitchoff',
'sid': None
})
device.set_switch_state_toggle()
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'setswitchtoggle',
'sid': None
})
def test_get_switch_power(self):
self.mock.side_effect = [
'18000',
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_switch_power(), 18000)
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'getswitchpower',
'sid': None
})
def test_get_switch_energy(self):
self.mock.side_effect = [
'2000',
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_switch_energy(), 2000)
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'getswitchenergy',
'sid': None
})
def test_get_temperature(self):
self.mock.side_effect = [
'245',
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_temperature(), 24.5)
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'gettemperature',
'sid': None
})
def test_get_target_temperature(self):
self.mock.side_effect = [
'38',
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_target_temperature(), 19.0)
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'gethkrtsoll',
'sid': None
})
def test_get_eco_temperature(self):
self.mock.side_effect = [
'40',
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_eco_temperature(), 20.0)
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'gethkrabsenk',
'sid': None
})
def test_get_comfort_temperature(self):
self.mock.side_effect = [
'41',
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_comfort_temperature(), 20.5)
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'08761 0000434',
'switchcmd': 'gethkrkomfort',
'sid': None
})
def test_hkr_without_temperature_values(self):
self.mock.side_effect = [
device_hkr_no_temp_values_xml,
]
element = self.fritz.get_device_element('11960 0071472')
device = FritzhomeDevice(node=element)
eq_(device.ain, '11960 0071472')
eq_(device.offset, None)
eq_(device.temperature, None)
def test_hkr_get_state_on(self):
self.mock.side_effect = [
device_hkr_state_on_xml,
device_hkr_state_on_xml,
]
device = self.fritz.get_device_by_ain('12345')
eq_(device.get_hkr_state(), 'on')
def test_hkr_get_state_off(self):
self.mock.side_effect = [
device_hkr_state_off_xml,
device_hkr_state_off_xml,
]
device = self.fritz.get_device_by_ain('12345')
eq_(device.get_hkr_state(), 'off')
def test_hkr_get_state_eco(self):
self.mock.side_effect = [
device_hkr_state_eco_xml,
device_hkr_state_eco_xml,
]
device = self.fritz.get_device_by_ain('12345')
eq_(device.get_hkr_state(), 'eco')
def test_hkr_get_state_comfort(self):
self.mock.side_effect = [
device_hkr_state_comfort_xml,
device_hkr_state_comfort_xml,
]
device = self.fritz.get_device_by_ain('12345')
eq_(device.get_hkr_state(), 'comfort')
def test_hkr_get_state_manual(self):
self.mock.side_effect = [
device_hkr_state_manual_xml,
device_hkr_state_manual_xml,
]
device = self.fritz.get_device_by_ain('12345')
eq_(device.get_hkr_state(), 'manual')
def test_hkr_set_state_on(self):
self.mock.side_effect = [
device_hkr_state_manual_xml,
device_hkr_state_manual_xml,
]
device = self.fritz.get_device_by_ain('12345')
device.set_hkr_state('on')
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'12345',
'switchcmd': 'sethkrtsoll',
'param': 254,
'sid': None
})
def test_hkr_set_state_off(self):
self.mock.side_effect = [
device_hkr_state_manual_xml,
device_hkr_state_manual_xml,
]
device = self.fritz.get_device_by_ain('12345')
device.set_hkr_state('off')
device._fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'ain': u'12345',
'switchcmd': 'sethkrtsoll',
'param': 253,
'sid': None
})
def test_hkr_battery_level(self):
self.mock.side_effect = [device_hkr_fritzos_7_xml]
device = self.fritz.get_device_by_ain('12345')
eq_(device.battery_level, 70)
def test_hkr_window_open(self):
self.mock.side_effect = [device_hkr_fritzos_7_xml]
device = self.fritz.get_device_by_ain('12345')
eq_(device.window_open, False)
def test_hkr_summer_active(self):
self.mock.side_effect = [device_hkr_fritzos_7_xml]
device = self.fritz.get_device_by_ain('12345')
eq_(device.summer_active, True)
def test_hkr_holiday_active(self):
self.mock.side_effect = [device_hkr_fritzos_7_xml]
device = self.fritz.get_device_by_ain('12345')
eq_(device.holiday_active, False)
def test_magenta_smoke_alarm(self):
self.mock.side_effect = [
device_magenta_smoke_alarm_xml,
]
device = self.fritz.get_device_by_ain('11324 0244498-1')
assert_true(device.present)
eq_(device.alert_state, None)
class TestFritzhomeDeviceLightBulb(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
self.fritz._devices = {}
def test_device_init(self):
self.mock.side_effect = [
Helper.response("lightbulb/device_FritzDECT500_34_12_16")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.ain, "12345")
eq_(device.fw_version, "34.10.16.16.009")
assert_true(device.present) # Lightbulb has power and is connected
# Get sub-device
device = self.fritz.get_device_by_ain("12345-1")
assert_true(device.has_lightbulb)
assert_true(device.state) # Lightbulb is switched on
eq_(device.color_mode, "1")
eq_(device.supported_color_mode, "5")
eq_(device.hue, 358)
eq_(device.saturation, 180)
eq_(device.color_temp, None)
eq_(device.name, u"FRITZ!DECT 500 Büro")
def test_device_init_color_temp_mode(self):
self.mock.side_effect = [
Helper.response("lightbulb/device_FritzDECT500_34_12_16_color_temp_mode")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345")
eq_(device.ain, "12345")
eq_(device.fw_version, "34.10.16.16.009")
assert_true(device.present) # Lightbulb has power and is connected
# Get sub-device
device = self.fritz.get_device_by_ain("12345-1")
assert_true(device.has_lightbulb)
assert_true(device.state) # Lightbulb is switched on
eq_(device.color_mode, "4")
eq_(device.supported_color_mode, "5")
eq_(device.hue, None)
eq_(device.saturation, None)
eq_(device.color_temp, 2800)
eq_(device.name, u"FRITZ!DECT 500 Büro")
def test_get_colors(self):
self.mock.side_effect = [
Helper.response("lightbulb/device_FritzDECT500_34_12_16")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345-1")
self.mock.side_effect = [
Helper.response("lightbulb/getcolors_FritzDECT500_34_12_16")
]
colors = device.get_colors()
expected_colors = {
'Rot': [
('358', '180', '230'),
('358', '112', '237'),
('358', '54', '245')
],
'Orange': [
('35', '214', '255'),
('35', '140', '255'),
('35', '72', '255')
],
'Gelb': [
('52', '153', '252'),
('52', '102', '252'),
('52', '51', '255')
],
'Grasgrün': [
('92', '123', '248'),
('92', '79', '250'),
('92', '38', '252')
],
'Grün': [
('120', '160', '220'),
('120', '82', '232'),
('120', '38', '242')
],
'Türkis': [
('160', '145', '235'),
('160', '84', '242'),
('160', '41', '248')
],
'Cyan': [
('195', '179', '255'),
('195', '118', '255'),
('195', '59', '255')
],
'Himmelblau': [
('212', '169', '252'),
('212', '110', '252'),
('212', '56', '255')
],
'Blau': [
('225', '204', '255'),
('225', '135', '255'),
('225', '67', '255')
],
'Violett': [
('266', '169', '250'),
('266', '110', '250'),
('266', '54', '252')
],
'Magenta': [
('296', '140', '250'),
('296', '92', '252'),
('296', '46', '255')
],
'Pink': [
('335', '180', '255'),
('335', '107', '248'),
('335', '51', '250')
]
}
eq_(colors, expected_colors)
def test_get_color_temps(self):
self.mock.side_effect = [
Helper.response("lightbulb/device_FritzDECT500_34_12_16")
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345-1")
self.mock.side_effect = [
Helper.response("lightbulb/getcolors_FritzDECT500_34_12_16")
]
temps = device.get_color_temps()
expected_temps = [
'2700',
'3000',
'3400',
'3800',
'4200',
'4700',
'5300',
'5900',
'6500'
]
eq_(temps, expected_temps)
def test_set_color(self):
self.mock.side_effect = [
Helper.response("lightbulb/device_FritzDECT500_34_12_16"),
"1",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345-1")
device.set_color(["180", "200"], 0)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"switchcmd": "setcolor", "sid": None, "hue": 180, "saturation": 200, "duration": 0, "ain": "12345-1"},
)
def test_set_unmapped_color(self):
self.mock.side_effect = [
Helper.response("lightbulb/device_FritzDECT500_34_12_16"),
"1",
]
self.fritz.update_devices()
device = self.fritz.get_device_by_ain("12345-1")
device.set_unmapped_color(["180", "200"], 0)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"switchcmd": "setunmappedcolor", "sid": None, "hue": 180, "saturation": 200, "duration": 0, "ain": "12345-1"},
)
class TestFritzhome(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
@raises(LoginError)
def test_login_fail(self):
self.mock.side_effect = [
response("login_rsp_without_valid_sid"),
response("login_rsp_without_valid_sid"),
]
self.fritz.login()
def test_login(self):
self.mock.side_effect = [
response("login_rsp_without_valid_sid"),
response("login_rsp_with_valid_sid"),
]
self.fritz.login()
def test_logout(self):
self.fritz.logout()
self.fritz._request.assert_called_with(
"http://10.0.0.1/login_sid.lua",
{"sid": None, "security:command/logout": "1"},
)
def test_aha_request(self):
self.fritz._aha_request(cmd="testcmd")
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"sid": None, "switchcmd": "testcmd"},
)
self.fritz._aha_request(cmd="testcmd", ain="1")
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"sid": None, "switchcmd": "testcmd", "ain": "1"},
)
self.fritz._aha_request(cmd="testcmd", ain="1", param={"a": "1", "b": "2"})
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"sid": None,
"switchcmd": "testcmd",
"ain": "1",
"param": {"a": "1", "b": "2"},
},
)
@raises(InvalidError)
def test_aha_request_invalid(self):
self.mock.side_effect = [
"inval",
]
self.fritz._aha_request(cmd="estcmd")
def test_get_device_element(self):
self.mock.side_effect = [
response("device_list"),
response("device_list"),
response("device_list"),
]
element = self.fritz.get_device_element("08761 0000434")
eq_(element.attrib["identifier"], "08761 0000434")
eq_(element.attrib["fwversion"], "03.33")
element = self.fritz.get_device_element("08761 1048079")
eq_(element.attrib["identifier"], "08761 1048079")
eq_(element.attrib["fwversion"], "03.44")
element = self.fritz.get_device_element("unknown")
eq_(element, None)
def test_get_device_by_ain(self):
self.mock.side_effect = [
response("device_list"),
response("device_list"),
]
device = self.fritz.get_device_by_ain("08761 0000434")
eq_(device.ain, "08761 0000434")
def test_aha_get_devices(self):
self.mock.side_effect = [
response("device_list"),
]
devices = self.fritz.get_devices()
eq_(devices[0].name, "Steckdose")
eq_(devices[1].name, "FRITZ!DECT Rep 100 #1")
def test_get_device_name(self):
self.mock.side_effect = ["testname"]
eq_(self.fritz.get_device_name(ain="1234"), "testname")
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"sid": None, "ain": "1234", "switchcmd": "getswitchname"},
)
def test_set_target_temperature(self):
self.fritz.set_target_temperature("1", 25.5)
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"sid": None, "ain": "1", "switchcmd": "sethkrtsoll", "param": 51},
)
self.fritz.set_target_temperature("1", 0.0)
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"sid": None, "ain": "1", "switchcmd": "sethkrtsoll", "param": 253},
)
self.fritz.set_target_temperature("1", 32.0)
self.fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{"sid": None, "ain": "1", "switchcmd": "sethkrtsoll", "param": 254},
)
def test_get_alert_state(self):
self.mock.side_effect = [
response("device_list"),
]
eq_(self.fritz.get_alert_state("05333 0077045-1"), True)
class TestDevice(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome("10.0.0.1", "user", "pass")
self.fritz._request = self.mock
def test_device_init(self):
self.mock.side_effect = [response("device_list")]
device = self.fritz.get_device_by_ain("08761 0000434")
eq_(device.ain, "08761 0000434")
eq_(device.fw_version, "03.33")
assert_true(device.present)
assert_true(device.has_switch)
assert_true(device.has_temperature_sensor)
assert_true(device.has_powermeter)
def test_device_init_present_false(self):
self.mock.side_effect = [
response("device_not_present"),
]
device = self.fritz.get_device_by_ain("11960 0089208")
eq_(device.ain, "11960 0089208")
assert_false(device.present)
def test_device_init_no_devicelock_element(self):
self.mock.side_effect = [
response("device_no_devicelock_element"),
]
device = self.fritz.get_device_by_ain("08761 0373130")
eq_(device.ain, "08761 0373130")
assert_true(device.present)
def test_device_umlaut(self):
self.mock.side_effect = [
response("device_with_umlaut_in_name"),
]
device = self.fritz.get_device_by_ain("08761 0373130")
eq_(device.ain, "08761 0373130")
eq_(device.name, u"äöü")
def test_device_hkr_fw_03_50(self):
self.mock.side_effect = [
response("device_hkr_fw_03_50"),
]
device = self.fritz.get_device_by_ain("12345")
assert_true(device.present)
eq_(device.device_lock, None)
eq_(device.lock, None)
eq_(device.error_code, None)
eq_(device.battery_low, None)
def test_device_hkr_fw_03_54(self):
self.mock.side_effect = [
response("device_hkr_fw_03_54"),
]
device = self.fritz.get_device_by_ain("23456")
assert_true(device.present)
def test_device_alert_on(self):
self.mock.side_effect = [
response("device_alert_on"),
]
device = self.fritz.get_device_by_ain("05333 0077045-1")
assert_true(device.present)
eq_(device.alert_state, True)
def test_device_alert_off(self):
self.mock.side_effect = [
response("device_alert_off"),
]
device = self.fritz.get_device_by_ain("05333 0077045-2")
assert_true(device.present)
eq_(device.alert_state, False)
def test_device_alert_no_alertstate(self):
self.mock.side_effect = [
response("device_alert_no_alertstate"),
]
device = self.fritz.get_device_by_ain("05333 0077045-3")
assert_true(device.present)
eq_(device.alert_state, None)
def test_device_update(self):
self.mock.side_effect = [
response("device_list_battery_ok"),
response("device_list_battery_low"),
]
device = self.fritz.get_device_by_ain("11959 0171328")
assert_false(device.battery_low)
device.update()
assert_true(device.battery_low)
def test_get_device_present(self):
self.mock.side_effect = ["1", "0"]
device = get_switch_test_device()
device._fritz._request = self.mock
assert_true(device.get_present())
assert_false(device.get_present())
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchpresent",
"sid": None
},
)
def test_get_switch_state(self):
self.mock.side_effect = ["1", "0"]
device = get_switch_test_device()
device._fritz._request = self.mock
assert_true(device.get_switch_state())
assert_false(device.get_switch_state())
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchstate",
"sid": None
},
)
def test_set_switch_state(self):
device = get_switch_test_device()
device._fritz._request = self.mock
device.set_switch_state_on()
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "setswitchon",
"sid": None
},
)
device.set_switch_state_off()
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "setswitchoff",
"sid": None
},
)
device.set_switch_state_toggle()
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "setswitchtoggle",
"sid": None
},
)
def test_get_switch_power(self):
self.mock.side_effect = [
"18000",
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_switch_power(), 18000)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchpower",
"sid": None
},
)
def test_get_switch_energy(self):
self.mock.side_effect = [
"2000",
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_switch_energy(), 2000)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "getswitchenergy",
"sid": None
},
)
def test_get_temperature(self):
self.mock.side_effect = [
"245",
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_temperature(), 24.5)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "gettemperature",
"sid": None
},
)
def test_get_target_temperature(self):
self.mock.side_effect = [
"38",
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_target_temperature(), 19.0)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "gethkrtsoll",
"sid": None
},
)
def test_get_eco_temperature(self):
self.mock.side_effect = [
"40",
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_eco_temperature(), 20.0)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "gethkrabsenk",
"sid": None
},
)
def test_get_comfort_temperature(self):
self.mock.side_effect = [
"41",
]
device = get_switch_test_device()
device._fritz._request = self.mock
eq_(device.get_comfort_temperature(), 20.5)
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"08761 0000434",
"switchcmd": "gethkrkomfort",
"sid": None
},
)
def test_hkr_without_temperature_values(self):
self.mock.side_effect = [
response("device_hkr_no_temp_values"),
]
element = self.fritz.get_device_element("11960 0071472")
device = FritzhomeDevice(node=element)
eq_(device.ain, "11960 0071472")
eq_(device.offset, None)
eq_(device.temperature, None)
def test_hkr_get_state_on(self):
self.mock.side_effect = [
response("device_hkr_state_on"),
response("device_hkr_state_on"),
]
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "on")
def test_hkr_get_state_off(self):
self.mock.side_effect = [
response("device_hkr_state_off"),
response("device_hkr_state_off"),
]
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "off")
def test_hkr_get_state_eco(self):
self.mock.side_effect = [
response("device_hkr_state_eco"),
response("device_hkr_state_eco"),
]
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "eco")
def test_hkr_get_state_comfort(self):
self.mock.side_effect = [
response("device_hkr_state_comfort"),
response("device_hkr_state_comfort"),
]
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "comfort")
def test_hkr_get_state_manual(self):
self.mock.side_effect = [
response("device_hkr_state_manual"),
response("device_hkr_state_manual"),
]
device = self.fritz.get_device_by_ain("12345")
eq_(device.get_hkr_state(), "manual")
def test_hkr_set_state_on(self):
self.mock.side_effect = [
response("device_hkr_state_manual"),
response("device_hkr_state_manual"),
]
device = self.fritz.get_device_by_ain("12345")
device.set_hkr_state("on")
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "sethkrtsoll",
"param": 254,
"sid": None
},
)
def test_hkr_set_state_off(self):
self.mock.side_effect = [
response("device_hkr_state_manual"),
response("device_hkr_state_manual"),
]
device = self.fritz.get_device_by_ain("12345")
device.set_hkr_state("off")
device._fritz._request.assert_called_with(
"http://10.0.0.1/webservices/homeautoswitch.lua",
{
"ain": u"12345",
"switchcmd": "sethkrtsoll",
"param": 253,
"sid": None
},
)
def test_hkr_battery_level(self):
self.mock.side_effect = [response("device_hkr_fritzos_7")]
device = self.fritz.get_device_by_ain("12345")
eq_(device.battery_level, 70)
def test_hkr_window_open(self):
self.mock.side_effect = [response("device_hkr_fritzos_7")]
device = self.fritz.get_device_by_ain("12345")
eq_(device.window_open, False)
def test_hkr_summer_active(self):
self.mock.side_effect = [response("device_hkr_fritzos_7")]
device = self.fritz.get_device_by_ain("12345")
eq_(device.summer_active, True)
def test_hkr_holiday_active(self):
self.mock.side_effect = [response("device_hkr_fritzos_7")]
device = self.fritz.get_device_by_ain("12345")
eq_(device.holiday_active, False)
def test_magenta_smoke_alarm(self):
self.mock.side_effect = [
response("device_magenta_smoke_alarm"),
]
device = self.fritz.get_device_by_ain("11324 0244498-1")
assert_true(device.present)
eq_(device.alert_state, None)
class TestFritzhome(object):
def setup(self):
self.mock = MagicMock()
self.fritz = Fritzhome('10.0.0.1', 'user', 'pass')
self.fritz._request = self.mock
@raises(LoginError)
def test_login_fail(self):
self.mock.side_effect = [
login_rsp_without_valid_sid,
login_rsp_without_valid_sid,
]
self.fritz.login()
def test_login(self):
self.mock.side_effect = [
login_rsp_without_valid_sid,
login_rsp_with_valid_sid,
]
self.fritz.login()
def test_logout(self):
self.fritz.logout()
self.fritz._request.assert_called_with(
'http://10.0.0.1/login_sid.lua', {
'sid': None,
'security:command/logout': '1'
})
def test_aha_request(self):
self.fritz._aha_request(cmd='testcmd')
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'switchcmd': 'testcmd'
})
self.fritz._aha_request(cmd='testcmd', ain='1')
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'switchcmd': 'testcmd',
'ain': '1'
})
self.fritz._aha_request(cmd='testcmd',
ain='1',
param={
'a': '1',
'b': '2'
})
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'switchcmd': 'testcmd',
'ain': '1',
'param': {
'a': '1',
'b': '2'
}
})
@raises(InvalidError)
def test_aha_request_invalid(self):
self.mock.side_effect = [
'inval',
]
self.fritz._aha_request(cmd='estcmd')
def test_get_device_element(self):
self.mock.side_effect = [
device_list_xml,
device_list_xml,
device_list_xml,
]
element = self.fritz.get_device_element('08761 0000434')
eq_(element.getAttribute('identifier'), '08761 0000434')
eq_(element.getAttribute('fwversion'), '03.33')
element = self.fritz.get_device_element('08761 1048079')
eq_(element.getAttribute('identifier'), '08761 1048079')
eq_(element.getAttribute('fwversion'), '03.44')
element = self.fritz.get_device_element('unknown')
eq_(element, None)
def test_get_device_by_ain(self):
self.mock.side_effect = [
device_list_xml,
device_list_xml,
]
device = self.fritz.get_device_by_ain('08761 0000434')
eq_(device.ain, '08761 0000434')
def test_aha_get_devices(self):
self.mock.side_effect = [
device_list_xml,
]
devices = self.fritz.get_devices()
eq_(devices[0].name, 'Steckdose')
eq_(devices[1].name, 'FRITZ!DECT Rep 100 #1')
def test_get_device_name(self):
self.mock.side_effect = ['testname']
eq_(self.fritz.get_device_name(ain='1234'), 'testname')
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'ain': '1234',
'switchcmd': 'getswitchname'
})
def test_set_target_temperature(self):
self.fritz.set_target_temperature('1', 25.5)
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'ain': '1',
'switchcmd': 'sethkrtsoll',
'param': 51
})
self.fritz.set_target_temperature('1', 0.0)
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'ain': '1',
'switchcmd': 'sethkrtsoll',
'param': 253
})
self.fritz.set_target_temperature('1', 32.0)
self.fritz._request.assert_called_with(
'http://10.0.0.1/webservices/homeautoswitch.lua', {
'sid': None,
'ain': '1',
'switchcmd': 'sethkrtsoll',
'param': 254
})
def test_get_alert_state(self):
self.mock.side_effect = [
device_list_xml,
]
eq_(self.fritz.get_alert_state('05333 0077045-1'), True)
class AVM_smarthome(SmartPlugin):
"""
Main class of the Plugin. Does all plugin specific stuff and provides
the update functions for the items
"""
PLUGIN_VERSION = '1.0.0' # (must match the version specified in plugin.yaml)
def __init__(self, sh):
"""
Initalizes the plugin.
If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for
a reference to the sh object any more.
Plugins have to use the new way of getting parameter values:
use the SmartPlugin method get_parameter_value(parameter_name). Anywhere within the Plugin you can get
the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It
returns the value in the datatype that is defined in the metadata.
"""
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self._cycle = self.get_parameter_value(
'cycle'
) # the frequency in seconds how often the query shoud be done
self.host = self.get_parameter_value(
'host') # IP Adress of the fritzbox
self.user = self.get_parameter_value('username') # Username
self.password = self.get_parameter_value('password') # Password
# Initialization code goes here
self.fritzbox = None
self.alive = False
self._items = []
self._devices = []
# On initialization error use:
# self._init_complete = False
# return
# if plugin should start even without web interface
self.init_webinterface()
# if plugin should not start without web interface
# if not self.init_webinterface():
# self._init_complete = False
self.connect()
return
def run(self):
"""
Run method for the plugin
"""
self.logger.debug("Run method called")
self.scheduler_add('poll_device', self.poll_device, cycle=self._cycle)
self.alive = True
def stop(self):
"""
Stop method for the plugin
"""
self.logger.debug("Stop method called")
self.disconnect()
self.alive = False
def connect(self):
"""
Connects to the AVM Fritzbox
"""
try:
self.fritzbox = Fritzhome(host=self.host,
user=self.user,
password=self.password)
self.fritzbox.login()
self.logger.debug('Login to Fritz!Box {} as {} successful.'.format(
self.host, self.user))
except LoginError:
self.logger.debug('Login to Fritz!Box {} as {} failed.'.format(
self.host, self.user))
def disconnect(self):
"""
Disconnects from the AVM Fritzbox
"""
if self.fritzbox is not None:
self.fritzbox.logout()
self.logger.debug('Logout successful')
def reconnect(self):
"""
Reconnects to the call monitor of the AVM device
"""
self.disconnect()
self.connect()
def parse_item(self, item):
"""
Default plugin parse_item method. Is called when the plugin is initialized.
The plugin can, corresponding to its attribute keywords, decide what to do with
the item in future, like adding it to an internal array for future reference
:param item: The item to process.
:return: If the plugin needs to be informed of an items change you should return a call back function
like the function update_item down below. An example when this is needed is the knx plugin
where parse_item returns the update_item function when the attribute knx_send is found.
This means that when the items value is about to be updated, the call back function is called
with the item, caller, source and dest as arguments and in case of the knx plugin the value
can be sent to the knx with a knx write function within the knx plugin.
"""
# Process the update config
if self.has_iattr(item.conf, 'avm_smarthome_update'):
self.log_debug(
"Item for requesting AVM Smarthome update found: {}".format(
item))
return self.update_item
# Process the device items
if self.has_iattr(item.conf, 'avm_ain'):
self.logger.debug('parse item: {}'.format(item))
self._devices.append(item)
#self.logger.debug(self._devices)
# Process the items read config
if self.has_iattr(item.conf, 'avm_smarthome_data'):
self.logger.debug('parse item: {}'.format(item))
self._items.append(item)
#self.logger.debug(self._items)
# Process the item write config
if self.get_iattr_value(item.conf, 'avm_smarthome_data') in [
'set_switch_state', 'set_switch_state_toggle',
'set_temperature'
]:
self.logger.debug('Update item: {}'.format(item))
return self.update_item
def parse_logic(self, logic):
"""
Default plugin parse_logic method
"""
if 'xxx' in logic.conf:
# self.function(logic['name'])
pass
def update_item(self, item, caller=None, source=None, dest=None):
"""
Item has been updated
This method is called, if the value of an item has been updated by SmartHomeNG.
It should write the changed value out to the device (hardware/interface) that
is managed by this plugin.
:param item: item to be updated towards the plugin
:param caller: if given it represents the callers name
:param source: if given it represents the source
:param dest: if given it represents the dest
"""
if self.alive and caller != self.get_shortname():
# code to execute if the plugin is not stopped
# and only, if the item has not been changed by this this plugin:
self.logger.info(
"Update item: {}, item has been changed outside this plugin".
format(item.id()))
if self.get_iattr_value(item.conf,
'avm_smarthome_data') == 'set_temperature':
self.logger.debug(
"update_item was called with item '{}' from caller '{}', source '{}' and dest '{}'"
.format(item, caller, source, dest))
cmd_temperature = float(item())
self.logger.debug("cmd_temp is: {0}".format(cmd_temperature))
parentItem = item.return_parent()
ainDevice = '0'
if isinstance(parentItem.conf['avm_ain'], str):
ainDevice = parentItem.conf['avm_ain']
else:
self.logger.error('device ain is not a string value')
self.logger.info("Target ain is {0}".format(ainDevice))
self.fritzbox.set_target_temperature(ainDevice,
cmd_temperature)
if self.get_iattr_value(
item.conf, 'avm_smarthome_data') == 'set_switch_state':
self.logger.debug(
"update_item was called with item '{}' from caller '{}', source '{}' and dest '{}'"
.format(item, caller, source, dest))
state = bool(item())
parentItem = item.return_parent()
ainDevice = '0'
if isinstance(parentItem.conf['avm_ain'], str):
ainDevice = parentItem.conf['avm_ain']
else:
self.logger.error('device ain is not a string value')
self.logger.info("Target ain is {0}".format(ainDevice))
if state is True:
self.fritzbox.set_switch_state_on(ainDevice)
else:
self.fritzbox.set_switch_state_off(ainDevice)
if self.get_iattr_value(
item.conf,
'avm_smarthome_data') == 'set_switch_state_toggle':
self.logger.debug(
"update_item was called with item '{}' from caller '{}', source '{}' and dest '{}'"
.format(item, caller, source, dest))
state = bool(item())
parentItem = item.return_parent()
ainDevice = '0'
if isinstance(parentItem.conf['avm_ain'], str):
ainDevice = parentItem.conf['avm_ain']
else:
self.logger.error('device ain is not a string value')
self.logger.info("Target ain is {0}".format(ainDevice))
self.fritzbox.set_switch_state_toggle(ainDevice)
pass
def poll_device(self):
"""
This method gets called by scheduler and queries all data
"""
self.logger.debug('Starting update loop for instance {}.'.format(
self.get_instance_name()))
for item in self._devices:
if self.has_iattr(item.conf, 'avm_ain'):
avm_ain = self.get_iattr_value(item.conf, 'avm_ain')
device = self.fritzbox.get_device_by_ain(avm_ain)
if device.present == True:
for child in item.return_children():
if self.has_iattr(child.conf, 'avm_smarthome_data'):
if self.get_iattr_value(
child.conf, 'avm_smarthome_data') == 'name':
child(device.name, self.get_shortname())
elif self.get_iattr_value(
child.conf, 'avm_smarthome_data') == 'ain':
child(device.ain, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'identifier':
child(device.identifier, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'productname':
child(device.productname, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'manufacturer':
child(device.manufacturer, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'firmware_version':
child(device.fw_version, self.get_shortname())
elif self.get_iattr_value(
child.conf, 'avm_smarthome_data') == 'present':
child(device.present, self.get_shortname())
elif self.get_iattr_value(
child.conf, 'avm_smarthome_data') == 'lock':
child(device.lock, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'device_lock':
child(device.device_lock, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'has_switch':
child(device.has_switch, self.get_shortname())
elif self.get_iattr_value(
child.conf, 'avm_smarthome_data'
) == 'has_temperature_sensor':
child(device.has_temperature_sensor,
self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'has_thermostat':
child(device.has_thermostat, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'has_alarm':
child(device.has_alarm, self.get_shortname())
if device.has_switch:
if self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'switch_state':
child(device.switch_state,
self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'power':
child(device.power, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'energy':
child(device.energy, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'voltage':
child(device.voltage, self.get_shortname())
if device.has_temperature_sensor:
if self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'temperature':
child(device.temperature, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'offset':
child(device.offset, self.get_shortname())
if device.has_thermostat:
if self.get_iattr_value(child.conf,
'avm_smarthome_data'
) == 'actual_temperature':
child(device.actual_temperature,
self.get_shortname())
elif self.get_iattr_value(
child.conf, 'avm_smarthome_data'
) == 'target_temperature':
child(device.target_temperature,
self.get_shortname())
elif self.get_iattr_value(
child.conf, 'avm_smarthome_data'
) == 'comfort_temperature':
child(device.comfort_temperature,
self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'eco_temperature':
child(device.eco_temperature,
self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'battery_low':
child(device.battery_low, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'battery_level':
child(device.battery_level,
self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'window_open':
child(device.window_open, self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'summer_active':
child(device.summer_active,
self.get_shortname())
elif self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'holiday_active':
child(device.holiday_active,
self.get_shortname())
if device.has_alarm:
if self.get_iattr_value(
child.conf,
'avm_smarthome_data') == 'alert_state':
child(device.alert_state, self.get_shortname())
else:
self.logger.debug(
'Requested device with AIN {} is not present.'.format(
avm_ain))
pass
def init_webinterface(self):
""""
Initialize the web interface for this plugin
This method is only needed if the plugin is implementing a web interface
"""
try:
self.mod_http = Modules.get_instance().get_module(
'http'
) # try/except to handle running in a core version that does not support modules
except:
self.mod_http = None
if self.mod_http == None:
self.logger.error("Not initializing the web interface")
return False
import sys
if not "SmartPluginWebIf" in list(
sys.modules['lib.model.smartplugin'].__dict__):
self.logger.warning(
"Web interface needs SmartHomeNG v1.5 and up. Not initializing the web interface"
)
return False
# set application configuration for cherrypy
webif_dir = self.path_join(self.get_plugin_dir(), 'webif')
config = {
'/': {
'tools.staticdir.root': webif_dir,
},
'/static': {
'tools.staticdir.on': True,
'tools.staticdir.dir': 'static'
}
}
# Register the web interface as a cherrypy app
self.mod_http.register_webif(WebInterface(webif_dir, self),
self.get_shortname(),
config,
self.get_classname(),
self.get_instance_name(),
description='')
return True
