capy.domo v0.5.4

def config(self):
data = {"brand": self.brand, "host": self.host, "id": self.id, "kind": self.kind}
if self.kind == "light":
    data.update(color=self.has_color, white=self.has_white)
data.update(self.extra)
return {k: v for k, v in data.items() if v is not None}

def set(self, on=None, brightness=None, color=None, kelvin=None):
changes = {}
if brightness is not None:
    changes["brightness"] = to_percent(brightness)
    if changes["brightness"] == 0:  # 0 % = éteint
        changes.pop("brightness")
        on = False
if color is not None:
    changes["rgb"] = to_rgb(color)
if kelvin is not None:
    changes["kelvin"] = to_kelvin(kelvin)
if self.kind == "switch" and changes:
    raise ValueError(f"capy.domo : {self.name!r} est une prise / un interrupteur : seulement on, off et toggle")
if "rgb" in changes and not self.has_color:
    raise ValueError(f"capy.domo : {self.name!r} ne fait pas de couleurs (essaie white() ou brightness())")
if "kelvin" in changes and not self.has_white:
    raise ValueError(f"capy.domo : {self.name!r} ne règle pas la température du blanc")
if "rgb" in changes and "kelvin" in changes:
    raise ValueError("capy.domo : une couleur OU un blanc, pas les deux à la fois")
if changes and on is None:
    on = True  # Régler la lumière d'une lampe éteinte l'allume
if on is not None:
    changes["on"] = bool(on)
if changes:
    try:
        self._apply(changes)
    except ConnectionError as e:
        raise ConnectionError(f"capy.domo : {self.name!r} ({self.brand}) ne répond pas : {e}") from None
return self

def on(self):
return self.set(on=True)

def off(self):
return self.set(on=False)

def toggle(self):
return self.set(on=not self.state()["on"])

def brightness(self, percent):
return self.set(brightness=percent)

def color(self, color):
return self.set(color=color)

def white(self, kelvin="neutre"):
return self.set(kelvin=kelvin)

def state(self):
try:
    state = self._state()
except ConnectionError:
    return {"on": False, "brightness": None, "color": None, "kelvin": None, "reachable": False}
return {"on": False, "brightness": None, "color": None, "kelvin": None, "reachable": True, **state}

def set(self, on=None, brightness=None, color=None, kelvin=None):
def one(device):
    if device.kind == "switch":
        wants = on
        if wants is None and any(v is not None for v in (brightness, color, kelvin)):
            wants = True
        if brightness is not None and to_percent(brightness) == 0:
            wants = False
        return device.set(on=wants)
    if color is not None and not device.has_color:
        return device.set(on=on, brightness=brightness, kelvin=kelvin if kelvin is not None else "neutre")
    return device.set(on=on, brightness=brightness, color=color, kelvin=kelvin)
self._run(one)
return self

def on(self):
return self.set(on=True)

def off(self):
return self.set(on=False)

def toggle(self):
return self.set(on=not any(s["on"] for s in self.state().values()))

def brightness(self, percent):
return self.set(brightness=percent)

def color(self, color):
return self.set(color=color)

def white(self, kelvin="neutre"):
return self.set(kelvin=kelvin)

def state(self):
return self._run(lambda device: device.state())

def group(self, name):
if name in EVERYTHING:
    return Group(name, self.devices.values())
if name not in self.groups:
    raise KeyError(f"capy.domo : aucun groupe {name!r} (groupes : {', '.join(self.groups) or 'aucun'})")
missing = [n for n in self.groups[name] if n not in self.devices]
if missing:
    raise KeyError(f"capy.domo : le groupe {name!r} contient {', '.join(missing)}, qui n'existe(nt) pas")
return Group(name, [self.devices[n] for n in self.groups[name]])

def all(self):
return self.group("tout")

def add(self, device, name=None):
base = slug(name or device.name)
name, n = base, 2
while name in self.devices or name in self.groups or name in EVERYTHING:
    name, n = f"{base}-{n}", n + 1
device.name = name
self.devices[name] = device
return name

def remove(self, name):
self.devices.pop(name)
for members in self.groups.values():
    if name in members:
        members.remove(name)

def set_group(self, name, members):
unknown = [m for m in members if m not in self.devices]
if unknown:
    raise KeyError(f"capy.domo : appareil(s) inconnu(s) : {', '.join(unknown)}")
self.groups[slug(name)] = list(members)

def save(self):
data = {"devices": {name: d.config() for name, d in self.devices.items()},
        "groups": self.groups, "scenes": self.scenes}
if self.hue:
    data["hue"] = self.hue
if self.homeassistant:
    data["homeassistant"] = self.homeassistant
self.path.write_text(jsonlib.dumps(data, indent=4, ensure_ascii=False) + "\n", encoding="utf-8")
return self.path

def scene(self, name):
if name not in self.scenes:
    raise KeyError(f"capy.domo : aucune scène {name!r} (scènes : {', '.join(self.scenes) or 'aucune'})")
settings = {target: {k: v for k, v in values.items() if k in ("on", "brightness", "color", "kelvin")}
            for target, values in self.scenes[name].items()}
Group(name, [self[target] for target in settings])._run(lambda target: target.set(**settings[target.name]))
return self

def save_scene(self, name, targets=None):
devices = [self.devices[t] for t in targets] if targets else list(self.devices.values())
scene = {}
for device_name, state in Group(name, devices).state().items():
    if not state["reachable"]:
        continue
    settings = {"on": state["on"]}
    if state["on"]:
        settings.update({k: state[k] for k in ("brightness", "color", "kelvin") if state[k] is not None})
        if "color" in settings and "kelvin" in settings:
            settings.pop("color")
    scene[device_name] = settings
self.scenes[slug(name)] = scene
return scene

def scan(self, timeout=2.0, brands=None, addresses=None, add=True):
brands, addresses = brands or list(BRANDS), addresses or {}
found, self.hints = [], []
jobs = {
    "wiz": lambda: _wiz.discover(timeout, **_address(addresses, "wiz")),
    "yeelight": lambda: _yeelight.discover(timeout, **_address(addresses, "yeelight")),
    "shelly": lambda: _shelly.discover(timeout, **_address(addresses, "shelly")),
    "hue": lambda: self._scan_hue(timeout, addresses),
    "homeassistant": lambda: self._scan_homeassistant(timeout, addresses),
}
results = {}

def run(brand):
    try:
        results[brand] = jobs[brand]()
    except (ConnectionError, OSError) as e:
        self.hints.append(f"{brand} : {e}")

threads = [threading.Thread(target=run, args=(b,)) for b in brands if b in jobs]
for t in threads:
    t.start()
for t in threads:
    t.join()
known = {(d.brand, d.host, d.id) for d in self.devices.values()}
for brand in brands:
    for device in results.get(brand, []):
        if (device.brand, device.host, device.id) not in known:
            known.add((device.brand, device.host, device.id))
            if add:
                self.add(device)
            found.append(device)
return found

def pair_hue(self, host):
self.hue[host] = _hue.pair(host)
return self._add_new(_hue.lights(host, self.hue[host]))

def pair_homeassistant(self, url, token):
_homeassistant.check(url, _env(token))
self.homeassistant = {"url": url, "token": token}
return self._add_new(_homeassistant.entities(url, _env(token)))

def list(self):
return self._ask("domo.list")

def state(self, name="tout"):
return self._ask("domo.state", name=name)

def scene(self, name):
self._ask("domo.scene", name=name)
return self

def set(self, on=None, brightness=None, color=None, kelvin=None):
if isinstance(color, tuple):
    color = list(color)
self.remote._ask("domo.set", name=self.name, on=on, brightness=brightness, color=color, kelvin=kelvin)
return self

def on(self):
return self.set(on=True)

def off(self):
return self.set(on=False)

def toggle(self):
self.remote._ask("domo.toggle", name=self.name)
return self

def brightness(self, percent):
return self.set(brightness=percent)

def color(self, color):
return self.set(color=color)

def white(self, kelvin="neutre"):
return self.set(kelvin=kelvin)

def state(self):
states = self.remote.state(self.name)
return states.get(self.name, states) if len(states) == 1 else states