File python-kasa-0.0~git1580219900.15b0c8c.obscpio of Package python-kasa

Overview Repositories Revisions Requests Users Attributes Meta

File python-kasa-0.0~git1580219900.15b0c8c.obscpio of Package python-kasa (Revision 938b66a95c620859dfca86a805f527ca)

Currently displaying revision 938b66a95c620859dfca86a805f527ca , Show latest

07070100000000000081A4000003E800000064000000015E303DFC00000016000000000000000000000000000000000000003700000000python-kasa-0.0~git1580219900.15b0c8c/.gitchangelog.rcinclude_merge = False
07070100000001000081A4000003E800000064000000015E303DFC00000047000000000000000000000000000000000000003100000000python-kasa-0.0~git1580219900.15b0c8c/.hound.ymlpython:
  enabled: true
  config_file: tox.ini
flake8:
  enabled: true
07070100000002000081A4000003E800000064000000015E303DFC00000327000000000000000000000000000000000000003E00000000python-kasa-0.0~git1580219900.15b0c8c/.pre-commit-config.yamlrepos:
- repo: https://github.com/pre-commit/pre-commit-hooks
  rev: v2.4.0
  hooks:
  - id: trailing-whitespace
  - id: end-of-file-fixer
  - id: check-docstring-first
  - id: check-yaml
  - id: debug-statements
  - id: check-ast

- repo: https://github.com/asottile/pyupgrade
  rev: v1.25.2
  hooks:
  - id: pyupgrade
    args: ['--py36-plus']

- repo: https://github.com/python/black
  rev: stable
  hooks:
  - id: black

- repo: https://github.com/pre-commit/pre-commit-hooks
  rev: v2.3.0
  hooks:
  - id: flake8
    additional_dependencies: [flake8-docstrings]

- repo: https://github.com/pre-commit/mirrors-isort
  rev: v4.3.21
  hooks:
  - id: isort

- repo: https://github.com/pre-commit/mirrors-mypy
  rev: v0.740
  hooks:
  - id: mypy
#    args: [--no-strict-optional, --ignore-missing-imports]
07070100000003000081A4000003E800000064000000015E303DFC00005B2F000000000000000000000000000000000000003000000000python-kasa-0.0~git1580219900.15b0c8c/CHANGELOGChangelog
=========

0.3.5 (2019-04-13)
------------

- Fix for SmartStrip repr (#169) [Alex]

* Added unit tests for repr.

* Fix repr for SmartStrip.

Fixes #165

- Smartstrip: return on_since state information only when the socket is on (#161) [Teemu R]

* Smartstrip: return on_since state information only when the socket is on

Fixes #160

* add proper cli printout for hs300 child sockets

* iterate over range, not an integer

- Bulb: add the temperature range to state_information, inform the user if the info is missing when calling temperature (#163) [Teemu R]

- Fix Discover#discover incorrect documentation (#159) [Georgi Kirichkov]

The documentation states the timeout defaults to 5 seconds, but in the definition of the method timeout is set to 3

- Add kelvin range for KL130 (#156) [dieselrabbit]

* Add kelvin range for KL130 (new color bulb)

* Add kelvin range for KL120

Unable to test this personally as I don't have this bulb.

- Add LB230. [Teemu R]

Works according to https://github.com/home-assistant/home-assistant.io/pull/8090

- Add KL series of bulbs. [Teemu R]

works according to https://github.com/home-assistant/home-assistant.io/pull/8134

0.3.4 (2019-01-16)
------------

There are two notable changes (and other small fixes) in this minor release thanks to our contributors:

* Support for HS300 smartstrip (thanks to jimboca!)
* The hue range for light bulbs is fixed (thanks to nkonopinski, Annika Jacobs and Joe Zach!)

- Updated valid range to 360 (with passing tests) (#153) [Annika Jacobs, Zac Koch]

* Updated valid range to 360

with it set to 359 it will not show the color red. Just tested this with a buddies bulb - same model/fw
  https://imgur.com/a/kSNZIuL

- Add support for HS300 power strip (#137) [jimboca]

- Add HS103 to readme. [Teemu R]

- Avoid 'referenced before assignment' exception (#150) [Kevron Rees]

- Cli: show an error for incorrect hsv values (#142) [Annika Jacobs]

Raising an exception if an incomplete HSV colour is provided.

- Add a "Reviewed by Hound" badge (#139) [Scott Albertson]

- Change valid hue range to 0-359 (fixes #130), update README.md & test
  (#140) [Annika Jacobs, nkonopinski]

Tested on LB130(EU) hardware 1.0, firmware 1.8.6 Build 180809 Rel.091659

- Remove deprecated identify, this has been deprecated for long enough.
  (#136) [Teemu R]

* Remove deprecated identify, this has been deprecated for long enough.

- Add missed test for invalid types. [Teemu R]

- Update README to include mention about hs220. [Teemu R]

- Add tests and pretty output for HS220, fix minor issues in tests.
  [Teemu R]

- Add reboot command to restart the device (#129) [Teemu R]

0.3.3 (2018-09-06)
------------------

This release contains a breaking change for hsv setter, which is changed to accept
the new brightness value in percentage instead of an integer between 1 and 255.

The alias support has been extended to allow changing the alias, as well as accessing
the device using it (without specifying an IP address or a hostname), which can be
useful in some setups. Furthermore utf8-encoded aliases are now handled correctly.

- Fix bug that changed brightness at each HSV update (#124) [Sebastian Templ]

* Fix bug that changed brightness at each hsv update

The HSV setter should accept a percentage for the brightness
  value but actually assumed the brightness to be in absolute values
  between 1 and 255.
  This resulted in brightness reductions at each HSV update, in
  steps of 100% -> 100/255=39% -> 39/255=15% -> ... (see also
  https://github.com/home-assistant/home-assistant/issues/15582,
  where I originally reported this bug).

* Modify HSV property to return brightness in percent

Switch from reported brightness values of 1..255 to percentage
  values, for consistency with the apidoc and 8761dd8.

* Add checks and tests for the hsv setter

- make sure that new (hue, saturation, brightness) values are
    within their valid ranges (0..255, 0..100, 0..100) and raise
    SmartDeviceException if they are not
  - add test function for the hsv setter

- Allow using alias instead of IP address or hostname (#127) [kwazel]

* Added option to control devices by device name

* set unused ip address to dont-care

* spend less time discovering by devicename, removed command

* consistent use of alias instead of device name

* processed review comments

* Return when no device with alias has been found

- Add 'alias' command for querying and setting the alias (#126) [Teemu R]

* add 'alias' command for querying and setting the alias

* calculate coverage only on library files, e.g., ignoring cli and test files

* remove py34 and add py37

* readd py33, remove it from travis as it seems to be a travis limitation only

* use xenial dist for travis, regular does not support py37..

- Support Unicode strings in encrypt/decrypt (#125) [Anders Melchiorsen]

0.3.2 (2018-06-17)
------------------

- Add bulb valid temperature range (#122) [Thibault Cohen]

0.3.1 (2018-06-16)
------------------

This release adds a few improvements, most importantly:

* emeter support for new HS110 hardware/firmware revision.

* HS220 supports now dimming.

Breaking changes:

* get_emeter_daily & get_emeter_monthly will report back in kwh on bulbs, making the API consistent with the smart plugs.

- Fix emeter support for newer HS110 firmwares (#107) [Teemu R]

* Add support for new-style emeter

This commit adds a straightforward dict-extending container,
  which converts between the old and new keys of the get_emeter_realtime()
  Furthermore the unit tests are converted to base on HS100
  instead of HS110.

This is the first step to fix #103, other emeter-using functionality
  has not yet been converted, only getting the current consumption.

* fix a couple of linting issues

* Convert new-style emeter values also for get_emeter_daily() and get_emeter_monthly()

* Adds a new 'kwh' parameter for those calls, which defaults to True
  * This changes the behavior of bulbs emeter reporting, use False if you prefer the preciser values

- Update pypi description (#102) [Teemu R]

* update pypi description

* add wall switches

- Update smartplug.py to support dimming in HS220 (#115) [JsChiSurf]

* Update smartplug.py to support dimming in HS220

Switch functions essentially as a "plug" with the addition to support for dimming, for which can be test for by verifying existence of
'brightness' array value.

* Attempt at updates to pass validator

* Maybe this time?  :-)

* Add more detail to comment blocks

Make clear in requests for current brightness level the expected return values, and note that light will turn on when setting a brightness
level, if not already on.  This makes clear that a state change request (turn_on) does NOT have to be made first when setting brightness.

* Update smartplug.py

Fixes #114

- Add python_requires for >= 3.4. [Teemu Rytilahti]

- Add hs210. [Teemu R]

Based on user report: https://community.home-assistant.io/t/tp-link-hs210-3-way-kit/39762/6

- Add support for DNS host names (#104) [K Henriksson]

- Use direct device type discovery for devices (#106) [K Henriksson]

This is more efficient than enumerating all devices and checking the IP.

- Cli: add 'time' command to get the current time from the device.
  [Teemu Rytilahti]

- Created a docker file to aid dev setup (#99) [TheSmokingGnu]

* created a docker file to aid dev setup

* fixed review comments in README and Dockerfile

* review comments to simplify the docker run command

0.3.0 (2017-09-14)
------------------

This is the first release after a while and aims to improve the robustness all-around.
To make this happen we have decided to break the API and drop the support for Python 2.

API break:
    * Python2 support has been dropped.
    * pyHS100/pyHS100.py has been splitted to smartdevice.py, smartplug.py and smartbulb.py, no one should have ever accessed these directly though.
    * SmartPlugException is no more, SmartDeviceException is used by both SmartPlug and SmartBulb
    * Discovery has been moved from TPLinkSmartHomeProtocol into its own class for easier 3rd party use.
    * SmartDevice's identify() and `features` will emit a warning when used. These will likely be dropped or revised in the future and their use should be avoided.

Other changes:

* CLI tool supports device discovery and is usable without specifying device type or IP for testing
    * CLI tool supports changing bulb-specific settings
    * Library support & unit tests are extended to cover more devices.
       - Supported plugs: HS100, HS105, HS110
       - Supported switches: HS200
       - Supported bulbs: LB100, LB110, LB120, LB130

- Bump the version. [Teemu Rytilahti]

- Revise README, fixes #86. [Teemu Rytilahti]

- Update the changelog. [Teemu Rytilahti]

- Local test clean (#96) [Sean Gollschewsky]

* Add ignores for working coverage/tox/IDE files.

* Allow tox not to fail if python version is not available.

- Move SmartDeviceException to SmartDevice, and remove types.py complet…
  (#95) [Teemu R]

* move SmartDeviceException to SmartDevice, and remove types.py completely. fixes #94

* do not import skipIf anymore

- Move has_emeter implementation from SmartDevice to SmartPlug, avoid
  using features() internally (#93) [Teemu R]

* move has_emeter implementation from SmartDevice to SmartPlug, avoid using features() internally

* add stacklevel to deprecation warnings to see where they are really called

* make tests pass on a real device. if PLUG_IP is not None, the tests will be run on a device at the defined IP address

- Add typing hints to make it easier for 3rd party developers to use the
  library (#90) [Teemu R]

* add typing hints to make it easier for 3rd party developers to use the library

* remove unused devicetype enum to support python3.3

* add python 3.3 to travis and tox, install typing module in setup.py
- Execute coveralls only on travis, fixes #84 (#91) [Teemu R]

- Make flake8 pass by some rewording. [Teemu Rytilahti]

- Make hound a bit more happier. [Teemu Rytilahti]

- Deprecate features and identify, use state_information in __repr__ instead of identify. [Teemu Rytilahti]

- Fix smartbulb hsv documentation, values are degrees and percentages instead of 0-255. [Teemu Rytilahti]

- Another try, just with module name. [Teemu Rytilahti]

- Make tox run pytest-cov, add coveralls. [Teemu Rytilahti]

- Prevent failure if device's sysinfo does not have a "feature" attribute. (#77) [Sean Gollschewsky]

- Allow None for rssi, add a missing newline to fakes.py. [Teemu Rytilahti]

- Add hs100 tests. [Teemu Rytilahti]

- Make tests to test against all known device variants. [Teemu Rytilahti]

- Remove unused tplinksmarthomeprotocol import. [Teemu Rytilahti]

- Fix hs105 mac to pass the test, wrap sysinfo_lb110 properly inside 'system' [Teemu Rytilahti]

- Return None instead of False for emeter related actions. [Teemu Rytilahti]

- Wrap sysinfo to defaultdict to return None for keys which do not exist, makes unsupported keys not to fail hard (#72) [Teemu R]

- Add hs100 example to fakes.py, thanks to Semant1ka on #67 (#74) [Teemu R]

- Discover refactoring, enhancements to the cli tool (#71) [Teemu R]

* Discover refactoring, enhancements to the cli tool

* Discover tries to detect the type of the device from sysinfo response
  * Discover.discover() returns an IP address keyed dictionary,
    values are initialized instances of the automatically detected device type.

* When no IP is given, autodetect all supported devices and print out their states
  * When only IP but no type is given, autodetect type and make a call based on that information.
    * One can define --bulb or --plug to skip the detection.

* renamed pyHS100.py -> smartdevice.py

* SmartPlugException -> SmartDeviceException in comments

* fix mic_type check

* make time() return None on failure as we don't know which devices support getting the time and it's used in the cli tool

* hw_info: check if key exists before accessing it, add mic_mac and mic_type

* Check for mic_mac on mac, based on work by kdschloesser on issue #59

* make hound happy, __init__ on SmartDevice cannot error out so removing 'raises' documentation

- Add LB110 sysinfo (#75) [Sean Gollschewsky]

* Add LB110 sysinfo

* Linting.

- Add @pass_dev to hsv, adjust ranges (#70) [Teemu R]

* add @pass_dev to hsv command, it was always broken

* Hue goes up to 360, saturation and value are up to 100(%)

- Extract shared types (exceptions, enums), add module level doc, rename exception to be generic. [Teemu Rytilahti]

- Add check to ensure devices with lat/lon with `_i` suffix are supported (#54) (#56) [Matt LeBrun]

* Add check to ensure devices with lat/lon with `_i` suffix are supported (#54)

* Add .gitignore for posterity

- Generalize smartdevice class and add bulb support for the cli tool (#50) [Teemu R]

Fixes #48 and #51. The basic functionality should work on all types of supported devices, for bulb specific commands it is currently necessary to specify ```--bulb```.

- Refactor and drop py2 support (#49) [Teemu R]

* move is_off property to SmartDevice, implement is_on for bulb and use it

* refactor by moving smartbulb and smartplug to their own classes

* drop python2 compatibility, make flake8 happy

* travis: remove 2.7, add 3.6

0.2.4.2 (2017-04-08)
--------------------
- Add installation requirement for future package. [Teemu Rytilahti]

0.2.4.1 (2017-03-26)
--------------------
- Cli: display an error if no ip is given. [Teemu Rytilahti]

0.2.4 (2017-03-26)
------------------

- Add new client tool (#42) [Teemu R]

* Add new client tool

After installing the package pyhs100 command-line tool can be used
  to control the plug.

See --help for its usage, most of the features for plugs are implemented,
  some of the shared functionality works for bulbs too.

* Add discover command

* Delete old examples, the cli works as an example well enough

- Ignore OSError on socket.shutdown() [Teemu Rytilahti]

This fixes #22 and obsoletes PR #23.
- Set color temp to 0 when trying to change color (#36) [pete1450]

* set color temp to 0 when trying to change color

* changed tabs to spaces

- Add changelog & add .gitchangelog.rc (#28) [Teemu R]

This commits adds .gitchangelog.rc for changelog generation.
  To generate, simply run gitchangelog.

- Discover: Catch socket.timeout and debug log it (#34) [Teemu R]

Fixes #33

- Add flake8 to tox, disable qa on pyHS100/__init__.py, fix py27
  compatibility (#31) [Teemu R]

- Add support for TP-Link smartbulbs (#30) [Matthew Garrett]

* Add support for new-style protocol

Newer devices (including my LB130) seem to include the request length in
  the previously empty message header, and ignore requests that lack it. They
  also don't send an empty packet as the final part of a response, which can
  lead to hangs. Add support for this, with luck not breaking existing devices
  in the process.

* Fix tests

We now include the request length in the encrypted packet header, so strip
  the header rather than assuming that it's just zeroes.

* Create a SmartDevice parent class

Add a generic SmartDevice class that SmartPlug can inherit from, in
  preparation for adding support for other device types.

* Add support for TP-Link smartbulbs

These bulbs use the same protocol as the smart plugs, but have additional
  commands for controlling bulb-specific features. In addition, the bulbs
  have their emeter under a different target and return responses that
  include the energy unit in the key names.

* Add tests for bulbs

Not entirely comprehensive, but has pretty much the same level of testing
  as plugs

0.2.3 (2017-01-11)
------------------

- Add .gitchnagelog.rc for changelog generation. to generate, simply
  install and run gitchangelog. [Teemu Rytilahti]

- Version bump. [GadgetReactor]

- Initial steps to remove caching (#26) [Teemu R]

This commit removes caching of sysinfo to avoid
  inconsistent states as described in issue #14.

Each an every access for properties will cause a request
  to be made to the device. To avoid this, user of the library
  may want to access sys_info() directly instead of using the helpers.

Currently sys_info() returns raw json object where-as helpers do
  parse information for easier consumption; current state is just to
  provide a PoC how it looks compared to having an active update()
  for fetching the info.

- Make tests runnable without device (#24) [Teemu R]

* Make tests runnable without device

Adds preliminary support for fake devices, thanks to
  hoveeman's sysinfos from issue #14,
  making running tests possible without a device.

At the moment we have only HS110 and HS200 infos available, and tests
  are currently run only against HS110 data.

* Make tests py27 compatible

- Add device discovery (#25) [Teemu R]

* add (untested) discover mode

* Keep discovery and normal communication separate, uppercase magic consts

This sepearates the earlier test code for discovering devices,
  and adds 5 sec timeout for gathering responses from potential devices.

This commit also uppercases magic constants.

Discovery & communication tested with HS110.

* update readme with example how to discover devices, pep8ify

- Add timeout to query (#19) [Austin]

- Refactor & add unittests for almost all functionality, add tox for
  running tests on py27 and py35 (#17) [Teemu R]

* Refactor & add unittests for almost all functionality, add tox for running tests on py27 and py35

This commit adds unit tests for current api functionality.
  - currently no mocking, all tests are run on the device.
  - the library is now compatible with python 2.7 and python 3.5, use tox for tests
  - schema checks are done with voluptuous

refactoring:
  - protocol is separated into its own file, smartplug adapted to receive protocol worker as parameter.
  - cleaned up the initialization routine, initialization is done on use, not on creation of smartplug
  - added model and features properties, identity kept for backwards compatibility
  - no more storing of local variables outside _sys_info, paves a way to handle state changes sanely (without complete reinitialization)

* Fix CI warnings, remove unused leftover code

* Rename _initialize to _fetch_sysinfo, as that's what it does.

* examples.cli: fix identify call, prettyprint sysinfo, update readme which had false format for led setting

* Add tox-travis for automated testing.

0.2.2 (2016-12-13)
------------------

- Version bump (#16) [Georgi Kirichkov]

- Read all data from the device, disable double-encoding, implement more
  APIs, refactor querying, update README (#11) [Teemu R]

* Read from socket until no data available, disable double string encoding

HS110 sends sometimes datagrams in chunks especially for get_daystat,
  this patch makes it to read until there is no more data to be read.

As json.dumps() does JSON encoding already, there's no need to str()
  the year or month either.

* Add cli.py, a simple script to query devices for debugging purposes.

* allow easier importing with from pyHS100 import SmartPlug

* move cli.py to examples, add short usage into README.md

* Implement more available APIs, refactor querying code.

This commit adds access to new properties, both read & write,  while keeping the old one (mostly) intact.
  Querying is refactored to be done inside _query_helper() method,
  which unwraps results automatically and rises SmartPlugException() in case of errors.
  Errors are to be handled by clients.

New features:
  * Setting device alias (plug.alias = "name")
  * led read & write
  * icon read (doesn't seem to return anything without cloud support at least), write API is not known, throws an exception currently
  * time read (returns datetime), time write implemented, but not working even when no error is returned from the device
  * timezone read
  * mac read & write, writing is untested for now.

Properties for easier access:
  * hw_info: return hw-specific elements from sysinfo
  * on_since: pretty-printed from sysinfo
  * location: latitude and longitued from sysinfo
  * rssi: rssi from sysinfo

* Update README.md with examples of available features.

* Handle comments from mweinelt

* Refactor state handling, use booleans instead of strings

* Fix issues raised during the review.

Following issues are addressed by this commit:
  * All API is more or less commented (including return types, exceptions, ..)
  * Converted state to use
  * Added properties is_on, is_off for those who don't want to check against strings.
  * Handled most issues reported by pylint.
  * Adjusted _query_helper() to strip off err_code from the result object.
  * Fixed broken format() syntax for string formattings.

* Fix ci woes plus one typo.

* Do initialization after changing device properties, fix nits.

- Constants will be static members of SmartPlug. [Martin Weinelt]

- Set up hound-ci. [Martin Weinelt]

- Normalize docstrings, address flake8 & pylint recommendations. [Martin
  Weinelt]

- Properly detect advertised features, expose alias. [Martin Weinelt]

- Externalize the TP-Link Smart Home Protocol. [Martin Weinelt]

- HS200 support. [GadgetReactor]

Update version to reflect latest changes

- Adding in support for the HS200 Wall switch referencing issues (#4),
  simplifying model determination. [Stephen Maggard]

- Adding in support for the HS200 Wall switch referencing issues (#4)
  [Stephen Maggard]

- Refactors state property to use get_info() and removes hs100_status()
  [Georgi Kirichkov]

- Adds model check to current_consumption() and removes whitespace.
  [Georgi Kirichkov]

- Fixes indentation and removes extra whitespaces. [Georgi Kirichkov]

- Update setup.py. [GadgetReactor]

- Update LICENSE. [GadgetReactor]

Updated to GPLv3 (instead of just copy and pasting)

0.2.0 (2016-10-17)
------------------

- Bumps the module version to 0.2.0. [Georgi Kirichkov]

- Adds additional comments, for better compliance with the Apache
  license. [Georgi Kirichkov]

- Makes the socket sending code compatible with both Python 2 and python
  3. [Georgi Kirichkov]

Adds a shutdown to the socket used to send commands

- Refactors state() to use turn_on() and turn_off() [Georgi Kirichkov]

- Adds Energy Meter commands available on the TP-Link HS110. [Georgi
  Kirichkov]

Also adds turn_on() and turn_off() commands to supplement the state

- Update pyHS100.py. [GadgetReactor]

- Update __init__.py. [GadgetReactor]

0.1.2 (2016-07-09)
------------------

- 0.1.2. [GadgetReactor]

- Update setup.py. [GadgetReactor]

- Delete pyHS100.py. [GadgetReactor]

- Create pyHS100.py. [GadgetReactor]

- Create __init__.py. [GadgetReactor]

- Create setup.py. [GadgetReactor]

- Create pyHS100.py. [GadgetReactor]

- Initial commit. [GadgetReactor]
07070100000004000081A4000003E800000064000000015E303DFC00000708000000000000000000000000000000000000003100000000python-kasa-0.0~git1580219900.15b0c8c/Dockerfile####################################################
# Use python 3.x and the latest version of alpine  #
####################################################
FROM python:3-alpine

LABEL maintainer=peter@grainger.xyz

###################################################
# Add all system packages relied upon by python   #
###################################################
RUN apk update && \
    apk add --no-cache gcc \
                       libffi-dev \
                       openssl-dev \
                       libxslt-dev \
                       libxml2-dev \
                       musl-dev \
                       linux-headers

###################################################
# Create somewhere to put the files               #
###################################################
RUN mkdir -p /opt/python-kasa
WORKDIR /opt/python-kasa

###################################################
# Requirements file first to help cache           #
###################################################
COPY requirements.txt .
RUN pip install -r requirements.txt

###################################################
# Install dev dependancies                        #
###################################################
RUN pip install pytest pytest-cov voluptuous typing

###################################################
# Copy over the rest.                             #
###################################################
COPY ./ ./

###################################################
# Install everything to the path                  #
###################################################
RUN python setup.py install

###################################################
# Run tests                                       #
###################################################
CMD pytest
07070100000005000081A4000003E800000064000000015E303DFC00000255000000000000000000000000000000000000003400000000python-kasa-0.0~git1580219900.15b0c8c/HOWTO_RELEASE# Preparing the changelog

Looks like gitchangelog is not as nice as thought before,
however, you can generate the changelog by doing this:

$ gitchangelog 0.x.y..HEAD

and manually placing the output to CHANGELOG and fixing
the newlines between commit messages, and cleaning up the
unnecessary entries,  and finally commiting the file.

After that prepare a pull request containing the changed,
release-related files (CHANGELOG, setup.py, README, ..).

# After release merge is done

$ git tag -a v0.x.y -m "0.x.y"
$ git push --tags

# Pushing to pypi

$ python setup.py sdist bdist_wheel upload
07070100000006000081A4000003E800000064000000015E303DFC000081C2000000000000000000000000000000000000002E00000000python-kasa-0.0~git1580219900.15b0c8c/LICENSE    pyHS100 Copyright (C) 2016 GadgetReactor

This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

Please send queries to sean@gadgetreactor.com

GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

Preamble

The GNU General Public License is a free, copyleft license for
software and other kinds of works.

The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

The precise terms and conditions for copying, distribution and
modification follow.

TERMS AND CONDITIONS

0. Definitions.

"This License" refers to version 3 of the GNU General Public License.

"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

"The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

A "covered work" means either the unmodified Program or a work based
on the Program.

To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

1. Source Code.

The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

The Corresponding Source for a work in source code form is that
same work.

2. Basic Permissions.

All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

3. Protecting Users' Legal Rights From Anti-Circumvention Law.

No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

4. Conveying Verbatim Copies.

You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

5. Conveying Modified Source Versions.

You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

6. Conveying Non-Source Forms.

You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

7. Additional Terms.

"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

8. Termination.

You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

9. Acceptance Not Required for Having Copies.

You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

10. Automatic Licensing of Downstream Recipients.

Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

11. Patents.

A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

12. No Surrender of Others' Freedom.

If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

13. Use with the GNU Affero General Public License.

Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

14. Revised Versions of this License.

The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

15. Disclaimer of Warranty.

THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. Limitation of Liability.

IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

17. Interpretation of Sections 15 and 16.

If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

END OF TERMS AND CONDITIONS
07070100000007000081A4000003E800000064000000015E303DFC00001C06000000000000000000000000000000000000003000000000python-kasa-0.0~git1580219900.15b0c8c/README.md# python-kasa

[![PyPI version](https://badge.fury.io/py/python-kasa.svg)](https://badge.fury.io/py/python-kasa)
[![Build Status](https://dev.azure.com/python-tplink-kasa/python-kasa/_apis/build/status/python-tplink-kasa.python-kasa?branchName=master)](https://dev.azure.com/python-tplink-kasa/python-kasa/_build/latest?definitionId=2&branchName=master)
[![Coverage Status](https://coveralls.io/repos/github/python-kasa/python-kasa/badge.svg?branch=master)](https://coveralls.io/github/python-kasa/python-kasa?branch=master)
[![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)

Python Library to control TPLink smart plugs/switches and smart bulbs.

**Supported devices**

* Plugs
  * HS100
  * HS103
  * HS105
  * HS110
* Power Strips
  * HS300
  * KP303
* Wall switches
  * HS200
  * HS210
  * HS220
* Bulbs
  * LB100
  * LB110
  * LB120
  * LB130
  * LB230
  * KL110
  * KL120
  * KL130

# Usage

The package is shipped with a console tool named kasa, please refer to ```kasa --help``` for detailed usage.
The device to which the commands are sent is chosen by `KASA_HOST` environment variable or passing `--host <address>` as an option.
To see what is being sent to and received from the device, specify option `--debug`.

To avoid discovering the devices when executing commands its type can be passed by specifying either `--plug` or `--bulb`,
if no type is given its type will be discovered automatically with a small delay.
Some commands (such as reading energy meter values and setting color of bulbs) additional parameters are required,
which you can find by adding `--help` after the command, e.g. `kasa emeter --help` or `kasa hsv --help`.

If no command is given, the `state` command will be executed to query the device state.

## Discovering devices

The devices can be discovered either by using `kasa discover` or by calling `kasa` without any parameters.
In both cases supported devices are discovered from the same broadcast domain, and their current state will be queried and printed out.

```
$ kasa
No --bulb nor --plug given, discovering..
Discovering devices for 3 seconds
== My Smart Plug - HS110(EU) ==
Device state: ON
IP address: 192.168.x.x
LED state: False
On since: 2017-03-26 18:29:17.242219
== Generic information ==
Time:         1970-06-22 02:39:41
Hardware:     1.0
Software:     1.0.8 Build 151101 Rel.24452
MAC (rssi):   50:C7:BF:XX:XX:XX (-77)
Location:     {'latitude': XXXX, 'longitude': XXXX}
== Emeter ==
Current state: {'total': 133.082, 'power': 100.418681, 'current': 0.510967, 'voltage': 225.600477}
```

## Basic controls

All devices support a variety of common commands, including:
 * `state` which returns state information
 * `on` and `off` for turning the device on or off
 * `emeter` (where applicable) to return energy consumption information
 * `sysinfo` to return raw system information which is used by e.g. `state`, useful for debugging and when adding support for new device types

## Energy meter

Passing no options to `emeter` command will return the current consumption.
Possible options include `--year` and `--month` for retrieving historical state,
and reseting the counters is done with `--erase`.

```
$ kasa emeter
== Emeter ==
Current state: {'total': 133.105, 'power': 108.223577, 'current': 0.54463, 'voltage': 225.296283}
```

## Plug-specific commands

At the moment only switching the state of the LED is implemented.
**Feel free to submit patches as pull requests for further features!**
### Controlling the LED

`led` command can be used to control whether the LED light on front of the plug is on or off.

```
$ kasa --plug led
LED state: False
$ kasa --plug led 1
Turning led to True
```

## Bulb-specific commands

At the moment setting brightness, color temperature and color (in HSV) is supported.
The commands are straightforward, so feel free to check `--help` for instructions how to use them.

**Feel free to submit patches as pull requests to add more functionality (e.g. scenes)!**

# Library usage

The public API is well documented, but here are some examples to get you started.
For all available API functions run ```help(SmartPlug)``` or ```help(SmartBulb)```.

## Discovering devices

`Discover` class' `discover()` can be used to discover supported devices,
which returns a dictionary keyed with the IP address whose value hold a ready-to-use instance of the detected device type.

Example:
```python
from kasa import Discover

for dev in Discover.discover().values():
    print(dev)
```
```
$ python3 example.py
<SmartPlug at 192.168.XXX.XXX (My Smart Plug), is_on: True - dev specific: {'LED state': True, 'On since': datetime.datetime(2017, 3, 26, 18, 29, 17, 52073)}>
```

## Querying basic information

*Please note that most property getters do I/O (e.g. fetching the system information) on each call.
If you want to avoid unnecessary communication with the device please use `get_sysinfo` and handle parsing of information by yourself.*

```python
from kasa import SmartPlug, SmartBulb
from pprint import pformat as pf

plug = SmartPlug("192.168.XXX.XXX")
print("Hardware: %s" % pf(plug.hw_info))
print("Full sysinfo: %s" % pf(plug.get_sysinfo())) # this prints lots of information about the device
```

## State & switching

Devices can be turned on and off by either calling appropriate methods on the device object,
or by assigning a new state to `state` property.

```python
print("Current state: %s" % plug.state)
plug.turn_off()
plug.turn_on()
```

```python
plug.state = "ON"
plug.state = "OFF"
```

## Time information
```python
print("Current time: %s" % plug.time)
print("Timezone: %s" % plug.timezone)
```

## Getting and setting the name
```python
print("Alias: %s" % plug.alias)
plug.alias = "My New Smartplug"
```

## Getting emeter status (if applicable)
```python
print("Current consumption: %s" % plug.get_emeter_realtime())
print("Per day: %s" % plug.get_emeter_daily(year=2016, month=12))
print("Per month: %s" % plug.get_emeter_monthly(year=2016))
```

## Plug-specific

### Switching the led (plugs only)
```python
print("Current LED state: %s" % plug.led)
plug.led = False # turn off led
print("New LED state: %s" % plug.led)
```

## Bulb-specific API

The bulb API is likewise straightforward, so please refer to its API documentation.
Information about supported features can be queried by using properties prefixed with `is_`, e.g. `is_dimmable`.

### Setting the brightness

The `brightness` property works in percentages.

```python
print(bulb.brightness)
if bulb.is_dimmable:
    bulb.brightness = 100
```

### Setting the color temperature
```python
print(bulb.color_temp)
if bulb.is_variable_color_temp:
    bulb.color_temp = 3000
```

### Setting the color

Hue is given in degrees (0-360) and saturation and value in percentage.

```python
print(bulb.hsv)
if bulb.is_color:
   bulb.hsv = (180, 100, 100) # set to cyan
```

## Development Setup

### Docker

The following assumes you have a working installation of Docker.

Set up the environment and run the tests on demand.

```shell
docker build . -t kasa && docker run -v $(PWD)/kasa/tests:/opt/python-kasa/kasa/tests kasa pytest
```
07070100000008000081A4000003E800000064000000015E303DFC0000065C000000000000000000000000000000000000003A00000000python-kasa-0.0~git1580219900.15b0c8c/azure-pipelines.ymltrigger:
- master
pr:
- master

pool:
  vmImage: 'ubuntu-latest'
strategy:
  matrix:
    # Python36:
    #   python.version: '3.6'
    Python37:
      python.version: '3.7'
   # Python38:
   #   python.version: '3.8'

steps:
- task: UsePythonVersion@0
  inputs:
    versionSpec: '$(python.version)'
  displayName: 'Use Python $(python.version)'

- script: |
    python -m pip install --upgrade pip
    pip install -r requirements.txt
    pip install -r requirements_test.txt
  displayName: 'Install dependencies'

- script: |
    pre-commit run black --all-files
  displayName: 'Code formating (black)'

- script: |
    pre-commit run flake8 --all-files
  displayName: 'Code formating (flake8)'

- script: |
    pre-commit run mypy --all-files
  displayName: 'Typing checks (mypy)'

- script: |
    pre-commit run isort --all-files
  displayName: 'Order of imports (isort)'

- script: |
    pre-commit run trailing-whitespace --all-files
  displayName: 'Run trailing-whitespace'

- script: |
    pre-commit run end-of-file-fixer --all-files
  displayName: 'Run end-of-file-fixer'

- script: |
    pre-commit run check-docstring-first --all-files
  displayName: 'Run check-docstring-first'

- script: |
    pre-commit run check-yaml --all-files
  displayName: 'Run check-yaml'

- script: |
    pre-commit run debug-statements --all-files
  displayName: 'Run debug-statements'

- script: |
    pre-commit run check-ast --all-files
  displayName: 'Run check-ast'

- script: |
    pre-commit run isort --all-files
  displayName: 'Order of imports (isort)'

- script: |
    pytest --cov kasa --cov-report html
  displayName: 'Tests'
07070100000009000041ED000003E800000064000000015E303DFC00000000000000000000000000000000000000000000002B00000000python-kasa-0.0~git1580219900.15b0c8c/kasa0707010000000A000081ED000003E800000064000000015E303DFC00000387000000000000000000000000000000000000003700000000python-kasa-0.0~git1580219900.15b0c8c/kasa/__init__.py"""Python interface for TP-Link's smart home devices.

All common, shared functionalities are available through `SmartDevice` class::

x = SmartDevice("192.168.1.1")
    print(x.sys_info)

For device type specific actions `SmartBulb`, `SmartPlug`, or `SmartStrip`
 should be used instead.

Module-specific errors are raised as `SmartDeviceException` and are expected
to be handled by the user of the library.
"""
from kasa.discover import Discover
from kasa.protocol import TPLinkSmartHomeProtocol
from kasa.smartbulb import SmartBulb
from kasa.smartdevice import DeviceType, EmeterStatus, SmartDevice, SmartDeviceException
from kasa.smartplug import SmartPlug
from kasa.smartstrip import SmartStrip

__all__ = [
    "Discover",
    "TPLinkSmartHomeProtocol",
    "SmartBulb",
    "DeviceType",
    "EmeterStatus",
    "SmartDevice",
    "SmartDeviceException",
    "SmartPlug",
    "SmartStrip",
]
0707010000000B000081ED000003E800000064000000015E303DFC00002EB5000000000000000000000000000000000000003200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/cli.py"""python-kasa cli tool."""
import asyncio
import json
import logging
import re
from pprint import pformat as pf

import click

from kasa import Discover, SmartBulb, SmartDevice, SmartStrip

from kasa import SmartPlug  # noqa: E402; noqa: E402

pass_dev = click.make_pass_decorator(SmartDevice)

@click.group(invoke_without_command=True)
@click.option(
    "--host",
    envvar="KASA_HOST",
    required=False,
    help="The host name or IP address of the device to connect to.",
)
@click.option(
    "--alias",
    envvar="KASA_NAME",
    required=False,
    help="The device name, or alias, of the device to connect to.",
)
@click.option(
    "--target",
    default="255.255.255.255",
    required=False,
    help="The broadcast address to be used for discovery.",
)
@click.option("--debug/--normal", default=False)
@click.option("--bulb", default=False, is_flag=True)
@click.option("--plug", default=False, is_flag=True)
@click.option("--strip", default=False, is_flag=True)
@click.version_option()
@click.pass_context
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("Alias is given, using discovery to find host %s" % alias)
        host = 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..")
        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 = asyncio.run(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:
        ctx.invoke(state)

@cli.command()
@click.option("--scrub/--no-scrub", default=True)
@click.pass_context
def dump_discover(ctx, scrub):
    """Dump discovery information.

Useful for dumping into a file to be added to the test suite.
    """
    target = ctx.parent.params["target"]
    keys_to_scrub = [
        "deviceId",
        "fwId",
        "hwId",
        "oemId",
        "mac",
        "latitude_i",
        "longitude_i",
        "latitude",
        "longitude",
    ]
    devs = asyncio.run(Discover.discover(target=target, return_raw=True))
    if scrub:
        click.echo("Scrubbing personal data before writing")
    for dev in devs.values():
        if scrub:
            for key in keys_to_scrub:
                if key in dev["system"]["get_sysinfo"]:
                    val = dev["system"]["get_sysinfo"][key]
                    if key in ["latitude_i", "longitude_i"]:
                        val = 0
                    else:
                        val = re.sub("\w", "0", val)
                    dev["system"]["get_sysinfo"][key] = val

model = dev["system"]["get_sysinfo"]["model"]
        hw_version = dev["system"]["get_sysinfo"]["hw_ver"]
        save_to = f"{model}_{hw_version}.json"
        click.echo("Saving info to %s" % save_to)
        with open(save_to, "w") as f:
            json.dump(dev, f, sort_keys=True, indent=4)
            f.write("\n")

@cli.command()
@click.option("--timeout", default=3, required=False)
@click.option("--discover-only", default=False)
@click.option("--dump-raw", is_flag=True)
@click.pass_context
def discover(ctx, timeout, discover_only, dump_raw):
    """Discover devices in the network."""
    target = ctx.parent.params["target"]
    click.echo("Discovering devices for %s seconds" % timeout)
    found_devs = asyncio.run(
        Discover.discover(target=target, timeout=timeout, return_raw=dump_raw)
    )
    if not discover_only:
        for ip, dev in found_devs.items():
            asyncio.run(dev.update())
            if dump_raw:
                click.echo(dev)
                continue
            ctx.obj = dev
            ctx.invoke(state)
            print()

return found_devs

def find_host_from_alias(alias, target="255.255.255.255", timeout=1, attempts=3):
    """Discover a device identified by its alias."""
    host = None
    click.echo(
        "Trying to discover %s using %s attempts of %s seconds"
        % (alias, attempts, timeout)
    )
    for attempt in range(1, attempts):
        click.echo(f"Attempt {attempt} of {attempts}")
        found_devs = Discover.discover(target=target, timeout=timeout).items()
        for ip, dev in found_devs:
            if dev.alias.lower() == alias.lower():
                host = dev.host
                return host
    return None

@cli.command()
@pass_dev
def sysinfo(dev):
    """Print out full system information."""
    asyncio.run(dev.update())
    click.echo(click.style("== System info ==", bold=True))
    click.echo(pf(dev.sys_info))

@cli.command()
@pass_dev
@click.pass_context
def state(ctx, dev: SmartDevice):
    """Print out device state and versions."""
    asyncio.run(dev.update())
    click.echo(click.style(f"== {dev.alias} - {dev.model} ==", bold=True))

click.echo(
        click.style(
            "Device state: {}".format("ON" if dev.is_on else "OFF"),
            fg="green" if dev.is_on else "red",
        )
    )
    if dev.is_strip:
        for plug in dev.plugs:  # type: ignore
            asyncio.run(plug.update())
            is_on = plug.is_on
            alias = plug.alias
            click.echo(
                click.style(
                    "  * {} state: {}".format(alias, ("ON" if is_on else "OFF")),
                    fg="green" if is_on else "red",
                )
            )

click.echo(f"Host/IP: {dev.host}")
    for k, v in dev.state_information.items():
        click.echo(f"{k}: {v}")
    click.echo(click.style("== Generic information ==", bold=True))
    click.echo("Time:         {}".format(asyncio.run(dev.get_time())))
    click.echo("Hardware:     {}".format(dev.hw_info["hw_ver"]))
    click.echo("Software:     {}".format(dev.hw_info["sw_ver"]))
    click.echo(f"MAC (rssi):   {dev.mac} ({dev.rssi})")
    click.echo(f"Location:     {dev.location}")

ctx.invoke(emeter)

@cli.command()
@pass_dev
@click.argument("new_alias", required=False, default=None)
def alias(dev, new_alias):
    """Get or set the device alias."""
    if new_alias is not None:
        click.echo(f"Setting alias to {new_alias}")
        asyncio.run(dev.set_alias(new_alias))

click.echo(f"Alias: {dev.alias}")

@cli.command()
@pass_dev
@click.argument("module")
@click.argument("command")
@click.argument("parameters", default=None, required=False)
def raw_command(dev: SmartDevice, module, command, parameters):
    """Run a raw command on the device."""
    import ast

if parameters is not None:
        parameters = ast.literal_eval(parameters)
    res = asyncio.run(dev._query_helper(module, command, parameters))
    asyncio.run(dev.update())
    click.echo(res)

@cli.command()
@pass_dev
@click.option("--year", type=click.DateTime(["%Y"]), default=None, required=False)
@click.option("--month", type=click.DateTime(["%Y-%m"]), default=None, required=False)
@click.option("--erase", is_flag=True)
def emeter(dev, year, month, erase):
    """Query emeter for historical consumption."""
    click.echo(click.style("== Emeter ==", bold=True))
    asyncio.run(dev.update())
    if not dev.has_emeter:
        click.echo("Device has no emeter")
        return

if erase:
        click.echo("Erasing emeter statistics..")
        asyncio.run(dev.erase_emeter_stats())
        return

if year:
        click.echo(f"== For year {year.year} ==")
        emeter_status = asyncio.run(dev.get_emeter_monthly(year.year))
    elif month:
        click.echo(f"== For month {month.month} of {month.year} ==")
        emeter_status = asyncio.run(
            dev.get_emeter_daily(year=month.year, month=month.month)
        )
    else:
        emeter_status = asyncio.run(dev.get_emeter_realtime())
        click.echo("== Current State ==")

if isinstance(emeter_status, list):
        for plug in emeter_status:
            click.echo("Plug %d: %s" % (emeter_status.index(plug) + 1, plug))
    else:
        click.echo(str(emeter_status))

@cli.command()
@click.argument("brightness", type=click.IntRange(0, 100), default=None, required=False)
@pass_dev
def brightness(dev, brightness):
    """Get or set brightness."""
    asyncio.run(dev.update())
    if not dev.is_dimmable:
        click.echo("This device does not support brightness.")
        return
    if brightness is None:
        click.echo("Brightness: %s" % dev.brightness)
    else:
        click.echo("Setting brightness to %s" % brightness)
        asyncio.run(dev.set_brightness(brightness))

@cli.command()
@click.argument(
    "temperature", type=click.IntRange(2500, 9000), default=None, required=False
)
@pass_dev
def temperature(dev: SmartBulb, temperature):
    """Get or set color temperature."""
    if temperature is None:
        click.echo(f"Color temperature: {dev.color_temp}")
        valid_temperature_range = dev.valid_temperature_range
        if valid_temperature_range != (0, 0):
            click.echo("(min: {}, max: {})".format(*valid_temperature_range))
        else:
            click.echo(
                "Temperature range unknown, please open a github issue"
                f" or a pull request for model '{dev.model}'"
            )
    else:
        click.echo(f"Setting color temperature to {temperature}")
        asyncio.run(dev.set_color_temp(temperature))

@cli.command()
@click.argument("h", type=click.IntRange(0, 360), default=None, required=False)
@click.argument("s", type=click.IntRange(0, 100), default=None, required=False)
@click.argument("v", type=click.IntRange(0, 100), default=None, required=False)
@click.pass_context
@pass_dev
def hsv(dev, ctx, h, s, v):
    """Get or set color in HSV. (Bulb only)."""
    if h is None or s is None or v is None:
        click.echo("Current HSV: %s %s %s" % dev.hsv)
    elif s is None or v is None:
        raise click.BadArgumentUsage("Setting a color requires 3 values.", ctx)
    else:
        click.echo(f"Setting HSV: {h} {s} {v}")
        asyncio.run(dev.set_hsv(h, s, v))

@cli.command()
@click.argument("state", type=bool, required=False)
@pass_dev
def led(dev, state):
    """Get or set (Plug's) led state."""
    if state is not None:
        click.echo("Turning led to %s" % state)
        asyncio.run(dev.set_led(state))
    else:
        click.echo("LED state: %s" % dev.led)

@cli.command()
@pass_dev
def time(dev):
    """Get the device time."""
    click.echo(asyncio.run(dev.get_time()))

@cli.command()
@click.argument("index", type=int, required=False)
@pass_dev
def on(plug, index):
    """Turn the device on."""
    click.echo("Turning on..")
    if index is None:
        asyncio.run(plug.turn_on())
    else:
        asyncio.run(plug.turn_on(index=(index - 1)))

@cli.command()
@click.argument("index", type=int, required=False)
@pass_dev
def off(plug, index):
    """Turn the device off."""
    click.echo("Turning off..")
    if index is None:
        asyncio.run(plug.turn_off())
    else:
        asyncio.run(plug.turn_off(index=(index - 1)))

@cli.command()
@click.option("--delay", default=1)
@pass_dev
def reboot(plug, delay):
    """Reboot the device."""
    click.echo("Rebooting the device..")
    asyncio.run(plug.reboot(delay))

if __name__ == "__main__":
    cli()
0707010000000C000081ED000003E800000064000000015E303DFC00001DD1000000000000000000000000000000000000003700000000python-kasa-0.0~git1580219900.15b0c8c/kasa/discover.py"""Discovery module for TP-Link Smart Home devices."""
import asyncio
import json
import logging
import socket
from typing import Awaitable, Callable, Dict, Mapping, Type, Union, cast

from kasa.protocol import TPLinkSmartHomeProtocol
from kasa.smartbulb import SmartBulb
from kasa.smartdevice import SmartDevice, SmartDeviceException
from kasa.smartplug import SmartPlug
from kasa.smartstrip import SmartStrip

_LOGGER = logging.getLogger(__name__)

OnDiscoveredCallable = Callable[[SmartDevice], Awaitable[None]]

class _DiscoverProtocol(asyncio.DatagramProtocol):
    """Implementation of the discovery protocol handler.

This is internal class, use :func:Discover.discover: instead.
    """

discovered_devices: Dict[str, SmartDevice]
    discovered_devices_raw: Dict[str, Dict]

def __init__(
        self,
        *,
        on_discovered: OnDiscoveredCallable = None,
        target: str = "255.255.255.255",
        timeout: int = 5,
        discovery_packets: int = 3,
    ):
        self.transport = None
        self.tries = discovery_packets
        self.timeout = timeout
        self.on_discovered = on_discovered
        self.protocol = TPLinkSmartHomeProtocol()
        self.target = (target, Discover.DISCOVERY_PORT)
        self.discovered_devices = {}
        self.discovered_devices_raw = {}

def connection_made(self, transport) -> None:
        """Set socket options for broadcasting."""
        self.transport = transport
        sock = transport.get_extra_info("socket")
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

self.do_discover()

def do_discover(self) -> None:
        """Send number of discovery datagrams."""
        req = json.dumps(Discover.DISCOVERY_QUERY)
        _LOGGER.debug("[DISCOVERY] %s >> %s", self.target, Discover.DISCOVERY_QUERY)
        encrypted_req = self.protocol.encrypt(req)
        for i in range(self.tries):
            self.transport.sendto(encrypted_req[4:], self.target)  # type: ignore

def datagram_received(self, data, addr) -> None:
        ip, port = addr
        if ip in self.discovered_devices:
            return

info = json.loads(self.protocol.decrypt(data))
        _LOGGER.debug("[DISCOVERY] %s << %s", ip, info)

device_class = Discover._get_device_class(info)
        device = device_class(ip)

self.discovered_devices[ip] = device
        self.discovered_devices_raw[ip] = info

if device_class is not None:
            if self.on_discovered is not None:
                asyncio.ensure_future(self.on_discovered(device))
        else:
            _LOGGER.error("Received invalid response: %s", info)

def error_received(self, ex):
        _LOGGER.error("Got error: %s", ex)

def connection_lost(self, ex):
        pass

class Discover:
    """Discover TPLink Smart Home devices.

The main entry point for this library is Discover.discover(),
    which returns a dictionary of the found devices. The key is the IP address
    of the device and the value contains ready-to-use, SmartDevice-derived
    device object.

discover_single() can be used to initialize a single device given its
    IP address. If the type of the device and its IP address is already known,
    you can initialize the corresponding device class directly without this.

The protocol uses UDP broadcast datagrams on port 9999 for discovery.
    """

DISCOVERY_PORT = 9999

DISCOVERY_QUERY = {
        "system": {"get_sysinfo": None},
        "emeter": {"get_realtime": None},
        "smartlife.iot.dimmer": {"get_dimmer_parameters": None},
        "smartlife.iot.common.emeter": {"get_realtime": None},
        "smartlife.iot.smartbulb.lightingservice": {"get_light_state": None},
    }

@staticmethod
    async def discover(
        *,
        target="255.255.255.255",
        on_discovered=None,
        timeout=5,
        discovery_packets=3,
        return_raw=False,
    ) -> Mapping[str, Union[SmartDevice, Dict]]:
        """Discover supported devices.

Sends discovery message to 255.255.255.255:9999 in order
        to detect available supported devices in the local network,
        and waits for given timeout for answers from devices.

If given, `on_discovered` coroutine will get passed with the SmartDevice as parameter.
        The results of the discovery can be accessed either via `discovered_devices` (SmartDevice-derived) or
        `discovered_devices_raw` (JSON objects).

:param target: The target broadcast address (e.g. 192.168.xxx.255).
        :param on_discovered:
        :param timeout: How long to wait for responses, defaults to 5
        :param discovery_packets: Number of discovery packets are broadcasted.
        :param return_raw: True to return JSON objects instead of Devices.
        :return:
        """
        loop = asyncio.get_event_loop()
        transport, protocol = await loop.create_datagram_endpoint(
            lambda: _DiscoverProtocol(
                target=target,
                on_discovered=on_discovered,
                timeout=timeout,
                discovery_packets=discovery_packets,
            ),
            local_addr=("0.0.0.0", 0),
        )
        protocol = cast(_DiscoverProtocol, protocol)

try:
            _LOGGER.debug("Waiting %s seconds for responses...", timeout)
            await asyncio.sleep(5)
        finally:
            transport.close()

_LOGGER.debug("Discovered %s devices", len(protocol.discovered_devices))

if return_raw:
            return protocol.discovered_devices_raw

return protocol.discovered_devices

@staticmethod
    async def discover_single(host: str) -> SmartDevice:
        """Discover a single device by the given IP address.

:param host: Hostname of device to query
        :rtype: SmartDevice
        :return: Object for querying/controlling found device.
        """
        protocol = TPLinkSmartHomeProtocol()

info = await protocol.query(host, Discover.DISCOVERY_QUERY)

device_class = Discover._get_device_class(info)
        if device_class is not None:
            return device_class(host)

raise SmartDeviceException("Unable to discover device, received: %s" % info)

@staticmethod
    def _get_device_class(info: dict) -> Type[SmartDevice]:
        """Find SmartDevice subclass for device described by passed data."""
        if "system" in info and "get_sysinfo" in info["system"]:
            sysinfo = info["system"]["get_sysinfo"]
            if "type" in sysinfo:
                type_ = sysinfo["type"]
            elif "mic_type" in sysinfo:
                type_ = sysinfo["mic_type"]
            else:
                raise SmartDeviceException("Unable to find the device type field!")
        else:
            raise SmartDeviceException("No 'system' nor 'get_sysinfo' in response")

if "smartplug" in type_.lower() and "children" in sysinfo:
            return SmartStrip
        elif "smartplug" in type_.lower():
            return SmartPlug
        elif "smartbulb" in type_.lower():
            return SmartBulb

raise SmartDeviceException("Unknown device type: %s", type_)

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    loop = asyncio.get_event_loop()

async def _on_device(dev):
        await dev.update()
        _LOGGER.info("Got device: %s", dev)

devices = loop.run_until_complete(Discover.discover(on_discovered=_on_device))
    for ip, dev in devices.items():
        print(f"[{ip}] {dev}")
0707010000000D000081ED000003E800000064000000015E303DFC00000DBD000000000000000000000000000000000000003700000000python-kasa-0.0~git1580219900.15b0c8c/kasa/protocol.py"""Implementation of the TP-Link Smart Home Protocol.

Encryption/Decryption methods based on the works of
Lubomir Stroetmann and Tobias Esser

https://www.softscheck.com/en/reverse-engineering-tp-link-hs110/
https://github.com/softScheck/tplink-smartplug/

which are licensed under the Apache License, Version 2.0
http://www.apache.org/licenses/LICENSE-2.0
"""
import asyncio
import json
import logging
import struct
from typing import Any, Dict, Union

_LOGGER = logging.getLogger(__name__)

class TPLinkSmartHomeProtocol:
    """Implementation of the TP-Link Smart Home protocol."""

INITIALIZATION_VECTOR = 171
    DEFAULT_PORT = 9999
    DEFAULT_TIMEOUT = 5

@staticmethod
    async def query(
        host: str, request: Union[str, Dict], port: int = DEFAULT_PORT
    ) -> Any:
        """Request information from a TP-Link SmartHome Device.

:param str host: host name or ip address of the device
        :param int port: port on the device (default: 9999)
        :param request: command to send to the device (can be either dict or
        json string)
        :return: response dict
        """
        if isinstance(request, dict):
            request = json.dumps(request)

timeout = TPLinkSmartHomeProtocol.DEFAULT_TIMEOUT
        writer = None
        try:
            task = asyncio.open_connection(host, port)
            reader, writer = await asyncio.wait_for(task, timeout=timeout)
            _LOGGER.debug("> (%i) %s", len(request), request)
            writer.write(TPLinkSmartHomeProtocol.encrypt(request))
            await writer.drain()

buffer = bytes()
            # Some devices send responses with a length header of 0 and
            # terminate with a zero size chunk. Others send the length and
            # will hang if we attempt to read more data.
            length = -1
            while True:
                chunk = await reader.read(4096)
                if length == -1:
                    length = struct.unpack(">I", chunk[0:4])[0]
                buffer += chunk
                if (length > 0 and len(buffer) >= length + 4) or not chunk:
                    break
        finally:
            if writer:
                writer.close()
                await writer.wait_closed()

response = TPLinkSmartHomeProtocol.decrypt(buffer[4:])
        _LOGGER.debug("< (%i) %s", len(response), response)

return json.loads(response)

@staticmethod
    def encrypt(request: str) -> bytes:
        """
        Encrypt a request for a TP-Link Smart Home Device.

:param request: plaintext request data
        :return: ciphertext request
        """
        key = TPLinkSmartHomeProtocol.INITIALIZATION_VECTOR

plainbytes = request.encode()
        buffer = bytearray(struct.pack(">I", len(plainbytes)))

for plainbyte in plainbytes:
            cipherbyte = key ^ plainbyte
            key = cipherbyte
            buffer.append(cipherbyte)

return bytes(buffer)

@staticmethod
    def decrypt(ciphertext: bytes) -> str:
        """
        Decrypt a response of a TP-Link Smart Home Device.

:param ciphertext: encrypted response data
        :return: plaintext response
        """
        key = TPLinkSmartHomeProtocol.INITIALIZATION_VECTOR
        buffer = []

for cipherbyte in ciphertext:
            plainbyte = key ^ cipherbyte
            key = cipherbyte
            buffer.append(plainbyte)

plaintext = bytes(buffer)

return plaintext.decode()
0707010000000E000081A4000003E800000064000000015E303DFC000026B4000000000000000000000000000000000000003800000000python-kasa-0.0~git1580219900.15b0c8c/kasa/smartbulb.py"""Module for bulbs."""
import re
from typing import Any, Dict, Optional, Tuple

from kasa.smartdevice import (
    DeviceType,
    SmartDevice,
    SmartDeviceException,
    requires_update,
)

TPLINK_KELVIN = {
    "LB130": (2500, 9000),
    "LB120": (2700, 6500),
    "LB230": (2500, 9000),
    "KB130": (2500, 9000),
    "KL130": (2500, 9000),
    r"KL120$EU$": (2700, 6500),
    r"KL120$US$": (2700, 5000),
}

class SmartBulb(SmartDevice):
    """Representation of a TP-Link Smart Bulb.

Usage example when used as library:
    ```python
    p = SmartBulb("192.168.1.105")
    await p.update()

# print the devices alias
    print(p.alias)

# change state of bulb
    await p.turn_on()
    await p.turn_off()

# query and print current state of plug
    print(p.state_information)

# check whether the bulb supports color changes
    if p.is_color:

# set the color to an HSV tuple
    await p.set_hsv(180, 100, 100)

# get the current HSV value
    print(p.hsv)

# check whether the bulb supports setting color temperature
    if p.is_variable_color_temp:
        # set the color temperature in Kelvin
        await p.set_color_temp(3000)

# get the current color temperature
        print(p.color_temp)

# check whether the bulb is dimmable
    if p.is_dimmable:

# set the bulb to 50% brightness
    await p.set_brightness(50)

# check the current brightness
    print(p.brightness)
    ```

Errors reported by the device are raised as SmartDeviceExceptions,
    and should be handled by the user of the library.
    """

LIGHT_SERVICE = "smartlife.iot.smartbulb.lightingservice"

def __init__(self, host: str, *, child_id: str = None, cache_ttl: int = 3) -> None:
        SmartDevice.__init__(self, host=host, child_id=child_id, cache_ttl=cache_ttl)
        self.emeter_type = "smartlife.iot.common.emeter"
        self._device_type = DeviceType.Bulb
        self._light_state = None

@property  # type: ignore
    @requires_update
    def is_color(self) -> bool:
        """Whether the bulb supports color changes.

:return: True if the bulb supports color changes, False otherwise
        :rtype: bool
        """
        sys_info = self.sys_info
        return bool(sys_info["is_color"])

@property  # type: ignore
    @requires_update
    def is_dimmable(self) -> bool:
        """Whether the bulb supports brightness changes.

:return: True if the bulb supports brightness changes, False otherwise
        :rtype: bool
        """
        sys_info = self.sys_info
        return bool(sys_info["is_dimmable"])

@property  # type: ignore
    @requires_update
    def is_variable_color_temp(self) -> bool:
        """Whether the bulb supports color temperature changes.

:return: True if the bulb supports color temperature changes, False
        otherwise
        :rtype: bool
        """
        sys_info = self.sys_info
        return bool(sys_info["is_variable_color_temp"])

@property  # type: ignore
    @requires_update
    def valid_temperature_range(self) -> Tuple[int, int]:
        """Return the device-specific white temperature range (in Kelvin).

:return: White temperature range in Kelvin (minimun, maximum)
        :rtype: tuple
        """
        if not self.is_variable_color_temp:
            return (0, 0)
        for model, temp_range in TPLINK_KELVIN.items():
            sys_info = self.sys_info
            if re.match(model, sys_info["model"]):
                return temp_range
        return (0, 0)

async def update(self):
        """Update `sys_info and `light_state`."""
        self._sys_info = await self.get_sys_info()
        self._light_state = await self.get_light_state()

@property  # type: ignore
    @requires_update
    def light_state(self) -> Optional[Dict[str, Dict]]:
        """Query the light state."""
        return self._light_state

async def get_light_state(self) -> Dict[str, Dict]:
        """Query the light state."""
        return await self._query_helper(self.LIGHT_SERVICE, "get_light_state")

async def set_light_state(self, state: Dict) -> Dict:
        """Set the light state."""
        light_state = await self._query_helper(
            self.LIGHT_SERVICE, "transition_light_state", state
        )
        await self.update()
        return light_state

@property  # type: ignore
    @requires_update
    def hsv(self) -> Tuple[int, int, int]:
        """Return the current HSV state of the bulb.

:return: hue, saturation and value (degrees, %, %)
        :rtype: tuple
        """
        if not self.is_color:
            raise SmartDeviceException("Bulb does not support color.")

light_state = self.light_state
        if not self.is_on:
            hue = light_state["dft_on_state"]["hue"]
            saturation = light_state["dft_on_state"]["saturation"]
            value = light_state["dft_on_state"]["brightness"]
        else:
            hue = light_state["hue"]
            saturation = light_state["saturation"]
            value = light_state["brightness"]

return hue, saturation, value

def _raise_for_invalid_brightness(self, value):
        if not isinstance(value, int) or not (0 <= value <= 100):
            raise ValueError(
                "Invalid brightness value: {} " "(valid range: 0-100%)".format(value)
            )

@requires_update
    async def set_hsv(self, hue: int, saturation: int, value: int):
        """Set new HSV.

:param int hue: hue in degrees
        :param int saturation: saturation in percentage [0,100]
        :param int value: value in percentage [0, 100]
        """
        if not self.is_color:
            raise SmartDeviceException("Bulb does not support color.")

if not isinstance(hue, int) or not (0 <= hue <= 360):
            raise ValueError(
                "Invalid hue value: {} " "(valid range: 0-360)".format(hue)
            )

if not isinstance(saturation, int) or not (0 <= saturation <= 100):
            raise ValueError(
                "Invalid saturation value: {} "
                "(valid range: 0-100%)".format(saturation)
            )

self._raise_for_invalid_brightness(value)

light_state = {
            "hue": hue,
            "saturation": saturation,
            "brightness": value,
            "color_temp": 0,
        }
        await self.set_light_state(light_state)

@property  # type: ignore
    @requires_update
    def color_temp(self) -> int:
        """Return color temperature of the device.

:return: Color temperature in Kelvin
        :rtype: int
        """
        if not self.is_variable_color_temp:
            raise SmartDeviceException("Bulb does not support colortemp.")

light_state = self.light_state
        if not self.is_on:
            return int(light_state["dft_on_state"]["color_temp"])
        else:
            return int(light_state["color_temp"])

@requires_update
    async def set_color_temp(self, temp: int) -> None:
        """Set the color temperature of the device.

:param int temp: The new color temperature, in Kelvin
        """
        if not self.is_variable_color_temp:
            raise SmartDeviceException("Bulb does not support colortemp.")

valid_temperature_range = self.valid_temperature_range
        if temp < valid_temperature_range[0] or temp > valid_temperature_range[1]:
            raise ValueError(
                "Temperature should be between {} "
                "and {}".format(*valid_temperature_range)
            )

light_state = {"color_temp": temp}
        await self.set_light_state(light_state)

@property  # type: ignore
    @requires_update
    def brightness(self) -> int:
        """Return the current brightness.

:return: brightness in percent
        :rtype: int
        """
        if not self.is_dimmable:  # pragma: no cover
            raise SmartDeviceException("Bulb is not dimmable.")

light_state = self.light_state
        if not self.is_on:
            return int(light_state["dft_on_state"]["brightness"])
        else:
            return int(light_state["brightness"])

@requires_update
    async def set_brightness(self, brightness: int) -> None:
        """Set the brightness.

:param int brightness: brightness in percent
        """
        if not self.is_dimmable:  # pragma: no cover
            raise SmartDeviceException("Bulb is not dimmable.")

self._raise_for_invalid_brightness(brightness)

light_state = {"brightness": brightness}
        await self.set_light_state(light_state)

@property  # type: ignore
    @requires_update
    def state_information(self) -> Dict[str, Any]:
        """Return bulb-specific state information.

:return: Bulb information dict, keys in user-presentable form.
        :rtype: dict
        """
        info: Dict[str, Any] = {
            "Brightness": self.brightness,
            "Is dimmable": self.is_dimmable,
        }
        if self.is_variable_color_temp:
            info["Color temperature"] = self.color_temp
            info["Valid temperature range"] = self.valid_temperature_range
        if self.is_color:
            info["HSV"] = self.hsv

return info

@property  # type: ignore
    @requires_update
    def is_on(self) -> bool:
        """Return whether the device is on."""
        light_state = self.light_state
        return bool(light_state["on_off"])

async def turn_off(self) -> None:
        """Turn the bulb off."""
        await self.set_light_state({"on_off": 0})

async def turn_on(self) -> None:
        """Turn the bulb on."""
        await self.set_light_state({"on_off": 1})

@property  # type: ignore
    @requires_update
    def has_emeter(self) -> bool:
        """Return that the bulb has an emeter."""
        return True
0707010000000F000081ED000003E800000064000000015E303DFC00005237000000000000000000000000000000000000003A00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/smartdevice.py"""Python library supporting TP-Link Smart Home devices.

The communication protocol was reverse engineered by Lubomir Stroetmann and
Tobias Esser in 'Reverse Engineering the TP-Link HS110':
https://www.softscheck.com/en/reverse-engineering-tp-link-hs110/

This library reuses codes and concepts of the TP-Link WiFi SmartPlug Client
at https://github.com/softScheck/tplink-smartplug, developed by Lubomir
Stroetmann which is licensed under the Apache License, Version 2.0.

You may obtain a copy of the license at
http://www.apache.org/licenses/LICENSE-2.0
"""
import functools
import inspect
import logging
from collections import defaultdict
from datetime import datetime, timedelta
from enum import Enum
from typing import Any, Dict, Optional

from kasa.protocol import TPLinkSmartHomeProtocol

_LOGGER = logging.getLogger(__name__)

class DeviceType(Enum):
    """Device type enum."""

Plug = 1
    Bulb = 2
    Strip = 3
    Unknown = -1

class SmartDeviceException(Exception):
    """Base exception for device errors."""

class EmeterStatus(dict):
    """Container for converting different representations of emeter data.

Newer FW/HW versions postfix the variable names with the used units,
    where-as the olders do not have this feature.

This class automatically converts between these two to allow
    backwards and forwards compatibility.
    """

def __getitem__(self, item):
        valid_keys = [
            "voltage_mv",
            "power_mw",
            "current_ma",
            "energy_wh",
            "total_wh",
            "voltage",
            "power",
            "current",
            "total",
            "energy",
        ]

# 1. if requested data is available, return it
        if item in super().keys():
            return super().__getitem__(item)
        # otherwise decide how to convert it
        else:
            if item not in valid_keys:
                raise KeyError(item)
            if "_" in item:  # upscale
                return super().__getitem__(item[: item.find("_")]) * 1000
            else:  # downscale
                for i in super().keys():
                    if i.startswith(item):
                        return self.__getitem__(i) / 1000

raise SmartDeviceException("Unable to find a value for '%s'" % item)

def requires_update(f):
    """Indicate that `update` should be called before accessing this method."""  # noqa: D202
    if inspect.iscoroutinefunction(f):

@functools.wraps(f)
        async def wrapped(*args, **kwargs):
            self = args[0]
            assert self._sys_info is not None
            return await f(*args, **kwargs)

else:

@functools.wraps(f)
        def wrapped(*args, **kwargs):
            self = args[0]
            assert self._sys_info is not None
            return f(*args, **kwargs)

f.requires_update = True
    return wrapped

class SmartDevice:
    """Base class for all supported device types."""

def __init__(self, host: str, *, child_id: str = None, cache_ttl: int = 3) -> None:
        """Create a new SmartDevice instance.

:param str host: host name or ip address on which the device listens
        :param child_id: optional child ID for context in a parent device
        """
        self.host = host

self.protocol = TPLinkSmartHomeProtocol()
        self.emeter_type = "emeter"
        self.child_id = child_id
        self.cache_ttl = timedelta(seconds=cache_ttl)
        _LOGGER.debug(
            "Initializing %s using child_id %s and cache ttl %s",
            self.host,
            self.child_id,
            self.cache_ttl,
        )
        self.cache = defaultdict(lambda: defaultdict(lambda: None))  # type: ignore
        self._device_type = DeviceType.Unknown
        self._sys_info = None

def _result_from_cache(self, target, cmd) -> Optional[Dict]:
        """Return query result from cache if still fresh.

Only results from commands starting with `get_` are considered cacheable.

:param target: Target system
        :param cmd: Command
        :rtype: query result or None if expired.
        """
        _LOGGER.debug("Checking cache for %s %s", target, cmd)
        if cmd not in self.cache[target]:
            return None

cached = self.cache[target][cmd]
        if cached and cached["last_updated"] is not None:
            if cached[
                "last_updated"
            ] + self.cache_ttl > datetime.utcnow() and cmd.startswith("get_"):
                _LOGGER.debug("Got cached %s %s", target, cmd)
                return self.cache[target][cmd]
            else:
                _LOGGER.debug("Invalidating the cache for %s cmd %s", target, cmd)
                for cache_entry in self.cache[target].values():
                    cache_entry["last_updated"] = datetime.utcfromtimestamp(0)
        return None

def _insert_to_cache(self, target: str, cmd: str, response: Dict) -> None:
        """Add response for a given command to the cache.

:param target: Target system
        :param cmd: Command
        :param response: Response to be cached
        """
        self.cache[target][cmd] = response.copy()
        self.cache[target][cmd]["last_updated"] = datetime.utcnow()

async def _query_helper(
        self, target: str, cmd: str, arg: Optional[Dict] = None
    ) -> Any:
        """Handle result unwrapping and error handling.

:param target: Target system {system, time, emeter, ..}
        :param cmd: Command to execute
        :param arg: JSON object passed as parameter to the command
        :return: Unwrapped result for the call.
        :rtype: dict
        :raises SmartDeviceException: if command was not executed correctly
        """
        request: Dict[str, Any] = {target: {cmd: arg}}
        if self.child_id is not None:
            request = {"context": {"child_ids": [self.child_id]}, target: {cmd: arg}}

try:
            response = self._result_from_cache(target, cmd)
            if response is None:
                _LOGGER.debug("Got no result from cache, querying the device.")
                response = await self.protocol.query(host=self.host, request=request)
                self._insert_to_cache(target, cmd, response)
        except Exception as ex:
            raise SmartDeviceException(f"Communication error on {target}:{cmd}") from ex

if target not in response:
            raise SmartDeviceException(f"No required {target} in response: {response}")

result = response[target]
        if "err_code" in result and result["err_code"] != 0:
            raise SmartDeviceException(f"Error on {target}.{cmd}: {result}")

if cmd not in result:
            raise SmartDeviceException(f"No command in response: {response}")
        result = result[cmd]
        if "err_code" in result and result["err_code"] != 0:
            raise SmartDeviceException(f"Error on {target} {cmd}: {result}")

if "err_code" in result:
            del result["err_code"]

return result

def _get_child_info(self) -> Dict:
        """Return the child information dict, if available.

:raises SmartDeviceException: if there is no child or it cannot be found.
        """
        for plug in self.sys_info["children"]:
            if plug["id"] == self.child_id:
                return plug
        raise SmartDeviceException("Unable to find children %s")

def has_emeter(self) -> bool:
        """Return if device has an energy meter.

:return: True if energey meter is available
                 False if energymeter is missing
        """
        raise NotImplementedError()

async def get_sys_info(self) -> Dict[str, Any]:
        """Retrieve system information.

:return: sysinfo
        :rtype dict
        :raises SmartDeviceException: on error
        """
        return await self._query_helper("system", "get_sysinfo")

async def update(self):
        """Update some of the attributes.

Needed for methods that are decorated with `requires_update`.
        """
        self._sys_info = await self.get_sys_info()

@property  # type: ignore
    @requires_update
    def sys_info(self) -> Dict[str, Any]:
        """Retrieve system information.

:return: sysinfo
        :rtype dict
        :raises SmartDeviceException: on error
        """
        assert self._sys_info is not None
        return self._sys_info

@property  # type: ignore
    @requires_update
    def model(self) -> str:
        """Return device model.

:return: device model
        :rtype: str
        :raises SmartDeviceException: on error
        """
        sys_info = self.sys_info
        return str(sys_info["model"])

@property  # type: ignore
    @requires_update
    def alias(self) -> str:
        """Return device name (alias).

:return: Device name aka alias.
        :rtype: str
        """
        sys_info = self.sys_info
        return str(sys_info["alias"])

async def set_alias(self, alias: str) -> None:
        """Set the device name (alias).

:param alias: New alias (name)
        :raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_dev_alias", {"alias": alias})
        await self.update()

async def get_icon(self) -> Dict:
        """Return device icon.

Note: not working on HS110, but is always empty.

:return: icon and its hash
        :rtype: dict
        :raises SmartDeviceException: on error
        """
        return await self._query_helper("system", "get_dev_icon")

def set_icon(self, icon: str) -> None:
        """Set device icon.

Content for hash and icon are unknown.

:param str icon: Icon path(?)
        :raises NotImplementedError: when not implemented
        :raises SmartPlugError: on error
        """
        raise NotImplementedError()
        # here just for the sake of completeness
        # await self._query_helper("system",
        #                    "set_dev_icon", {"icon": "", "hash": ""})
        # self.initialize()

async def get_time(self) -> Optional[datetime]:
        """Return current time from the device.

:return: datetime for device's time
        :rtype: datetime or None when not available
        :raises SmartDeviceException: on error
        """
        try:
            res = await self._query_helper("time", "get_time")
            return datetime(
                res["year"],
                res["month"],
                res["mday"],
                res["hour"],
                res["min"],
                res["sec"],
            )
        except SmartDeviceException:
            return None

async def set_time(self, ts: datetime) -> None:
        """Set the device time.

Note: this calls set_timezone() for setting.

:param datetime ts: New date and time
        :return: result
        :type: dict
        :raises NotImplemented: when not implemented.
        :raises SmartDeviceException: on error
        """
        raise NotImplementedError("Fails with err_code == 0 with HS110.")
        """
        here just for the sake of completeness.
        if someone figures out why it doesn't work,
        please create a PR :-)
        ts_obj = {
            "index": self.timezone["index"],
            "hour": ts.hour,
            "min": ts.minute,
            "sec": ts.second,
            "year": ts.year,
            "month": ts.month,
            "mday": ts.day,
        }

response = await self._query_helper("time", "set_timezone", ts_obj)
        self.initialize()

return response
        """

async def get_timezone(self) -> Dict:
        """Return timezone information.

:return: Timezone information
        :rtype: dict
        :raises SmartDeviceException: on error
        """
        return await self._query_helper("time", "get_timezone")

@property  # type: ignore
    @requires_update
    def hw_info(self) -> Dict:
        """Return hardware information.

:return: Information about hardware
        :rtype: dict
        """
        keys = [
            "sw_ver",
            "hw_ver",
            "mac",
            "mic_mac",
            "type",
            "mic_type",
            "hwId",
            "fwId",
            "oemId",
            "dev_name",
        ]
        sys_info = self.sys_info
        return {key: sys_info[key] for key in keys if key in sys_info}

@property  # type: ignore
    @requires_update
    def location(self) -> Dict:
        """Return geographical location.

:return: latitude and longitude
        :rtype: dict
        """
        sys_info = self.sys_info
        loc = {"latitude": None, "longitude": None}

if "latitude" in sys_info and "longitude" in sys_info:
            loc["latitude"] = sys_info["latitude"]
            loc["longitude"] = sys_info["longitude"]
        elif "latitude_i" in sys_info and "longitude_i" in sys_info:
            loc["latitude"] = sys_info["latitude_i"]
            loc["longitude"] = sys_info["longitude_i"]
        else:
            _LOGGER.warning("Unsupported device location.")

return loc

@property  # type: ignore
    @requires_update
    def rssi(self) -> Optional[int]:
        """Return WiFi signal strenth (rssi).

:return: rssi
        :rtype: int
        """
        sys_info = self.sys_info
        if "rssi" in sys_info:
            return int(sys_info["rssi"])
        return None

@property  # type: ignore
    @requires_update
    def mac(self) -> str:
        """Return mac address.

:return: mac address in hexadecimal with colons, e.g. 01:23:45:67:89:ab
        :rtype: str
        """
        sys_info = self.sys_info

if "mac" in sys_info:
            return str(sys_info["mac"])
        elif "mic_mac" in sys_info:
            return ":".join(
                format(s, "02x") for s in bytes.fromhex(sys_info["mic_mac"])
            )

raise SmartDeviceException(
            "Unknown mac, please submit a bug report with sys_info output."
        )

async def set_mac(self, mac):
        """Set the mac address.

:param str mac: mac in hexadecimal with colons, e.g. 01:23:45:67:89:ab
        :raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_mac_addr", {"mac": mac})
        await self.update()

@requires_update
    async def get_emeter_realtime(self) -> EmeterStatus:
        """Retrieve current energy readings.

:returns: current readings or False
        :rtype: dict, None
        :raises SmartDeviceException: on error
        """
        if not self.has_emeter:
            raise SmartDeviceException("Device has no emeter")

return EmeterStatus(await self._query_helper(self.emeter_type, "get_realtime"))

@requires_update
    async def get_emeter_daily(
        self, year: int = None, month: int = None, kwh: bool = True
    ) -> Dict:
        """Retrieve daily statistics for a given month.

if year is None:
            year = datetime.now().year
        if month is None:
            month = datetime.now().month

response = await self._query_helper(
            self.emeter_type, "get_daystat", {"month": month, "year": year}
        )
        response = [EmeterStatus(**x) for x in response["day_list"]]

key = "energy_wh"
        if kwh:
            key = "energy"

data = {entry["day"]: entry[key] for entry in response}

return data

@requires_update
    async def get_emeter_monthly(self, year: int = None, kwh: bool = True) -> Dict:
        """Retrieve monthly statistics for a given year.

if year is None:
            year = datetime.now().year

response = await self._query_helper(
            self.emeter_type, "get_monthstat", {"year": year}
        )
        response = [EmeterStatus(**x) for x in response["month_list"]]

key = "energy_wh"
        if kwh:
            key = "energy"

return {entry["month"]: entry[key] for entry in response}

@requires_update
    async def erase_emeter_stats(self):
        """Erase energy meter statistics.

:return: True if statistics were deleted
        :raises SmartDeviceException: on error
        """
        if not self.has_emeter:
            raise SmartDeviceException("Device has no emeter")

await self._query_helper(self.emeter_type, "erase_emeter_stat", None)
        await self.update()

@requires_update
    async def current_consumption(self) -> float:
        """Get the current power consumption in Watt.

:return: the current power consumption in Watts.
        :raises SmartDeviceException: on error
        """
        if not self.has_emeter:
            raise SmartDeviceException("Device has no emeter")

response = EmeterStatus(await self.get_emeter_realtime())
        return response["power"]

async def reboot(self, delay=1) -> None:
        """Reboot the device.

Note that giving a delay of zero causes this to block,
        as the device reboots immediately without responding to the call.

:param delay: Delay the reboot for `delay` seconds.
        :return: None
        """
        await self._query_helper("system", "reboot", {"delay": delay})

async def turn_off(self) -> None:
        """Turn off the device."""
        raise NotImplementedError("Device subclass needs to implement this.")

@property  # type: ignore
    @requires_update
    def is_off(self) -> bool:
        """Return True if device is off.

:return: True if device is off, False otherwise.
        :rtype: bool
        """
        return not self.is_on

async def turn_on(self) -> None:
        """Turn device on."""
        raise NotImplementedError("Device subclass needs to implement this.")

@property  # type: ignore
    @requires_update
    def is_on(self) -> bool:
        """Return if the device is on.

:return: True if the device is on, False otherwise.
        :rtype: bool
        :return:
        """
        raise NotImplementedError("Device subclass needs to implement this.")

@property  # type: ignore
    @requires_update
    def state_information(self) -> Dict[str, Any]:
        """Return device-type specific, end-user friendly state information.

:return: dict with state information.
        :rtype: dict
        """
        raise NotImplementedError("Device subclass needs to implement this.")

@property  # type: ignore
    @requires_update
    def device_id(self) -> str:
        """Return unique ID for the device.

For regular devices this is the MAC address of the device,
        for child devices a combination of MAC and child's ID.
        """
        if self.is_child_device:
            return f"{self.mac}_{self.child_id}"
        return self.mac

@property
    def device_type(self) -> DeviceType:
        """Return the device type."""
        return self._device_type

@property
    def is_bulb(self) -> bool:
        """Return True if the device is a bulb."""
        return self._device_type == DeviceType.Bulb

@property
    def is_plug(self) -> bool:
        """Return True if the device is a plug."""
        return self._device_type == DeviceType.Plug

@property
    def is_strip(self) -> bool:
        """Return True if the device is a strip."""
        return self._device_type == DeviceType.Strip

@property
    def is_dimmable(self) -> bool:
        """Return  True if the device is dimmable."""
        return False

@property
    def is_variable_color_temp(self) -> bool:
        """Return True if the device supports color temperature."""
        return False

@property
    def is_child_device(self) -> bool:
        """Return True if the device is a child device of another device."""
        return self.child_id is not None

def __repr__(self):
        return "<{} model {} at {} ({}), is_on: {} - dev specific: {}>".format(
            self.__class__.__name__,
            self.model,
            self.host,
            self.alias,
            self.is_on,
            self.state_information,
        )
07070100000010000081A4000003E800000064000000015E303DFC00001615000000000000000000000000000000000000003800000000python-kasa-0.0~git1580219900.15b0c8c/kasa/smartplug.py"""Module for plugs."""
import datetime
import logging
from typing import Any, Dict

from kasa.smartdevice import (
    DeviceType,
    SmartDevice,
    SmartDeviceException,
    requires_update,
)

_LOGGER = logging.getLogger(__name__)

class SmartPlug(SmartDevice):
    """Representation of a TP-Link Smart Switch.

Usage example when used a a synchronous library:
    ```python
    p = SmartPlug("192.168.1.105")

# print the devices alias
    print(p.alias)

# change state of plug
    await p.turn_on()
    await p.turn_off()

# query and print current state of plug
    print(p.state_information)
    ```

Errors reported by the device are raised as SmartDeviceExceptions,
    and should be handled by the user of the library.
    """

def __init__(self, host: str, *, child_id: str = None, cache_ttl: int = 3) -> None:
        SmartDevice.__init__(self, host, child_id=child_id, cache_ttl=cache_ttl)
        self.emeter_type = "emeter"
        self._device_type = DeviceType.Plug

@property  # type: ignore
    @requires_update
    def brightness(self) -> int:
        """Return current brightness on dimmers.

Will return a range between 0 - 100.

:returns: integer
        :rtype: int
        """
        if not self.is_dimmable:
            raise SmartDeviceException("Device is not dimmable.")

sys_info = self.sys_info
        return int(sys_info["brightness"])

@requires_update
    async def set_brightness(self, value: int):
        """Set the new dimmer brightness level.

Note:
        When setting brightness, if the light is not
        already on, it will be turned on automatically.

:param value: integer between 1 and 100

"""
        if not self.is_dimmable:
            raise SmartDeviceException("Device is not dimmable.")

if not isinstance(value, int):
            raise ValueError("Brightness must be integer, " "not of %s.", type(value))
        elif 0 < value <= 100:
            await self.turn_on()
            await self._query_helper(
                "smartlife.iot.dimmer", "set_brightness", {"brightness": value}
            )
            await self.update()
        else:
            raise ValueError("Brightness value %s is not valid." % value)

@property  # type: ignore
    @requires_update
    def alias(self) -> str:
        """Return device name (alias).

:return: Device name aka alias.
        :rtype: str
        """
        if self.is_child_device:
            info = self._get_child_info()
            return info["alias"]
        else:
            return super().alias

@property  # type: ignore
    @requires_update
    def is_dimmable(self):
        """Whether the switch supports brightness changes.

:return: True if switch supports brightness changes, False otherwise
        :rtype: bool
        """
        sys_info = self.sys_info
        return "brightness" in sys_info

@property  # type: ignore
    @requires_update
    def has_emeter(self):
        """Return whether device has an energy meter.

:return: True if energy meter is available
                 False otherwise
        """
        sys_info = self.sys_info
        features = sys_info["feature"].split(":")
        return "ENE" in features

@property  # type: ignore
    @requires_update
    def is_on(self) -> bool:
        """Return whether device is on.

:return: True if device is on, False otherwise
        """
        if self.is_child_device:
            info = self._get_child_info()
            return info["state"]

sys_info = self.sys_info
        return bool(sys_info["relay_state"])

async def turn_on(self):
        """Turn the switch on.

:raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_relay_state", {"state": 1})
        await self.update()

async def turn_off(self):
        """Turn the switch off.

:raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_relay_state", {"state": 0})
        await self.update()

@property  # type: ignore
    @requires_update
    def led(self) -> bool:
        """Return the state of the led.

:return: True if led is on, False otherwise
        :rtype: bool
        """
        sys_info = self.sys_info
        return bool(1 - sys_info["led_off"])

async def set_led(self, state: bool):
        """Set the state of the led (night mode).

:param bool state: True to set led on, False to set led off
        :raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_led_off", {"off": int(not state)})
        await self.update()

@property  # type: ignore
    @requires_update
    def on_since(self) -> datetime.datetime:
        """Return pretty-printed on-time.

:return: datetime for on since
        :rtype: datetime
        """
        sys_info = self.sys_info
        if self.is_child_device:
            info = self._get_child_info()
            on_time = info["on_time"]
        else:
            on_time = sys_info["on_time"]

return datetime.datetime.now() - datetime.timedelta(seconds=on_time)

@property  # type: ignore
    @requires_update
    def state_information(self) -> Dict[str, Any]:
        """Return switch-specific state information.

:return: Switch information dict, keys in user-presentable form.
        :rtype: dict
        """
        info = {"LED state": self.led, "On since": self.on_since}
        if self.is_dimmable:
            info["Brightness"] = self.brightness
        return info
07070100000011000081ED000003E800000064000000015E303DFC000017F2000000000000000000000000000000000000003900000000python-kasa-0.0~git1580219900.15b0c8c/kasa/smartstrip.py"""Module for multi-socket devices (HS300, HS107).

.. todo:: describe how this interfaces with single plugs.
"""
import datetime
import logging
from collections import defaultdict
from typing import Any, DefaultDict, Dict, List

from kasa.smartdevice import DeviceType, requires_update
from kasa.smartplug import SmartPlug

_LOGGER = logging.getLogger(__name__)

class SmartStrip(SmartPlug):
    """Representation of a TP-Link Smart Power Strip.

Usage example when used as library:
    ```python
    p = SmartStrip("192.168.1.105")

# query the state of the strip
    await p.update()
    print(p.is_on)

# change state of all outlets
    await p.turn_on()
    await p.turn_off()

# individual outlets are accessible through plugs variable
    for plug in p.plugs:
        print(f"{p}: {p.is_on}")

# change state of a single outlet
    await p.plugs[0].turn_on()
    ```

Errors reported by the device are raised as SmartDeviceExceptions,
    and should be handled by the user of the library.
    """

def __init__(self, host: str, *, cache_ttl: int = 3) -> None:
        SmartPlug.__init__(self, host=host, cache_ttl=cache_ttl)
        self.emeter_type = "emeter"
        self._device_type = DeviceType.Strip
        self.plugs: List[SmartPlug] = []

@property  # type: ignore
    @requires_update
    def is_on(self) -> bool:
        """Return if any of the outlets are on."""
        for plug in self.plugs:
            is_on = plug.is_on
            if is_on:
                return True
        return False

async def update(self):
        """Update some of the attributes.

Needed for methods that are decorated with `requires_update`.
        """
        await super().update()

# Initialize the child devices during the first update.
        if not self.plugs:
            children = self.sys_info["children"]
            self.num_children = len(children)
            for child in children:
                self.plugs.append(
                    SmartPlug(
                        self.host,
                        child_id=child["id"],
                        cache_ttl=self.cache_ttl.total_seconds(),
                    )
                )

async def turn_on(self):
        """Turn the strip on.

:raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_relay_state", {"state": 1})
        await self.update()

async def turn_off(self):
        """Turn the strip off.

:raises SmartDeviceException: on error
        """
        await self._query_helper("system", "set_relay_state", {"state": 0})
        await self.update()

@property  # type: ignore
    @requires_update
    def on_since(self) -> datetime.datetime:
        """Return the maximum on-time of all outlets."""
        return max(plug.on_since for plug in self.plugs)

@property  # type: ignore
    @requires_update
    def state_information(self) -> Dict[str, Any]:
        """Return strip-specific state information.

:return: Strip information dict, keys in user-presentable form.
        :rtype: dict
        """
        state: Dict[str, Any] = {"LED state": self.led}
        for plug in self.plugs:
            if plug.is_on:
                state["Plug %s on since" % str(plug)] = self.on_since

return state

async def current_consumption(self) -> float:
        """Get the current power consumption in watts.

:return: the current power consumption in watts.
        :rtype: float
        :raises SmartDeviceException: on error
        """
        consumption = sum([await plug.current_consumption() for plug in self.plugs])

return consumption

async def get_icon(self) -> Dict:
        """Icon for the device.

Overriden to keep the API, as the SmartStrip and children do not
        have icons, we just return dummy strings.
        """
        return {"icon": "SMARTSTRIP-DUMMY", "hash": "SMARTSTRIP-DUMMY"}

async def set_alias(self, alias: str) -> None:
        """Set the alias for the strip.

:param alias: new alias
        :raises SmartDeviceException: on error
        """
        return await super().set_alias(alias)

@requires_update
    async def get_emeter_daily(
        self, year: int = None, month: int = None, kwh: bool = True
    ) -> Dict:
        """Retrieve daily statistics for a given month.

:param year: year for which to retrieve statistics (default: this year)
        :param month: month for which to retrieve statistics (default: this
                      month)
        :param kwh: return usage in kWh (default: True)
        :return: mapping of day of month to value
        :rtype: dict
        :raises SmartDeviceException: on error
        """
        emeter_daily: DefaultDict[int, float] = defaultdict(lambda: 0.0)
        for plug in self.plugs:
            plug_emeter_daily = await plug.get_emeter_daily(
                year=year, month=month, kwh=kwh
            )
            for day, value in plug_emeter_daily.items():
                emeter_daily[day] += value
        return emeter_daily

@requires_update
    async def get_emeter_monthly(self, year: int = None, kwh: bool = True) -> Dict:
        """Retrieve monthly statistics for a given year.

:param year: year for which to retrieve statistics (default: this year)
        :param kwh: return usage in kWh (default: True)
        :return: dict: mapping of month to value
        :rtype: dict
        :raises SmartDeviceException: on error
        """
        emeter_monthly: DefaultDict[int, float] = defaultdict(lambda: 0.0)
        for plug in self.plugs:
            plug_emeter_monthly = await plug.get_emeter_monthly(year=year, kwh=kwh)
            for month, value in plug_emeter_monthly:
                emeter_monthly[month] += value
        return emeter_monthly

@requires_update
    async def erase_emeter_stats(self):
        """Erase energy meter statistics for all plugs.

:raises SmartDeviceException: on error
        """
        for plug in self.plugs:
            await plug.erase_emeter_stats()
07070100000012000041ED000003E800000064000000015E303DFC00000000000000000000000000000000000000000000003100000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests07070100000013000081A4000003E800000064000000015E303DFC00000000000000000000000000000000000000000000003D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/__init__.py07070100000014000081A4000003E800000064000000015E303DFC00000F49000000000000000000000000000000000000003D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/conftest.pyimport asyncio
import glob
import json
import os
from os.path import basename

import pytest

from kasa import Discover, SmartBulb, SmartPlug, SmartStrip

from .newfakes import FakeTransportProtocol

SUPPORTED_DEVICES = glob.glob(
    os.path.dirname(os.path.abspath(__file__)) + "/fixtures/*.json"
)

BULBS = {"LB100", "LB120", "LB130", "KL120"}
VARIABLE_TEMP = {"LB120", "LB130", "KL120"}
PLUGS = {"HS100", "HS105", "HS110", "HS200", "HS210", "HS220", "HS300"}
STRIPS = {"HS107", "HS300"}
COLOR_BULBS = {"LB130"}
DIMMABLE = {*BULBS, "HS220"}
EMETER = {"HS110", "HS300", *BULBS}

ALL_DEVICES = BULBS.union(PLUGS)

def filter_model(desc, filter):
    filtered = list()
    for dev in SUPPORTED_DEVICES:
        for filt in filter:
            if filt in basename(dev):
                filtered.append(dev)

filtered_basenames = [basename(f) for f in filtered]
    print(f"{desc}: {filtered_basenames}")
    return filtered

has_emeter = pytest.mark.parametrize(
    "dev", filter_model("has emeter", EMETER), indirect=True
)
no_emeter = pytest.mark.parametrize(
    "dev", filter_model("no emeter", ALL_DEVICES - EMETER), indirect=True
)

bulb = pytest.mark.parametrize("dev", filter_model("bulbs", BULBS), indirect=True)
plug = pytest.mark.parametrize("dev", filter_model("plugs", PLUGS), indirect=True)
strip = pytest.mark.parametrize("dev", filter_model("strips", STRIPS), indirect=True)

dimmable = pytest.mark.parametrize(
    "dev", filter_model("dimmable", DIMMABLE), indirect=True
)
non_dimmable = pytest.mark.parametrize(
    "dev", filter_model("non-dimmable", ALL_DEVICES - DIMMABLE), indirect=True
)

variable_temp = pytest.mark.parametrize(
    "dev", filter_model("variable color temp", VARIABLE_TEMP), indirect=True
)
non_variable_temp = pytest.mark.parametrize(
    "dev", filter_model("non-variable color temp", BULBS - VARIABLE_TEMP), indirect=True
)

color_bulb = pytest.mark.parametrize(
    "dev", filter_model("color bulbs", COLOR_BULBS), indirect=True
)
non_color_bulb = pytest.mark.parametrize(
    "dev", filter_model("non-color bulbs", BULBS - COLOR_BULBS), indirect=True
)

# Parametrize tests to run with device both on and off
turn_on = pytest.mark.parametrize("turn_on", [True, False])

async def handle_turn_on(dev, turn_on):
    if turn_on:
        await dev.turn_on()
    else:
        await dev.turn_off()

@pytest.fixture(params=SUPPORTED_DEVICES)
def dev(request):
    """Device fixture.

Provides a device (given --ip) or parametrized fixture for the supported devices.
    The initial update is called automatically before returning the device.
    """
    loop = asyncio.get_event_loop()
    file = request.param

ip = request.config.getoption("--ip")
    if ip:
        d = loop.run_until_complete(Discover.discover_single(ip))
        loop.run_until_complete(d.update())
        print(d.model)
        if d.model in file:
            return d
        return

def device_for_file(model):
        for d in STRIPS:
            if d in model:
                return SmartStrip
        for d in PLUGS:
            if d in model:
                return SmartPlug
        for d in BULBS:
            if d in model:
                return SmartBulb

raise Exception("Unable to find type for %s", model)

with open(file) as f:
        sysinfo = json.load(f)
        model = basename(file)
        params = {"host": "123.123.123.123", "cache_ttl": 0}
        p = device_for_file(model)(**params)
        p.protocol = FakeTransportProtocol(sysinfo)
        loop.run_until_complete(p.update())
        yield p

def pytest_addoption(parser):
    parser.addoption("--ip", action="store", default=None, help="run against device")

def pytest_collection_modifyitems(config, items):
    if not config.getoption("--ip"):
        print("Testing against fixtures.")
        return
    else:
        print("Running against ip %s" % config.getoption("--ip"))
07070100000015000041ED000003E800000064000000015E303DFC00000000000000000000000000000000000000000000003A00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures07070100000016000081A4000003E800000064000000015E303DFC00000566000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS100(US)_1.0.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Mock hs100",
            "dev_name": "Wi-Fi Smart Plug",
            "deviceId": "048F069965D3230FD1382F0B78EAE68D42CAA2DE",
            "err_code": 0,
            "feature": "TIM",
            "hwId": "92688D028799C60F926049D1C9EFD9E8",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude": 63.5442,
            "latitude_i": 63.5442,
            "led_off": 0,
            "longitude": -148.2817,
            "longitude_i": -148.2817,
            "mac": "50:c7:bf:a3:71:c0",
            "model": "HS100(US)",
            "oemId": "149C8A24AA3A1445DE84F00DFB210D60",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -65,
            "sw_ver": "1.2.5 Build 171129 Rel.174814",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
07070100000017000081A4000003E800000064000000015E303DFC00000519000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS100(US)_1.0_real.json{
    "emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Unused 3",
            "dev_name": "Wi-Fi Smart Plug",
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "fwId": "00000000000000000000000000000000",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude": 0,
            "led_off": 0,
            "longitude": 0,
            "mac": "00:00:00:00:00:00",
            "model": "HS100(US)",
            "oemId": "00000000000000000000000000000000",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -63,
            "sw_ver": "1.2.5 Build 171129 Rel.174814",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
07070100000018000081A4000003E800000064000000015E303DFC0000058E000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS100(US)_2.0_real.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "3D Printer",
            "dev_name": "Smart Wi-Fi Plug",
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "fwId": "00000000000000000000000000000000",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "2.0",
            "icon_hash": "",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": 0,
            "mac": "00:00:00:00:00:00",
            "model": "HS100(US)",
            "next_action": {
                "type": -1
            },
            "oemId": "00000000000000000000000000000000",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -36,
            "sw_ver": "1.5.6 Build 191118 Rel.140307",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
07070100000019000081A4000003E800000064000000015E303DFC00000575000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS105(US)_1.0.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Mock hs105",
            "dev_name": "Smart Wi-Fi Plug Mini",
            "deviceId": "F0723FAFC1FA27FC755B9F228A2297D921FEBCD1",
            "err_code": 0,
            "feature": "TIM",
            "hwId": "51E17031929D5FEF9147091AD67B954A",
            "hw_ver": "1.0",
            "icon_hash": "",
            "INVALIDlatitude": 79.7779,
            "latitude_i": 79.7779,
            "led_off": 0,
            "INVALIDlongitude": 90.8844,
            "longitude_i": 90.8844,
            "mac": "50:c7:bf:ac:c0:6a",
            "model": "HS105(US)",
            "oemId": "990ADB7AEDE871C41D1B7613D1FE7A76",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -65,
            "sw_ver": "1.2.9 Build 170808 Rel.145916",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
0707010000001A000081A4000003E800000064000000015E303DFC00000591000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS105(US)_1.0_real.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "Unused 1",
            "dev_name": "Smart Wi-Fi Plug Mini",
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "fwId": "00000000000000000000000000000000",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": 0,
            "mac": "00:00:00:00:00:00",
            "model": "HS105(US)",
            "next_action": {
                "type": -1
            },
            "oemId": "00000000000000000000000000000000",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -46,
            "sw_ver": "1.5.6 Build 191114 Rel.104204",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
0707010000001B000081A4000003E800000064000000015E303DFC000006C1000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS107(US)_1.0_real.json{
    "emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "alias": "TP-LINK_Smart Plug_D310",
            "child_num": 2,
            "children": [
                {
                    "alias": "Garage Charger 1",
                    "id": "00",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Garage Charger 2",
                    "id": "01",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                }
            ],
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": -0,
            "mac": "00:00:00:00:00:00",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS107(US)",
            "oemId": "00000000000000000000000000000000",
            "rssi": -51,
            "sw_ver": "1.0.8 Build 190103 Rel.163436",
            "updating": 0
        }
    }
}
0707010000001C000081A4000003E800000064000000015E303DFC000005C5000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS110(EU)_1.0_real.json{
    "emeter": {
        "get_realtime": {
            "current": 0.015342,
            "err_code": 0,
            "power": 0.983971,
            "total": 32.448,
            "voltage": 235.595234
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Kitchen",
            "dev_name": "Wi-Fi Smart Plug With Energy Monitoring",
            "deviceId": "8006588E50AD389303FF31AB6302907A17442F16",
            "err_code": 0,
            "feature": "TIM:ENE",
            "fwId": "00000000000000000000000000000000",
            "hwId": "45E29DA8382494D2E82688B52A0B2EB5",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude": 51.476938,
            "led_off": 1,
            "longitude": 7.216849,
            "mac": "50:C7:BF:01:F8:CD",
            "model": "HS110(EU)",
            "oemId": "3D341ECE302C0642C99E31CE2430544B",
            "on_time": 512874,
            "relay_state": 1,
            "rssi": -71,
            "sw_ver": "1.2.5 Build 171213 Rel.101523",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
0707010000001D000081A4000003E800000064000000015E303DFC000005DF000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS110(EU)_2.0.json{
    "emeter": {
        "get_realtime": {
            "current_ma": 125,
            "err_code": 0,
            "power_mw": 3140,
            "total_wh": 51493,
            "voltage_mv": 122049
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Mock hs110v2",
            "dev_name": "Smart Wi-Fi Plug With Energy Monitoring",
            "deviceId": "A466BCDB5026318939145B7CC7EF18D8C1D3A954",
            "err_code": 0,
            "feature": "TIM:ENE",
            "hwId": "1F7FABB46373CA51E3AFDE5930ECBB36",
            "hw_ver": "2.0",
            "icon_hash": "",
            "INVALIDlatitude": -60.4599,
            "latitude_i": -60.4599,
            "led_off": 0,
            "INVALIDlongitude": 76.1249,
            "longitude_i": 76.1249,
            "mac": "50:c7:bf:b9:40:08",
            "model": "HS110(EU)",
            "oemId": "BB668B949FA4559655F1187DD56622BD",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -65,
            "sw_ver": "1.5.2 Build 180130 Rel.085820",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
0707010000001E000081A4000003E800000064000000015E303DFC000005C8000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS110(US)_1.0.json{
    "emeter": {
        "get_realtime": {
            "current": 0.1256,
            "err_code": 0,
            "power": 3.14,
            "total": 51.493,
            "voltage": 122.049119
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Mock hs110",
            "dev_name": "Wi-Fi Smart Plug With Energy Monitoring",
            "deviceId": "11A5FD4A0FA1FCE5468F55D23CE77D1753A93E11",
            "err_code": 0,
            "feature": "TIM:ENE",
            "hwId": "6C56A17315351DD0EDE0BDB1D9EBBD66",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude": 82.2866,
            "latitude_i": 82.2866,
            "led_off": 0,
            "longitude": 10.0036,
            "longitude_i": 10.0036,
            "mac": "50:c7:bf:66:29:29",
            "model": "HS110(US)",
            "oemId": "F7DFC14D43DA806B55DB66D21F212B60",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -65,
            "sw_ver": "1.0.8 Build 151113 Rel.24658",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
0707010000001F000081A4000003E800000064000000015E303DFC0000056C000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS200(US)_1.0.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "schedule",
            "alias": "Mock hs200",
            "dev_name": "Wi-Fi Smart Light Switch",
            "deviceId": "EC565185337CF59A4C9A73442AAD5F11C6E91716",
            "err_code": 0,
            "feature": "TIM",
            "hwId": "4B5DB5E42F13728107D075EF5C3ECFA1",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude": 58.7882,
            "latitude_i": 58.7882,
            "led_off": 0,
            "longitude": 107.7225,
            "longitude_i": 107.7225,
            "mac": "50:c7:bf:95:4b:45",
            "model": "HS200(US)",
            "oemId": "D2A5D690B25980755216FD684AF8CD88",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -65,
            "sw_ver": "1.1.0 Build 160521 Rel.085826",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
07070100000020000081A4000003E800000064000000015E303DFC000005A2000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS200(US)_2.0_real.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "Master Bedroom Fan",
            "dev_name": "Smart Wi-Fi Light Switch",
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "fwId": "00000000000000000000000000000000",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "2.0",
            "icon_hash": "",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": 0,
            "mac": "00:00:00:00:00:00",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS200(US)",
            "next_action": {
                "type": -1
            },
            "oemId": "00000000000000000000000000000000",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -33,
            "sw_ver": "1.5.7 Build 191118 Rel.140152",
            "updating": 0
        }
    }
}
07070100000021000081A4000003E800000064000000015E303DFC000005C4000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS210(US)_1.0_real.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "abnormal_detect": 1,
            "active_mode": "none",
            "alias": "Garage Light",
            "dev_name": "Smart Wi-Fi 3-Way Light Switch",
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "fwId": "00000000000000000000000000000000",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": 0,
            "mac": "00:00:00:00:00:00",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS210(US)",
            "next_action": {
                "type": -1
            },
            "oemId": "00000000000000000000000000000000",
            "on_time": 0,
            "relay_state": 0,
            "rssi": -52,
            "sw_ver": "1.5.8 Build 191118 Rel.135937",
            "updating": 0
        }
    }
}
07070100000022000081A4000003E800000064000000015E303DFC0000087F000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS220(US)_1.0.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "get_dimmer_parameters": {
            "bulb_type": 1,
            "err_code": 0,
            "fadeOffTime": 3000,
            "fadeOnTime": 3000,
            "gentleOffTime": 510000,
            "gentleOnTime": 3000,
            "minThreshold": 0,
            "rampRate": 30
        }
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "count_down",
            "alias": "Mock hs220",
            "brightness": 50,
            "dev_name": "Smart Wi-Fi Dimmer",
            "deviceId": "98E16F2D5ED204F3094CF472260237133DC0D547",
            "err_code": 0,
            "feature": "TIM",
            "hwId": "231004CCCDB6C0B8FC7A3260C3470257",
            "hw_ver": "1.0",
            "icon_hash": "",
            "INVALIDlatitude": 11.6210,
            "latitude_i": 11.6210,
            "led_off": 0,
            "INVALIDlongitude": 42.2074,
            "longitude_i": 42.2074,
            "mac": "50:c7:bf:af:75:5d",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS220(US)",
            "oemId": "8FBD0F3CCF7E82836DC7996C524EF772",
            "on_time": 0,
            "preferred_state": [
                {
                    "brightness": 100,
                    "index": 0
                },
                {
                    "brightness": 75,
                    "index": 1
                },
                {
                    "brightness": 50,
                    "index": 2
                },
                {
                    "brightness": 25,
                    "index": 3
                }
            ],
            "relay_state": 0,
            "rssi": -65,
            "sw_ver": "1.5.7 Build 180912 Rel.104837",
            "type": "IOT.SMARTPLUGSWITCH",
            "updating": 0
        }
    }
}
07070100000023000081A4000003E800000064000000015E303DFC00000887000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS220(US)_1.0_real.json{
    "emeter": {
        "get_realtime": {
            "err_code": -1,
            "err_msg": "module not support"
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "get_dimmer_parameters": {
            "bulb_type": 1,
            "err_code": 0,
            "fadeOffTime": 1000,
            "fadeOnTime": 1000,
            "gentleOffTime": 10000,
            "gentleOnTime": 3000,
            "minThreshold": 0,
            "rampRate": 30
        }
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "Living room left dimmer",
            "brightness": 25,
            "dev_name": "Smart Wi-Fi Dimmer",
            "deviceId": "000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "fwId": "00000000000000000000000000000000",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "icon_hash": "",
            "latitude_i": 11.6210,
            "led_off": 0,
            "longitude_i": 42.2074,
            "mac": "00:00:00:00:00:00",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS220(US)",
            "next_action": {
                "type": -1
            },
            "oemId": "00000000000000000000000000000000",
            "on_time": 0,
            "preferred_state": [
                {
                    "brightness": 100,
                    "index": 0
                },
                {
                    "brightness": 75,
                    "index": 1
                },
                {
                    "brightness": 50,
                    "index": 2
                },
                {
                    "brightness": 25,
                    "index": 3
                }
            ],
            "relay_state": 0,
            "rssi": -35,
            "sw_ver": "1.5.7 Build 180912 Rel.104837",
            "updating": 0
        }
    }
}
07070100000024000081A4000003E800000064000000015E303DFC00000BB8000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS300(US)_1.0.json{
    "emeter": {
        "get_realtime": {
            "current_ma": 125,
            "err_code": 0,
            "power_mw": 3140,
            "total_wh": 51493,
            "voltage_mv": 122049
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "alias": "Mock hs300",
            "child_num": 6,
            "children": [
                {
                    "alias": "Mock One",
                    "id": "00",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 123,
                    "state": 1
                },
                {
                    "alias": "Mock Two",
                    "id": "01",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 333,
                    "state": 1
                },
                {
                    "alias": "Mock Three",
                    "id": "02",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Mock Four",
                    "id": "03",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Mock Five",
                    "id": "04",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Mock Six",
                    "id": "05",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                }
            ],
            "deviceId": "4BFC2F2C8678FE623700FD3737EC4E245196F3CF",
            "err_code": 0,
            "feature": "TIM:ENE",
            "hwId": "1B63E5DF21B5AFB52F364DE66BFAAF8A",
            "hw_ver": "1.0",
            "latitude": -68.9980,
            "latitude_i": -68.9980,
            "led_off": 0,
            "longitude": -109.4400,
            "longitude_i": -109.4400,
            "mac": "50:c7:bf:c2:75:88",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS300(US)",
            "oemId": "FC71DAAB004326F9369EDEF4353E4FE1",
            "rssi": -68,
            "sw_ver": "1.0.6 Build 180627 Rel.081000",
            "updating": 0
        }
    }
}
07070100000025000081A4000003E800000064000000015E303DFC00000B94000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/HS300(US)_1.0_real.json{
    "emeter": {
        "get_realtime": {
            "current_ma": 4,
            "err_code": 0,
            "power_mw": 17,
            "total_wh": 1279,
            "voltage_mv": 122414
        }
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "alias": "TP-LINK_Power Strip_DAE1",
            "child_num": 6,
            "children": [
                {
                    "alias": "Office Monitor 1",
                    "id": "00",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Office Monitor 2",
                    "id": "01",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Office Monitor 3",
                    "id": "02",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Office Laptop Dock",
                    "id": "03",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Office Desk Light",
                    "id": "04",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Laptop",
                    "id": "05",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": -32407,
                    "state": 1
                }
            ],
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM:ENE",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": -0,
            "mac": "00:00:00:00:00:00",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "HS300(US)",
            "oemId": "00000000000000000000000000000000",
            "rssi": -62,
            "sw_ver": "1.0.10 Build 190103 Rel.163517",
            "updating": 0
        }
    }
}
07070100000026000081A4000003E800000064000000015E303DFC00000AA4000000000000000000000000000000000000005200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/KL120(US)_1.0_real.json{
    "emeter": {
        "err_code": -2001,
        "err_msg": "Module not support"
    },
    "smartlife.iot.common.emeter": {
        "get_realtime": {
            "err_code": 0,
            "power_mw": 1800
        }
    },
    "smartlife.iot.dimmer": {
        "err_code": -2001,
        "err_msg": "Module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "get_light_state": {
            "brightness": 10,
            "color_temp": 2700,
            "err_code": 0,
            "hue": 0,
            "mode": "normal",
            "on_off": 1,
            "saturation": 0
        }
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "",
            "ctrl_protocols": {
                "name": "Linkie",
                "version": "1.0"
            },
            "description": "Smart Wi-Fi LED Bulb with Tunable White Light",
            "dev_state": "normal",
            "deviceId": "801200814AD69370AC59DE5501319C051AF409C3",
            "disco_ver": "1.0",
            "err_code": 0,
            "heapsize": 290784,
            "hwId": "111E35908497A05512E259BB76801E10",
            "hw_ver": "1.0",
            "is_color": 0,
            "is_dimmable": 1,
            "is_factory": false,
            "is_variable_color_temp": 1,
            "light_state": {
                "brightness": 10,
                "color_temp": 2700,
                "hue": 0,
                "mode": "normal",
                "on_off": 1,
                "saturation": 0
            },
            "mic_mac": "D80D17150474",
            "mic_type": "IOT.SMARTBULB",
            "model": "KL120(US)",
            "oemId": "1210657CD7FBDC72895644388EEFAE8B",
            "preferred_state": [
                {
                    "brightness": 100,
                    "color_temp": 3500,
                    "hue": 0,
                    "index": 0,
                    "saturation": 0
                },
                {
                    "brightness": 50,
                    "color_temp": 5000,
                    "hue": 0,
                    "index": 1,
                    "saturation": 0
                },
                {
                    "brightness": 50,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 2,
                    "saturation": 0
                },
                {
                    "brightness": 1,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 3,
                    "saturation": 0
                }
            ],
            "rssi": -52,
            "sw_ver": "1.8.6 Build 180809 Rel.091659"
        }
    }
}
07070100000027000081A4000003E800000064000000015E303DFC000007F4000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/KP303(UK)_1.0.json{
    "emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.common.emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "system": {
        "get_sysinfo": {
            "alias": "TP-LINK_Power Strip_CF69",
            "child_num": 3,
            "children": [
                {
                    "alias": "Plug 1",
                    "id": "00",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 302,
                    "state": 1
                },
                {
                    "alias": "Plug 2",
                    "id": "01",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                },
                {
                    "alias": "Plug 3",
                    "id": "02",
                    "next_action": {
                        "type": -1
                    },
                    "on_time": 0,
                    "state": 0
                }
            ],
            "deviceId": "0000000000000000000000000000000000000000",
            "err_code": 0,
            "feature": "TIM",
            "hwId": "00000000000000000000000000000000",
            "hw_ver": "1.0",
            "latitude_i": 0,
            "led_off": 0,
            "longitude_i": 0,
            "mac": "00:00:00:00:00:00",
            "mic_type": "IOT.SMARTPLUGSWITCH",
            "model": "KP303(UK)",
            "ntc_state": 0,
            "oemId": "00000000000000000000000000000000",
            "rssi": -63,
            "status": "new",
            "sw_ver": "1.0.3 Build 191105 Rel.113122",
            "updating": 0
        }
    }
}
07070100000028000081A4000003E800000064000000015E303DFC00000BF6000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/LB100(US)_1.0.json{
    "emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.common.emeter": {
        "get_realtime": {
            "err_code": 0,
            "power_mw": 10800
        }
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "get_light_state": {
            "dft_on_state": {
                "brightness": 100,
                "color_temp": 2700,
                "hue": 0,
                "mode": "normal",
                "saturation": 0
            },
            "err_code": 0,
            "on_off": 0
        }
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "Mock lb100",
            "ctrl_protocols": {
                "name": "Linkie",
                "version": "1.0"
            },
            "description": "Smart Wi-Fi LED Bulb with Dimmable Light",
            "dev_state": "normal",
            "deviceId": "15BD5A6C4B729A7C0D4D46ADDFA7E2600793C56A",
            "disco_ver": "1.0",
            "err_code": 0,
            "heapsize": 302452,
            "hwId": "1B0DF0A2EFE6251DBE726D1D2167C78F",
            "hw_ver": "1.0",
            "is_color": 0,
            "is_dimmable": 1,
            "is_factory": false,
            "is_variable_color_temp": 0,
            "latitude": -51.8361,
            "latitude_i": -51.8361,
            "light_state": {
                "dft_on_state": {
                    "brightness": 100,
                    "color_temp": 2700,
                    "hue": 0,
                    "mode": "normal",
                    "saturation": 0
                },
                "err_code": 0,
                "on_off": 0
            },
            "longitude": -34.0697,
            "longitude_i": -34.0697,
            "mac": "50:c7:bf:51:10:65",
            "mic_type": "IOT.SMARTBULB",
            "model": "LB100(US)",
            "oemId": "C9CF655C9A5AA101E66EBA5B382E40CC",
            "on_time": 0,
            "preferred_state": [
                {
                    "brightness": 100,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 0,
                    "saturation": 0
                },
                {
                    "brightness": 75,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 1,
                    "saturation": 0
                },
                {
                    "brightness": 25,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 2,
                    "saturation": 0
                },
                {
                    "brightness": 1,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 3,
                    "saturation": 0
                }
            ],
            "rssi": -65,
            "sw_ver": "1.4.3 Build 170504 Rel.144921"
        }
    }
}
07070100000029000081A4000003E800000064000000015E303DFC00000BFB000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/LB120(US)_1.0.json{
    "emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.common.emeter": {
        "get_realtime": {
            "err_code": 0,
            "power_mw": 10800
        }
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "get_light_state": {
            "dft_on_state": {
                "brightness": 100,
                "color_temp": 2700,
                "hue": 0,
                "mode": "normal",
                "saturation": 0
            },
            "err_code": 0,
            "on_off": 0
        }
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "Mock lb120",
            "ctrl_protocols": {
                "name": "Linkie",
                "version": "1.0"
            },
            "description": "Smart Wi-Fi LED Bulb with Tunable White Light",
            "dev_state": "normal",
            "deviceId": "62FD818E5B66A509D571D07D0F00FA4DD6468494",
            "disco_ver": "1.0",
            "err_code": 0,
            "heapsize": 302452,
            "hwId": "CC0588817E251DF996F1848ED331F543",
            "hw_ver": "1.0",
            "is_color": 0,
            "is_dimmable": 1,
            "is_factory": false,
            "is_variable_color_temp": 1,
            "latitude": -76.9197,
            "latitude_i": -76.9197,
            "light_state": {
                "dft_on_state": {
                    "brightness": 100,
                    "color_temp": 2700,
                    "hue": 0,
                    "mode": "normal",
                    "saturation": 0
                },
                "err_code": 0,
                "on_off": 0
            },
            "longitude": 164.7293,
            "longitude_i": 164.7293,
            "mac": "50:c7:bf:dc:62:13",
            "mic_type": "IOT.SMARTBULB",
            "model": "LB120(US)",
            "oemId": "05D0D97951F565579A7F5A70A57AED0B",
            "on_time": 0,
            "preferred_state": [
                {
                    "brightness": 100,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 0,
                    "saturation": 0
                },
                {
                    "brightness": 75,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 1,
                    "saturation": 0
                },
                {
                    "brightness": 25,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 2,
                    "saturation": 0
                },
                {
                    "brightness": 1,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 3,
                    "saturation": 0
                }
            ],
            "rssi": -65,
            "sw_ver": "1.1.0 Build 160630 Rel.085319"
        }
    }
}
0707010000002A000081A4000003E800000064000000015E303DFC00000C22000000000000000000000000000000000000004D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/fixtures/LB130(US)_1.0.json{
    "emeter": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.common.emeter": {
        "get_realtime": {
            "err_code": 0,
            "power_mw": 10800
        }
    },
    "smartlife.iot.dimmer": {
        "err_code": -1,
        "err_msg": "module not support"
    },
    "smartlife.iot.smartbulb.lightingservice": {
        "get_light_state": {
            "dft_on_state": {
                "brightness": 100,
                "color_temp": 2700,
                "hue": 0,
                "mode": "normal",
                "saturation": 0
            },
            "err_code": 0,
            "on_off": 0
        }
    },
    "system": {
        "get_sysinfo": {
            "active_mode": "none",
            "alias": "Mock lb130",
            "ctrl_protocols": {
                "name": "Linkie",
                "version": "1.0"
            },
            "description": "Smart Wi-Fi LED Bulb with Color Changing",
            "dev_state": "normal",
            "deviceId": "50BE9E7B6F26CA75D495C13EAA459C491768F143",
            "disco_ver": "1.0",
            "err_code": 0,
            "heapsize": 302452,
            "hwId": "C8AD962B53417C2845CC10CE25C00BB1",
            "hw_ver": "1.0",
            "is_color": 1,
            "is_dimmable": 1,
            "is_factory": false,
            "is_variable_color_temp": 1,
            "latitude": 76.8649,
            "latitude_i": 76.8649,
            "light_state": {
                "dft_on_state": {
                    "brightness": 100,
                    "color_temp": 2700,
                    "hue": 0,
                    "mode": "normal",
                    "saturation": 0
                },
                "err_code": 0,
                "on_off": 0
            },
            "longitude": -40.7284,
            "longitude_i": -40.7284,
            "INVALIDmac": "50:c7:bf:ac:f6:19",
            "mic_mac": "50C7BFACF619",
            "mic_type": "IOT.SMARTBULB",
            "model": "LB130(US)",
            "oemId": "CF78964560AAB75A43F15D2E468B63EF",
            "on_time": 0,
            "preferred_state": [
                {
                    "brightness": 100,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 0,
                    "saturation": 0
                },
                {
                    "brightness": 75,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 1,
                    "saturation": 0
                },
                {
                    "brightness": 25,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 2,
                    "saturation": 0
                },
                {
                    "brightness": 1,
                    "color_temp": 2700,
                    "hue": 0,
                    "index": 3,
                    "saturation": 0
                }
            ],
            "rssi": -65,
            "sw_ver": "1.6.0 Build 170703 Rel.141938"
        }
    }
}
0707010000002B000081A4000003E800000064000000015E303DFC000035D4000000000000000000000000000000000000003D00000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/newfakes.pyimport logging
import re

from voluptuous import REMOVE_EXTRA, All, Any, Coerce, Invalid, Optional, Range, Schema

from ..protocol import TPLinkSmartHomeProtocol

_LOGGER = logging.getLogger(__name__)

def check_int_bool(x):
    if x != 0 and x != 1:
        raise Invalid(x)
    return x

def check_mac(x):
    if re.match("[0-9a-f]{2}([-:])[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", x.lower()):
        return x
    raise Invalid(x)

def check_mode(x):
    if x in ["schedule", "none", "count_down"]:
        return x

raise Invalid(f"invalid mode {x}")

def lb_dev_state(x):
    if x in ["normal"]:
        return x

raise Invalid(f"Invalid dev_state {x}")

TZ_SCHEMA = Schema(
    {"zone_str": str, "dst_offset": int, "index": All(int, Range(min=0)), "tz_str": str}
)

CURRENT_CONSUMPTION_SCHEMA = Schema(
    Any(
        {
            "voltage": Any(All(float, Range(min=0, max=300)), None),
            "power": Any(Coerce(float, Range(min=0)), None),
            "total": Any(Coerce(float, Range(min=0)), None),
            "current": Any(All(float, Range(min=0)), None),
            "voltage_mv": Any(
                All(float, Range(min=0, max=300000)), int, None
            ),  # TODO can this be int?
            "power_mw": Any(Coerce(float, Range(min=0)), None),
            "total_wh": Any(Coerce(float, Range(min=0)), None),
            "current_ma": Any(
                All(float, Range(min=0)), int, None
            ),  # TODO can this be int?
        },
        None,
    )
)

# these schemas should go to the mainlib as
# they can be useful when adding support for new features/devices
# as well as to check that faked devices are operating properly.
PLUG_SCHEMA = Schema(
    {
        "active_mode": check_mode,
        "alias": str,
        "dev_name": str,
        "deviceId": str,
        "feature": str,
        "fwId": str,
        "hwId": str,
        "hw_ver": str,
        "icon_hash": str,
        "led_off": check_int_bool,
        "latitude": Any(All(float, Range(min=-90, max=90)), 0, None),
        "latitude_i": Any(All(float, Range(min=-90, max=90)), 0, None),
        "longitude": Any(All(float, Range(min=-180, max=180)), 0, None),
        "longitude_i": Any(All(float, Range(min=-180, max=180)), 0, None),
        "mac": check_mac,
        "model": str,
        "oemId": str,
        "on_time": int,
        "relay_state": int,
        "rssi": Any(int, None),  # rssi can also be positive, see #54
        "sw_ver": str,
        "type": str,
        "mic_type": str,
        "updating": check_int_bool,
        # these are available on hs220
        "brightness": int,
        "preferred_state": [
            {"brightness": All(int, Range(min=0, max=100)), "index": int}
        ],
        "next_action": {"type": int},
        "child_num": Optional(Any(None, int)),  # TODO fix hs300 checks
        "children": Optional(list),  # TODO fix hs300
        # TODO some tplink simulator entries contain invalid (mic_mac, _i variants for lat/lon)
        # Therefore we add REMOVE_EXTRA..
        # "INVALIDmac": Optional,
        # "INVALIDlatitude": Optional,
        # "INVALIDlongitude": Optional,
    },
    extra=REMOVE_EXTRA,
)

BULB_SCHEMA = PLUG_SCHEMA.extend(
    {
        "ctrl_protocols": Optional(dict),
        "description": Optional(str),  # TODO: LBxxx similar to dev_name
        "dev_state": lb_dev_state,
        "disco_ver": str,
        "heapsize": int,
        "is_color": check_int_bool,
        "is_dimmable": check_int_bool,
        "is_factory": bool,
        "is_variable_color_temp": check_int_bool,
        "light_state": {
            "brightness": All(int, Range(min=0, max=100)),
            "color_temp": int,
            "hue": All(int, Range(min=0, max=255)),
            "mode": str,
            "on_off": check_int_bool,
            "saturation": All(int, Range(min=0, max=255)),
            "dft_on_state": Optional(
                {
                    "brightness": All(int, Range(min=0, max=100)),
                    "color_temp": All(int, Range(min=2700, max=9000)),
                    "hue": All(int, Range(min=0, max=255)),
                    "mode": str,
                    "saturation": All(int, Range(min=0, max=255)),
                }
            ),
            "err_code": int,
        },
        "preferred_state": [
            {
                "brightness": All(int, Range(min=0, max=100)),
                "color_temp": int,
                "hue": All(int, Range(min=0, max=255)),
                "index": int,
                "saturation": All(int, Range(min=0, max=255)),
            }
        ],
    }
)

def get_realtime(obj, x, *args):
    return {
        "current": 0.268587,
        "voltage": 125.836131,
        "power": 33.495623,
        "total": 0.199000,
    }

def get_monthstat(obj, x, *args):
    if x["year"] < 2016:
        return {"month_list": []}

return {
        "month_list": [
            {"year": 2016, "month": 11, "energy": 1.089000},
            {"year": 2016, "month": 12, "energy": 1.582000},
        ]
    }

def get_daystat(obj, x, *args):
    if x["year"] < 2016:
        return {"day_list": []}

return {
        "day_list": [
            {"year": 2016, "month": 11, "day": 24, "energy": 0.026000},
            {"year": 2016, "month": 11, "day": 25, "energy": 0.109000},
        ]
    }

emeter_support = {
    "get_realtime": get_realtime,
    "get_monthstat": get_monthstat,
    "get_daystat": get_daystat,
}

def get_realtime_units(obj, x, *args):
    return {"power_mw": 10800}

def get_monthstat_units(obj, x, *args):
    if x["year"] < 2016:
        return {"month_list": []}

return {
        "month_list": [
            {"year": 2016, "month": 11, "energy_wh": 32},
            {"year": 2016, "month": 12, "energy_wh": 16},
        ]
    }

def get_daystat_units(obj, x, *args):
    if x["year"] < 2016:
        return {"day_list": []}

return {
        "day_list": [
            {"year": 2016, "month": 11, "day": 24, "energy_wh": 20},
            {"year": 2016, "month": 11, "day": 25, "energy_wh": 32},
        ]
    }

emeter_units_support = {
    "get_realtime": get_realtime_units,
    "get_monthstat": get_monthstat_units,
    "get_daystat": get_daystat_units,
}

emeter_commands = {
    "emeter": emeter_support,
    "smartlife.iot.common.emeter": emeter_units_support,
}

def error(target, cmd="no-command", msg="default msg"):
    return {target: {cmd: {"err_code": -1323, "msg": msg}}}

def success(target, cmd, res):
    if res:
        res.update({"err_code": 0})
    else:
        res = {"err_code": 0}
    return {target: {cmd: res}}

class FakeTransportProtocol(TPLinkSmartHomeProtocol):
    def __init__(self, info, invalid=False):
        # TODO remove invalid when removing the old tests.
        proto = FakeTransportProtocol.baseproto
        for target in info:
            # print("target %s" % target)
            for cmd in info[target]:
                # print("initializing tgt %s cmd %s" % (target, cmd))
                proto[target][cmd] = info[target][cmd]
        # if we have emeter support, check for it
        for module in ["emeter", "smartlife.iot.common.emeter"]:
            if module not in info:
                # TODO required for old tests
                continue
            if "get_realtime" in info[module]:
                get_realtime_res = info[module]["get_realtime"]
                # TODO remove when removing old tests
                if callable(get_realtime_res):
                    get_realtime_res = get_realtime_res()
                if (
                    "err_code" not in get_realtime_res
                    or not get_realtime_res["err_code"]
                ):
                    proto[module] = emeter_commands[module]
        self.proto = proto

def set_alias(self, x, child_ids=[]):
        _LOGGER.debug("Setting alias to %s, child_ids: %s", x["alias"], child_ids)
        if child_ids:
            for child in self.proto["system"]["get_sysinfo"]["children"]:
                if child["id"] in child_ids:
                    child["alias"] = x["alias"]
        else:
            self.proto["system"]["get_sysinfo"]["alias"] = x["alias"]

def set_relay_state(self, x, child_ids=[]):
        _LOGGER.debug("Setting relay state to %s", x["state"])

if not child_ids and "children" in self.proto["system"]["get_sysinfo"]:
            for child in self.proto["system"]["get_sysinfo"]["children"]:
                child_ids.append(child["id"])

_LOGGER.info("child_ids: %s", child_ids)
        if child_ids:
            for child in self.proto["system"]["get_sysinfo"]["children"]:
                if child["id"] in child_ids:
                    _LOGGER.info("Found %s, turning to %s", child, x["state"])
                    child["state"] = x["state"]
        else:
            self.proto["system"]["get_sysinfo"]["relay_state"] = x["state"]

def set_led_off(self, x, *args):
        _LOGGER.debug("Setting led off to %s", x)
        self.proto["system"]["get_sysinfo"]["led_off"] = x["off"]

def set_mac(self, x, *args):
        _LOGGER.debug("Setting mac to %s", x)
        self.proto["system"]["get_sysinfo"]["mac"] = x

def set_hs220_brightness(self, x, *args):
        _LOGGER.debug("Setting brightness to %s", x)
        self.proto["system"]["get_sysinfo"]["brightness"] = x["brightness"]

def transition_light_state(self, x, *args):
        _LOGGER.debug("Setting light state to %s", x)
        light_state = self.proto["smartlife.iot.smartbulb.lightingservice"][
            "get_light_state"
        ]
        # The required change depends on the light state,
        # exception being turning the bulb on and off

if "on_off" in x:
            if x["on_off"] and not light_state["on_off"]:  # turning on
                new_state = light_state["dft_on_state"]
                new_state["on_off"] = 1
                self.proto["smartlife.iot.smartbulb.lightingservice"][
                    "get_light_state"
                ] = new_state
            elif not x["on_off"] and light_state["on_off"]:
                new_state = {"dft_on_state": light_state, "on_off": 0}

self.proto["smartlife.iot.smartbulb.lightingservice"][
                    "get_light_state"
                ] = new_state

return

if not light_state["on_off"] and "on_off" not in x:
            light_state = light_state["dft_on_state"]

_LOGGER.debug("Current state: %s", light_state)
        for key in x:
            light_state[key] = x[key]

def light_state(self, x, *args):
        light_state = self.proto["smartlife.iot.smartbulb.lightingservice"][
            "get_light_state"
        ]
        # Our tests have light state off, so we simply return the dft_on_state when device is on.
        _LOGGER.info("reporting light state: %s", light_state)
        if light_state["on_off"]:
            return light_state["dft_on_state"]
        else:
            return light_state

baseproto = {
        "system": {
            "set_relay_state": set_relay_state,
            "set_dev_alias": set_alias,
            "set_led_off": set_led_off,
            "get_dev_icon": {"icon": None, "hash": None},
            "set_mac_addr": set_mac,
            "get_sysinfo": None,
        },
        "emeter": {
            "get_realtime": None,
            "get_daystat": None,
            "get_monthstat": None,
            "erase_emeter_state": None,
        },
        "smartlife.iot.common.emeter": {
            "get_realtime": None,
            "get_daystat": None,
            "get_monthstat": None,
            "erase_emeter_state": None,
        },
        "smartlife.iot.smartbulb.lightingservice": {
            "get_light_state": light_state,
            "transition_light_state": transition_light_state,
        },
        "time": {
            "get_time": {
                "year": 2017,
                "month": 1,
                "mday": 2,
                "hour": 3,
                "min": 4,
                "sec": 5,
            },
            "get_timezone": {
                "zone_str": "test",
                "dst_offset": -1,
                "index": 12,
                "tz_str": "test2",
            },
            "set_timezone": None,
        },
        # HS220 brightness, different setter and getter
        "smartlife.iot.dimmer": {"set_brightness": set_hs220_brightness},
    }

async def query(self, host, request, port=9999):
        proto = self.proto

# collect child ids from context
        try:
            child_ids = request["context"]["child_ids"]
            request.pop("context", None)
        except KeyError:
            child_ids = []

target = next(iter(request))
        if target not in proto.keys():
            return error(target, msg="target not found")

cmd = next(iter(request[target]))
        if cmd not in proto[target].keys():
            return error(target, cmd, msg="command not found")

params = request[target][cmd]
        _LOGGER.debug(f"Going to execute {target}.{cmd} (params: {params}).. ")

if callable(proto[target][cmd]):
            res = proto[target][cmd](self, params, child_ids)
            _LOGGER.debug("[callable] %s.%s: %s", target, cmd, res)
            # verify that change didn't break schema, requires refactoring..
            # TestSmartPlug.sysinfo_schema(self.proto["system"]["get_sysinfo"])
            return success(target, cmd, res)
        elif isinstance(proto[target][cmd], dict):
            res = proto[target][cmd]
            _LOGGER.debug("[static] %s.%s: %s", target, cmd, res)
            return success(target, cmd, res)
        else:
            raise NotImplementedError(f"target {target} cmd {cmd}")
0707010000002C000081A4000003E800000064000000015E303DFC0000314B000000000000000000000000000000000000004200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/test_fixtures.pyimport asyncio
import datetime
from unittest.mock import patch

import pytest

from kasa import DeviceType, SmartDeviceException, SmartStrip

from .conftest import (
    bulb,
    color_bulb,
    dimmable,
    handle_turn_on,
    has_emeter,
    no_emeter,
    non_color_bulb,
    non_dimmable,
    non_variable_temp,
    plug,
    strip,
    turn_on,
    variable_temp,
)
from .newfakes import (
    BULB_SCHEMA,
    CURRENT_CONSUMPTION_SCHEMA,
    PLUG_SCHEMA,
    TZ_SCHEMA,
    FakeTransportProtocol,
)

# to avoid adding this for each async function separately
pytestmark = pytest.mark.asyncio

@plug
async def test_plug_sysinfo(dev):
    assert dev.sys_info is not None
    PLUG_SCHEMA(dev.sys_info)

assert dev.model is not None

assert dev.device_type == DeviceType.Plug or dev.device_type == DeviceType.Strip
    assert dev.is_plug or dev.is_strip

@bulb
async def test_bulb_sysinfo(dev):
    assert dev.sys_info is not None
    BULB_SCHEMA(dev.sys_info)

assert dev.model is not None

assert dev.device_type == DeviceType.Bulb
    assert dev.is_bulb

async def test_state_info(dev):
    assert isinstance(dev.state_information, dict)

async def test_invalid_connection(dev):
    with patch.object(FakeTransportProtocol, "query", side_effect=SmartDeviceException):
        with pytest.raises(SmartDeviceException):
            await dev.update()
            dev.is_on

async def test_query_helper(dev):
    with pytest.raises(SmartDeviceException):
        await dev._query_helper("test", "testcmd", {})
    # TODO check for unwrapping?

@turn_on
async def test_state(dev, turn_on):
    await handle_turn_on(dev, turn_on)
    orig_state = dev.is_on
    if orig_state:
        await dev.turn_off()
        assert not dev.is_on
        assert dev.is_off

await dev.turn_on()
        assert dev.is_on
        assert not dev.is_off
    else:
        await dev.turn_on()
        assert dev.is_on
        assert not dev.is_off

await dev.turn_off()
        assert not dev.is_on
        assert dev.is_off

@no_emeter
async def test_no_emeter(dev):
    assert not dev.has_emeter

with pytest.raises(SmartDeviceException):
        await dev.get_emeter_realtime()
    with pytest.raises(SmartDeviceException):
        await dev.get_emeter_daily()
    with pytest.raises(SmartDeviceException):
        await dev.get_emeter_monthly()
    with pytest.raises(SmartDeviceException):
        await dev.erase_emeter_stats()

@has_emeter
async def test_get_emeter_realtime(dev):
    if dev.is_strip:
        pytest.skip("Disabled for strips temporarily")

assert dev.has_emeter

current_emeter = await dev.get_emeter_realtime()
    CURRENT_CONSUMPTION_SCHEMA(current_emeter)

@has_emeter
async def test_get_emeter_daily(dev):
    if dev.is_strip:
        pytest.skip("Disabled for strips temporarily")

assert dev.has_emeter

assert await dev.get_emeter_daily(year=1900, month=1) == {}

d = await dev.get_emeter_daily()
    assert len(d) > 0

k, v = d.popitem()
    assert isinstance(k, int)
    assert isinstance(v, float)

# Test kwh (energy, energy_wh)
    d = await dev.get_emeter_daily(kwh=False)
    k2, v2 = d.popitem()
    assert v * 1000 == v2

@has_emeter
async def test_get_emeter_monthly(dev):
    if dev.is_strip:
        pytest.skip("Disabled for strips temporarily")

assert dev.has_emeter

assert await dev.get_emeter_monthly(year=1900) == {}

d = await dev.get_emeter_monthly()
    assert len(d) > 0

k, v = d.popitem()
    assert isinstance(k, int)
    assert isinstance(v, float)

# Test kwh (energy, energy_wh)
    d = await dev.get_emeter_monthly(kwh=False)
    k2, v2 = d.popitem()
    assert v * 1000 == v2

@has_emeter
async def test_emeter_status(dev):
    if dev.is_strip:
        pytest.skip("Disabled for strips temporarily")

assert dev.has_emeter

d = await dev.get_emeter_realtime()

with pytest.raises(KeyError):
        assert d["foo"]

assert d["power_mw"] == d["power"] * 1000
    # bulbs have only power according to tplink simulator.
    if not dev.is_bulb:
        assert d["voltage_mv"] == d["voltage"] * 1000

assert d["current_ma"] == d["current"] * 1000
        assert d["total_wh"] == d["total"] * 1000

@pytest.mark.skip("not clearing your stats..")
@has_emeter
async def test_erase_emeter_stats(dev):
    assert dev.has_emeter

await dev.erase_emeter()

@has_emeter
async def test_current_consumption(dev):
    if dev.is_strip:
        pytest.skip("Disabled for strips temporarily")

if dev.has_emeter:
        x = await dev.current_consumption()
        assert isinstance(x, float)
        assert x >= 0.0
    else:
        assert await dev.current_consumption() is None

async def test_alias(dev):
    test_alias = "TEST1234"
    original = dev.alias

assert isinstance(original, str)
    await dev.set_alias(test_alias)
    assert dev.alias == test_alias

await dev.set_alias(original)
    assert dev.alias == original

@plug
async def test_led(dev):
    original = dev.led

await dev.set_led(False)
    assert not dev.led

await dev.set_led(True)
    assert dev.led

await dev.set_led(original)

@plug
async def test_on_since(dev):
    assert isinstance(dev.on_since, datetime.datetime)

async def test_icon(dev):
    assert set((await dev.get_icon()).keys()), {"icon", "hash"}

async def test_time(dev):
    assert isinstance(await dev.get_time(), datetime.datetime)
    # TODO check setting?

async def test_timezone(dev):
    TZ_SCHEMA(await dev.get_timezone())

async def test_hw_info(dev):
    PLUG_SCHEMA(dev.hw_info)

async def test_location(dev):
    PLUG_SCHEMA(dev.location)

async def test_rssi(dev):
    PLUG_SCHEMA({"rssi": dev.rssi})  # wrapping for vol

async def test_mac(dev):
    PLUG_SCHEMA({"mac": dev.mac})  # wrapping for val
    # TODO check setting?

@non_variable_temp
async def test_temperature_on_nonsupporting(dev):
    assert dev.valid_temperature_range == (0, 0)

# TODO test when device does not support temperature range
    with pytest.raises(SmartDeviceException):
        await dev.set_color_temp(2700)
    with pytest.raises(SmartDeviceException):
        print(dev.color_temp)

@variable_temp
async def test_out_of_range_temperature(dev):
    with pytest.raises(ValueError):
        await dev.set_color_temp(1000)
    with pytest.raises(ValueError):
        await dev.set_color_temp(10000)

@non_dimmable
async def test_non_dimmable(dev):
    assert not dev.is_dimmable

with pytest.raises(SmartDeviceException):
        assert dev.brightness == 0
    with pytest.raises(SmartDeviceException):
        await dev.set_brightness(100)

@dimmable
@turn_on
async def test_dimmable_brightness(dev, turn_on):
    await handle_turn_on(dev, turn_on)
    assert dev.is_dimmable

await dev.set_brightness(50)
    assert dev.brightness == 50

await dev.set_brightness(10)
    assert dev.brightness == 10

with pytest.raises(ValueError):
        await dev.set_brightness("foo")

@dimmable
async def test_invalid_brightness(dev):
    assert dev.is_dimmable

with pytest.raises(ValueError):
        await dev.set_brightness(110)

with pytest.raises(ValueError):
        await dev.set_brightness(-100)

@color_bulb
@turn_on
async def test_hsv(dev, turn_on):
    await handle_turn_on(dev, turn_on)
    assert dev.is_color

hue, saturation, brightness = dev.hsv
    assert 0 <= hue <= 255
    assert 0 <= saturation <= 100
    assert 0 <= brightness <= 100

await dev.set_hsv(hue=1, saturation=1, value=1)

hue, saturation, brightness = dev.hsv
    assert hue == 1
    assert saturation == 1
    assert brightness == 1

@color_bulb
@turn_on
async def test_invalid_hsv(dev, turn_on):
    await handle_turn_on(dev, turn_on)
    assert dev.is_color

for invalid_hue in [-1, 361, 0.5]:
        with pytest.raises(ValueError):
            await dev.set_hsv(invalid_hue, 0, 0)

for invalid_saturation in [-1, 101, 0.5]:
        with pytest.raises(ValueError):
            await dev.set_hsv(0, invalid_saturation, 0)

for invalid_brightness in [-1, 101, 0.5]:
        with pytest.raises(ValueError):
            await dev.set_hsv(0, 0, invalid_brightness)

@non_color_bulb
async def test_hsv_on_non_color(dev):
    assert not dev.is_color

with pytest.raises(SmartDeviceException):
        await dev.set_hsv(0, 0, 0)
    with pytest.raises(SmartDeviceException):
        print(dev.hsv)

@variable_temp
@turn_on
async def test_try_set_colortemp(dev, turn_on):
    await handle_turn_on(dev, turn_on)
    await dev.set_color_temp(2700)
    assert dev.color_temp == 2700

@non_variable_temp
async def test_non_variable_temp(dev):
    with pytest.raises(SmartDeviceException):
        await dev.set_color_temp(2700)

@strip
@turn_on
async def test_children_change_state(dev, turn_on):
    await handle_turn_on(dev, turn_on)
    for plug in dev.plugs:
        orig_state = plug.is_on
        if orig_state:
            await plug.turn_off()
            assert not plug.is_on
            assert plug.is_off

await plug.turn_on()
            assert plug.is_on
            assert not plug.is_off
        else:
            await plug.turn_on()
            assert plug.is_on
            assert not plug.is_off

await plug.turn_off()
            assert not plug.is_on
            assert plug.is_off

@strip
async def test_children_alias(dev):
    test_alias = "TEST1234"
    for plug in dev.plugs:
        original = plug.alias
        await plug.set_alias(alias=test_alias)
        assert plug.alias == test_alias

await plug.set_alias(alias=original)
        assert plug.alias == original

@strip
async def test_children_on_since(dev):
    for plug in dev.plugs:
        assert plug.on_since

@pytest.mark.skip("this test will wear out your relays")
async def test_all_binary_states(dev):
    # test every binary state
    # TODO: this needs to be fixed, dev.plugs is not available for each device..
    for state in range(2 ** len(dev.plugs)):
        # create binary state map
        state_map = {}
        for plug_index in range(len(dev.plugs)):
            state_map[plug_index] = bool((state >> plug_index) & 1)

if state_map[plug_index]:
                await dev.turn_on(index=plug_index)
            else:
                await dev.turn_off(index=plug_index)

# check state map applied
        for index, state in dev.is_on.items():
            assert state_map[index] == state

# toggle each outlet with state map applied
        for plug_index in range(len(dev.plugs)):

# toggle state
            if state_map[plug_index]:
                await dev.turn_off(index=plug_index)
            else:
                await dev.turn_on(index=plug_index)

# only target outlet should have state changed
            for index, state in dev.is_on.items():
                if index == plug_index:
                    assert state != state_map[index]
                else:
                    assert state == state_map[index]

# reset state
            if state_map[plug_index]:
                await dev.turn_on(index=plug_index)
            else:
                await dev.turn_off(index=plug_index)

# original state map should be restored
            for index, state in dev.is_on.items():
                assert state == state_map[index]

# def test_cache(dev):
#     from datetime import timedelta

#     dev.cache_ttl = timedelta(seconds=3)
#     with patch.object(
#         FakeTransportProtocol, "query", wraps=dev.protocol.query
#     ) as query_mock:
#         CHECK_COUNT = 1
#         # Smartstrip calls sysinfo in its __init__ to request children, so
#         # the even first get call here will get its results from the cache.
#         if dev.is_strip:
#             CHECK_COUNT = 0

#         dev.sys_info
#         assert query_mock.call_count == CHECK_COUNT
#         dev.sys_info
#         assert query_mock.call_count == CHECK_COUNT

# def test_cache_invalidates(dev):
#     from datetime import timedelta

#     dev.cache_ttl = timedelta(seconds=0)

#     with patch.object(
#         FakeTransportProtocol, "query", wraps=dev.protocol.query
#     ) as query_mock:
#         dev.sys_info
#         assert query_mock.call_count == 1
#         dev.sys_info
#         assert query_mock.call_count == 2
#         # assert query_mock.called_once()

async def test_representation(dev):
    import re

pattern = re.compile("<.* model .* at .* (.*), is_on: .* - dev specific: .*>")
    assert pattern.match(str(dev))
0707010000002D000081A4000003E800000064000000015E303DFC0000067A000000000000000000000000000000000000004200000000python-kasa-0.0~git1580219900.15b0c8c/kasa/tests/test_protocol.pyimport json
from unittest import TestCase

from ..protocol import TPLinkSmartHomeProtocol

class TestTPLinkSmartHomeProtocol(TestCase):
    def test_encrypt(self):
        d = json.dumps({"foo": 1, "bar": 2})
        encrypted = TPLinkSmartHomeProtocol.encrypt(d)
        # encrypt adds a 4 byte header
        encrypted = encrypted[4:]
        self.assertEqual(d, TPLinkSmartHomeProtocol.decrypt(encrypted))

def test_encrypt_unicode(self):
        d = "{'snowman': '\u2603'}"

e = bytes(
            [
                208,
                247,
                132,
                234,
                133,
                242,
                159,
                254,
                144,
                183,
                141,
                173,
                138,
                104,
                240,
                115,
                84,
                41,
            ]
        )

encrypted = TPLinkSmartHomeProtocol.encrypt(d)
        # encrypt adds a 4 byte header
        encrypted = encrypted[4:]

self.assertEqual(e, encrypted)

def test_decrypt_unicode(self):
        e = bytes(
            [
                208,
                247,
                132,
                234,
                133,
                242,
                159,
                254,
                144,
                183,
                141,
                173,
                138,
                104,
                240,
                115,
                84,
                41,
            ]
        )

d = "{'snowman': '\u2603'}"

self.assertEqual(d, TPLinkSmartHomeProtocol.decrypt(e))
0707010000002E000081A4000003E800000064000000015E303DFC0000002A000000000000000000000000000000000000003600000000python-kasa-0.0~git1580219900.15b0c8c/kasa/version.py# flake8: noqa
__version__ = "0.4.0.dev0"
0707010000002F000081A4000003E800000064000000015E303DFC0000002B000000000000000000000000000000000000003700000000python-kasa-0.0~git1580219900.15b0c8c/requirements.txtclick
click-datetime
pre-commit
voluptuous
07070100000030000081A4000003E800000064000000015E303DFC00000037000000000000000000000000000000000000003C00000000python-kasa-0.0~git1580219900.15b0c8c/requirements_test.txtpytest
pytest-azurepipelines
pytest-cov
pytest-asyncio
07070100000031000081A4000003E800000064000000015E303DFC00000202000000000000000000000000000000000000002F00000000python-kasa-0.0~git1580219900.15b0c8c/setup.pyfrom setuptools import setup

with open("kasa/version.py") as f:
    exec(f.read())

setup(
    name="python-kasa",
    version=__version__,  # type: ignore # noqa: F821
    description="Python API for TP-Link Kasa Smarthome products",
    url="https://github.com/python-kasa/python-kasa",
    author="",
    author_email="",
    license="GPLv3",
    packages=["kasa"],
    install_requires=["click"],
    python_requires=">=3.7",
    entry_points={"console_scripts": ["kasa=kasa.cli:cli"]},
    zip_safe=False,
)
07070100000032000081A4000003E800000064000000015E303DFC000004F4000000000000000000000000000000000000002E00000000python-kasa-0.0~git1580219900.15b0c8c/tox.ini[tox]
envlist=py35,py36,py37,flake8,linting,typing
skip_missing_interpreters = True

[tox:travis]
3.5 = py35
3.6 = py36
3.7 = py37

[testenv]
passenv = TRAVIS TRAVIS_JOB_ID TRAVIS_BRANCH
deps=
  pytest
  pytest-cov
  voluptuous
  typing
  flake8
  pytest-asyncio
commands=
    py.test --cov --cov-config=tox.ini kasa

[testenv:flake8]
deps=
  flake8
  flake8-docstrings
commands=flake8 kasa

[testenv:typing]
skip_install=true
deps=mypy
commands=mypy --ignore-missing-imports kasa

[flake8]
exclude = .git,.tox,__pycache__,kasa/tests/newfakes.py,kasa/tests/test_fixtures.py
max-line-length = 88
per-file-ignores =
  kasa/tests/*.py:D100,D101,D102,D103,D104
  setup.py:D100
ignore = D105, D107, E203, E501, W503
#ignore = E203, E266, E501, W503, F403, F401
#max-complexity = 18
#select = B,C,E,F,W,T4,B9

[testenv:lint]
deps = pre-commit
skip_install = true
commands = pre-commit run --all-files

[coverage:run]
source = kasa
branch = True
omit =
  kasa/cli.py
  kasa/tests/*

[coverage:report]
exclude_lines =
  # ignore abstract methods
  raise NotImplementedError
  def __repr__

[isort]
multi_line_output=3
include_trailing_comma=True
force_grid_wrap=0
use_parentheses=True
line_length=88
known_first_party=kasa
known_third_party=click,pytest,setuptools,voluptuous
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!431 blocks

Places

File python-kasa-0.0~git1580219900.15b0c8c.obscpio of Package python-kasa (Revision 938b66a95c620859dfca86a805f527ca)

Places