aioafero.v1.controllers package

Submodules

aioafero.v1.controllers.base module

Base class for Controllers.

class aioafero.v1.controllers.base.NumbersName(unit: str, display_name: str | None = None)[source]

Bases: NamedTuple

Data used for displaying a Number.

Parameters:

  • unit (str)

  • display_name (str | None)

unit: str

Alias for field number 0

display_name: str | None

Alias for field number 1

class aioafero.v1.controllers.base.BaseResourcesController(bridge: AferoBridgeV1)[source]

Bases: Generic

Base controller for device types registered on AferoBridgeV1.

Subclasses expose typed models and action methods. Use get_device to read state and subscribe for update callbacks.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = None
ITEM_TYPES: list[ResourceTypes] | None = None
ITEM_CLS = None
ITEM_SENSORS: dict[str, str] = {}
ITEM_BINARY_SENSORS: dict[str, str] = {}
ITEM_NUMBERS: dict[tuple[str, str | None], NumbersName] = {}
ITEM_SELECTS: dict[tuple[str, str | None], str] = {}
DEVICE_SPLIT_CALLBACKS: dict[str, callable] = {}
__init__(bridge: AferoBridgeV1) → None[source]

Initialize instance.

Parameters:

bridge (AferoBridgeV1)

Return type:

None

__getitem__(device_id: str) → AferoResource[source]

Get item by device_id.

Parameters:

device_id (str)

Return type:

AferoResource

__iter__() → Iterator[source]

Iterate items.

Return type:

Iterator

__contains__(device_id: str) → bool[source]

Return bool if device_id is in items.

Parameters:

device_id (str)

Return type:

bool

property items: list[AferoResource]

Return all items for this resource.

property initialized: bool

Determine if the controller has been initialized.

property subscribers: dict[str, list[tuple[Callable[[EventType, dict | None], None], tuple[EventType] | None]]]

Get all subscribers aligned to this controller.

async emit_to_subscribers(evt_type: EventType, item_id: str, item: AferoResource)[source]

Emit updates to subscribers.

Parameters:

  • evt_type (EventType) – Type of event

  • item_id (str) – ID of the item

  • item (AferoResource) – Item to emit to subscribers

get_filtered_devices(initial_data: list[dict]) → list[AferoDevice][source]

Determine devices that align to the controller.

Parameters:

initial_data (list[dict])

Return type:

list[AferoDevice]

async initialize() → None[source]

Initialize controller the controller.

Initialization process should only occur once. During this process, it will subscribe to all updates for the given resources and register any device split callbacks for the event controller.

Return type:

None

async initialize_number(func_def: dict, state: AferoState) → tuple[tuple[str, str | None], NumbersFeature] | None[source]

Initialize a number from the provided data.

Parameters:
Return type:

tuple[tuple[str, str | None], NumbersFeature] | None

async initialize_select(functions: list[dict], state: AferoState) → tuple[tuple[str, str | None], SelectFeature] | None[source]

Initialize a select from the provided data.

Parameters:
Return type:

tuple[tuple[str, str | None], SelectFeature] | None

async initialize_sensor(state: AferoState, child_id: str) → AferoSensor | AferoBinarySensor | None[source]

Initialize the sensor.

Parameters:

  • state (AferoState) – State to update

  • child_id (str) – device_id of the parent device

Return type:

AferoSensor | AferoBinarySensor | None

async update_number(state: AferoState, cur_item: AferoResource) → str | None[source]

Update the number if its tracked and a change has been detected.

Parameters:

  • state (AferoState) – State to update

  • cur_item (AferoResource) – Current item to update

Returns:

Identifier of the number that was updated or None

Return type:

str | None

async update_select(state: AferoState, cur_item: AferoResource) → str | None[source]

Update the select if its tracked and a change has been detected.

Parameters:

  • state (AferoState) – State to update

  • cur_item (AferoResource) – Current item to update

Returns:

Identifier of the select that was updated or None

Return type:

str | None

async update_sensor(state: AferoState, cur_item: AferoResource) → str | None[source]

Update the sensor if its tracked and a change has been detected.

Parameters:

  • state (AferoState) – State to update

  • cur_item (AferoResource) – Current item to update

Returns:

Identifier of the sensor that was updated or None

Return type:

str | None

async split_sensor_data(state: AferoState) → tuple[Any, str | None][source]

Split the sensor value and return a tuple of the sensor value and key.

Parameters:

state (AferoState)

Return type:

tuple[Any, str | None]

async initialize_elem(element: AferoDevice) → None[source]

Initialize the element.

Parameters:

  • afero_device – Afero Device that contains the updated states

  • element (AferoDevice)

Returns:

Newly initialized resource

Return type:

None

async update_elem(element: AferoDevice) → None[source]

Update the Portable AC with the latest API data.

Parameters:

  • afero_device – Afero Device that contains the updated states

  • element (AferoDevice)

Returns:

States that have been modified

Return type:

None

subscribe(callback: Callable[[EventType, dict | None], None], id_filter: str | tuple[str] | None = None, event_filter: EventType | tuple[EventType] | None = None) → Callable[source]

Subscribe to status changes for this resource type.

Parameters:

  • callback (Callable[[EventType, dict | None], None]) – callback function to call when an event emits.

  • id_filter (str | tuple[str] | None) – Optionally provide resource ID(s) to filter events for.

  • event_filter (EventType | tuple[EventType] | None) – Optionally provide EventType(s) as filter.

Returns:

function to unsubscribe.

Return type:

Callable

async update_afero_api(device_id: str, states: list[dict]) → ClientResponse | bool[source]

Update Afero IoT API with the new states.

Parameters:

  • device_id (str) – Afero IoT Device ID

  • states (list[dict]) – States to manually set

Returns:

Response if successful, False otherwise.

Return type:

ClientResponse | bool

async update(device_id: str, obj_in: AferoResource | None = None, states: list[dict] | None = None, send_duplicate_states: bool = False) → ClientResponse | None[source]

Update Afero IoT with the new data.

Parameters:

  • device_id (str) – Afero IoT Device ID

  • obj_in (AferoResource | None) – Afero IoT Resource elements to change

  • states (list[dict] | None) – States to manually set

  • send_duplicate_states (bool) – Send all states, regardless if there’s been a change

Return type:

ClientResponse | None

generate_update_dev(device_id: str, states: list[AferoState]) → AferoDevice[source]

Generate update data for the event controller.

Parameters:
Return type:

AferoDevice

get_device(device_id: str) → AferoResource[source]

Return the current model for a tracked device.

Parameters:

device_id (str) – Device ID on this controller (split or parent metadevice ID).

Returns:

Resource model with parsed feature state.

Raises:

DeviceNotFound – If device_id is not tracked by this controller.

Return type:

AferoResource

aioafero.v1.controllers.base.dataclass_to_afero(elem: AferoResource, cls: dataclass, send_duplicate_states: bool) → list[dict][source]

Convert Put features into Afero IoT states.

Each feature owns its function_class / function_instance identity.

Parameters:

  • elem (AferoResource)

  • cls (dataclass)

  • send_duplicate_states (bool)

Return type:

list[dict]

aioafero.v1.controllers.base.get_afero_state_from_feature(function_class: str, function_instance: str | None, current_value: Any) → dict[source]

Generate a single state from feature-owned identity and value.

Parameters:

  • function_class (str)

  • function_instance (str | None)

  • current_value (Any)

Return type:

dict

aioafero.v1.controllers.base.get_afero_states_from_list(states: list[dict]) → list[dict][source]

Add timestamp to manually supplied states.

Assume each state already has functionClass, functionInstance, and value.

Parameters:

states (list[dict])

Return type:

list[dict]

aioafero.v1.controllers.callback module

Shared types for device-split callbacks (kept free of EventStream imports).

class aioafero.v1.controllers.callback.CallbackResponse(split_devices: Sequence[AferoDevice] = (), remove_original: bool = False)[source]

Bases: NamedTuple

Callback response for DEVICE_SPLIT_CALLBACKS.

Parameters:

  • split_devices (Sequence[AferoDevice]) – New devices that should be added to the overall list

  • remove_original (bool) – Remove the original device from the list of devices

split_devices: Sequence[AferoDevice]

Alias for field number 0

remove_original: bool

Alias for field number 1

aioafero.v1.controllers.climate module

Base controller for climate devices.

aioafero.v1.controllers.climate.generate_target_temp(func_def: dict, state: AferoState) → TargetTemperatureFeature[source]

Determine the target temp based on the function definition.

Parameters:
Return type:

TargetTemperatureFeature

aioafero.v1.controllers.climate.generate_target_temp_capability(capability: AferoCapability, state: AferoState) → TargetTemperatureFeature[source]

Determine the target temp based on the function definition.

Parameters:
Return type:

TargetTemperatureFeature

class aioafero.v1.controllers.climate.ClimateController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[AferoResourceT]

Base controller for climate devices.

Parameters:

bridge (AferoBridgeV1)

async initialize_climate_elem(afero_device: AferoDevice) → dict[source]

Initialize the climate elements of a device.

Parameters:

afero_device (AferoDevice)

Return type:

dict

async update_climate_elem(afero_device: AferoDevice) → set[source]

Update the climate elements of a device.

Parameters:

afero_device (AferoDevice)

Return type:

set

async set_climate_state(device_id: str, update_obj, **kwargs) → None[source]

Set climate state.

Parameters:

device_id (str)

Return type:

None

aioafero.v1.controllers.dehumidifier module

Controller holding and managing Afero IoT resources of type dehumidifier.

aioafero.v1.controllers.dehumidifier.generate_target_humidity(functions: list[dict], state: AferoState) → NumbersFeature[source]

Build the target humidity number from the function definition.

Parameters:
Return type:

NumbersFeature

class aioafero.v1.controllers.dehumidifier.DehumidifierController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[Dehumidifier]

Dehumidifiers on bridge.dehumidifiers.

Error states (water tray full, filter, sensor failures) are reported by bridge.devices like every other parent device.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.DEHUMIDIFIER]
ITEM_CLS

alias of Dehumidifier

ITEM_SELECTS: dict[tuple[str, str | None], str] = {('fan-speed', 'dehumidifier-fan-speed'): 'Fan Speed', ('pump', None): 'Pump'}
async turn_on(device_id: str) → None[source]

Turn on the dehumidifier.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async turn_off(device_id: str) → None[source]

Turn off the dehumidifier.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → Dehumidifier[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Dehumidifier

async update_elem(afero_device: AferoDevice) → set[source]

Update the Dehumidifier with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, on: bool | None = None, mode: str | None = None, target_humidity: int | None = None, selects: dict[tuple[str, str | None], str] | None = None) → None[source]

Update dehumidifier state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • on (bool | None) – Power state.

  • mode (str | None) – Mode name from mode.modes (set, continuous, …).

  • target_humidity (int | None) – Target relative humidity in percent.

  • selects (dict[tuple[str, str | None], str] | None) – Select features keyed by (functionClass, functionInstance).

Return type:

None

aioafero.v1.controllers.device module

Controller that holds top-level devices.

class aioafero.v1.controllers.device.DeviceController(*args, **kwargs)[source]

Bases: BaseResourcesController[Device]

Top-level / parent devices on bridge.devices (read-only).

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = []
ITEM_CLS

alias of Device

ITEM_SENSORS: dict[str, str] = {'battery-level': '%', 'wifi-rssi': 'dB'}
ITEM_BINARY_SENSORS: dict[str, str] = {'error': 'alerting'}
__init__(*args, **kwargs)[source]

Initialize instance.

async initialize_elem(afero_device: AferoDevice) → Device[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Device

async initialize() → None[source]

Initialize controller by fetching all items for this resource type from bridge.

Return type:

None

get_filtered_devices(devices: list[AferoDevice]) → list[AferoDevice][source]

Find parent devices.

Parameters:

devices (list[AferoDevice])

Return type:

list[AferoDevice]

async update_elem(afero_device: AferoDevice) → set[source]

Update the Device with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

aioafero.v1.controllers.event module

Handle connecting to Afero IoT and distribute events.

class aioafero.v1.controllers.event.AferoEvent[source]

Bases: TypedDict

Afero IoT Event message as emitted by the EventStream.

type: EventType
device_id: NotRequired[str]
device: NotRequired[AferoDevice]
polled_data: NotRequired[Any]
polled_devices: NotRequired[Any]
force_forward: NotRequired[bool]
exception aioafero.v1.controllers.event.BackoffException[source]

Bases: Exception

Exception raised when a backoff is required.

class aioafero.v1.controllers.event.CallbackResponse(split_devices: Sequence[AferoDevice] = (), remove_original: bool = False)[source]

Bases: NamedTuple

Callback response for DEVICE_SPLIT_CALLBACKS.

Parameters:

  • split_devices (Sequence[AferoDevice]) – New devices that should be added to the overall list

  • remove_original (bool) – Remove the original device from the list of devices

split_devices: Sequence[AferoDevice]

Alias for field number 0

remove_original: bool

Alias for field number 1

class aioafero.v1.controllers.event.EventStream(bridge: AferoBridgeV1, polling_interval: int, poll_version: bool, discovery_interval: int = 3600)[source]

Bases: object

Data gatherer and eventer.

Polls Afero IoT API, converts the response into devices, and notifies subscribers of the event.

Parameters:
__init__(bridge: AferoBridgeV1, polling_interval: int, poll_version: bool, discovery_interval: int = 3600) → None[source]

Initialize instance.

Parameters:
Return type:

None

property connected: bool

Return bool if we’re connected.

property status: EventStreamStatus

Return connection status.

property registered_multiple_devices: dict[str, Callable]

Get all registered callbacks for splitting devices.

property polling_interval: int

Number of seconds between polling.

property poll_version: bool

Determine if version polling should occur.

tombstone_device(device_id: str) → None[source]

Remember a Conclave removal so stale discovery cannot revive it.

Entries expire after max(120, 2 * discovery_interval) seconds so a missed Conclave add cannot block REST rediscovery forever.

Parameters:

device_id (str)

Return type:

None

clear_discovery_tombstone(device_id: str) → None[source]

Clear tombstones for device_id, its parent, and split clones.

Parameters:

device_id (str)

Return type:

None

clear_all_discovery_tombstones() → None[source]

Drop every discovery tombstone (intentional full rediscovery).

Return type:

None

active_discovery_tombstones() → set[str][source]

Return non-expired Conclave-removal tombstones (prunes expired).

Return type:

set[str]

async wait_for_first_poll() → None[source]

Wait until the first poll has completed.

Return type:

None

async initialize() → None[source]

Start the polling processes.

Return type:

None

async initialize_discovery() → None[source]

Initialize gathering data from Afero API.

Return type:

None

async initialize_device_polling() → None[source]

Initialize gathering device state data from Afero API.

Return type:

None

async initialize_processor() → None[source]

Initialize the processor.

Return type:

None

register_multi_device(name: str, generate_devices: callable)[source]

Register a callable to find multi-devices within the payload.

The callable must return a list of tracked AferoDevices

Parameters:

  • name (str)

  • generate_devices (callable)

async stop() → None[source]

Stop listening for events.

Cancel discovery/polling/processor loops and await them so in-flight HTTP work finishes (as cancelled) before the caller’s session teardown.

Return type:

None

subscribe(callback: Callable[[EventType, dict | None], None], event_filter: EventType | tuple[EventType] | None = None, resource_filter: tuple[str] | None = None) → Callable[source]

Subscribe to events emitted.

Parameters:

  • callback (Callable[[EventType, dict | None], None]) – callback function to call when an event emits.

  • event_filter (EventType | tuple[EventType] | None) – Optionally provide an EventType as filter.

  • resource_filter (tuple[str] | None) – Optionally provide a ResourceType as filter.

Returns:

function to unsubscribe.

Return type:

Callable

add_job(event: AferoEvent) → None[source]

Manually add a job to be processed.

Parameters:

event (AferoEvent)

Return type:

None

async async_block_until_done()[source]

Blocking call until everything has finished.

emit(event_type: EventType, data: AferoEvent = None) → None[source]

Emit event to all listeners.

Parameters:
Return type:

None

async process_backoff(attempt: int) → None[source]

Handle backoff timer for Afero IoT API.

Parameters:

  • attempt (int) – Number of attempts

  • reason – Reason why the backoff is occurring

Return type:

None

async gather_discovery_data() → list[dict[Any, str]][source]

Gather all data from the Afero IoT API.

Return type:

list[dict[Any, str]]

async generate_devices_from_data(data: list[dict[Any, str]]) → list[AferoDevice][source]

Generate all devices from a given payload.

Generating devices will attempt to split devices where required and remove devices that are no longer needed, as identified by the callback.

Parameters:

data (list[dict[Any, str]])

Return type:

list[AferoDevice]

async split_devices(devices: list[AferoDevice]) → list[AferoDevice][source]

Split Afero devices into multiple devices where required.

Parameters:

devices (list[AferoDevice])

Return type:

list[AferoDevice]

async generate_events_from_update(dev: AferoDevice) → None[source]

Fan out a patched parent metadevice through splits and the queue.

Call this once after merging new states into the parent (REST write echo, state poll, or Conclave push). Split callbacks re-derive clones; existing clones are also refreshed from dev so filtered zone state matches the parent. Do not call once per clone — that re-runs split_devices and duplicates RESOURCE_UPDATE_RESPONSE events.

Parameters:

dev (AferoDevice)

Return type:

None

async generate_events_from_added_data(data: list[dict[Any, str]]) → list[AferoDevice][source]

Process newly discovered metadevice payloads without reconciling removals.

Unlike generate_events_from_data(), this does not emit RESOURCE_DELETED for devices missing from data. Used by Conclave public / invalidate add handling where only the new ids are known.

Parameters:

data (list[dict[Any, str]])

Return type:

list[AferoDevice]

async generate_events_from_data(data: list[dict[Any, str]], *, reconcile_deletes_from: set[str] | None = None, skip_readd_ids: set[str] | None = None) → None[source]

Process the raw Afero IoT data for emitting.

Parameters:

  • data (list[dict[Any, str]]) – Raw data from Afero IoT

  • reconcile_deletes_from (set[str] | None) – When set (discovery polls), only emit RESOURCE_DELETED for ids that were already tracked when the poll started. Devices added concurrently (e.g. Conclave inventory add) are kept until a later poll that still omits them.

  • skip_readd_ids (set[str] | None) – Device ids removed while a discovery poll was in flight. Stale REST bodies that still list them must not revive the cache / emit RESOURCE_ADDED.

Return type:

None

async perform_discovery_poll() → None[source]

Poll Afero IoT and generate the required events.

Return type:

None

async process_event()[source]

Process a single event in the queue.

class aioafero.v1.controllers.event.EventStreamStatus(*values)[source]

Bases: Enum

Status options of EventStream.

CONNECTING = 0
CONNECTED = 1
DISCONNECTED = 2

aioafero.v1.controllers.exhaust_fan module

Controller holding and managing Afero IoT resources of type exhaust-fan.

aioafero.v1.controllers.exhaust_fan.get_split_instances(afero_dev: AferoDevice) → list[str][source]

Determine available instances from the states.

Parameters:

afero_dev (AferoDevice)

Return type:

list[str]

aioafero.v1.controllers.exhaust_fan.get_valid_states(afero_dev: AferoDevice, instance: str) → list[source]

Find states associated with the specific instance.

Parameters:
Return type:

list

aioafero.v1.controllers.exhaust_fan.exhaust_fan_callback(afero_device: AferoDevice) → CallbackResponse[source]

Convert an AferoDevice into multiple devices.

Parameters:

afero_device (AferoDevice)

Return type:

CallbackResponse

class aioafero.v1.controllers.exhaust_fan.ExhaustFanController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[ExhaustFan]

Exhaust fans on bridge.exhaust_fans.

Tracks sensors, numbers, and selects. Toggles, fan speed, and light on the same unit are on bridge.switches, bridge.fans, and bridge.lights.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.EXHAUST_FAN]
ITEM_CLS

alias of ExhaustFan

ITEM_SENSORS: dict[str, str] = {}
ITEM_BINARY_SENSORS: dict[str, str] = {'humidity-threshold-met': 'above-threshold', 'motion-detection': 'motion-detected'}
ITEM_NUMBERS: dict[tuple[str, str | None], NumbersName] = {('auto-off-timer', 'auto-off'): ('seconds', None)}
ITEM_SELECTS: dict[tuple[str, str | None], str] = {('motion-action', 'exhaust-fan'): 'Motion Action', ('sensitivity', 'humidity-sensitivity'): 'Humidity Sensitivity'}
DEVICE_SPLIT_CALLBACKS: dict[str, callable] = {'exhaust-fan': <function exhaust_fan_callback>}
async initialize_elem(afero_device: AferoDevice) → ExhaustFan[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

ExhaustFan

async update_elem(afero_device: AferoDevice) → set[source]

Update the Exhaust Fan with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, numbers: dict[tuple[str, str | None], float] | None = None, selects: dict[tuple[str, str | None], str] | None = None) → None[source]

Update exhaust fan numbers and selects in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • numbers (dict[tuple[str, str | None], float] | None) – Number features keyed by (functionClass, functionInstance).

  • selects (dict[tuple[str, str | None], str] | None) – Select features keyed by (functionClass, functionInstance).

Return type:

None

aioafero.v1.controllers.fan module

Controller holding and managing Afero IoT resources of type fan.

class aioafero.v1.controllers.fan.FanController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[Fan]

Fan devices on bridge.fans.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.FAN]
ITEM_CLS

alias of Fan

async turn_on(device_id: str) → None[source]

Turn on the fan.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async turn_off(device_id: str) → None[source]

Turn off the fan.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async set_speed(device_id: str, speed: int) → None[source]

Set fan speed as a percentage.

Parameters:

  • device_id (str) – Device ID from this controller.

  • speed (int) – Speed percentage (0 turns the fan off).

Return type:

None

async set_direction(device_id: str, forward: bool) → None[source]

Set fan rotation direction.

Parameters:

  • device_id (str) – Device ID from this controller.

  • forward (bool) – True for forward, False for reverse. Ignored if the fan is off (Hubspace API quirk).

Return type:

None

async set_preset(device_id: str, preset: bool) → None[source]

Enable or disable the comfort-breeze preset.

Parameters:

  • device_id (str) – Device ID from this controller.

  • preset (bool) – True to enable the preset, False to disable.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → Fan[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Fan

async update_elem(afero_device: AferoDevice) → set[source]

Update the Fan with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, on: bool | None = None, speed: int | None = None, forward: bool | None = None, preset: bool | None = None) → None[source]

Update fan state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • on (bool | None) – Power state.

  • speed (int | None) – Fan speed percentage (0 turns off).

  • forward (bool | None) – True for forward rotation, False for reverse.

  • preset (bool | None) – Comfort-breeze preset enabled state.

Return type:

None

aioafero.v1.controllers.light module

Controller holding and managing Hubspace resources of type light.

aioafero.v1.controllers.light.process_names(values: list[dict]) → set[str][source]

Extract unique names from the elements.

Parameters:

values (list[dict])

Return type:

set[str]

aioafero.v1.controllers.light.is_dual_channel_rgb_fixture(afero_dev: AferoDevice) → bool[source]

Return True for RGB+WW fixtures with color and white brightness channels.

Parameters:

afero_dev (AferoDevice)

Return type:

bool

aioafero.v1.controllers.light.preferred_brightness_instance(afero_dev: AferoDevice) → str | None[source]

Return the overall brightness instance for dual-channel lights.

Parameters:

afero_dev (AferoDevice)

Return type:

str | None

aioafero.v1.controllers.light.should_use_brightness_state(afero_dev: AferoDevice, state: AferoState) → bool[source]

Return whether a brightness state should populate Light.dimming.

Parameters:
Return type:

bool

aioafero.v1.controllers.light.resolve_brightness_instance(cur_item: Light, *, color_mode: str | None = None, color: tuple[int, int, int] | None = None, temperature: int | None = None, effect: str | None = None, channel: str | None = None) → str | None[source]

Return the brightness functionInstance to PUT for dual-channel fixtures.

Parameters:
Return type:

str | None

aioafero.v1.controllers.light.resolve_color_mode(cur_item: Light, color_mode: str | None) → str | None[source]

Return the color-mode to PUT for dual-channel fixtures.

Exclusive color / white becomes mixed when another channel is already on, so the write does not shut off the other driver.

Parameters:

  • cur_item (Light)

  • color_mode (str | None)

Return type:

str | None

aioafero.v1.controllers.light.color_mode_after_channel_off(cur_item: Light, channel: str) → str | None[source]

Return color-mode after turning channel off.

When another channel remains on, switch to that exclusive mode (or mixed if more than one remains). When nothing remains on, return None so color-mode is left unchanged.

Parameters:
Return type:

str | None

aioafero.v1.controllers.light.apply_brightness_state_update(afero_device: AferoDevice, cur_item: Light, state: AferoState, updated_keys: set[str]) → None[source]

Apply an inbound brightness state to channels and/or overall dimming.

Parameters:
Return type:

None

aioafero.v1.controllers.light.get_split_instances(afero_dev: AferoDevice) → list[tuple[str, ResourceTypes]][source]

Determine available instances from the states.

Parameters:

afero_dev (AferoDevice)

Return type:

list[tuple[str, ResourceTypes]]

aioafero.v1.controllers.light.state_belongs_to_light_instance(afero_dev: AferoDevice, state: AferoState, instance: str) → bool[source]

Return whether a state belongs to a light zone instance.

Parameters:
Return type:

bool

aioafero.v1.controllers.light.state_matches_instance(afero_device: AferoDevice, state: AferoState) → bool[source]

Return whether a state belongs to a split light instance.

Parameters:
Return type:

bool

aioafero.v1.controllers.light.resolve_function_instance(afero_device: AferoDevice) → str | None[source]

Return the functionInstance key for this light resource (split zone or single).

Parameters:

afero_device (AferoDevice)

Return type:

str | None

aioafero.v1.controllers.light.get_color_modes_for_device(afero_device: AferoDevice) → list[str][source]

Return supported color-mode names for this zone’s color-mode function.

Parameters:

afero_device (AferoDevice)

Return type:

list[str]

aioafero.v1.controllers.light.get_color_mode_hints_for_device(afero_device: AferoDevice) → dict[str, list[str]][source]

Return category hints keyed by color-mode name (e.g. no-brightness).

Parameters:

afero_device (AferoDevice)

Return type:

dict[str, list[str]]

aioafero.v1.controllers.light.get_valid_states(afero_dev: AferoDevice, instance: str) → list[source]

Find states associated with the specific instance.

Parameters:
Return type:

list

aioafero.v1.controllers.light.light_callback(afero_device: AferoDevice) → CallbackResponse[source]

Convert an AferoDevice into multiple devices.

Parameters:

afero_device (AferoDevice)

Return type:

CallbackResponse

class aioafero.v1.controllers.light.LightController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[Light]

Light devices on bridge.lights (including split zones).

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.LIGHT]
ITEM_CLS

alias of Light

ITEM_NUMBERS: dict[tuple[str, str | None], NumbersName] = {('speed', 'color-sequence'): ('speed', 'Effect Speed')}
DEVICE_SPLIT_CALLBACKS: dict[str, callable] = {'light': <function light_callback>}
async turn_on(device_id: str) → None[source]

Turn on the light.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async turn_off(device_id: str) → None[source]

Turn off the light.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async set_color_temperature(device_id: str, temperature: int) → None[source]

Set color temperature or white mode when CCT is unavailable.

Parameters:

  • device_id (str) – Device ID from this controller.

  • temperature (int) – Color temperature in kelvin.

Return type:

None

async set_white(device_id: str, *, on: bool | None = True, brightness: int | None = None) → None[source]

Set white mode without a color-temperature function.

Parameters:

  • device_id (str) – Device ID from this controller.

  • on (bool | None) – Power state (defaults to True).

  • brightness (int | None) – Brightness percentage when on is True.

Return type:

None

async set_brightness(device_id: str, brightness: int) → None[source]

Set brightness, turning the light on if needed.

Parameters:

  • device_id (str) – Device ID from this controller.

  • brightness (int) – Brightness percentage.

Return type:

None

async set_rgb(device_id: str, red: int, green: int, blue: int) → None[source]

Set RGB color, turning the light on if needed.

Parameters:

  • device_id (str) – Device ID from this controller.

  • red (int) – Red channel 0–255.

  • green (int) – Green channel 0–255.

  • blue (int) – Blue channel 0–255.

Return type:

None

async set_effect(device_id: str, effect: str) → None[source]

Set a color sequence effect, turning the light on if needed.

Parameters:

  • device_id (str) – Device ID from this controller.

  • effect (str) – Effect name from the model’s effect.effects list.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → Light[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Light

async update_elem(afero_device: AferoDevice) → set[source]

Update the Light with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async update_elem_color(cur_item: Light, color_seq_states: dict[str | None, AferoState]) → set[source]

Perform the update for effects.

Parameters:
Return type:

set

async set_state(device_id: str, *, on: bool | None = None, temperature: int | None = None, brightness: int | None = None, color_mode: str | None = None, color: tuple[int, int, int] | None = None, effect: str | None = None, force_white_mode: int | None = None, numbers: dict[tuple[str, str | None], float] | None = None, channel: str | None = None) → None[source]

Update light state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • on (bool | None) – Power state.

  • temperature (int | None) – Color temperature in kelvin.

  • brightness (int | None) – Brightness percentage.

  • color_mode (str | None) – API color mode (white, color, sequence, night-light, etc.).

  • color (tuple[int, int, int] | None) – RGB tuple (red, green, blue).

  • effect (str | None) – Named color sequence effect.

  • force_white_mode (int | None) – Brightness to apply after forcing white mode.

  • numbers (dict[tuple[str, str | None], float] | None) – Number features keyed by (functionClass, functionInstance).

  • channel (str | None) – When set, target that dual-channel instance (color / white): on uses the channel toggle, and brightness is routed to that channel when color_mode is omitted. Turning a channel off also moves color-mode to the remaining channel when one is still on. Unknown channel names are ignored (logged) and do not fall through to primary power.

Return type:

None

no-brightness modes omit brightness and, when turning on from off, select the mode before power (aborting if that PUT fails). Turn-off never includes a color-mode change.

aioafero.v1.controllers.light.process_color_temps(color_temps: dict) → list[int][source]

Determine the supported color temps.

Parameters:

color_temps (dict) – Result from functions[“values”]

Return type:

list[int]

aioafero.v1.controllers.light.process_effects(functions: list[dict]) → dict[str, set][source]

Determine the supported effects.

Parameters:

functions (list[dict])

Return type:

dict[str, set]

aioafero.v1.controllers.light.resolve_effect_value(effects: dict[str, set[str]], states: dict[str | None, AferoState]) → str | None[source]

Resolve the active effect from plural color-sequence states.

Parameters:
Return type:

str | None

aioafero.v1.controllers.lock module

Controller holding and managing Afero IoT resources of type lock.

class aioafero.v1.controllers.lock.LockController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[Lock]

Lock devices on bridge.locks.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.LOCK]
ITEM_CLS

alias of Lock

async lock(device_id: str) → None[source]

Engage the lock.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async unlock(device_id: str) → None[source]

Disengage the lock.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → Lock[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Lock

async update_elem(afero_device: AferoDevice) → set[source]

Update the Lock with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, lock_position: CurrentPositionEnum | None = None) → None[source]

Update lock state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • lock_position (CurrentPositionEnum | None) – Target lock position (LOCKING / UNLOCKING).

Return type:

None

aioafero.v1.controllers.portable_ac module

Controller holding and managing Afero IoT resources of type portable-air-conditioner.

aioafero.v1.controllers.portable_ac.get_valid_states(afero_dev: AferoDevice) → list[source]

Find states associated with the element.

Parameters:

afero_dev (AferoDevice)

Return type:

list

aioafero.v1.controllers.portable_ac.portable_ac_callback(afero_device: AferoDevice) → CallbackResponse[source]

Convert an AferoDevice into multiple devices.

Parameters:

afero_device (AferoDevice)

Return type:

CallbackResponse

class aioafero.v1.controllers.portable_ac.PortableACController(bridge: AferoBridgeV1)[source]

Bases: ClimateController[PortableAC]

Portable air conditioners on bridge.portable_acs.

The power toggle is split onto bridge.switches.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.PORTABLE_AC]
ITEM_CLS

alias of PortableAC

ITEM_SELECTS: dict[tuple[str, str | None], str] = {('air-swing', None): 'Swing', ('eco-mode', None): 'Eco Mode', ('fan-speed', 'ac-fan-speed'): 'Fan Speed', ('sleep', None): 'Sleep Mode'}
DEVICE_SPLIT_CALLBACKS: dict[str, callable] = {'portable-air-conditioner': <function portable_ac_callback>}
async initialize_elem(afero_device: AferoDevice) → PortableAC[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

PortableAC

async update_elem(afero_device: AferoDevice) → set[source]

Update the Portable AC with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, **kwargs) → None[source]

Update portable AC climate state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • hvac_mode – HVAC mode name from hvac_mode.supported_modes.

  • target_temperature – Cooling setpoint shorthand.

  • target_temperature_cooling – Cooling setpoint.

  • target_temperature_heating – Heating setpoint (when supported).

  • selects – Select features keyed by (functionClass, functionInstance).

  • **kwargs – Remaining climate fields forwarded to set_climate_state.

Return type:

None

aioafero.v1.controllers.security_system module

Controller holding and managing Afero IoT resources of type security-system.

aioafero.v1.controllers.security_system.get_sensor_ids(device) → set[int][source]

Determine available sensors from the states.

Return type:

set[int]

aioafero.v1.controllers.security_system.get_valid_states(afero_states: list, sensor_id: int) → list[source]

Find states associated with the specific sensor.

Parameters:

  • afero_states (list)

  • sensor_id (int)

Return type:

list

aioafero.v1.controllers.security_system.get_model_type(states: list[AferoState], sensor_id: int) → str[source]

Get the model type from the state list.

Parameters:
Return type:

str

aioafero.v1.controllers.security_system.get_valid_functions(afero_functions: list, sensor_id: int) → list[source]

Find functions associated with the specific sensor.

Parameters:

  • afero_functions (list)

  • sensor_id (int)

Return type:

list

aioafero.v1.controllers.security_system.get_sensor_name(afero_capabilities: list[AferoCapability], sensor_id: int) → str[source]

Get the Afero name for a specific sensor.

Parameters:
Return type:

str

aioafero.v1.controllers.security_system.security_system_callback(afero_device: AferoDevice) → CallbackResponse[source]

Convert an AferoDevice into multiple devices.

Parameters:

afero_device (AferoDevice)

Return type:

CallbackResponse

class aioafero.v1.controllers.security_system.SecuritySystemController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[SecuritySystem]

Security systems on bridge.security_systems.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.SECURITY_SYSTEM]
ITEM_CLS

alias of SecuritySystem

ITEM_SENSORS: dict[str, str] = {'alarm-state': None, 'disarmed-by': None, 'history-event': None}
ITEM_BINARY_SENSORS: dict[str, str] = {'battery-powered': 'battery-powered'}
ITEM_NUMBERS: dict[tuple[str, str | None], NumbersName] = {('arm-exit-delay', 'away'): ('seconds', 'Arm Exit Delay Away'), ('arm-exit-delay', 'stay'): ('seconds', 'Arm Exit Delay Home'), ('disarm-entry-delay', None): ('seconds', 'Disarm Entry Delay'), ('siren-alarm-timeout', None): ('seconds', 'Siren Timeout'), ('temporary-bypass-time', None): ('seconds', 'Bypass Time')}
ITEM_SELECTS: dict[tuple[str, str | None], str] = {('bypass-allowed', None): 'Enable Temporary Bypass', ('song-id', 'alarm'): 'Alarm Noise', ('song-id', 'chime'): 'Chime Noise', ('volume', 'chime'): 'Chime Volume', ('volume', 'entry-delay'): 'Entry Delay Volume', ('volume', 'exit-delay-away'): 'Exit Delay Volume Away', ('volume', 'exit-delay-stay'): 'Exit Delay Volume Home', ('volume', 'siren'): 'Alarm Volume'}
DEVICE_SPLIT_CALLBACKS: dict[str, callable] = {'security-system-sensor': <function security_system_callback>}
async disarm(device_id: str, disarm_pin: int) → None[source]

Disarm the security system.

Parameters:

  • device_id (str) – Device ID from this controller.

  • disarm_pin (int) – Numeric PIN configured on the panel.

Return type:

None

async arm_home(device_id: str) → None[source]

Arm the system in home mode.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async arm_away(device_id: str) → None[source]

Arm the system in away mode.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async alarm_trigger(device_id: str) → None[source]

Manually trigger the alarm siren.

Parameters:

device_id (str) – Device ID from this controller.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → SecuritySystem[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

SecuritySystem

async update_elem(afero_device: AferoDevice) → set[source]

Update the Security System with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, disarm_pin: int | None = None, command: int | None = None, numbers: dict[tuple[str, str | None], float] | None = None, selects: dict[tuple[str, str | None], str] | None = None) → None[source]

Update security system state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • disarm_pin (int | None) – PIN for disarm commands.

  • command (int | None) – Panel command code (2 away, 4 home, 5 alarm trigger).

  • numbers (dict[tuple[str, str | None], float] | None) – Number features keyed by (functionClass, functionInstance).

  • selects (dict[tuple[str, str | None], str] | None) – Select features keyed by (functionClass, functionInstance).

Return type:

None

async refresh_alarm_state(device_id: str) → None[source]

Refresh the alarm state after alarm state change command.

Parameters:

device_id (str)

Return type:

None

async validate_disarm_pin(device_id: str) → None[source]

Ensure the system has switched to disarmed.

Parameters:

device_id (str)

Return type:

None

async validate_arm_state(device_id: str, arm_type: int) → bool[source]

Ensure the system can arm.

Parameters:

  • device_id (str)

  • arm_type (int)

Return type:

bool

aioafero.v1.controllers.security_system_keypad module

Controller holding and managing Afero IoT resources of type security-system-keypad.

class aioafero.v1.controllers.security_system_keypad.SecuritySystemKeypadController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[SecuritySystemKeypad]

Security keypads on bridge.security_systems_keypads.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.SECURITY_SYSTEM_KEYPAD]
ITEM_CLS

alias of SecuritySystemKeypad

ITEM_BINARY_SENSORS: dict[str, str] = {'tamper-detection': 'tampered'}
ITEM_SELECTS: dict[tuple[str, str | None], str] = {('volume', 'buzzer-volume'): 'Buzzer Volume'}
async initialize_elem(afero_device: AferoDevice) → SecuritySystemKeypad[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

SecuritySystemKeypad

async update_elem(afero_device: AferoDevice) → set[source]

Update the Security System with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, selects: dict[tuple[str, str | None], str] | None = None) → None[source]

Update security keypad selects in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • selects (dict[tuple[str, str | None], str] | None) – Select features keyed by (functionClass, functionInstance).

Return type:

None

aioafero.v1.controllers.security_system_sensor module

Controller holding and managing Afero IoT resources of type security-system.

class aioafero.v1.controllers.security_system_sensor.SecuritySystemSensorController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[SecuritySystemSensor]

Security sensors split from a system on bridge.security_systems_sensors.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.SECURITY_SYSTEM_SENSOR]
ITEM_CLS

alias of SecuritySystemSensor

SENSOR_TYPES = {1: 'Motion Sensor', 2: 'Door/Window Sensor'}
ITEM_BINARY_SENSORS: dict[str, str] = {'tampered': 'On', 'triggered': 'On'}
ITEM_SELECTS: dict[tuple[str, str | None], str] = {('bypassType', None): 'Bypass', ('chirpMode', None): 'Chime', ('triggerType', None): 'Alarming State'}
async initialize_elem(device: AferoDevice)[source]

Initialize the element.

Parameters:

  • afero_device – Afero Device that contains the updated states

  • device (AferoDevice)

Returns:

Newly initialized resource

async update_elem(afero_device: AferoDevice) → set[str][source]

Update the Security System Sensor with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set[str]

async set_state(device_id: str, *, selects: dict[tuple[str, str | None], str] | None = None) → None[source]

Update security sensor selects in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • selects (dict[tuple[str, str | None], str] | None) – Select values keyed by (functionClass, functionInstance). Supported keys include chirpMode, triggerType, and bypassType.

Return type:

None

aioafero.v1.controllers.split_refresh module

Refresh filtered states on split clones after the parent metadevice changes.

Split callbacks already build clones with filtered states during discovery. After an in-place parent patch (REST write echo or Conclave push), existing clones must be re-filtered from the parent before RESOURCE_UPDATE_RESPONSE events fire.

Controller imports are deferred so this module cannot participate in an import cycle with event / base (those controllers import event).

aioafero.v1.controllers.split_refresh.split_instance_from_device(device: AferoDevice) → str | None[source]

Return the split-zone instance key for a clone.

Parameters:

device (AferoDevice)

Return type:

str | None

aioafero.v1.controllers.split_refresh.refresh_split_clone_states(parent: AferoDevice, clone: AferoDevice) → None[source]

Copy filtered parent states onto a split clone before emitting events.

Parameters:
Return type:

None

aioafero.v1.controllers.switch module

Controller holding and managing Afero IoT resources of type switch.

class aioafero.v1.controllers.switch.SwitchController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[Switch]

Switch devices on bridge.switches.

A switch can have one or more toggleable elements controlled by instance.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.SWITCH, ResourceTypes.POWER_OUTLET, ResourceTypes.LANDSCAPE_TRANSFORMER]
ITEM_CLS

alias of Switch

ITEM_SENSORS: dict[str, str] = {'output-voltage-switch': 'V', 'watts': 'W'}
ITEM_BINARY_SENSORS: dict[str, str] = {}
async turn_on(device_id: str, *, instance: str | None = None) → None[source]

Turn on the switch.

Parameters:

  • device_id (str) – Device ID from this controller.

  • instance (str | None) – functionInstance when the device has multiple toggles.

Return type:

None

async turn_off(device_id: str, *, instance: str | None = None) → None[source]

Turn off the switch.

Parameters:

  • device_id (str) – Device ID from this controller.

  • instance (str | None) – functionInstance when the device has multiple toggles.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → Switch[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Switch

async update_elem(afero_device: AferoDevice) → set[source]

Update the Switch with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, on: bool | None = None, instance: str | None = None) → None[source]

Update switch state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • on (bool | None) – Power state for the selected instance.

  • instance (str | None) – functionInstance when the device has multiple toggles.

Return type:

None

aioafero.v1.controllers.thermostat module

Controller holding and managing Afero IoT resources of type thermostat.

class aioafero.v1.controllers.thermostat.ThermostatController(bridge: AferoBridgeV1)[source]

Bases: ClimateController[Thermostat]

Thermostat devices on bridge.thermostats.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.THERMOSTAT]
ITEM_CLS

alias of Thermostat

ITEM_BINARY_SENSORS: dict[str, str] = {'filter-replacement': 'replacement-needed', 'max-temp-exceeded': 'alerting', 'min-temp-exceeded': 'alerting'}
async initialize_elem(afero_device: AferoDevice) → Thermostat[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Thermostat

async update_elem(afero_device: AferoDevice) → set[source]

Update the Thermostat with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_fan_mode(device_id: str, fan_mode: str) → None[source]

Set thermostat fan mode.

Parameters:

  • device_id (str) – Device ID from this controller.

  • fan_mode (str) – Fan mode name from the device model’s fan_mode.modes.

Return type:

None

async set_hvac_mode(device_id: str, hvac_mode: str) → None[source]

Set HVAC mode.

Parameters:

  • device_id (str) – Device ID from this controller.

  • hvac_mode (str) – Mode name from hvac_mode.supported_modes on the model.

Return type:

None

async set_target_temperature(device_id: str, target_temperature: float) → None[source]

Set target temperature for the active heat/cool mode.

Parameters:

  • device_id (str) – Device ID from this controller.

  • target_temperature (float) – Target temperature in the bridge’s configured unit.

Return type:

None

async set_temperature_range(device_id: str, temp_low: float, temp_high: float) → None[source]

Set auto-mode heating/cooling setpoints.

Parameters:

  • device_id (str) – Device ID from this controller.

  • temp_low (float) – Auto-mode heating setpoint.

  • temp_high (float) – Auto-mode cooling setpoint.

Return type:

None

async set_state(device_id: str, *, fan_mode: str | None = None, hvac_mode: str | None = None, safety_max_temp: float | None = None, safety_min_temp: float | None = None, target_temperature_auto_heating: float | None = None, target_temperature_auto_cooling: float | None = None, target_temperature_heating: float | None = None, target_temperature_cooling: float | None = None, **kwargs) → None[source]

Update thermostat state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • fan_mode (str | None) – Fan mode name.

  • hvac_mode (str | None) – HVAC mode name.

  • safety_max_temp (float | None) – Maximum safety cutoff temperature.

  • safety_min_temp (float | None) – Minimum safety cutoff temperature.

  • target_temperature_auto_heating (float | None) – Auto-mode heating setpoint.

  • target_temperature_auto_cooling (float | None) – Auto-mode cooling setpoint.

  • target_temperature_heating (float | None) – Heating setpoint.

  • target_temperature_cooling (float | None) – Cooling setpoint.

  • target_temperature – Shorthand applied to the active heat/cool setpoint.

  • **kwargs – Remaining climate fields forwarded to set_climate_state.

Return type:

None

aioafero.v1.controllers.thermostat.get_supported_modes(system_type: str, all_modes: set[str]) → set[source]

Determine the supported modes based on the system_type.

Parameters:
Return type:

set

aioafero.v1.controllers.valve module

Controller holding and managing Afero IoT resources of type valve.

class aioafero.v1.controllers.valve.ValveController(bridge: AferoBridgeV1)[source]

Bases: BaseResourcesController[Valve]

Valve / water-timer devices on bridge.valves.

Valves can have multiple toggleable elements controlled by instance.

Parameters:

bridge (AferoBridgeV1)

ITEM_TYPE_ID: ResourceTypes | None = 'metadevice.device'
ITEM_TYPES: list[ResourceTypes] | None = [ResourceTypes.WATER_TIMER]
ITEM_CLS

alias of Valve

async turn_on(device_id: str, *, instance: str | None = None) → None[source]

Open the valve.

Parameters:

  • device_id (str) – Device ID from this controller.

  • instance (str | None) – functionInstance for multi-zone valves.

Return type:

None

async turn_off(device_id: str, *, instance: str | None = None) → None[source]

Close the valve.

Parameters:

  • device_id (str) – Device ID from this controller.

  • instance (str | None) – functionInstance for multi-zone valves.

Return type:

None

async initialize_elem(afero_device: AferoDevice) → Valve[source]

Initialize the element.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

Newly initialized resource

Return type:

Valve

async update_elem(afero_device: AferoDevice) → set[source]

Update the Valve with the latest API data.

Parameters:

afero_device (AferoDevice) – Afero Device that contains the updated states

Returns:

States that have been modified

Return type:

set

async set_state(device_id: str, *, valve_open: bool | None = None, instance: str | None = None) → None[source]

Update valve state in the cloud.

Parameters:

  • device_id (str) – Device ID from this controller.

  • valve_open (bool | None) – True to open, False to close.

  • instance (str | None) – functionInstance for multi-zone valves.

Return type:

None

Module contents

Sub-package that holds controllers for creating and updating devices from Afero API.