from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import BinarySensor, BinarySensorInfo # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the sensor sensor_info = BinarySensorInfo(name="MySensor", device_class="motion") settings = Settings(mqtt=mqtt_settings, entity=sensor_info) # Instantiate the sensor mysensor = BinarySensor(settings) # Change the state of the sensor, publishing an MQTT message that gets picked up by HA mysensor.on() mysensor.off() # Or, change the state using a boolean mysensor.update_state(True) mysensor.update_state(False) # You can also set custom attributes on the sensor via a Python dict mysensor.set_attributes({"my attribute": "awesome"})

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Button, ButtonInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the button button_info = ButtonInfo(name="test") settings = Settings(mqtt=mqtt_settings, entity=button_info) # To receive button commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): perform_my_custom_action() # Instantiate the button my_button = Button(settings, my_callback) # Publish the button's discoverability message to let HA automatically notice it my_button.write_config()

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Camera, CameraInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the camera camera_info = CameraInfo(name="test", topic="zanzito/shared_locations/my-device") settings = Settings(mqtt=mqtt_settings, entity=camera_info) # To receive state commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): payload = message.payload.decode() perform_my_custom_action() # Instantiate the camera my_camera = Camera(settings, my_callback) # Set the initial state of the cover, which also makes it discoverable my_camera.set_topic("zanzito/shared_locations/my-device") # not needed if already defined

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Cover, CoverInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the cover cover_info = CoverInfo(name="test") settings = Settings(mqtt=mqtt_settings, entity=cover_info) # To receive state commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): payload = message.payload.decode() if payload == "OPEN": # let HA know that the cover is opening my_cover.opening() # call function to open cover open_my_custom_cover() # Let HA know that the cover was opened my_cover.open() if payload == "CLOSE": # let HA know that the cover is closing my_cover.closing() # call function to close the cover close_my_custom_cover() # Let HA know that the cover was closed my_cover.closed() if payload == "STOP": # call function to stop the cover stop_my_custom_cover() # Let HA know that the cover was stopped my_cover.stopped() # Instantiate the cover my_cover = Cover(settings, my_callback) # Set the initial state of the cover, which also makes it discoverable my_cover.closed()

from ha_mqtt_discoverable import Settings, DeviceInfo from ha_mqtt_discoverable.sensors import BinarySensor, BinarySensorInfo # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Define the device. At least one of `identifiers` or `connections` must be supplied device_info = DeviceInfo(name="My device", identifiers="device_id") # Associate the sensor with the device via the `device` parameter # `unique_id` must also be set, otherwise Home Assistant will not display the device in the UI motion_sensor_info = BinarySensorInfo(name="My motion sensor", device_class="motion", unique_id="my_motion_sensor", device=device_info) motion_settings = Settings(mqtt=mqtt_settings, entity=motion_sensor_info) # Instantiate the sensor motion_sensor = BinarySensor(motion_settings) # Change the state of the sensor, publishing an MQTT message that gets picked up by HA motion_sensor.on() # An additional sensor can be added to the same device, by re-using the DeviceInfo instance previously defined door_sensor_info = BinarySensorInfo(name="My door sensor", device_class="door", unique_id="my_door_sensor", device=device_info) door_settings = Settings(mqtt=mqtt_settings, entity=door_sensor_info) # Instantiate the sensor door_sensor = BinarySensor(door_settings) # Change the state of the sensor, publishing an MQTT message that gets picked up by HA door_sensor.on() # The two sensors should be visible inside Home Assistant under the device `My device`

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import DeviceInfo, DeviceTriggerInfo, DeviceTrigger # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Define the device. At least one of `identifiers` or `connections` must be supplied device_info = DeviceInfo(name="My device", identifiers="device_id") # Associate the sensor with the device via the `device` parameter trigger_info = DeviceTriggerInfo(name="MyTrigger", type="button_press", subtype="button_1", unique_id="my_device_trigger", device=device_info) settings = Settings(mqtt=mqtt_settings, entity=trigger_info) # Instantiate the device trigger mytrigger = DeviceTrigger(settings) # Generate a device trigger event, publishing an MQTT message that gets picked up by HA # Optionally include a payload as part of the event mytrigger.trigger("My custom payload")

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Image, ImageInfo # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the image image_info = ImageInfo(name="test", url_topic="topic_to_publish_image_url_to") settings = Settings(mqtt=mqtt_settings, entity=image_info) # Instantiate the image my_image = Image(settings) # Publish an image URL to url_topic my_image.set_url("http://camera.local/latest.jpg")

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Image, ImageInfo from base64 import b64encode # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the image image_info = ImageInfo(name="test", image_topic="topic_to_publish_image_payload_to", image_encoding="b64", content_type="image/png") settings = Settings(mqtt=mqtt_settings, entity=image_info) # Instantiate the image my_image = Image(settings) # Set the image payload with open("example.png", "rb") as example_file: example_blob = b64encode(example_file.read()) my_image.set_payload(example_blob)

import json from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Light, LightInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the light light_info = LightInfo( name="test_light", brightness=True, color_mode=True, supported_color_modes=["rgb"], effect=True, effect_list=["blink", "my_custom_effect"]) settings = Settings(mqtt=mqtt_settings, entity=light_info) # To receive state commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): # Make sure received payload is JSON try: payload = json.loads(message.payload.decode()) except ValueError: print("Ony JSON schema is supported for light entities!") return # Parse received dictionary if "color" in payload: set_color_of_my_light() my_light.color("rgb", payload["color"]) elif "brightness" in payload: set_brightness_of_my_light() my_light.brightness(payload["brightness"]) elif "effect" in payload: set_effect_of_my_light() my_light.effect(payload["effect"]) elif "state" in payload: if payload["state"] == light_info.payload_on: turn_on_my_light() my_light.on() else: turn_off_my_light() my_light.off() else: print("Unknown payload") # Instantiate the light my_light = Light(settings, my_callback) # Set the initial state of the light, which also makes it discoverable my_light.off()

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Lock, LockInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the lock lock_info = LockInfo(name="test") settings = Settings(mqtt=mqtt_settings, entity=lock_info) # To receive state commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): payload = message.payload.decode() if payload == my_lock._entity.payload_lock: # let HA know that the lock is locking my_lock.locking() # call function to lock the lock lock_my_custom_lock() # Let HA know that the lock is locked now my_lock.locked() if payload == my_lock._entity.payload_unlock: # let HA know that the lock is unlocking my_lock.unlocking() # call function to unlock the lock unlock_my_custom_lock() # Let HA know that the lock is unlocked now my_lock.unlocked() # Instantiate the lock my_lock = Lock(settings, my_callback) # Set the initial state of the lock, which also makes it discoverable my_lock.locked()

import logging from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Number, NumberInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the `number` entity. number_info = NumberInfo(name="test", min=0, max=50, mode="slider", step=5) settings = Settings(mqtt=mqtt_settings, entity=number_info) # To receive number updates from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): number = int(message.payload.decode()) logging.info(f"Received {number} from HA") do_some_custom_thing(number) # Send an MQTT message to confirm to HA that the number was changed my_number.set_value(number) # Instantiate the number my_number = Number(settings, my_callback) # Set the initial number displayed in HA UI, publishing an MQTT message that gets picked up by HA my_number.set_value(42.0)

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Select, SelectInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the switch select_info = SelectInfo(name="test", options=["option1", "option2", "option3"]) settings = Settings(mqtt=mqtt_settings, entity=select_info) # To receive state commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): payload = message.payload.decode() do_something() # Instantiate the selection my_selection = Select(settings, my_callback) # Publish the select's discovery message to let HA automatically notice it my_selection.write_config() # Or select the initial option of the selection, which also makes it discoverable my_selection.select_option("option1")

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Sensor, SensorInfo # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the sensor sensor_info = SensorInfo( name="MyTemperatureSensor", device_class="temperature", unit_of_measurement="°C", ) settings = Settings(mqtt=mqtt_settings, entity=sensor_info) # Instantiate the sensor mysensor = Sensor(settings) # Change the state of the sensor, publishing an MQTT message that gets picked up by HA mysensor.set_state(20.5)

from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Switch, SwitchInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the switch switch_info = SwitchInfo(name="test") settings = Settings(mqtt=mqtt_settings, entity=switch_info) # To receive state commands from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): payload = message.payload.decode() if payload == "ON": turn_my_custom_thing_on() # Let HA know that the switch was successfully activated my_switch.on() elif payload == "OFF": turn_my_custom_thing_off() # Let HA know that the switch was successfully deactivated my_switch.off() # Instantiate the switch my_switch = Switch(settings, my_callback) # Set the initial state of the switch, which also makes it discoverable my_switch.off()

import logging from ha_mqtt_discoverable import Settings from ha_mqtt_discoverable.sensors import Text, TextInfo from paho.mqtt.client import Client, MQTTMessage # Configure the required parameters for the MQTT broker mqtt_settings = Settings.MQTT(host="localhost") # Information about the `text` entity text_info = TextInfo(name="test") settings = Settings(mqtt=mqtt_settings, entity=text_info) # To receive text updates from HA, define a callback function: def my_callback(client: Client, user_data, message: MQTTMessage): text = message.payload.decode() logging.info(f"Received {text} from HA") do_some_custom_thing(text) # Send an MQTT message to confirm to HA that the text was changed my_text.set_text(text) # Instantiate the text my_text = Text(settings, my_callback) # Set the initial text displayed in HA UI, publishing an MQTT message that gets picked up by HA my_text.set_text("Some awesome text")

from ha_mqtt_discoverable import Settings from paho.mqtt.client import Client # Creating the MQTT client client = Client() # Doing other stuff with the client, like connecting to the broker # ... # Providing the client to the Settings object # In this case, no other MQTT settings are needed mqtt_settings = Settings.MQTT(client=client) # Continue with the rest of the code as usual