3 """Utilities for dealing with the smart lights."""
5 from abc import ABC, abstractmethod
13 from typing import Dict, List, Optional, Set
19 from google_assistant import ask_google, GoogleResponse
20 from decorator_utils import timeout, memoized
22 logger = logging.getLogger(__name__)
24 parser = config.add_commandline_args(
25 f"Light Utils ({__file__})",
26 "Args related to light utilities."
29 '--light_utils_tplink_location',
30 default='/home/scott/bin/tplink.py',
32 help='The location of the tplink.py helper',
33 type=argparse_utils.valid_filename,
36 '--light_utils_network_mac_addresses_location',
37 default='/home/scott/bin/network_mac_addresses.txt',
39 help='The location of network_mac_addresses.txt',
40 type=argparse_utils.valid_filename,
45 5.0, use_signals=False, error_message="Timed out waiting for tplink.py"
47 def tplink_light_command(command: str) -> bool:
48 result = os.system(command)
49 signal = result & 0xFF
51 logging_utils.hlog("%s died with signal %d" % (command, signal))
54 exit_value = result >> 8
56 logging_utils.hlog("%s failed, exit %d" % (command, exit_value))
62 def __init__(self, name: str, mac: str, keywords: str = "") -> None:
63 self.name = name.strip()
64 self.mac = mac.strip()
65 self.keywords = keywords.strip()
66 self.kws = keywords.split()
68 def get_name(self) -> str:
71 def get_mac(self) -> str:
75 def turn_on(self) -> bool:
79 def turn_off(self) -> bool:
83 def is_on(self) -> bool:
87 def is_off(self) -> bool:
91 def get_dimmer_level(self) -> Optional[int]:
95 def set_dimmer_level(self, level: int) -> bool:
99 def make_color(self, color: str) -> bool:
102 def get_keywords(self) -> List[str]:
105 def has_keyword(self, keyword: str) -> bool:
112 class GoogleLight(Light):
113 def __init__(self, name: str, mac: str, keywords: str = "") -> None:
114 super().__init__(name, mac, keywords)
116 def goog_name(self) -> str:
117 name = self.get_name()
118 return name.replace("_", " ")
121 def parse_google_response(response: GoogleResponse) -> bool:
122 return response.success
124 def turn_on(self) -> bool:
125 return GoogleLight.parse_google_response(
126 ask_google(f"turn {self.goog_name()} on")
129 def turn_off(self) -> bool:
130 return GoogleLight.parse_google_response(
131 ask_google(f"turn {self.goog_name()} off")
134 def is_on(self) -> bool:
135 r = ask_google(f"is {self.goog_name()} on?")
138 return 'is on' in r.audio_transcription
140 def is_off(self) -> bool:
141 return not self.is_on()
143 def get_dimmer_level(self) -> Optional[int]:
144 if not self.has_keyword("dimmer"):
146 r = ask_google(f'how bright is {self.goog_name()}?')
150 # the bookcase one is set to 40% bright
151 txt = r.audio_transcription
152 m = re.search(r"(\d+)% bright", txt)
154 return int(m.group(1))
159 def set_dimmer_level(self, level: int) -> bool:
160 if not self.has_keyword("dimmer"):
162 if 0 <= level <= 100:
163 was_on = self.is_on()
164 r = ask_google(f"set {self.goog_name()} to {level} percent")
172 def make_color(self, color: str) -> bool:
173 return GoogleLight.parse_google_response(
174 ask_google(f"make {self.goog_name()} {color}")
178 class TPLinkLight(Light):
179 def __init__(self, name: str, mac: str, keywords: str = "") -> None:
180 super().__init__(name, mac, keywords)
181 self.children: List[str] = []
182 self.info: Optional[Dict] = None
183 self.info_ts: Optional[datetime.datetime] = None
184 if "children" in self.keywords:
185 self.info = self.get_info()
186 if self.info is not None:
187 for child in self.info["children"]:
188 self.children.append(child["id"])
191 def get_tplink_name(self) -> Optional[str]:
192 self.info = self.get_info()
193 if self.info is not None:
194 return self.info["alias"]
197 def get_cmdline(self, child: str = None) -> str:
199 f"{config.config['light_utils_tplink_location']} -m {self.mac} "
200 f"--no_logging_console "
202 if child is not None:
203 cmd += f"-x {child} "
206 def get_children(self) -> List[str]:
210 self, cmd: str, child: str = None, extra_args: str = None
212 cmd = self.get_cmdline(child) + f"-c {cmd}"
213 if extra_args is not None:
214 cmd += f" {extra_args}"
215 return tplink_light_command(cmd)
217 def turn_on(self, child: str = None) -> bool:
218 return self.command("on", child)
220 def turn_off(self, child: str = None) -> bool:
221 return self.command("off", child)
223 def is_on(self) -> bool:
224 return self.get_on_duration_seconds() > 0
226 def is_off(self) -> bool:
227 return not self.is_on()
229 def make_color(self, color: str) -> bool:
230 raise NotImplementedError
233 10.0, use_signals=False, error_message="Timed out waiting for tplink.py"
235 def get_info(self) -> Optional[Dict]:
236 cmd = self.get_cmdline() + "-c info"
237 out = subprocess.getoutput(cmd)
238 out = re.sub("Sent:.*\n", "", out)
239 out = re.sub("Received: *", "", out)
241 self.info = json.loads(out)["system"]["get_sysinfo"]
242 self.info_ts = datetime.datetime.now()
244 except Exception as e:
246 print(out, file=sys.stderr)
251 def get_on_duration_seconds(self, child: str = None) -> int:
252 self.info = self.get_info()
254 if self.info is None:
256 return int(self.info.get("on_time", "0"))
258 if self.info is None:
260 for chi in self.info.get("children", {}):
261 if chi["id"] == child:
262 return int(chi.get("on_time", "0"))
265 def get_on_limit_seconds(self) -> Optional[int]:
267 m = re.search(r"timeout:(\d+)", kw)
269 return int(m.group(1)) * 60
272 def get_dimmer_level(self) -> Optional[int]:
273 if not self.has_keyword("dimmer"):
275 self.info = self.get_info()
276 if self.info is None:
278 return int(self.info.get("brightness", "0"))
280 def set_dimmer_level(self, level: int) -> bool:
281 if not self.has_keyword("dimmer"):
285 + f'-j \'{{"smartlife.iot.dimmer":{{"set_brightness":{{"brightness":{level} }} }} }}\''
287 return tplink_light_command(cmd)
290 class GoogleLightGroup(GoogleLight):
291 def __init__(self, name: str, members: List[GoogleLight], keywords: str = "") -> None:
293 raise Exception("There must be at least one light in the group.")
294 self.members = members
295 mac = GoogleLightGroup.make_up_mac(members)
296 super().__init__(name, mac, keywords)
299 def make_up_mac(members: List[GoogleLight]):
300 mac = members[0].get_mac()
302 b[5] = int(b[5], 16) + 1
308 def is_on(self) -> bool:
309 r = ask_google(f"are {self.goog_name()} on?")
312 return 'is on' in r.audio_transcription
314 def get_dimmer_level(self) -> Optional[int]:
315 if not self.has_keyword("dimmer"):
317 r = ask_google(f'how bright are {self.goog_name()}?')
321 # four lights are set to 100% brightness
322 txt = r.audio_transcription
323 m = re.search(r"(\d+)% bright", txt)
325 return int(m.group(1))
330 def set_dimmer_level(self, level: int) -> bool:
331 if not self.has_keyword("dimmer"):
333 if 0 <= level <= 100:
334 was_on = self.is_on()
335 r = ask_google(f"set {self.goog_name()} to {level} percent")
343 def make_color(self, color: str) -> bool:
344 return GoogleLight.parse_google_response(
345 ask_google(f"make {self.goog_name()} {color}")
349 def group_google_lights(lights: List[Light]) -> List[Light]:
351 diningroom_group = []
353 name = light.get_name()
354 if "bookcase_light_" in name:
355 bookcase_group.append(light)
356 elif "diningroom_light_" in name:
357 diningroom_group.append(light)
360 did_diningroom = False
363 name = light.get_name()
364 if "bookcase_light_" in name:
365 if len(bookcase_group) == 4 and not did_bookcase:
370 "perm wifi light smart goog dimmer"
374 elif "diningroom_light_" in name:
375 if len(diningroom_group) == 2 and not did_diningroom:
378 "dining_room_lights",
380 "intermittent wifi light smart goog dimmer"
383 did_diningroom = True
389 class LightingConfig(object):
390 """Representation of the smart light device config."""
394 config_file: str = None,
396 if config_file is None:
397 config_file = config.config[
398 'light_utils_network_mac_addresses_location'
400 self.macs_by_name = {}
401 self._keywords_by_name = {}
402 self.keywords_by_mac = {}
403 self.names_by_mac = {}
404 self.corpus = logical_search.Corpus()
405 with open(config_file, "r") as f:
406 contents = f.readlines()
408 diningroom_lights = []
410 for line in contents:
411 line = line.rstrip("\n")
412 line = re.sub(r"#.*$", r"", line)
416 (mac, name, keywords) = line.split(",")
419 keywords = keywords.strip()
420 if "perm" not in keywords:
422 self.macs_by_name[name] = mac
423 self._keywords_by_name[name] = keywords
424 self.keywords_by_mac[mac] = keywords
425 self.names_by_mac[mac] = name
427 if "bookcase_light_" in name:
428 bookcase_lights.append(mac)
429 elif "diningroom_light_" in name:
430 diningroom_lights.append(mac)
432 self.index_light(name, keywords, mac)
434 name = 'bookcase_lights'
436 keywords = 'perm wifi light smart goog dimmer'
437 for b in bookcase_lights:
438 group.append(self.get_light_by_mac(b))
439 self.bookcase_group = GoogleLightGroup(
444 mac = self.bookcase_group.get_mac()
445 self.macs_by_name[name] = mac
446 self._keywords_by_name[name] = keywords
447 self.keywords_by_mac[mac] = keywords
448 self.names_by_mac[mac] = name
449 self.index_light(name, keywords, mac)
451 name = 'dining_room_lights'
453 for b in diningroom_lights:
454 group.append(self.get_light_by_mac(b))
455 self.diningroom_group = GoogleLightGroup(
460 mac = self.diningroom_group.get_mac()
461 self.macs_by_name[name] = mac
462 self._keywords_by_name[name] = keywords
463 self.keywords_by_mac[mac] = keywords
464 self.names_by_mac[mac] = name
465 self.index_light(name, keywords, mac)
467 def index_light(self, name: str, keywords: str, mac: str) -> None:
468 properties = [("name", name)]
470 for kw in keywords.split():
472 key, value = kw.split(":")
473 properties.append((key, value))
477 logical_search.Document(
480 properties=properties,
485 def __repr__(self) -> str:
486 s = "Known devices:\n"
487 for name, keywords in self._keywords_by_name.items():
488 mac = self.macs_by_name[name]
489 s += f" {name} ({mac}) => {keywords}\n"
492 def get_keywords_by_name(self, name: str) -> Optional[str]:
493 return self._keywords_by_name.get(name, None)
495 def get_macs_by_name(self, name: str) -> Set[str]:
497 for (mac, lname) in self.names_by_mac.items():
502 def get_macs_by_keyword(self, keyword: str) -> Set[str]:
504 for (mac, keywords) in self.keywords_by_mac.items():
505 if keyword in keywords:
509 def get_light_by_name(self, name: str) -> Optional[Light]:
510 if name in self.macs_by_name:
511 return self.get_light_by_mac(self.macs_by_name[name])
514 def get_all_lights(self) -> List[Light]:
516 for (mac, kws) in self.keywords_by_mac.items():
518 light = self.get_light_by_mac(mac)
519 if light is not None:
521 return group_google_lights(retval)
523 def get_light_by_mac(self, mac: str) -> Optional[Light]:
524 if mac in self.keywords_by_mac:
525 name = self.names_by_mac[mac]
526 kws = self.keywords_by_mac[mac]
527 if name == 'bookcase_lights':
528 return self.bookcase_group
529 elif name == 'dining_room_lights':
530 return self.diningroom_group
531 elif "tplink" in kws.lower():
532 return TPLinkLight(name, mac, kws)
534 return GoogleLight(name, mac, kws)
537 def query(self, query: str) -> List[Light]:
538 """Evaluates a lighting query expression formed of keywords to search
539 for, logical operators (and, or, not), and parenthesis.
540 Returns a list of matching lights.
543 results = self.corpus.query(query)
544 if results is not None:
547 light = self.get_light_by_mac(mac)
548 if light is not None:
550 return group_google_lights(retval)