response
stringlengths 1
33.1k
| instruction
stringlengths 22
582k
|
|---|---|
Mock Supervisor add-on store info. | def addon_store_info_fixture():
"""Mock Supervisor add-on store info."""
with patch(
"homeassistant.components.hassio.addon_manager.async_get_addon_store_info"
) as addon_store_info:
addon_store_info.return_value = {
"available": True,
"installed": None,
"state": None,
"version": "1.0.0",
}
yield addon_store_info |
Mock Supervisor add-on info. | def addon_info_fixture():
"""Mock Supervisor add-on info."""
with patch(
"homeassistant.components.hassio.addon_manager.async_get_addon_info",
) as addon_info:
addon_info.return_value = {
"available": True,
"hostname": None,
"options": {},
"state": None,
"update_available": False,
"version": None,
}
yield addon_info |
Mock set add-on options. | def set_addon_options_fixture():
"""Mock set add-on options."""
with patch(
"homeassistant.components.hassio.addon_manager.async_set_addon_options"
) as set_options:
yield set_options |
Return the install add-on side effect. | def install_addon_side_effect_fixture(addon_store_info, addon_info):
"""Return the install add-on side effect."""
async def install_addon(hass, slug):
"""Mock install add-on."""
addon_store_info.return_value = {
"installed": "1.0.0",
"state": "stopped",
"version": "1.0.0",
}
addon_info.return_value["hostname"] = "core-silabs-multiprotocol"
addon_info.return_value["state"] = "stopped"
addon_info.return_value["version"] = "1.0.0"
return install_addon |
Mock install add-on. | def mock_install_addon(install_addon_side_effect):
"""Mock install add-on."""
with patch(
"homeassistant.components.hassio.addon_manager.async_install_addon",
side_effect=install_addon_side_effect,
) as install_addon:
yield install_addon |
Mock start add-on. | def start_addon_fixture():
"""Mock start add-on."""
with patch(
"homeassistant.components.hassio.addon_manager.async_start_addon"
) as start_addon:
yield start_addon |
Fixture for a test config flow. | def config_flow_handler(hass: HomeAssistant) -> Generator[None, None, None]:
"""Fixture for a test config flow."""
with patch(
"homeassistant.components.homeassistant_hardware.silabs_multiprotocol_addon.WaitingAddonManager.async_wait_until_addon_state"
):
yield |
Mock getting yellow settings. | def mock_get_yellow_settings():
"""Mock getting yellow settings."""
with patch(
"homeassistant.components.homeassistant_yellow.config_flow.async_get_yellow_settings",
return_value={"disk_led": True, "heartbeat_led": True, "power_led": True},
) as get_yellow_settings:
yield get_yellow_settings |
Mock setting yellow settings. | def mock_set_yellow_settings():
"""Mock setting yellow settings."""
with patch(
"homeassistant.components.homeassistant_yellow.config_flow.async_set_yellow_settings",
) as set_yellow_settings:
yield set_yellow_settings |
Mock rebooting host. | def mock_reboot_host():
"""Mock rebooting host."""
with patch(
"homeassistant.components.homeassistant_yellow.config_flow.async_reboot_host",
) as reboot_host:
yield reboot_host |
Mock the iid storage. | def iid_storage(hass):
"""Mock the iid storage."""
with patch.object(AccessoryIIDStorage, "_async_schedule_save"):
yield AccessoryIIDStorage(hass, "") |
Return a custom AccessoryDriver instance for HomeKit accessory init.
This mock does not mock async_stop, so the driver will not be stopped | def run_driver(hass, event_loop, iid_storage):
"""Return a custom AccessoryDriver instance for HomeKit accessory init.
This mock does not mock async_stop, so the driver will not be stopped
"""
with (
patch("pyhap.accessory_driver.AsyncZeroconf"),
patch("pyhap.accessory_driver.AccessoryEncoder"),
patch("pyhap.accessory_driver.HAPServer"),
patch("pyhap.accessory_driver.AccessoryDriver.publish"),
patch(
"pyhap.accessory_driver.AccessoryDriver.persist",
),
):
yield HomeDriver(
hass,
pincode=b"123-45-678",
entry_id="",
entry_title="mock entry",
bridge_name=BRIDGE_NAME,
iid_storage=iid_storage,
address="127.0.0.1",
loop=event_loop,
) |
Return a custom AccessoryDriver instance for HomeKit accessory init. | def hk_driver(hass, event_loop, iid_storage):
"""Return a custom AccessoryDriver instance for HomeKit accessory init."""
with (
patch("pyhap.accessory_driver.AsyncZeroconf"),
patch("pyhap.accessory_driver.AccessoryEncoder"),
patch("pyhap.accessory_driver.HAPServer.async_stop"),
patch("pyhap.accessory_driver.HAPServer.async_start"),
patch(
"pyhap.accessory_driver.AccessoryDriver.publish",
),
patch(
"pyhap.accessory_driver.AccessoryDriver.persist",
),
):
yield HomeDriver(
hass,
pincode=b"123-45-678",
entry_id="",
entry_title="mock entry",
bridge_name=BRIDGE_NAME,
iid_storage=iid_storage,
address="127.0.0.1",
loop=event_loop,
) |
Return a custom AccessoryDriver instance for HomeKit accessory init. | def mock_hap(hass, event_loop, iid_storage, mock_zeroconf):
"""Return a custom AccessoryDriver instance for HomeKit accessory init."""
with (
patch("pyhap.accessory_driver.AsyncZeroconf"),
patch("pyhap.accessory_driver.AccessoryEncoder"),
patch("pyhap.accessory_driver.HAPServer.async_stop"),
patch("pyhap.accessory_driver.HAPServer.async_start"),
patch(
"pyhap.accessory_driver.AccessoryDriver.publish",
),
patch(
"pyhap.accessory_driver.AccessoryDriver.async_start",
),
patch(
"pyhap.accessory_driver.AccessoryDriver.async_stop",
),
patch(
"pyhap.accessory_driver.AccessoryDriver.persist",
),
):
yield HomeDriver(
hass,
pincode=b"123-45-678",
entry_id="",
entry_title="mock entry",
bridge_name=BRIDGE_NAME,
iid_storage=iid_storage,
address="127.0.0.1",
loop=event_loop,
) |
Yield caught homekit_changed events. | def events(hass):
"""Yield caught homekit_changed events."""
return async_capture_events(hass, EVENT_HOMEKIT_CHANGED) |
Clean up device tracker demo file. | def demo_cleanup(hass):
"""Clean up device tracker demo file."""
yield
with suppress(FileNotFoundError):
os.remove(hass.config.path(YAML_DEVICES)) |
Test HomeBridge class. | def test_home_bridge(hk_driver) -> None:
"""Test HomeBridge class."""
bridge = HomeBridge("hass", hk_driver, BRIDGE_NAME)
assert bridge.hass == "hass"
assert bridge.display_name == BRIDGE_NAME
assert bridge.category == 2 # Category.BRIDGE
assert len(bridge.services) == 2
serv = bridge.services[0] # SERV_ACCESSORY_INFO
assert serv.display_name == SERV_ACCESSORY_INFO
assert serv.get_characteristic(CHAR_NAME).value == BRIDGE_NAME
assert format_version(hass_version).startswith(
serv.get_characteristic(CHAR_FIRMWARE_REVISION).value
)
assert serv.get_characteristic(CHAR_MANUFACTURER).value == MANUFACTURER
assert serv.get_characteristic(CHAR_MODEL).value == BRIDGE_MODEL
assert serv.get_characteristic(CHAR_SERIAL_NUMBER).value == BRIDGE_SERIAL_NUMBER |
Test HomeBridge setup message. | def test_home_bridge_setup_message(hk_driver) -> None:
"""Test HomeBridge setup message."""
bridge = HomeBridge("hass", hk_driver, "test_name")
assert bridge.display_name == "test_name"
assert len(bridge.services) == 2
# setup_message
bridge.setup_message() |
Test HomeDriver class. | def test_home_driver(iid_storage) -> None:
"""Test HomeDriver class."""
ip_address = "127.0.0.1"
port = 51826
path = ".homekit.state"
pin = b"123-45-678"
with patch("pyhap.accessory_driver.AccessoryDriver.__init__") as mock_driver:
driver = HomeDriver(
"hass",
"entry_id",
"name",
"title",
iid_storage=iid_storage,
address=ip_address,
port=port,
persist_file=path,
)
mock_driver.assert_called_with(
address=ip_address, port=port, persist_file=path, mac=EMPTY_MAC
)
driver.state = Mock(pincode=pin, paired=False)
xhm_uri_mock = Mock(return_value="X-HM://0")
driver.accessory = Mock(display_name="any", xhm_uri=xhm_uri_mock)
# pair
with (
patch("pyhap.accessory_driver.AccessoryDriver.pair") as mock_pair,
patch(
"homeassistant.components.homekit.accessories.async_dismiss_setup_message"
) as mock_dissmiss_msg,
):
driver.pair("client_uuid", "client_public", b"1")
mock_pair.assert_called_with("client_uuid", "client_public", b"1")
mock_dissmiss_msg.assert_called_with("hass", "entry_id")
# unpair
with (
patch("pyhap.accessory_driver.AccessoryDriver.unpair") as mock_unpair,
patch(
"homeassistant.components.homekit.accessories.async_show_setup_message"
) as mock_show_msg,
):
driver.unpair("client_uuid")
mock_unpair.assert_called_with("client_uuid")
mock_show_msg.assert_called_with("hass", "entry_id", "title (any)", pin, "X-HM://0") |
Create a mock config entry with options populated. | def _mock_config_entry_with_options_populated():
"""Create a mock config entry with options populated."""
return MockConfigEntry(
domain=DOMAIN,
data={CONF_NAME: "mock_name", CONF_PORT: 12345},
options={
"filter": {
"include_domains": [
"fan",
"humidifier",
"vacuum",
"media_player",
"climate",
"alarm_control_panel",
],
"exclude_entities": ["climate.front_gate"],
},
},
) |
Iterate schema to find a key. | def _get_schema_default(schema, key_name):
"""Iterate schema to find a key."""
for schema_key in schema:
if schema_key == key_name:
return schema_key.default()
raise KeyError(f"{key_name} not found in schema") |
Test if none is returned if entity isn't supported. | def test_not_supported(caplog: pytest.LogCaptureFixture) -> None:
"""Test if none is returned if entity isn't supported."""
# not supported entity
assert get_accessory(None, None, State("demo.demo", "on"), 2, {}) is None
# invalid aid
assert get_accessory(None, None, State("light.demo", "on"), None, None) is None
assert caplog.records[0].levelname == "WARNING"
assert "invalid aid" in caplog.records[0].msg |
Test if mode isn't supported and if no supported modes. | def test_not_supported_media_player() -> None:
"""Test if mode isn't supported and if no supported modes."""
# selected mode for entity not supported
config = {CONF_FEATURE_LIST: {FEATURE_ON_OFF: None}}
entity_state = State("media_player.demo", "on")
assert get_accessory(None, None, entity_state, 2, config) is None
# no supported modes for entity
entity_state = State("media_player.demo", "on")
assert get_accessory(None, None, entity_state, 2, {}) is None |
Test with customized options. | def test_customize_options(config, name) -> None:
"""Test with customized options."""
mock_type = Mock()
conf = config.copy()
conf[ATTR_INTEGRATION] = "platform_name"
with patch.dict(TYPES, {"Light": mock_type}):
entity_state = State("light.demo", "on")
get_accessory(None, None, entity_state, 2, conf)
mock_type.assert_called_with(None, None, name, "light.demo", 2, conf) |
Test if types are associated correctly. | def test_types(type_name, entity_id, state, attrs, config) -> None:
"""Test if types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, config)
assert mock_type.called
if config:
assert mock_type.call_args[0][-1] == config |
Test if cover types are associated correctly. | def test_type_covers(type_name, entity_id, state, attrs) -> None:
"""Test if cover types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, {})
assert mock_type.called |
Test if media_player types are associated correctly. | def test_type_media_player(type_name, entity_id, state, attrs, config) -> None:
"""Test if media_player types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, config)
assert mock_type.called
if config:
assert mock_type.call_args[0][-1] == config |
Test if sensor types are associated correctly. | def test_type_sensors(type_name, entity_id, state, attrs) -> None:
"""Test if sensor types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, {})
assert mock_type.called |
Test if switch types are associated correctly. | def test_type_switches(type_name, entity_id, state, attrs, config) -> None:
"""Test if switch types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, config)
assert mock_type.called |
Test if vacuum types are associated correctly. | def test_type_vacuum(type_name, entity_id, state, attrs) -> None:
"""Test if vacuum types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, {})
assert mock_type.called |
Test if camera types are associated correctly. | def test_type_camera(type_name, entity_id, state, attrs) -> None:
"""Test if camera types are associated correctly."""
mock_type = Mock()
with patch.dict(TYPES, {type_name: mock_type}):
entity_state = State(entity_id, state, attrs)
get_accessory(None, None, entity_state, 2, {})
assert mock_type.called |
Generate an entity filter using the standard method. | def generate_filter(
include_domains,
include_entities,
exclude_domains,
exclude_entites,
include_globs=None,
exclude_globs=None,
):
"""Generate an entity filter using the standard method."""
return convert_filter(
{
CONF_INCLUDE_DOMAINS: include_domains,
CONF_INCLUDE_ENTITIES: include_entities,
CONF_EXCLUDE_DOMAINS: exclude_domains,
CONF_EXCLUDE_ENTITIES: exclude_entites,
CONF_INCLUDE_ENTITY_GLOBS: include_globs or [],
CONF_EXCLUDE_ENTITY_GLOBS: exclude_globs or [],
}
) |
Load the hk_driver fixture. | def always_patch_driver(hk_driver):
"""Load the hk_driver fixture.""" |
Patch homeassistant and pyhap functions for getting local address. | def patch_source_ip(mock_get_source_ip):
"""Patch homeassistant and pyhap functions for getting local address."""
with patch("pyhap.util.get_local_address", return_value="10.10.10.10"):
yield |
Mock ffmpeg reader. | def _mock_reader():
"""Mock ffmpeg reader."""
async def _readline(*args, **kwargs):
await asyncio.sleep(0.1)
async def _get_reader(*args, **kwargs):
return AsyncMock(readline=_readline)
return _get_reader |
Return a ffmpeg that will have an invalid pid. | def _get_exits_after_startup_mock_ffmpeg():
"""Return a ffmpeg that will have an invalid pid."""
ffmpeg = MagicMock()
type(ffmpeg.process).pid = PropertyMock(return_value=PID_THAT_WILL_NEVER_BE_ALIVE)
ffmpeg.open = AsyncMock(return_value=True)
ffmpeg.close = AsyncMock(return_value=True)
ffmpeg.kill = AsyncMock(return_value=True)
ffmpeg.get_reader = _mock_reader()
return ffmpeg |
Return a working ffmpeg. | def _get_working_mock_ffmpeg():
"""Return a working ffmpeg."""
ffmpeg = MagicMock()
ffmpeg.open = AsyncMock(return_value=True)
ffmpeg.close = AsyncMock(return_value=True)
ffmpeg.kill = AsyncMock(return_value=True)
ffmpeg.get_reader = _mock_reader()
return ffmpeg |
Return an ffmpeg that fails to shutdown. | def _get_failing_mock_ffmpeg():
"""Return an ffmpeg that fails to shutdown."""
ffmpeg = MagicMock()
type(ffmpeg.process).pid = PropertyMock(return_value=PID_THAT_WILL_NEVER_BE_ALIVE)
ffmpeg.open = AsyncMock(return_value=False)
ffmpeg.close = AsyncMock(side_effect=OSError)
ffmpeg.kill = AsyncMock(side_effect=OSError)
ffmpeg.get_reader = _mock_reader()
return ffmpeg |
Mock a socket that fails to bind failure_attempts amount of times. | def _mock_socket(failure_attempts: int = 0) -> MagicMock:
"""Mock a socket that fails to bind failure_attempts amount of times."""
mock_socket = MagicMock()
attempts = 0
def _simulate_bind(*_):
nonlocal attempts
attempts += 1
if attempts <= failure_attempts:
raise OSError
mock_socket.bind = Mock(side_effect=_simulate_bind)
return mock_socket |
Test validate entities. | def test_validate_entity_config() -> None:
"""Test validate entities."""
configs = [
None,
[],
"string",
12345,
{"invalid_entity_id": {}},
{"demo.test": 1},
{"binary_sensor.demo": {CONF_LINKED_BATTERY_SENSOR: None}},
{"binary_sensor.demo": {CONF_LINKED_BATTERY_SENSOR: "switch.demo"}},
{"binary_sensor.demo": {CONF_LOW_BATTERY_THRESHOLD: "switch.demo"}},
{"binary_sensor.demo": {CONF_LOW_BATTERY_THRESHOLD: -10}},
{"demo.test": "test"},
{"demo.test": [1, 2]},
{"demo.test": None},
{"demo.test": {CONF_NAME: None}},
{"media_player.test": {CONF_FEATURE_LIST: [{CONF_FEATURE: "invalid_feature"}]}},
{
"media_player.test": {
CONF_FEATURE_LIST: [
{CONF_FEATURE: FEATURE_ON_OFF},
{CONF_FEATURE: FEATURE_ON_OFF},
]
}
},
{"switch.test": {CONF_TYPE: "invalid_type"}},
]
for conf in configs:
with pytest.raises(vol.Invalid):
vec(conf)
assert vec({}) == {}
assert vec({"demo.test": {CONF_NAME: "Name"}}) == {
"demo.test": {CONF_NAME: "Name", CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec(
{"binary_sensor.demo": {CONF_LINKED_BATTERY_SENSOR: "sensor.demo_battery"}}
) == {
"binary_sensor.demo": {
CONF_LINKED_BATTERY_SENSOR: "sensor.demo_battery",
CONF_LOW_BATTERY_THRESHOLD: 20,
}
}
assert vec({"binary_sensor.demo": {CONF_LOW_BATTERY_THRESHOLD: 50}}) == {
"binary_sensor.demo": {CONF_LOW_BATTERY_THRESHOLD: 50}
}
assert vec({"alarm_control_panel.demo": {}}) == {
"alarm_control_panel.demo": {ATTR_CODE: None, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"alarm_control_panel.demo": {ATTR_CODE: "1234"}}) == {
"alarm_control_panel.demo": {ATTR_CODE: "1234", CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"lock.demo": {}}) == {
"lock.demo": {ATTR_CODE: None, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"lock.demo": {ATTR_CODE: "1234"}}) == {
"lock.demo": {ATTR_CODE: "1234", CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"media_player.demo": {}}) == {
"media_player.demo": {CONF_FEATURE_LIST: {}, CONF_LOW_BATTERY_THRESHOLD: 20}
}
config = {
CONF_FEATURE_LIST: [
{CONF_FEATURE: FEATURE_ON_OFF},
{CONF_FEATURE: FEATURE_PLAY_PAUSE},
]
}
assert vec({"media_player.demo": config}) == {
"media_player.demo": {
CONF_FEATURE_LIST: {FEATURE_ON_OFF: {}, FEATURE_PLAY_PAUSE: {}},
CONF_LOW_BATTERY_THRESHOLD: 20,
}
}
assert vec({"switch.demo": {CONF_TYPE: TYPE_FAUCET}}) == {
"switch.demo": {CONF_TYPE: TYPE_FAUCET, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"switch.demo": {CONF_TYPE: TYPE_OUTLET}}) == {
"switch.demo": {CONF_TYPE: TYPE_OUTLET, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"switch.demo": {CONF_TYPE: TYPE_SHOWER}}) == {
"switch.demo": {CONF_TYPE: TYPE_SHOWER, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"switch.demo": {CONF_TYPE: TYPE_SPRINKLER}}) == {
"switch.demo": {CONF_TYPE: TYPE_SPRINKLER, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"switch.demo": {CONF_TYPE: TYPE_SWITCH}}) == {
"switch.demo": {CONF_TYPE: TYPE_SWITCH, CONF_LOW_BATTERY_THRESHOLD: 20}
}
assert vec({"switch.demo": {CONF_TYPE: TYPE_VALVE}}) == {
"switch.demo": {CONF_TYPE: TYPE_VALVE, CONF_LOW_BATTERY_THRESHOLD: 20}
} |
Test validate modes for media players. | def test_validate_media_player_features() -> None:
"""Test validate modes for media players."""
config = {}
attrs = {ATTR_SUPPORTED_FEATURES: 20873}
entity_state = State("media_player.demo", "on", attrs)
assert validate_media_player_features(entity_state, config) is True
config = {FEATURE_ON_OFF: None}
assert validate_media_player_features(entity_state, config) is True
entity_state = State("media_player.demo", "on")
assert validate_media_player_features(entity_state, config) is False |
Test convert_to_float method. | def test_convert_to_float() -> None:
"""Test convert_to_float method."""
assert convert_to_float(12) == 12
assert convert_to_float(12.4) == 12.4
assert convert_to_float(STATE_UNKNOWN) is None
assert convert_to_float(None) is None |
Ensure name sanitize works as expected. | def test_cleanup_name_for_homekit() -> None:
"""Ensure name sanitize works as expected."""
assert cleanup_name_for_homekit("abc") == "abc"
assert cleanup_name_for_homekit("a b c") == "a b c"
assert cleanup_name_for_homekit("ab_c") == "ab c"
assert (
cleanup_name_for_homekit('ab!@#$%^&*()-=":.,><?//\\ frog')
== "ab--#---&----- -.,------ frog"
)
assert cleanup_name_for_homekit("の日本_語文字セット") == "の日本 語文字セット" |
Test temperature conversion from HA to HomeKit. | def test_temperature_to_homekit() -> None:
"""Test temperature conversion from HA to HomeKit."""
assert temperature_to_homekit(20.46, UnitOfTemperature.CELSIUS) == 20.5
assert temperature_to_homekit(92.1, UnitOfTemperature.FAHRENHEIT) == 33.4 |
Test temperature conversion from HomeKit to HA. | def test_temperature_to_states() -> None:
"""Test temperature conversion from HomeKit to HA."""
assert temperature_to_states(20, UnitOfTemperature.CELSIUS) == 20.0
assert temperature_to_states(20.2, UnitOfTemperature.FAHRENHEIT) == 68.5 |
Test map PM2.5 density to HomeKit AirQuality level. | def test_density_to_air_quality() -> None:
"""Test map PM2.5 density to HomeKit AirQuality level."""
assert density_to_air_quality(0) == 1
assert density_to_air_quality(12) == 1
assert density_to_air_quality(12.1) == 2
assert density_to_air_quality(35.4) == 2
assert density_to_air_quality(35.5) == 3
assert density_to_air_quality(55.4) == 3
assert density_to_air_quality(55.5) == 4
assert density_to_air_quality(150.4) == 4
assert density_to_air_quality(150.5) == 5
assert density_to_air_quality(200) == 5 |
Get next aid. | def get_next_aid():
"""Get next aid."""
return model_mixin.id_counter + 1 |
Freeze time at a known point. | def freeze_time_in_future(request):
"""Freeze time at a known point."""
now = dt_util.utcnow()
start_dt = datetime.datetime(now.year + 1, 1, 1, 0, 0, 0, tzinfo=now.tzinfo)
with freeze_time(start_dt) as frozen_time:
yield frozen_time |
Replace aiohomekit.Controller with an instance of aiohomekit.testing.FakeController. | def controller(hass):
"""Replace aiohomekit.Controller with an instance of aiohomekit.testing.FakeController."""
instance = FakeController()
with unittest.mock.patch(
"homeassistant.components.homekit_controller.utils.Controller",
return_value=instance,
):
yield instance |
Auto mock zeroconf. | def hk_mock_async_zeroconf(mock_async_zeroconf):
"""Auto mock zeroconf.""" |
Auto mock bluetooth. | def auto_mock_bluetooth(mock_bluetooth):
"""Auto mock bluetooth.""" |
Define a security-system characteristics as per page 219 of HAP spec. | def create_security_system_service(accessory):
"""Define a security-system characteristics as per page 219 of HAP spec."""
service = accessory.add_service(ServicesTypes.SECURITY_SYSTEM)
cur_state = service.add_char(CharacteristicsTypes.SECURITY_SYSTEM_STATE_CURRENT)
cur_state.value = 0
targ_state = service.add_char(CharacteristicsTypes.SECURITY_SYSTEM_STATE_TARGET)
targ_state.value = 0
# According to the spec, a battery-level characteristic is normally
# part of a separate service. However as the code was written (which
# predates this test) the battery level would have to be part of the lock
# service as it is here.
targ_state = service.add_char(CharacteristicsTypes.BATTERY_LEVEL)
targ_state.value = 50 |
Define motion characteristics as per page 225 of HAP spec. | def create_motion_sensor_service(accessory):
"""Define motion characteristics as per page 225 of HAP spec."""
service = accessory.add_service(ServicesTypes.MOTION_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.MOTION_DETECTED)
cur_state.value = 0 |
Define contact characteristics. | def create_contact_sensor_service(accessory):
"""Define contact characteristics."""
service = accessory.add_service(ServicesTypes.CONTACT_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.CONTACT_STATE)
cur_state.value = 0 |
Define smoke sensor characteristics. | def create_smoke_sensor_service(accessory):
"""Define smoke sensor characteristics."""
service = accessory.add_service(ServicesTypes.SMOKE_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.SMOKE_DETECTED)
cur_state.value = 0 |
Define carbon monoxide sensor characteristics. | def create_carbon_monoxide_sensor_service(accessory):
"""Define carbon monoxide sensor characteristics."""
service = accessory.add_service(ServicesTypes.CARBON_MONOXIDE_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.CARBON_MONOXIDE_DETECTED)
cur_state.value = 0 |
Define occupancy characteristics. | def create_occupancy_sensor_service(accessory):
"""Define occupancy characteristics."""
service = accessory.add_service(ServicesTypes.OCCUPANCY_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.OCCUPANCY_DETECTED)
cur_state.value = 0 |
Define leak characteristics. | def create_leak_sensor_service(accessory):
"""Define leak characteristics."""
service = accessory.add_service(ServicesTypes.LEAK_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.LEAK_DETECTED)
cur_state.value = 0 |
Define setup button characteristics. | def create_switch_with_setup_button(accessory):
"""Define setup button characteristics."""
service = accessory.add_service(ServicesTypes.OUTLET)
setup = service.add_char(CharacteristicsTypes.VENDOR_HAA_SETUP)
setup.value = ""
setup.format = "string"
cur_state = service.add_char(CharacteristicsTypes.ON)
cur_state.value = True
return service |
Define setup button characteristics. | def create_switch_with_ecobee_clear_hold_button(accessory):
"""Define setup button characteristics."""
service = accessory.add_service(ServicesTypes.OUTLET)
setup = service.add_char(CharacteristicsTypes.VENDOR_ECOBEE_CLEAR_HOLD)
setup.value = ""
setup.format = "string"
cur_state = service.add_char(CharacteristicsTypes.ON)
cur_state.value = True
return service |
Define camera characteristics. | def create_camera(accessory):
"""Define camera characteristics."""
accessory.add_service(ServicesTypes.CAMERA_RTP_STREAM_MANAGEMENT) |
Define thermostat characteristics. | def create_thermostat_service(accessory):
"""Define thermostat characteristics."""
service = accessory.add_service(ServicesTypes.THERMOSTAT)
char = service.add_char(CharacteristicsTypes.HEATING_COOLING_TARGET)
char.value = 0
char = service.add_char(CharacteristicsTypes.HEATING_COOLING_CURRENT)
char.value = 0
char = service.add_char(CharacteristicsTypes.FAN_STATE_TARGET)
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_COOLING_THRESHOLD)
char.minValue = 15
char.maxValue = 40
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_HEATING_THRESHOLD)
char.minValue = 4
char.maxValue = 30
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_TARGET)
char.minValue = 7
char.maxValue = 35
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_CURRENT)
char.value = 0
char = service.add_char(CharacteristicsTypes.RELATIVE_HUMIDITY_TARGET)
char.value = 0
char = service.add_char(CharacteristicsTypes.RELATIVE_HUMIDITY_CURRENT)
char.value = 0 |
Define thermostat characteristics. | def create_thermostat_service_min_max(accessory):
"""Define thermostat characteristics."""
service = accessory.add_service(ServicesTypes.THERMOSTAT)
char = service.add_char(CharacteristicsTypes.HEATING_COOLING_TARGET)
char.value = 0
char.minValue = 0
char.maxValue = 1 |
Define thermostat characteristics. | def create_thermostat_service_valid_vals(accessory):
"""Define thermostat characteristics."""
service = accessory.add_service(ServicesTypes.THERMOSTAT)
char = service.add_char(CharacteristicsTypes.HEATING_COOLING_TARGET)
char.value = 0
char.valid_values = [0, 1, 2] |
Define thermostat characteristics with a single set point in auto. | def create_thermostat_single_set_point_auto(accessory):
"""Define thermostat characteristics with a single set point in auto."""
service = accessory.add_service(ServicesTypes.THERMOSTAT)
char = service.add_char(CharacteristicsTypes.HEATING_COOLING_TARGET)
char.value = 0
char = service.add_char(CharacteristicsTypes.HEATING_COOLING_CURRENT)
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_TARGET)
char.minValue = 7
char.maxValue = 35
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_CURRENT)
char.value = 0
char = service.add_char(CharacteristicsTypes.RELATIVE_HUMIDITY_TARGET)
char.value = 0
char = service.add_char(CharacteristicsTypes.RELATIVE_HUMIDITY_CURRENT)
char.value = 0 |
Define thermostat characteristics. | def create_heater_cooler_service(accessory):
"""Define thermostat characteristics."""
service = accessory.add_service(ServicesTypes.HEATER_COOLER)
char = service.add_char(CharacteristicsTypes.TARGET_HEATER_COOLER_STATE)
char.value = 0
char = service.add_char(CharacteristicsTypes.CURRENT_HEATER_COOLER_STATE)
char.value = 0
char = service.add_char(CharacteristicsTypes.ACTIVE)
char.value = 1
char = service.add_char(CharacteristicsTypes.TEMPERATURE_COOLING_THRESHOLD)
char.minValue = 7
char.maxValue = 35
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_HEATING_THRESHOLD)
char.minValue = 7
char.maxValue = 35
char.value = 0
char = service.add_char(CharacteristicsTypes.TEMPERATURE_CURRENT)
char.value = 0
char = service.add_char(CharacteristicsTypes.SWING_MODE)
char.value = 0
char = service.add_char(CharacteristicsTypes.ROTATION_SPEED)
char.value = 100 |
Define thermostat characteristics. | def create_heater_cooler_service_min_max(accessory):
"""Define thermostat characteristics."""
service = accessory.add_service(ServicesTypes.HEATER_COOLER)
char = service.add_char(CharacteristicsTypes.TARGET_HEATER_COOLER_STATE)
char.value = 1
char.minValue = 1
char.maxValue = 2 |
Define heater-cooler characteristics. | def create_theater_cooler_service_valid_vals(accessory):
"""Define heater-cooler characteristics."""
service = accessory.add_service(ServicesTypes.HEATER_COOLER)
char = service.add_char(CharacteristicsTypes.TARGET_HEATER_COOLER_STATE)
char.value = 1
char.valid_values = [1, 2] |
Test ensure_pin_format raises for an invalid pin code. | def test_invalid_pairing_codes(pairing_code) -> None:
"""Test ensure_pin_format raises for an invalid pin code."""
with pytest.raises(aiohomekit.exceptions.MalformedPinError):
config_flow.ensure_pin_format(pairing_code) |
Test ensure_pin_format raises for an invalid setup code. | def test_insecure_pairing_codes(pairing_code) -> None:
"""Test ensure_pin_format raises for an invalid setup code."""
with pytest.raises(config_flow.InsecureSetupCode):
config_flow.ensure_pin_format(pairing_code)
config_flow.ensure_pin_format(pairing_code, allow_insecure_setup_codes=True) |
Test ensure_pin_format corrects format for a valid pin in an alternative format. | def test_valid_pairing_codes(pairing_code) -> None:
"""Test ensure_pin_format corrects format for a valid pin in an alternative format."""
valid_pin = config_flow.ensure_pin_format(pairing_code).split("-")
assert len(valid_pin) == 3
assert len(valid_pin[0]) == 3
assert len(valid_pin[1]) == 2
assert len(valid_pin[2]) == 3 |
Get the flow context from the result of async_init or async_configure. | def get_flow_context(hass, result):
"""Get the flow context from the result of async_init or async_configure."""
flow = next(
flow
for flow in hass.config_entries.flow.async_progress()
if flow["flow_id"] == result["flow_id"]
)
return flow["context"] |
Turn a aiohomekit format zeroconf entry into a homeassistant one. | def get_device_discovery_info(
device, upper_case_props=False, missing_csharp=False, paired=False
) -> zeroconf.ZeroconfServiceInfo:
"""Turn a aiohomekit format zeroconf entry into a homeassistant one."""
result = zeroconf.ZeroconfServiceInfo(
ip_address=ip_address("127.0.0.1"),
ip_addresses=[ip_address("127.0.0.1")],
hostname=device.description.name,
name=device.description.name + "._hap._tcp.local.",
port=8080,
properties={
"md": device.description.model,
"pv": "1.0",
zeroconf.ATTR_PROPERTIES_ID: device.description.id,
"c#": device.description.config_num,
"s#": device.description.state_num,
"ff": "0",
"ci": "7",
"sf": "0" if paired else "1",
"sh": "",
},
type="_hap._tcp.local.",
)
if missing_csharp:
del result.properties["c#"]
if upper_case_props:
result.properties = {
key.upper(): val for (key, val) in result.properties.items()
}
return result |
Add a bridge accessory to a test controller. | def setup_mock_accessory(controller):
"""Add a bridge accessory to a test controller."""
bridge = Accessories()
accessory = Accessory.create_with_info(
name="Koogeek-LS1-20833F",
manufacturer="Koogeek",
model="LS1",
serial_number="12345",
firmware_revision="1.1",
)
accessory.aid = 1
service = accessory.add_service(ServicesTypes.LIGHTBULB)
on_char = service.add_char(CharacteristicsTypes.ON)
on_char.value = 0
bridge.add_accessory(accessory)
return controller.add_device(bridge) |
Define a window-covering characteristics as per page 219 of HAP spec. | def create_window_covering_service(accessory):
"""Define a window-covering characteristics as per page 219 of HAP spec."""
service = accessory.add_service(ServicesTypes.WINDOW_COVERING)
cur_state = service.add_char(CharacteristicsTypes.POSITION_CURRENT)
cur_state.value = 0
targ_state = service.add_char(CharacteristicsTypes.POSITION_TARGET)
targ_state.value = 0
position_state = service.add_char(CharacteristicsTypes.POSITION_STATE)
position_state.value = 0
position_hold = service.add_char(CharacteristicsTypes.POSITION_HOLD)
position_hold.value = 0
obstruction = service.add_char(CharacteristicsTypes.OBSTRUCTION_DETECTED)
obstruction.value = False
name = service.add_char(CharacteristicsTypes.NAME)
name.value = "testdevice"
return service |
Define a window-covering characteristics as per page 219 of HAP spec. | def create_window_covering_service_with_h_tilt(accessory):
"""Define a window-covering characteristics as per page 219 of HAP spec."""
service = create_window_covering_service(accessory)
tilt_current = service.add_char(CharacteristicsTypes.HORIZONTAL_TILT_CURRENT)
tilt_current.value = 0
tilt_current.minValue = 0
tilt_current.maxValue = 90
tilt_target = service.add_char(CharacteristicsTypes.HORIZONTAL_TILT_TARGET)
tilt_target.value = 0
tilt_target.minValue = 0
tilt_target.maxValue = 90 |
Define a window-covering characteristics as per page 219 of HAP spec. | def create_window_covering_service_with_h_tilt_2(accessory):
"""Define a window-covering characteristics as per page 219 of HAP spec."""
service = create_window_covering_service(accessory)
tilt_current = service.add_char(CharacteristicsTypes.HORIZONTAL_TILT_CURRENT)
tilt_current.value = 0
tilt_current.minValue = -90
tilt_current.maxValue = 0
tilt_target = service.add_char(CharacteristicsTypes.HORIZONTAL_TILT_TARGET)
tilt_target.value = 0
tilt_target.minValue = -90
tilt_target.maxValue = 0 |
Define a window-covering characteristics as per page 219 of HAP spec. | def create_window_covering_service_with_v_tilt(accessory):
"""Define a window-covering characteristics as per page 219 of HAP spec."""
service = create_window_covering_service(accessory)
tilt_current = service.add_char(CharacteristicsTypes.VERTICAL_TILT_CURRENT)
tilt_current.value = 0
tilt_current.minValue = 0
tilt_current.maxValue = 90
tilt_target = service.add_char(CharacteristicsTypes.VERTICAL_TILT_TARGET)
tilt_target.value = 0
tilt_target.minValue = 0
tilt_target.maxValue = 90 |
Define a window-covering characteristics as per page 219 of HAP spec. | def create_window_covering_service_with_v_tilt_2(accessory):
"""Define a window-covering characteristics as per page 219 of HAP spec."""
service = create_window_covering_service(accessory)
tilt_current = service.add_char(CharacteristicsTypes.VERTICAL_TILT_CURRENT)
tilt_current.value = 0
tilt_current.minValue = -90
tilt_current.maxValue = 0
tilt_target = service.add_char(CharacteristicsTypes.VERTICAL_TILT_TARGET)
tilt_target.value = 0
tilt_target.minValue = -90
tilt_target.maxValue = 0 |
Define a garage-door-opener chars as per page 217 of HAP spec. | def create_garage_door_opener_service(accessory):
"""Define a garage-door-opener chars as per page 217 of HAP spec."""
service = accessory.add_service(ServicesTypes.GARAGE_DOOR_OPENER)
cur_state = service.add_char(CharacteristicsTypes.DOOR_STATE_CURRENT)
cur_state.value = 0
cur_state = service.add_char(CharacteristicsTypes.DOOR_STATE_TARGET)
cur_state.value = 0
obstruction = service.add_char(CharacteristicsTypes.OBSTRUCTION_DETECTED)
obstruction.value = False
name = service.add_char(CharacteristicsTypes.NAME)
name.value = "testdevice"
return service |
Stub copying the blueprints to the config folder. | def stub_blueprint_populate_autouse(stub_blueprint_populate: None) -> None:
"""Stub copying the blueprints to the config folder.""" |
Track calls to a mock service. | def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation") |
Define characteristics for a button (that is inn a group). | def create_remote(accessory):
"""Define characteristics for a button (that is inn a group)."""
service_label = accessory.add_service(ServicesTypes.SERVICE_LABEL)
char = service_label.add_char(CharacteristicsTypes.SERVICE_LABEL_NAMESPACE)
char.value = 1
for i in range(4):
button = accessory.add_service(ServicesTypes.STATELESS_PROGRAMMABLE_SWITCH)
button.linked.append(service_label)
char = button.add_char(CharacteristicsTypes.INPUT_EVENT)
char.value = 0
char.perms = ["pw", "pr", "ev"]
char = button.add_char(CharacteristicsTypes.NAME)
char.value = f"Button {i + 1}"
char = button.add_char(CharacteristicsTypes.SERVICE_LABEL_INDEX)
char.value = i
battery = accessory.add_service(ServicesTypes.BATTERY_SERVICE)
battery.add_char(CharacteristicsTypes.BATTERY_LEVEL) |
Define a button (that is not in a group). | def create_button(accessory):
"""Define a button (that is not in a group)."""
button = accessory.add_service(ServicesTypes.STATELESS_PROGRAMMABLE_SWITCH)
char = button.add_char(CharacteristicsTypes.INPUT_EVENT)
char.value = 0
char.perms = ["pw", "pr", "ev"]
char = button.add_char(CharacteristicsTypes.NAME)
char.value = "Button 1"
battery = accessory.add_service(ServicesTypes.BATTERY_SERVICE)
battery.add_char(CharacteristicsTypes.BATTERY_LEVEL) |
Define a button (that is not in a group). | def create_doorbell(accessory):
"""Define a button (that is not in a group)."""
button = accessory.add_service(ServicesTypes.DOORBELL)
char = button.add_char(CharacteristicsTypes.INPUT_EVENT)
char.value = 0
char.perms = ["pw", "pr", "ev"]
char = button.add_char(CharacteristicsTypes.NAME)
char.value = "Doorbell"
battery = accessory.add_service(ServicesTypes.BATTERY_SERVICE)
battery.add_char(CharacteristicsTypes.BATTERY_LEVEL) |
Define characteristics for a button (that is inn a group). | def create_remote(accessory):
"""Define characteristics for a button (that is inn a group)."""
service_label = accessory.add_service(ServicesTypes.SERVICE_LABEL)
char = service_label.add_char(CharacteristicsTypes.SERVICE_LABEL_NAMESPACE)
char.value = 1
for i in range(4):
button = accessory.add_service(ServicesTypes.STATELESS_PROGRAMMABLE_SWITCH)
button.linked.append(service_label)
char = button.add_char(CharacteristicsTypes.INPUT_EVENT)
char.value = 0
char.perms = ["pw", "pr", "ev"]
char = button.add_char(CharacteristicsTypes.NAME)
char.value = f"Button {i + 1}"
char = button.add_char(CharacteristicsTypes.SERVICE_LABEL_INDEX)
char.value = i
battery = accessory.add_service(ServicesTypes.BATTERY_SERVICE)
battery.add_char(CharacteristicsTypes.BATTERY_LEVEL) |
Define a button (that is not in a group). | def create_button(accessory):
"""Define a button (that is not in a group)."""
button = accessory.add_service(ServicesTypes.STATELESS_PROGRAMMABLE_SWITCH)
char = button.add_char(CharacteristicsTypes.INPUT_EVENT)
char.value = 0
char.perms = ["pw", "pr", "ev"]
char = button.add_char(CharacteristicsTypes.NAME)
char.value = "Button 1"
battery = accessory.add_service(ServicesTypes.BATTERY_SERVICE)
battery.add_char(CharacteristicsTypes.BATTERY_LEVEL) |
Define a button (that is not in a group). | def create_doorbell(accessory):
"""Define a button (that is not in a group)."""
button = accessory.add_service(ServicesTypes.DOORBELL)
char = button.add_char(CharacteristicsTypes.INPUT_EVENT)
char.value = 0
char.perms = ["pw", "pr", "ev"]
char = button.add_char(CharacteristicsTypes.NAME)
char.value = "Doorbell"
battery = accessory.add_service(ServicesTypes.BATTERY_SERVICE)
battery.add_char(CharacteristicsTypes.BATTERY_LEVEL) |
Define fan v1 characteristics as per HAP spec.
This service is no longer documented in R2 of the public HAP spec but existing
devices out there use it (like the SIMPLEconnect fan) | def create_fan_service(accessory):
"""Define fan v1 characteristics as per HAP spec.
This service is no longer documented in R2 of the public HAP spec but existing
devices out there use it (like the SIMPLEconnect fan)
"""
service = accessory.add_service(ServicesTypes.FAN)
cur_state = service.add_char(CharacteristicsTypes.ON)
cur_state.value = 0
direction = service.add_char(CharacteristicsTypes.ROTATION_DIRECTION)
direction.value = 0
speed = service.add_char(CharacteristicsTypes.ROTATION_SPEED)
speed.value = 0 |
Define fan v2 characteristics as per HAP spec. | def create_fanv2_service(accessory):
"""Define fan v2 characteristics as per HAP spec."""
service = accessory.add_service(ServicesTypes.FAN_V2)
cur_state = service.add_char(CharacteristicsTypes.ACTIVE)
cur_state.value = 0
direction = service.add_char(CharacteristicsTypes.ROTATION_DIRECTION)
direction.value = 0
speed = service.add_char(CharacteristicsTypes.ROTATION_SPEED)
speed.value = 0
swing_mode = service.add_char(CharacteristicsTypes.SWING_MODE)
swing_mode.value = 0 |
Define fan v2 with a non-standard rotation range. | def create_fanv2_service_non_standard_rotation_range(accessory):
"""Define fan v2 with a non-standard rotation range."""
service = accessory.add_service(ServicesTypes.FAN_V2)
cur_state = service.add_char(CharacteristicsTypes.ACTIVE)
cur_state.value = 0
speed = service.add_char(CharacteristicsTypes.ROTATION_SPEED)
speed.value = 0
speed.minValue = 0
speed.maxValue = 3
speed.minStep = 1 |
Define fan v2 characteristics as per HAP spec. | def create_fanv2_service_with_min_step(accessory):
"""Define fan v2 characteristics as per HAP spec."""
service = accessory.add_service(ServicesTypes.FAN_V2)
cur_state = service.add_char(CharacteristicsTypes.ACTIVE)
cur_state.value = 0
direction = service.add_char(CharacteristicsTypes.ROTATION_DIRECTION)
direction.value = 0
speed = service.add_char(CharacteristicsTypes.ROTATION_SPEED)
speed.value = 0
speed.minStep = 25
swing_mode = service.add_char(CharacteristicsTypes.SWING_MODE)
swing_mode.value = 0 |
Define fan v2 characteristics as per HAP spec. | def create_fanv2_service_without_rotation_speed(accessory):
"""Define fan v2 characteristics as per HAP spec."""
service = accessory.add_service(ServicesTypes.FAN_V2)
cur_state = service.add_char(CharacteristicsTypes.ACTIVE)
cur_state.value = 0
direction = service.add_char(CharacteristicsTypes.ROTATION_DIRECTION)
direction.value = 0
swing_mode = service.add_char(CharacteristicsTypes.SWING_MODE)
swing_mode.value = 0 |
Define a humidifier characteristics as per page 219 of HAP spec. | def create_humidifier_service(accessory):
"""Define a humidifier characteristics as per page 219 of HAP spec."""
service = accessory.add_service(ServicesTypes.HUMIDIFIER_DEHUMIDIFIER)
service.add_char(CharacteristicsTypes.ACTIVE, value=False)
cur_state = service.add_char(CharacteristicsTypes.RELATIVE_HUMIDITY_CURRENT)
cur_state.value = 0
cur_state = service.add_char(
CharacteristicsTypes.CURRENT_HUMIDIFIER_DEHUMIDIFIER_STATE
)
cur_state.value = -1
targ_state = service.add_char(
CharacteristicsTypes.TARGET_HUMIDIFIER_DEHUMIDIFIER_STATE
)
targ_state.value = 0
cur_state = service.add_char(
CharacteristicsTypes.RELATIVE_HUMIDITY_HUMIDIFIER_THRESHOLD
)
cur_state.value = 0
return service |
Define a dehumidifier characteristics as per page 219 of HAP spec. | def create_dehumidifier_service(accessory):
"""Define a dehumidifier characteristics as per page 219 of HAP spec."""
service = accessory.add_service(ServicesTypes.HUMIDIFIER_DEHUMIDIFIER)
service.add_char(CharacteristicsTypes.ACTIVE, value=False)
cur_state = service.add_char(CharacteristicsTypes.RELATIVE_HUMIDITY_CURRENT)
cur_state.value = 0
cur_state = service.add_char(
CharacteristicsTypes.CURRENT_HUMIDIFIER_DEHUMIDIFIER_STATE
)
cur_state.value = -1
targ_state = service.add_char(
CharacteristicsTypes.TARGET_HUMIDIFIER_DEHUMIDIFIER_STATE
)
targ_state.value = 0
targ_state = service.add_char(
CharacteristicsTypes.RELATIVE_HUMIDITY_DEHUMIDIFIER_THRESHOLD
)
targ_state.value = 0
return service |
Define motion characteristics as per page 225 of HAP spec. | def create_motion_sensor_service(accessory):
"""Define motion characteristics as per page 225 of HAP spec."""
service = accessory.add_service(ServicesTypes.MOTION_SENSOR)
cur_state = service.add_char(CharacteristicsTypes.MOTION_DETECTED)
cur_state.value = 0 |
Create a service to validate we can only remove dead devices. | def create_alive_service(accessory):
"""Create a service to validate we can only remove dead devices."""
service = accessory.add_service(ServicesTypes.LIGHTBULB, name=ALIVE_DEVICE_NAME)
service.add_char(CharacteristicsTypes.ON)
return service |
Define lightbulb characteristics. | def create_lightbulb_service(accessory):
"""Define lightbulb characteristics."""
service = accessory.add_service(ServicesTypes.LIGHTBULB, name=LIGHT_BULB_NAME)
on_char = service.add_char(CharacteristicsTypes.ON)
on_char.value = 0
brightness = service.add_char(CharacteristicsTypes.BRIGHTNESS)
brightness.value = 0
return service |
Define a lightbulb service with hue + saturation. | def create_lightbulb_service_with_hs(accessory):
"""Define a lightbulb service with hue + saturation."""
service = create_lightbulb_service(accessory)
hue = service.add_char(CharacteristicsTypes.HUE)
hue.value = 0
saturation = service.add_char(CharacteristicsTypes.SATURATION)
saturation.value = 0
return service |
Define a lightbulb service with color temp. | def create_lightbulb_service_with_color_temp(accessory):
"""Define a lightbulb service with color temp."""
service = create_lightbulb_service(accessory)
color_temp = service.add_char(CharacteristicsTypes.COLOR_TEMPERATURE)
color_temp.value = 0
return service |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.