Debian Codegraph @

src/anova_wifi/web_socket_containers.py

raw
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