async def async_setup(hass, config):
"""Set up the Ness Alarm platform."""
from nessclient import Client, ArmingState
conf = config[DOMAIN]
zones = conf[CONF_ZONES]
host = conf[CONF_DEVICE_HOST]
port = conf[CONF_DEVICE_PORT]
client = Client(host=host, port=port, loop=hass.loop)
hass.data[DATA_NESS] = client
async def _close(event):
await client.close()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _close)
hass.async_create_task(
async_load_platform(hass, 'binary_sensor', DOMAIN, {CONF_ZONES: zones},
config))
hass.async_create_task(
async_load_platform(hass, 'alarm_control_panel', DOMAIN, {}, config))
def on_zone_change(zone_id: int, state: bool):
"""Receives and propagates zone state updates."""
async_dispatcher_send(hass, SIGNAL_ZONE_CHANGED,
ZoneChangedData(
zone_id=zone_id,
state=state,
))
def on_state_change(arming_state: ArmingState):
"""Receives and propagates arming state updates."""
async_dispatcher_send(hass, SIGNAL_ARMING_STATE_CHANGED, arming_state)
client.on_zone_change(on_zone_change)
client.on_state_change(on_state_change)
# Force update for current arming status and current zone states
hass.loop.create_task(client.keepalive())
hass.loop.create_task(client.update())
async def handle_panic(call):
await client.panic(call.data[ATTR_CODE])
async def handle_aux(call):
await client.aux(call.data[ATTR_OUTPUT_ID], call.data[ATTR_STATE])
hass.services.async_register(DOMAIN,
SERVICE_PANIC,
handle_panic,
schema=SERVICE_SCHEMA_PANIC)
hass.services.async_register(DOMAIN,
SERVICE_AUX,
handle_aux,
schema=SERVICE_SCHEMA_AUX)
return True
async def async_setup(hass, config):
"""Set up the Ness Alarm platform."""
from nessclient import Client, ArmingState
conf = config[DOMAIN]
zones = conf[CONF_ZONES]
host = conf[CONF_HOST]
port = conf[CONF_DEVICE_PORT]
scan_interval = conf[CONF_SCAN_INTERVAL]
infer_arming_state = conf[CONF_INFER_ARMING_STATE]
client = Client(host=host, port=port, loop=hass.loop,
update_interval=scan_interval.total_seconds(),
infer_arming_state=infer_arming_state)
hass.data[DATA_NESS] = client
async def _close(event):
await client.close()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _close)
hass.async_create_task(
async_load_platform(hass, 'binary_sensor', DOMAIN, {CONF_ZONES: zones},
config))
hass.async_create_task(
async_load_platform(hass, 'alarm_control_panel', DOMAIN, {}, config))
def on_zone_change(zone_id: int, state: bool):
"""Receives and propagates zone state updates."""
async_dispatcher_send(hass, SIGNAL_ZONE_CHANGED, ZoneChangedData(
zone_id=zone_id,
state=state,
))
def on_state_change(arming_state: ArmingState):
"""Receives and propagates arming state updates."""
async_dispatcher_send(hass, SIGNAL_ARMING_STATE_CHANGED, arming_state)
client.on_zone_change(on_zone_change)
client.on_state_change(on_state_change)
# Force update for current arming status and current zone states
hass.loop.create_task(client.keepalive())
hass.loop.create_task(client.update())
async def handle_panic(call):
await client.panic(call.data[ATTR_CODE])
async def handle_aux(call):
await client.aux(call.data[ATTR_OUTPUT_ID], call.data[ATTR_STATE])
hass.services.async_register(DOMAIN, SERVICE_PANIC, handle_panic,
schema=SERVICE_SCHEMA_PANIC)
hass.services.async_register(DOMAIN, SERVICE_AUX, handle_aux,
schema=SERVICE_SCHEMA_AUX)
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up the Ness Alarm platform."""
conf = config[DOMAIN]
zones = conf[CONF_ZONES]
host = conf[CONF_HOST]
port = conf[CONF_DEVICE_PORT]
scan_interval = conf[CONF_SCAN_INTERVAL]
infer_arming_state = conf[CONF_INFER_ARMING_STATE]
client = Client(
host=host,
port=port,
loop=hass.loop,
update_interval=scan_interval.total_seconds(),
infer_arming_state=infer_arming_state,
)
hass.data[DATA_NESS] = client
async def _close(event):
await client.close()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _close)
hass.async_create_task(
async_load_platform(hass, Platform.BINARY_SENSOR, DOMAIN,
{CONF_ZONES: zones}, config))
hass.async_create_task(
async_load_platform(hass, Platform.ALARM_CONTROL_PANEL, DOMAIN, {},
config))
def on_zone_change(zone_id: int, state: bool):
"""Receives and propagates zone state updates."""
async_dispatcher_send(hass, SIGNAL_ZONE_CHANGED,
ZoneChangedData(zone_id=zone_id, state=state))
def on_state_change(arming_state: ArmingState):
"""Receives and propagates arming state updates."""
async_dispatcher_send(hass, SIGNAL_ARMING_STATE_CHANGED, arming_state)
client.on_zone_change(on_zone_change)
client.on_state_change(on_state_change)
# Force update for current arming status and current zone states
hass.loop.create_task(client.keepalive())
hass.loop.create_task(client.update())
async def handle_panic(call: ServiceCall) -> None:
await client.panic(call.data[ATTR_CODE])
async def handle_aux(call: ServiceCall) -> None:
await client.aux(call.data[ATTR_OUTPUT_ID], call.data[ATTR_STATE])
hass.services.async_register(DOMAIN,
SERVICE_PANIC,
handle_panic,
schema=SERVICE_SCHEMA_PANIC)
hass.services.async_register(DOMAIN,
SERVICE_AUX,
handle_aux,
schema=SERVICE_SCHEMA_AUX)
return True
import asyncio
from nessclient import Client
loop = asyncio.get_event_loop()
host = '127.0.0.1'
port = 65432
client = Client(host=host, port=port, loop=loop)
# Send arming command via library abstraction
loop.run_until_complete(client.arm_away('1234'))
# Send panic command via library abstraction
loop.run_until_complete(client.panic('1234'))
# Send disarm command via library abstraction
loop.run_until_complete(client.disarm('1234'))
# Send aux control command for output 2 via library abstraction
loop.run_until_complete(client.aux(2))
# Send custom command
# In this instance, we are sending a status update command to view
# output status
loop.run_until_complete(client.send_command('S15'))
client.close()
loop.close()
import asyncio
from nessclient import Client, ArmingState, BaseEvent
loop = asyncio.get_event_loop()
host = '127.0.0.1'
port = 65432
client = Client(host=host, port=port, loop=loop)
@client.on_zone_change
def on_zone_change(zone: int, triggered: bool):
print('Zone {} changed to {}'.format(zone, triggered))
@client.on_state_change
def on_state_change(state: ArmingState):
print('Alarm state changed to {}'.format(state))
@client.on_event_received
def on_event_received(event: BaseEvent):
print('Event received:', event)
loop.run_until_complete(asyncio.gather(
client.keepalive(),
client.update(),
))
client.close()
async def async_setup(opp, config):
"""Set up the Ness Alarm platform."""
conf = config[DOMAIN]
zones = conf[CONF_ZONES]
host = conf[CONF_HOST]
port = conf[CONF_DEVICE_PORT]
scan_interval = conf[CONF_SCAN_INTERVAL]
infer_arming_state = conf[CONF_INFER_ARMING_STATE]
client = Client(
host=host,
port=port,
loop=opp.loop,
update_interval=scan_interval.total_seconds(),
infer_arming_state=infer_arming_state,
)
opp.data[DATA_NESS] = client
async def _close(event):
await client.close()
opp.bus.async_listen_once(EVENT_OPENPEERPOWER_STOP, _close)
opp.async_create_task(
async_load_platform(opp, "binary_sensor", DOMAIN, {CONF_ZONES: zones},
config))
opp.async_create_task(
async_load_platform(opp, "alarm_control_panel", DOMAIN, {}, config))
def on_zone_change(zone_id: int, state: bool):
"""Receives and propagates zone state updates."""
async_dispatcher_send(opp, SIGNAL_ZONE_CHANGED,
ZoneChangedData(zone_id=zone_id, state=state))
def on_state_change(arming_state: ArmingState):
"""Receives and propagates arming state updates."""
async_dispatcher_send(opp, SIGNAL_ARMING_STATE_CHANGED, arming_state)
client.on_zone_change(on_zone_change)
client.on_state_change(on_state_change)
# Force update for current arming status and current zone states
opp.loop.create_task(client.keepalive())
opp.loop.create_task(client.update())
async def handle_panic(call):
await client.panic(call.data[ATTR_CODE])
async def handle_aux(call):
await client.aux(call.data[ATTR_OUTPUT_ID], call.data[ATTR_STATE])
opp.services.async_register(DOMAIN,
SERVICE_PANIC,
handle_panic,
schema=SERVICE_SCHEMA_PANIC)
opp.services.async_register(DOMAIN,
SERVICE_AUX,
handle_aux,
schema=SERVICE_SCHEMA_AUX)
return True
def client(connection, alarm) -> Client:
return Client(connection=connection, alarm=alarm)