async def connect(self): try: self.strip = SmartStrip(self.address) await self.strip.update() return 0, f'Strip {self.strip.alias}: {self.strip.hw_info}' except Exception: return 1, str(traceback.print_exc())
async def kill(self, ctx): if not await self.isOnCooldown(ctx) and not await self.voteInEffect(ctx ): print('vote started...') self.start_vote = True dev = SmartStrip("192.168.0.165") await dev.update() await ctx.send(f'Kill vote started, type !y or !n in chat!') #vote delay await asyncio.sleep(self.vote_delay) print('vote ended...') #handle pass/fail and reset vote bool if (self.ycount > self.ncount): await ctx.send(f'Vote passed!') print(self.cooldown_end) self.cooldown_end = time.time() + self.kill_delay #reboot plug1 await dev.children[0].turn_off() await asyncio.sleep(1) await dev.children[0].turn_on() print('on cooldown...') await self.kill_wait() print('off cooldown...') else: await ctx.send(f'Vote failed!') self.ycount = 0 self.ncount = 0 self.voter_list = [] self.start_vote = False print('reset!')
def power_get(host, port, index): assert port is None index = int(index) strip = SmartStrip(host) asyncio.run(strip.update()) assert (len(strip.children) > index), "Trying to access non-existant plug socket on strip" return strip.children[index].is_on
def try_connect(self): try: from kasa import SmartStrip self.strip = SmartStrip(self.plug_address) asyncio.run(self.strip.update()) self.output_setup = True except Exception as e: self.logger.error( "Output was unable to be setup: {err}".format(err=e))
async def cli(ctx, host, alias, target, debug, bulb, plug, lightstrip, strip, klap, user, password): """A tool for controlling TP-Link smart home devices.""" # noqa if debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) if ctx.invoked_subcommand == "discover": return if alias is not None and host is None: click.echo(f"Alias is given, using discovery to find host {alias}") host = await find_host_from_alias(alias=alias, target=target) if host: click.echo(f"Found hostname is {host}") else: click.echo(f"No device with name {alias} found") return if password != "" and user == "": click.echo("Using a password requires a username") return if klap or user != "": authentication = Auth(user=user, password=password) else: authentication = None if host is None: click.echo("No host name given, trying discovery..") await ctx.invoke(discover) return else: if not bulb and not plug and not strip and not lightstrip: click.echo("No --strip nor --bulb nor --plug given, discovering..") dev = await Discover.discover_single(host, authentication) elif bulb: dev = SmartBulb(host) elif plug: dev = SmartPlug(host, authentication) elif strip: dev = SmartStrip(host) elif lightstrip: dev = SmartLightStrip(host) else: click.echo( "Unable to detect type, use --strip or --bulb or --plug!") return ctx.obj = dev if ctx.invoked_subcommand is None: await ctx.invoke(state)
async def _power_set(host, port, index, value): """We embed the coroutines in an `async` function to minimise calls to `asyncio.run`""" assert port is None index = int(index) strip = SmartStrip(host) await strip.update() assert (len(strip.children) > index), "Trying to access non-existant plug socket on strip" if value is True: await strip.children[index].turn_on() elif value is False: await strip.children[index].turn_off()
def start(self): LOGGER.debug(f'{self.pfx} start') self.dev = SmartStrip(self.host) super(SmartStripNode, self).start() self.update() self.check_st() LOGGER.info(f'{self.pfx} {self.dev.alias} has {len(self.dev.children)+1} children') for pnum in range(len(self.dev.children)): naddress = "{}{:02d}".format(self.address,pnum+1) nname = self.dev.children[pnum].alias LOGGER.info(f"{self.pfx} adding plug num={pnum} address={naddress} name={nname}") self.nodes.append(self.controller.addNode(SmartStripPlugNode(self.controller, self, naddress, nname, self.dev.children[pnum]))) self.ready = True LOGGER.debug(f'{self.pfx} done')
async def change_outlet_state(self, channel, state): from kasa import SmartStrip self.strip = SmartStrip(self.plug_address) await self.strip.update() if state: msg = await self.strip.children[channel].turn_on() self.output_states[channel] = True else: msg = await self.strip.children[channel].turn_off() self.output_states[channel] = False await self.strip.update() return msg
async def try_connect(self): from kasa import SmartStrip lf = LockFile() if lf.lock_acquire(self.lock_file, timeout=self.lock_timeout): try: self.strip = SmartStrip(self.plug_address) await self.strip.update() self.logger.debug( f'Strip {self.strip.alias}: {self.strip.hw_info}') self.output_setup = True except Exception as err: self.logger.error(f"Output was unable to be setup: {err}") finally: time.sleep(self.switch_wait) lf.lock_release(self.lock_file)
def _load_hardware(self): # Input format should be either: # - [IP],[POWER_SWITCH_NR] # Use an internal caching for speeding things up. self.__state_cache = terrariumCache() self._async = terrariumAsync() address = self._address if len(address) == 1: self._device['device'] = SmartPlug(address[0]) self._device['switch'] = 0 else: self._device['device'] = SmartStrip(address[0]) self._device['switch'] = int(address[1])-1 return self._device['device']
async def connect(self): self.logger.debug("try_connect") from kasa import SmartStrip try: self.strip = SmartStrip(self.plug_address) await self.strip.update() self.logger.debug( f'Connected to {self.strip.alias}: {self.strip.hw_info}') self.output_setup = True self.failed_connect_count = 0 except Exception as err: self.logger.error(f"Output was unable to be setup: {err}") self.failed_connect_count += 1 wait_timer = time.time() if self.failed_connect_count > 19: if self.failed_connect_count == 20: self.logger.error( "Failed to connect 20 times. Increasing reconnect attempt interval to 300 seconds." ) while wait_timer > time.time() - 300 and self.running: time.sleep(1) elif self.failed_connect_count > 4: if self.failed_connect_count == 5: self.logger.error( "Failed to connect 5 times. Increasing reconnect attempt interval to 60 seconds." ) while wait_timer > time.time() - 60 and self.running: time.sleep(1) else: self.logger.error("Failed to connect. Retrying in 5 seconds.") while wait_timer > time.time() - 5 and self.running: time.sleep(1) if self.first_connect and self.output_setup: self.first_connect = False for channel in channels_dict: if channel not in self.output_states: self.output_states[channel] = None if self.options_channels['state_startup'][channel] == 1: await self.strip.children[channel].turn_on() elif self.options_channels['state_startup'][channel] == 0: await self.strip.children[channel].turn_off() self.logger.debug( f'Strip children: {self.strip.children[channel]}')
async def cli(ctx, host, alias, target, debug, bulb, plug, strip): """A cli tool for controlling TP-Link smart home plugs.""" # noqa if debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) if ctx.invoked_subcommand == "discover": return if alias is not None and host is None: click.echo(f"Alias is given, using discovery to find host {alias}") host = await find_host_from_alias(alias=alias, target=target) if host: click.echo(f"Found hostname is {host}") else: click.echo(f"No device with name {alias} found") return if host is None: click.echo("No host name given, trying discovery..") await ctx.invoke(discover) return else: if not bulb and not plug and not strip: click.echo("No --strip nor --bulb nor --plug given, discovering..") dev = await Discover.discover_single(host) elif bulb: dev = SmartBulb(host) elif plug: dev = SmartPlug(host) elif strip: dev = SmartStrip(host) else: click.echo( "Unable to detect type, use --strip or --bulb or --plug!") return ctx.obj = dev if ctx.invoked_subcommand is None: await ctx.invoke(state)
async def get_status(self): from kasa import SmartStrip lf = LockFile() if lf.lock_acquire(self.lock_file, timeout=self.lock_timeout): try: self.strip = SmartStrip(self.plug_address) await self.strip.update() for channel in channels_dict: if self.strip.children[channel].is_on: self.output_states[channel] = True else: self.output_states[channel] = False except Exception as err: self.logger.error( f"get_status() raised an exception when taking a reading: {err}" ) return 'error', err finally: time.sleep(self.switch_wait) lf.lock_release(self.lock_file)
if bulb: asyncio.run(bulb.update()) asyncio.run(bulb.set_brightness(30)) def bulb_brightness_100(): if bulb: asyncio.run(bulb.update()) asyncio.run(bulb.set_brightness(100)) ### TPLINK KASA HS300 ### Change the ip addresss accordingly print('LOADING SMART-STRIP <--- HS300') strip = SmartStrip("192.168.1.22") # Plug1 def on_plug_0(): strip.turn_on(index=0) def off_plug_0(): strip.turn_off(index=0) # Plug2 def on_plug_1(): strip.turn_on(index=1)
def load_hardware(self): address = self.__get_address() if len(address) == 2: self._device = SmartStrip(address[0]) else: self._device = SmartPlug(address[0])
def __init__(self, address): self.worker = ThreadedWorker() self.device = SmartStrip(address)
import asyncio import logging from time import sleep from kasa import SmartStrip LOG = logging.getLogger(__name__) STRIPS = [SmartStrip("192.168.0.123"), SmartStrip("192.168.0.194")] def reboot_plug(plug): LOG.info("rebooting plug %s", plug.alias) asyncio.run(plug.turn_off()) sleep(3) asyncio.run(plug.turn_on()) def find_plug(plug_name): return_value = None for strip in STRIPS: asyncio.run(strip.update()) for plug in strip.children: if plug_name in plug.alias: return_value = plug return return_value