| 1 |
from dataclasses import dataclass |
| 2 |
from enum import Enum |
| 3 |
from typing import Any, Callable |
| 4 |
|
| 5 |
# All of the containers would probably be better of using dacite, but since HA sometimes has issues with dacite I am |
| 6 |
# doing them manually |
| 7 |
|
| 8 |
|
| 9 |
@dataclass |
| 10 |
class APCUpdateBinary: |
| 11 |
cooking: bool |
| 12 |
preheating: bool | None = None |
| 13 |
maintaining: bool | None = None |
| 14 |
device_safe: bool | None = None |
| 15 |
water_leak: bool | None = None |
| 16 |
water_level_critical: bool | None = None |
| 17 |
water_temp_too_high: bool | None = None |
| 18 |
water_level_low: bool | None = None |
| 19 |
|
| 20 |
|
| 21 |
@dataclass |
| 22 |
class APCUpdateSensor: |
| 23 |
cook_time: int | None = None |
| 24 |
mode: str | None = None |
| 25 |
state: str | None = None |
| 26 |
a3_state: str | None = None |
| 27 |
target_temperature: float | None = None |
| 28 |
cook_time_remaining: int | None = None |
| 29 |
firmware_version: str | None = None |
| 30 |
heater_temperature: float | None = None |
| 31 |
triac_temperature: float | None = None |
| 32 |
water_temperature: float | None = None |
| 33 |
|
| 34 |
|
| 35 |
@dataclass |
| 36 |
class APCUpdate: |
| 37 |
binary_sensor: APCUpdateBinary |
| 38 |
sensor: APCUpdateSensor |
| 39 |
|
| 40 |
|
| 41 |
class AnovaMode(str, Enum): |
| 42 |
startup = "STARTUP" |
| 43 |
idle = "IDLE" |
| 44 |
cook = "COOK" |
| 45 |
low_water = "LOW WATER" |
| 46 |
ota = "OTA" |
| 47 |
provisioning = "PROVISIONING" |
| 48 |
high_temp = "HIGH TEMP" |
| 49 |
device_failure = "DEVICE FAILURE" |
| 50 |
|
| 51 |
|
| 52 |
class AnovaState(str, Enum): |
| 53 |
preheating = "PREHEATING" |
| 54 |
cooking = "COOKING" |
| 55 |
maintaining = "MAINTAINING" |
| 56 |
timer_expired = "TIMER EXPIRED" |
| 57 |
set_timer = "SET TIMER" |
| 58 |
no_state = "" |
| 59 |
|
| 60 |
|
| 61 |
class AnovaA3State(str, Enum): |
| 62 |
no_state = "none" |
| 63 |
connected = "connected" |
| 64 |
disconnected = "disconnected" |
| 65 |
heating = "heating" |
| 66 |
keeping_warm = "keeping_warm" |
| 67 |
cooking = "cooking" |
| 68 |
reconnecting = "reconnecting" |
| 69 |
|
| 70 |
|
| 71 |
class AnovaCommand(str, Enum): |
| 72 |
EVENT_APC_WIFI_LIST = "EVENT_APC_WIFI_LIST" |
| 73 |
EVENT_APC_STATE = "EVENT_APC_STATE" |
| 74 |
EVENT_APC_WIFI_VERSION = "EVENT_APC_WIFI_VERSION" |
| 75 |
EVENT_APC_WIFI_ADDED = "EVENT_APC_WIFI_ADDED" |
| 76 |
EVENT_APC_WIFI_REMOVED = "EVENT_APC_WIFI_REMOVED" |
| 77 |
CMD_APC_SET_TARGET_TEMP = "CMD_APC_SET_TARGET_TEMP" |
| 78 |
CMD_APC_SET_TIMER = "CMD_APC_SET_TIMER" |
| 79 |
CMD_APC_START = "CMD_APC_START" |
| 80 |
CMD_APC_STOP = "CMD_APC_STOP" |
| 81 |
RESPONSE = "RESPONSE" |
| 82 |
|
| 83 |
# Grabbed from apk |
| 84 |
CMD_AUTH_TOKEN = "CMD_AUTH_TOKEN" |
| 85 |
AUTH_TOKEN_V2 = "AUTH_TOKEN_V2" |
| 86 |
CMD_APC_SET_METADATA = "CMD_APC_SET_METADATA" |
| 87 |
CMD_APC_SET_TEMPERATURE_UNIT = "CMD_APC_SET_TEMPERATURE_UNIT" |
| 88 |
CMD_APC_OTA = "CMD_APC_OTA" |
| 89 |
CMD_NAME_WIFI_DEVICE = "CMD_NAME_WIFI_DEVICE" |
| 90 |
CMD_APC_A3_SET_CREDENTIALS = "CMD_APC_A3_SET_CREDENTIALS" |
| 91 |
CMD_APC_REGISTER_PUSH_TOKEN = "CMD_APC_REGISTER_PUSH_TOKEN" |
| 92 |
CMD_APC_START_ICEBATH_MONITORING = "CMD_APC_START_ICEBATH_MONITORING" |
| 93 |
CMD_APC_DISCONNECT = "CMD_APC_DISCONNECT" |
| 94 |
CMD_APC_HEALTHCHECK = "CMD_APC_HEALTHCHECK" |
| 95 |
|
| 96 |
|
| 97 |
@dataclass |
| 98 |
class WifiJob: |
| 99 |
id: str |
| 100 |
cook_time_seconds: int |
| 101 |
target_temperature: float |
| 102 |
temperature_unit: str |
| 103 |
mode: AnovaMode |
| 104 |
ota_url: str |
| 105 |
|
| 106 |
|
| 107 |
@dataclass |
| 108 |
class WifiJobStatus: |
| 109 |
cook_time_remaining: int | None |
| 110 |
state: AnovaState |
| 111 |
|
| 112 |
|
| 113 |
@dataclass |
| 114 |
class WifiPinInfo: |
| 115 |
is_device_safe: bool | None |
| 116 |
is_water_leak: bool | None |
| 117 |
is_water_level_critical: bool | None |
| 118 |
is_water_level_low: bool | None |
| 119 |
water_temp_too_high: bool | None |
| 120 |
|
| 121 |
|
| 122 |
@dataclass |
| 123 |
class WifiSystemInfo: |
| 124 |
firmware_version: str |
| 125 |
class_name: str | None = None |
| 126 |
type: str | None = None |
| 127 |
|
| 128 |
|
| 129 |
@dataclass |
| 130 |
class WifiSystemInfo3220: |
| 131 |
firmware_version: str |
| 132 |
has_real_cert_catalog: str | None = None |
| 133 |
firmware_version_raw: str | None = None |
| 134 |
largest_free_heap_size: int | None = None |
| 135 |
stack_low_level: int | None = None |
| 136 |
stack_low_task: int | None = None |
| 137 |
systick: int | None = None |
| 138 |
total_free_heap_size: int | None = None |
| 139 |
|
| 140 |
|
| 141 |
@dataclass |
| 142 |
class WifiSystemInfoNxp: |
| 143 |
firmware_version: str # 'version-string' |
| 144 |
|
| 145 |
|
| 146 |
@dataclass |
| 147 |
class WifiTemperatureInfo: |
| 148 |
"""Gets temperature info for the device. All in celsius.""" |
| 149 |
|
| 150 |
heater_temperature: float | None |
| 151 |
triac_temperature: float | None |
| 152 |
water_temperature: float |
| 153 |
|
| 154 |
|
| 155 |
@dataclass |
| 156 |
class WifiCookerStateBody: |
| 157 |
audio_control: Any | None |
| 158 |
boot_id: str | None |
| 159 |
cap_touch: Any | None |
| 160 |
heater_control: Any | None |
| 161 |
job: WifiJob |
| 162 |
job_status: WifiJobStatus |
| 163 |
motor_control: Any | None |
| 164 |
network_info: Any | None |
| 165 |
pin_info: WifiPinInfo |
| 166 |
system_info: WifiSystemInfo | None |
| 167 |
system_info_3220: WifiSystemInfo3220 | None |
| 168 |
system_info_nxp: WifiSystemInfoNxp | None |
| 169 |
temperature_info: WifiTemperatureInfo |
| 170 |
|
| 171 |
@property |
| 172 |
def firmware_version(self) -> str: |
| 173 |
if self.system_info: |
| 174 |
return self.system_info.firmware_version |
| 175 |
if self.system_info_3220: |
| 176 |
return self.system_info_3220.firmware_version |
| 177 |
if self.system_info_nxp: |
| 178 |
return self.system_info_nxp.firmware_version |
| 179 |
else: |
| 180 |
return "unknown" |
| 181 |
|
| 182 |
def to_apc_update(self) -> APCUpdate: |
| 183 |
sensors = APCUpdateSensor( |
| 184 |
cook_time=self.job.cook_time_seconds, |
| 185 |
mode=self.job.mode.name, |
| 186 |
state=self.job_status.state.name, |
| 187 |
target_temperature=self.job.target_temperature, |
| 188 |
cook_time_remaining=self.job_status.cook_time_remaining, |
| 189 |
firmware_version=self.firmware_version, |
| 190 |
heater_temperature=self.temperature_info.heater_temperature, |
| 191 |
triac_temperature=self.temperature_info.triac_temperature, |
| 192 |
water_temperature=self.temperature_info.water_temperature, |
| 193 |
) |
| 194 |
|
| 195 |
binary_sensors = APCUpdateBinary( |
| 196 |
cooking=bool(self.job.mode == AnovaMode.cook), |
| 197 |
preheating=bool(self.job_status.state == AnovaState.preheating), |
| 198 |
maintaining=bool( |
| 199 |
self.job_status.state == AnovaState.maintaining |
| 200 |
or self.job_status.state == AnovaState.timer_expired |
| 201 |
), |
| 202 |
device_safe=self.pin_info.is_device_safe, |
| 203 |
water_leak=self.pin_info.is_water_leak, |
| 204 |
water_level_critical=self.pin_info.is_water_level_critical, |
| 205 |
water_temp_too_high=self.pin_info.water_temp_too_high, |
| 206 |
water_level_low=self.pin_info.is_water_level_low, |
| 207 |
) |
| 208 |
return APCUpdate(sensor=sensors, binary_sensor=binary_sensors) |
| 209 |
|
| 210 |
|
| 211 |
def build_wifi_cooker_state_body(apc_response: dict[str, Any]) -> WifiCookerStateBody: |
| 212 |
system_info = None |
| 213 |
system_info_3220 = None |
| 214 |
system_info_nxp = None |
| 215 |
audio_control = apc_response.get("audio-control") |
| 216 |
boot_id = apc_response.get("boot-id") |
| 217 |
cap_touch = apc_response.get("cap-touch") |
| 218 |
heater_control = apc_response.get("heater-control") |
| 219 |
job_json: dict[str, Any] = apc_response["job"] |
| 220 |
job = WifiJob( |
| 221 |
id=job_json["id"], |
| 222 |
cook_time_seconds=job_json["cook-time-seconds"], |
| 223 |
mode=AnovaMode(job_json["mode"]), |
| 224 |
ota_url=job_json["ota-url"], |
| 225 |
target_temperature=job_json["target-temperature"], |
| 226 |
temperature_unit=job_json["temperature-unit"], |
| 227 |
) |
| 228 |
job_status_json: dict[str, Any] = apc_response["job-status"] |
| 229 |
job_status = WifiJobStatus( |
| 230 |
cook_time_remaining=job_status_json.get("cook-time-remaining"), |
| 231 |
state=AnovaState(job_status_json["state"]), |
| 232 |
) |
| 233 |
network_info = apc_response.get("network-info") |
| 234 |
motor_control = apc_response.get("motor-control") |
| 235 |
pin_info_json: dict[str, int] = apc_response["pin-info"] |
| 236 |
pin_info = WifiPinInfo( |
| 237 |
is_device_safe=bool(pin_info_json["device-safe"]) |
| 238 |
if "device-safe" in pin_info_json |
| 239 |
else None, |
| 240 |
is_water_leak=bool(pin_info_json.get("water-leak")) |
| 241 |
if "water-leak" in pin_info_json |
| 242 |
else None, |
| 243 |
is_water_level_critical=bool(pin_info_json.get("water-level-critical")) |
| 244 |
if "water-level-critical" in pin_info_json |
| 245 |
else None, |
| 246 |
is_water_level_low=bool(pin_info_json.get("water-level-low")) |
| 247 |
if "water-level-low" in pin_info_json |
| 248 |
else None, |
| 249 |
water_temp_too_high=bool(pin_info_json.get("water-temp-too-high")) |
| 250 |
if "water-temp-too-high" in pin_info_json |
| 251 |
else None, |
| 252 |
) |
| 253 |
system_info_json: dict[str, str] | None = apc_response.get("system-info") |
| 254 |
if system_info_json is not None: |
| 255 |
system_info = WifiSystemInfo( |
| 256 |
firmware_version=system_info_json["firmware-version"], |
| 257 |
class_name=system_info_json.get("class"), |
| 258 |
type=system_info_json.get("type"), |
| 259 |
) |
| 260 |
system_info_3220_json: dict[str, str] | None = apc_response.get("system-info-3220") |
| 261 |
if system_info_3220_json: |
| 262 |
largest_free_heap_size = system_info_3220_json.get("largest-free-heap-size") |
| 263 |
system_info_3220 = WifiSystemInfo3220( |
| 264 |
firmware_version=system_info_3220_json["firmware-version"], |
| 265 |
has_real_cert_catalog=system_info_3220_json.get("has-real-cert-catalog"), |
| 266 |
firmware_version_raw=system_info_3220_json.get("firmware-version-raw"), |
| 267 |
largest_free_heap_size=int(largest_free_heap_size) |
| 268 |
if largest_free_heap_size is not None |
| 269 |
else None, |
| 270 |
# Too lazy to do these right now. |
| 271 |
# stack_low_level=system_info_3220_json.get("stack-low-level"), |
| 272 |
# stack_low_task=system_info_3220_json.get("stack-low-task"), |
| 273 |
# systick=system_info_3220_json.get("systick"), |
| 274 |
# total_free_heap_size=system_info_3220_json.get("total-free-heap-size"), |
| 275 |
) |
| 276 |
system_info_nxp_json: dict[str, str] | None = apc_response.get("system-info-nxp") |
| 277 |
if system_info_nxp_json: |
| 278 |
system_info_nxp = WifiSystemInfoNxp( |
| 279 |
firmware_version=system_info_nxp_json["version-string"] |
| 280 |
) |
| 281 |
temperature_info_json: dict[str, float] = apc_response["temperature-info"] |
| 282 |
temperature_info = WifiTemperatureInfo( |
| 283 |
heater_temperature=temperature_info_json.get("heater-temperature"), |
| 284 |
water_temperature=temperature_info_json["water-temperature"], |
| 285 |
triac_temperature=temperature_info_json.get("triac-temperature"), |
| 286 |
) |
| 287 |
return WifiCookerStateBody( |
| 288 |
audio_control=audio_control, |
| 289 |
boot_id=boot_id, |
| 290 |
cap_touch=cap_touch, |
| 291 |
heater_control=heater_control, |
| 292 |
job=job, |
| 293 |
job_status=job_status, |
| 294 |
motor_control=motor_control, |
| 295 |
pin_info=pin_info, |
| 296 |
system_info=system_info, |
| 297 |
system_info_3220=system_info_3220, |
| 298 |
system_info_nxp=system_info_nxp, |
| 299 |
temperature_info=temperature_info, |
| 300 |
network_info=network_info, |
| 301 |
) |
| 302 |
|
| 303 |
|
| 304 |
def build_a3_payload(apc_response: dict[str, Any]) -> APCUpdate: |
| 305 |
firmware_version: str = apc_response["firmwareVersion"] |
| 306 |
is_cooking: bool = apc_response["isCooking"] |
| 307 |
current_temperature: float = apc_response["currentTemperature"] |
| 308 |
target_temperature: float = apc_response["targetTemperature"] |
| 309 |
timer_in_seconds: int = apc_response["timerInSeconds"] |
| 310 |
# unit = apc_response.get("unit") |
| 311 |
# is_timer_running = apc_response.get("isTimerRunning") |
| 312 |
# is_speaker_on = apc_response.get("isSpeakerOn") |
| 313 |
# is_alarm_active = apc_response.get("isAlarmActive") |
| 314 |
# current_job_id = apc_response.get("currentJobID") |
| 315 |
current_job = apc_response.get("currentJob") |
| 316 |
# is_keeping_warm = apc_response.get("isKeepingWarming") |
| 317 |
# is_checking_temperature_for_ice_bath = apc_response.get( |
| 318 |
# "isCheckingTemperatureForIceBath" |
| 319 |
# ) |
| 320 |
# is_monitoring_ice_bath = apc_response.get("isMonitoringIcebath") |
| 321 |
# is_connected = apc_response.get("isConnected") |
| 322 |
if current_job is not None: |
| 323 |
job_stage: str = current_job["jobStage"] |
| 324 |
status = AnovaA3State(job_stage) |
| 325 |
else: |
| 326 |
status = AnovaA3State.no_state |
| 327 |
sensors = APCUpdateSensor( |
| 328 |
a3_state=status.name, |
| 329 |
target_temperature=float(target_temperature), |
| 330 |
cook_time_remaining=int(timer_in_seconds), |
| 331 |
firmware_version=firmware_version, |
| 332 |
water_temperature=float(current_temperature), |
| 333 |
) |
| 334 |
|
| 335 |
binary_sensors = APCUpdateBinary( |
| 336 |
cooking=bool(is_cooking), |
| 337 |
preheating=bool(status == AnovaState.preheating), |
| 338 |
maintaining=bool( |
| 339 |
status == AnovaState.maintaining or status == AnovaState.timer_expired |
| 340 |
), |
| 341 |
) |
| 342 |
return APCUpdate(binary_sensors, sensors) |
| 343 |
|
| 344 |
|
| 345 |
def build_a6_a7_payload(apc_response: dict[str, Any]) -> APCUpdate: |
| 346 |
system_info = apc_response["systemInfo"] |
| 347 |
firmware_version = system_info["firmwareVersion"] |
| 348 |
mode = apc_response["state"]["mode"] |
| 349 |
nodes = apc_response["nodes"] |
| 350 |
sensors = APCUpdateSensor( |
| 351 |
firmware_version=firmware_version, |
| 352 |
mode=mode, |
| 353 |
water_temperature=float(nodes["waterTemperatureSensor"]["current"]["celsius"]), |
| 354 |
target_temperature=float( |
| 355 |
nodes["waterTemperatureSensor"]["setpoint"]["celsius"] |
| 356 |
), |
| 357 |
cook_time=int(nodes["timer"]["initial"]), |
| 358 |
) |
| 359 |
binary_sensors = APCUpdateBinary( |
| 360 |
cooking=bool(mode == "cook"), |
| 361 |
water_level_low=bool(nodes["lowWater"]["warning"]), |
| 362 |
water_level_critical=bool(nodes["lowWater"]["empty"]), |
| 363 |
) |
| 364 |
return APCUpdate(binary_sensors, sensors) |
| 365 |
|
| 366 |
|
| 367 |
@dataclass |
| 368 |
class APCWifiDevice: |
| 369 |
cooker_id: str |
| 370 |
type: str |
| 371 |
paired_at: str |
| 372 |
name: str |
| 373 |
update_listener: Callable[[APCUpdate], None] | None = None |
| 374 |
|
| 375 |
def set_update_listener(self, update_function: Callable[[APCUpdate], None]) -> None: |
| 376 |
self.update_listener = update_function |