Python core.HomeAssistant方法代码示例

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def dummy_repository_base(repository=None):
    if repository is None:
        repository = HacsRepository()
    repository.hacs.hass = HomeAssistant()
    repository.hacs.hass.data = {"custom_components": []}
    repository.hacs.system.config_path = tempfile.gettempdir()
    repository.logger = Logger("hacs.test.test")
    repository.data.full_name = "test/test"
    repository.data.domain = "test"
    repository.data.last_version = "3"
    repository.data.selected_tag = "3"
    repository.ref = version_to_install(repository)
    repository.integration_manifest = {"config_flow": False, "domain": "test"}
    repository.data.published_tags = ["1", "2", "3"]
    repository.data.update_data(repository_data)
    return repository 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def async_options_updated(hass: HomeAssistant, entry: ConfigEntry):
    """Edit visonic entry."""
    log.info("************* update connection here ************** {0}".format(entry.entry_id))
    #log.info("     options {0}".format(entry.options))
    #log.info("     data    {0}".format(entry.data))

    client = hass.data[DOMAIN][DOMAINCLIENT][entry.unique_id]

    # convert python map to dictionary
    conf = {}
    # the entry.data dictionary contains all the old data used on creation and is a complete set
    for k in entry.data:
        conf[k] = entry.data[k]
    # the entry.config dictionary contains the latest/updated values but may not be a complete set
    for k in entry.options:
        conf[k] = entry.options[k]
       
    # save the parameters for control flow editing
    set_defaults(conf)
    
    # update the client parameter set
    client.updateConfig(conf)
    
    return True 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Set up Home Connect from a config entry."""
    implementation = await config_entry_oauth2_flow.async_get_config_entry_implementation(
        hass, entry
    )

    hc_api = api.ConfigEntryAuth(hass, entry, implementation)

    hass.data[DOMAIN][entry.entry_id] = hc_api

    await update_all_devices(hass, entry)

    for component in PLATFORMS:
        hass.async_create_task(
            hass.config_entries.async_forward_entry_setup(entry, component)
        )

    return True 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def all(self, hass: HomeAssistant = None, init_flag: bool = False) -> list:
        if not self._devices_cache or init_flag:
            self._devices_cache.clear()
            for device_id, device_attributes in hass.data[INTEGRATION][DATA_HAVCS_ITEMS].items():
                if ATTR_DEVICE_VISABLE not in device_attributes:
                    pass
                elif isinstance(device_attributes.get(ATTR_DEVICE_VISABLE) , str) and self._platform == device_attributes.get(ATTR_DEVICE_VISABLE):
                    pass
                elif isinstance(device_attributes.get(ATTR_DEVICE_VISABLE) , list) and self._platform in device_attributes.get(ATTR_DEVICE_VISABLE):
                    pass
                else:
                    continue
                if isinstance(device_attributes.get(ATTR_DEVICE_ENTITY_ID) , str):
                    device_attributes[ATTR_DEVICE_ENTITY_ID]= [device_attributes.get(ATTR_DEVICE_ENTITY_ID)]

                self._devices_cache.update(self.get(device_id, hass, device_attributes))

        return list(self._devices_cache.values()) 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def _create_entities(hass: HomeAssistant, entry: dict):
    entities = []

    controller = hass.data[DOMAIN][entry.entry_id]["controller"]
    coordinator = hass.data[DOMAIN][entry.entry_id]["coordinator"]
    name = entry.data[CONF_NAME]

    entities.append(ControllerOperationSwitch(entry, name, controller, coordinator))

    for _, program in controller.programs.items():
        entities.append(ProgramEnabledSwitch(entry, name, program, coordinator))

    for _, station in controller.stations.items():
        entities.append(StationEnabledSwitch(entry, name, station, coordinator))

    return entities 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def _create_entities(hass: HomeAssistant, entry: dict):
    entities = []

    controller = hass.data[DOMAIN][entry.entry_id]["controller"]
    coordinator = hass.data[DOMAIN][entry.entry_id]["coordinator"]
    name = entry.data[CONF_NAME]

    entities.append(
        ControllerSensorActive(entry, name, "sensor_1", controller, coordinator)
    )
    entities.append(
        ControllerSensorActive(entry, name, "sensor_2", controller, coordinator)
    )
    entities.append(
        ControllerSensorActive(entry, name, "rain_delay", controller, coordinator)
    )

    for _, program in controller.programs.items():
        entities.append(ProgramIsRunningBinarySensor(entry, name, program, coordinator))

    for _, station in controller.stations.items():
        entities.append(StationIsRunningBinarySensor(entry, name, station, coordinator))

    return entities 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def _create_entities(hass: HomeAssistant, entry: dict):
    entities = []

    controller = hass.data[DOMAIN][entry.entry_id]["controller"]
    coordinator = hass.data[DOMAIN][entry.entry_id]["coordinator"]
    name = entry.data[CONF_NAME]

    entities.append(LastRunSensor(entry, name, controller, coordinator))
    entities.append(RainDelayStopTimeSensor(entry, name, controller, coordinator))
    entities.append(WaterLevelSensor(entry, name, controller, coordinator))
    entities.append(FlowRateSensor(entry, name, controller, coordinator))

    for _, station in controller.stations.items():
        entities.append(StationStatusSensor(entry, name, station, coordinator))

    return entities 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
    """Handle removal of an entry."""
    coordinator = hass.data[DOMAIN][entry.entry_id]
    unloaded = all(
        await asyncio.gather(
            *[
                hass.config_entries.async_forward_entry_unload(entry, platform)
                for platform in PLATFORMS
                if platform in coordinator.platforms
            ]
        )
    )
    if unloaded:
        hass.data[DOMAIN].pop(entry.entry_id)

    return unloaded 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def test_save(tmpdir):
    hass = HomeAssistant()
    hass.config.config_dir = tmpdir.dirname
    await async_save_to_store(hass, "repositories", REPOSITORIES) 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def test_load(tmpdir):
    hass = HomeAssistant()
    hass.config.config_dir = tmpdir.dirname

    repositories = await async_load_from_store(hass, "repositories")
    assert repositories["999999"]["name"] == "test1"

    repositories = await async_load_from_store(hass, "does_not_exist")
    assert not repositories 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def test_setup_platform():
    await async_setup_platform(hass, {}, mock_setup) 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def test_setup_entry():
    await async_setup_entry(hass, {}, mock_setup) 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def async_setup_entry( hass: HomeAssistant, entry: ConfigEntry, async_add_entities ) -> None:
    """Set up the Visonic Alarm Binary Sensors"""
    if DOMAIN in hass.data:
        client = hass.data[DOMAIN][DOMAINCLIENT][entry.unique_id]
        devices = [
            VisonicSwitch(hass, client, device)
            for device in hass.data[DOMAIN]['switch']   
        ]
        hass.data[DOMAIN]["switch"] = list()
        async_add_entities(devices) 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def __init__(self, hass: HomeAssistant, client, visonic_device):
        """Initialise a Visonic X10 Device."""
        #_LOGGER.info("Creating X10 Switch {0}".format(visonic_device.name))
        self.client = client
        self.visonic_device = visonic_device
        self.x10id = self.visonic_device.id
        self._name = "Visonic " + self.visonic_device.name
        # Append device id to prevent name clashes in HA.
        self.visonic_id = slugify(self._name) # VISONIC_ID_FORMAT.format( slugify(self._name), visonic_device.getDeviceID())
        self.entity_id = ENTITY_ID_FORMAT.format(self.visonic_id)
        self.current_value = self.visonic_device.state
        self.visonic_device.install_change_handler(self.onChange) 

# 需要导入模块: from homeassistant import core [as 别名]
# 或者: from homeassistant.core import HomeAssistant [as 别名]
def async_setup_entry( hass: HomeAssistant, entry: ConfigEntry, async_add_entities ) -> None:
    """Set up the Visonic Alarm Binary Sensors"""
    
    _LOGGER.info("************* binary sensor async_setup_entry **************")
    #_LOGGER.info("     options {0}".format(entry.options))
    #_LOGGER.info("     data    {0}".format(entry.data))
    
#    @callback
#    def async_add_binary_sensor(binary_sensor):
#        """Add Visonic binary sensor."""
#        _LOGGER.info(f"   got device {binary_sensor.getDeviceID()}")
#        async_add_entities([binary_sensor], True)

#    async_dispatcher_connect(hass, "visonic_new_binary_sensor", async_add_binary_sensor)

    if DOMAIN in hass.data:
        _LOGGER.info("   In binary sensor async_setup_entry")
        sensors = [
            VisonicSensor(device)
            for device in hass.data[DOMAIN]['binary_sensor']   
        ]
        # empty the list as we have copied the entries so far in to sensors
        hass.data[DOMAIN]["binary_sensor"] = list()       
        async_add_entities(sensors, True)

#   Each Sensor in Visonic Alarms can be Armed/Bypassed individually