class TpLinkHandler(SmartDeviceException): def __init__(self, address): self.device = SmartPlug(address) def update(self): asyncio.run(self.device.update()) def update_two(self): asyncio.create_task(self.device.update()) def shutdown_btn(self): asyncio.create_task(self.device.turn_off()) return "shutdown" def turnOn_btn(self): asyncio.create_task(self.device.turn_on()) return "Turning on" def shutdown(self): asyncio.run(self.device.turn_off()) return "shutdown" def turnOn(self): asyncio.run(self.device.turn_on()) return "Turning on" def get_plug_information(self): return self.device.hw_info def __repr__(self): pass
def switch_plug(): p = SmartPlug("192.168.0.51") try: asyncio.run(p.update()) except SmartDeviceException as e: logging.error("Could not reach smart plug...") sys.exit(e) if p.is_on: asyncio.run(p.turn_off()) else: asyncio.run(p.turn_on()) asyncio.run(p.update()) print("The plug is on: ", p.is_on)
def switch(request): if request.method == 'POST': post_data = json.loads(request.body.decode("utf-8")) plug_name = post_data.get('name', None) try: switch = get_switch(plug_name) except ValueError: return JsonResponse({'error': 'invalid name'}) command = post_data.get('command', None) if command == 'on': if switch.is_on: return JsonResponse({'error': 'already on'}) asyncio.run(switch.turn_on()) return JsonResponse({'success': f"{plug_name} turned on"}) elif command == 'off': if not switch.is_on: return JsonResponse({'error': 'already off'}) asyncio.run(switch.turn_off()) return JsonResponse({'success': f"{plug_name} turned off"}) else: print(command) if request.method == 'GET': switches = get_all_switches() if not switches: switches = [] for s in SWITCHES: switch = SmartPlug(s['ip']) asyncio.run(switch.update()) switches.append(switch) switches = [{'name': switch.alias, 'is_on': switch.is_on} for switch in switches] return JsonResponse({'switches': switches})
def get_switch(switch_name: str): found_devices = asyncio.run(Discover.discover()) device = [ dev for addr, dev in found_devices.items() if dev.alias == switch_name ] if len(device) != 1: if switch_name not in [s['alias'] for s in SWITCHES]: raise ValueError("Invalid Name") s = [s for s in SWITCHES if s['alias'] == switch_name][0] switch = SmartPlug(s['ip']) asyncio.run(switch.update()) return switch return device[0]
class TpLinkHandlerSmartPlug(SmartDeviceException): def __init__(self, address): self.device = SmartPlug(address) def update(self): asyncio.run(self.device.update()) def update_two(self): asyncio.create_task(self.device.update()) def update_three(self): future = asyncio.run_coroutine_threadsafe(self.device.update(), self.worker.loop) result = future.result() def shutdown_btn(self, settings): asyncio.create_task(self.device.turn_off()) return "shutdown" def turnOn_btn(self, settings): asyncio.create_task(self.device.turn_on()) return "Turning on" def shutdown(self): asyncio.run(self.device.turn_off()) return "shutdown" def turnOn(self): asyncio.run(self.device.turn_on()) return "Turning on" def get_plug_information(self): return self.device.hw_info def __repr__(self): pass
def scan(): """Check whether the smart plug is on. After checking the smart plug, we perform a poll operation, as in ``poll()``. Normally, we rely on the contents of the state file to determine whether the smart plug is on. However, this assumes that only ``BatteryController`` turns it on and off. If something else turns it on or off, we should call ``scan()`` to ensure that ``BatteryController`` picks up the change. """ BatteryController._ping_plug() plug = SmartPlug(BatteryController._PLUG_IP_ADDRESS) asyncio.run(plug.update()) with BatteryController._lock(): status = BatteryController._read_state() status['currentState'] = plug.is_on BatteryController._poll(status)
def create_device_from_ip_or_scan(ip, device_name): """Tries to create a kasa SmartDevice object either from a given IP address or by scanning the network.""" device = None if ip: try: device = SmartPlug(ip) asyncio.run(device.update()) except exceptions.SmartDeviceException: print( "Unable to connect to device at provided IP. Attempting scan.") # If unable to create device from ip, or ip is not given, scan the network. if not device: devices = asyncio.run(Discover.discover()) for _, dev in devices.items(): if dev.alias == device_name: asyncio.run(dev.update()) device = dev return device
def off(): plug = SmartPlug("192.168.178.23") asyncio.run(plug.update()) asyncio.run(plug.turn_off()) return redirect("/")
def status(): plug = SmartPlug("192.168.178.23") asyncio.run(plug.update()) return {'host': plug.host, 'state': plug.is_on}
from astral import LocationInfo from astral.sun import sun from datetime import date, datetime, timedelta from apscheduler.schedulers.blocking import BlockingScheduler from kasa import SmartPlug import asyncio import os IP_ADDRESS = "192.168.1.3" scheduler = BlockingScheduler() plug = SmartPlug(IP_ADDRESS) asyncio.run(plug.update()) os.environ['TZ'] = 'America/New_York' def main(): print(f"{datetime.now()} - Adding Daily Job To Scheduler") print(datetime.now()) scheduler.add_job(schedule_on_and_off_time, 'cron', hour=18, minute=50, misfire_grace_time=300) try: print(f"{datetime.now()} - Scheduler Starting") scheduler.start() except (KeyboardInterrupt, SystemExit): pass
class LightControl: def __init__(self, ip=None): self._ip = ip self._plug = None self._args = None def parse_args(self): parser = argparse.ArgumentParser(prog="light") parser.add_argument('command', choices=['on', 'off', 'status']) parser.add_argument('--verbose', '-v', action='count', default=0) parser.add_argument('-ip', help='IP address of smart plug', default=None) self._args = parser.parse_args() self._debug(self._args, 3) self._debug('debug level only goes to 3 (-vvv)', 4) if hasattr(self._args, 'ip') and self._args.ip is not None: self._debug('loading ip from sys.argv', 3) self._ip = self._args.ip else: self._debug('loading ip from environment', 3) load_dotenv() self._ip = os.getenv('LIGHT_CONTROL_IP_ADDR') if self._ip is None: self._debug(f'Invalid IP address (actual {self._ip} expected XX.XX.XX.XX)') sys.exit() if verify_ip(self._ip) == False: self._debug(f'Invalid IP address (actual {self._ip} expected XX.XX.XX.XX)') sys.exit() self._debug(f'ip address is set to {self._ip}', 1) def run_command(self): self._initalize_device() if self._args.command == 'on': self._on() elif self._args.command == 'off': self._off() elif self._args.command == 'status': self._status() else: print(f"command not valid (actual {self._args.command} expected one of {'on', 'off', 'status'}") def _initalize_device(self): # self._ip self._plug = SmartPlug(self._ip) asyncio.run(self._plug.update()) self._debug(f'connected to plug: {self._plug.alias}', 1) def _on(self): asyncio.run(self._plug.turn_on()) if self._verify_state(True): self._debug('light is turned on', 1) else: self._debug('light failed to turn on') def _off(self): asyncio.run(self._plug.turn_off()) if self._verify_state(False): self._debug('light is turned off', 1) else: self._debug('light failed to turn off') def _status(self): if self._verify_state(True): self._debug('light is turned on', 0) else: self._debug('light is turned off', 0) def _verify_state(self, state): asyncio.run(self._plug.update()) return self._plug.is_on == state def _debug(self, msg, level=0): if level <= self._args.verbose: print("-"*level, end="") print(msg)