HAP-python 1.0.5__tar.gz → 1.0.7__tar.gz

{usr/local/lib/python3.6/site-packages/HAP_python-1.0.5-py3.6.egg-info → HAP-python-1.0.7/HAP_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: HAP-python
-Version: 1.0.5
+Version: 1.0.7
 Summary: HomeKit Accessory Protocol implementation in python3
 Home-page: https://github.com/ikalchev/HAP-python.git
 Author: Ivan Kalchev

{usr/local/lib/python3.6/site-packages/HAP_python-1.0.5-py3.6.egg-info → HAP-python-1.0.7/HAP_python.egg-info}/SOURCES.txt

@@ -25,6 +25,7 @@ pyhap/accessories/FakeFan.py
 pyhap/accessories/Http.py
 pyhap/accessories/LightBulb.py
 pyhap/accessories/MotionSensor.py
+pyhap/accessories/SDS011.py
 pyhap/accessories/ShutdownSwitch.py
 pyhap/accessories/TSL2591.py
 pyhap/accessories/TemperatureSensor.py

{usr/local/lib/python3.6/site-packages/HAP_python-1.0.5-py3.6.egg-info → HAP-python-1.0.7/HAP_python.egg-info}/requires.txt

@@ -3,3 +3,7 @@ tlslite-ng
 ed25519
 zeroconf
 curve25519-donna
+
+[dev]
+pytest
+tox

HAP-python-1.0.7/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

HAP-python-1.0.7/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+recursive-include pyhap/resources *

HAP-python-1.0.7/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 1.1
+Name: HAP-python
+Version: 1.0.7
+Summary: HomeKit Accessory Protocol implementation in python3
+Home-page: https://github.com/ikalchev/HAP-python.git
+Author: Ivan Kalchev
+Author-email: UNKNOWN
+License: Apache-2.0
+Description-Content-Type: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Intended Audience :: Developers

HAP-python-1.0.7/README.md

@@ -0,0 +1,230 @@
+[![PyPI version](https://badge.fury.io/py/HAP-python.svg)](https://badge.fury.io/py/HAP-python)
+# HAP-python
+
+HomeKit Accessory Protocol implementation in python 3 (tested with 3.4, 3.5 and 3.6).
+With this project, you can integrate your own accessories and add them to your
+iOS Home app. Since Siri is integrated with the Home app, you can start voice-control your
+accessories right away - e.g. "What is the temperature in my bedroom." and "Turn on the
+lights in the Dining Room."
+
+The project was developed for a Raspberry Pi, but it should work on other platforms. You
+can even integrate with HAP-python remotely using HTTP (see below). To kick-start things,
+you can open `main.py`, where you can find out how to launch a mock temperature sensor.
+Just run `python3 main.py` and you should see it in the Home app (be sure to be in the same network).
+Stop it by hitting Ctrl+C.
+
+There are example accessories in [the accessories folder](pyhap/accessories) (e.g. AM2302 temperature and humidity sensor).
+
+## Table of Contents
+1. [API](#API)
+2. [Installation](#Installation)
+3. [Integrating non-compatible devices](#HttpAcc)
+4. [Run at boot (and a Switch to shutdown your device)](#AtBoot)
+5. [Notice](#Notice)
+
+## Installation <a name="Installation"></a>
+
+As a prerequisite, you will need Avahi/Bonjour installed (due to zeroconf package).
+On a Raspberry Pi, you can get it with:
+```
+sudo apt-get install libavahi-compat-libdnssd-dev
+```
+`avahi-utils` may also fit the bill. Then, you can install with `pip3` (you will need `sudo` or `--user` for the install):
+```sh
+pip3 install HAP-python
+```
+
+This will install HAP-python in your python packages, so that you can import it as `pyhap`. To uninstall, just do:
+```
+pip3 uninstall HAP-python
+```
+
+## API <a name="API"></a>
+
+A typical flow for using HAP-python starts with implementing an Accessory. This is done by
+subclassing [Accessory](pyhap/accessory.py) and putting in place a few details
+(see below). After that, you give your accessory to an AccessoryDriver to manage. This
+will take care of advertising it on the local network, setting a HAP server and
+running the Accessory. Take a look at [main.py](main.py) for a quick start on that.
+
+```python
+from pyhap.accessory import Accessory, Category
+import pyhap.loader as loader
+
+class TemperatureSensor(Accessory):
+    """Implementation of a mock temperature sensor accessory."""
+
+    category = Category.SENSOR  # This is for the icon in the iOS Home app.
+
+    def __init__(self, *args, **kwargs):
+        """Here, we just store a reference to the current temperature characteristic and
+        add a method that will be executed every time its value changes.
+        """
+        # If overriding this method, be sure to call the super's implementation first,
+        # because it calls _set_services and performs some other important actions.
+        super(TemperatureSensor, self).__init__(*args, **kwargs)
+
+        self.temp_char = self.get_service("TemperatureSensor")\
+                             .get_characteristic("CurrentTemperature")
+        # Having a callback is optional, but you can use it to add functionality.
+        self.temp_char.setter_callback = self.temperature_changed
+
+    def temperature_changed(self, value):
+        """This will be called every time the value of the CurrentTemperature Characteristic
+        is changed. Use setter_callbacks to react to user actions, e.g. setting the
+        lights On could fire some GPIO code to turn on a LED (see pyhap/accessories/LightBulb.py).
+
+        NOTE: no need to set the value yourself, this is done for you, before the callback
+        is called.
+        """
+        print("Temperature changed to: ", value)
+
+    def _set_services(self):
+        """We override this method to add the services that we want our accessory to
+        support. Services have "mandatory" characteristics and optional
+        characteristics. Mandatory characteristics are automatically added
+        to your selected service, but you must add optional characteristics yourself.
+        Take a look at pyhap/accessories/FakeFan.py for an example of how to do that.
+        """
+        super(TemperatureSensor, self)._set_services()  # Adds some neccessary characteristics.
+        # A loader creates Service and Characteristic objects based on json representation
+        # such as the Apple-defined ones in pyhap/resources/.
+        temp_sensor_service = loader.get_serv_loader().get("TemperatureSensor")
+        self.add_service(temp_sensor_service)
+
+    def run(self):
+        """We override this method to implement what the accessory will do when it is
+        started. An accessory is started and stopped from the AccessoryDriver.
+
+        It might be convenient to use the Accessory's run_sentinel, which is a
+        threading.Event object which is set when the accessory should stop running.
+
+        In this example, we wait 3 seconds to see if the run_sentinel will be set and if
+        not, we set the current temperature to a random number.
+        """
+        while not self.run_sentinel.wait(3):
+            self.temp_char.set_value(random.randint(18, 26))
+
+    def stop(self):
+        """We override this method to clean up any resources or perform final actions, as
+        this is called by the AccessoryDriver when the Accessory is being stopped (it is
+        called right after run_sentinel is set).
+        """
+        print("Stopping accessory.")
+```
+
+## Integrating non-compatible devices <a name="HttpAcc"></a>
+HAP-python may not be available for many IoT devices. For them, HAP-python allows devices
+to be bridged by means of communicating with an HTTP server - the [HttpBridge](pyhap/accessories/Http.py). You can add as many remote accessories as you like.
+
+For example, the bellow snippet creates an Http Accessory that listens on port 51800
+for updates on the TemperatureSensor service:
+```python
+import pyhap.util as util
+import pyhap.loader as loader
+from pyhap.accessories.Http import HttpBridge
+from pyhap.accessory import Accessory
+from pyhap.accessory_driver import AccessoryDriver
+
+# get loaders
+service_loader = loader.get_serv_loader()
+char_loader = loader.get_char_loader()
+
+# Create an accessory with the temperature sensor service.
+# Also, add an optional characteristic StatusLowBattery to that service.
+remote_accessory = Accessory("foo", aid=2)  # aids must be unique for each accessory.
+tservice = service_loader.get("TemperatureSensor")
+tservice.add_opt_characteristic(
+    char_loader.get("StatusLowBattery"))
+remote_accessory.add_service(tservice)
+
+# Create the HTTP Bridge and add the accessory to it.
+address = ("", 51111)
+http_bridge = HttpBridge(address=address,
+                         display_name="HTTP Bridge",
+                         pincode=b"203-23-999")
+http_bridge.add_accessory(remote_accessory)
+
+# Add to driver and run.
+driver = AccessoryDriver(http_bridge, 51826)
+driver.start()
+```
+Now, remote accessories can do an HTTP POST to the address of the device where the
+accessory is running (port 51111) with the following content:
+```json
+{
+    "aid": 2,
+    "services": {
+        "TemperatureSensor": {
+            "CurrentTemperature" : 20,
+            "StatusLowBattery": true,
+        }
+    }
+}
+```
+This will update the value of the characteristic "CurrentTemperature" to 20 degrees C
+and "StatusLowBattery" to `true`.
+Needless to say the communication to the Http Bridge poses a security risk, so
+keep that in mind.
+
+## Run at boot <a name="AtBoot"></a>
+This is a quick way to get `HAP-python` to run at boot on a Raspberry Pi. It is recommended
+to turn on "Wait for network" in `raspi-config`. If this turns to be unreliable, see
+[this](https://www.raspberrypi.org/forums/viewtopic.php?f=66&t=187225).
+
+Copy the below in `/etc/systemd/system/HAP-python.service` (needs sudo).
+```
+[Unit]
+Description = HAP-python daemon
+Wants = pigpiod.service  # Remove this if you don't depend on pigpiod
+After = local-fs.target network-online.target pigpiod.service
+
+[Service]
+User = lesserdaemon  # It's a good idea to use some unprivileged system user
+# Script starting HAP-python, e.g. main.py
+# Be careful to set any paths you use, e.g. for persisting the state.
+ExecStart = /usr/bin/python3 /home/lesserdaemon/.hap-python/hap-python.py
+
+[Install]
+WantedBy = multi-user.target
+```
+
+Test that everything is fine by doing:
+
+```sh
+> sudo systemctl start HAP-python
+> systemctl status HAP-python
+> sudo journalctl -u HAP-python  # to see the output of the start up script.
+> sudo systemctl stop HAP-python
+```
+
+To enable or disable at boot, do:
+
+```sh
+> sudo systemctl enable HAP-python
+> sudo systemctl disable HAP-python
+```
+
+### Shutdown switch
+
+If you are running `HAP-python` on a Raspberry Pi, you may want to add a
+[Shutdown Switch](pyhap/accessories/ShutdownSwitch.py) to your Home. This is a
+Switch Accessory, which, when triggered, executes `sudo shutdown -h now`, i.e.
+it shutdowns and halts the Pi. This allows you to safely unplug it.
+
+For the above to work, you need to enable passwordless `/sbin/shutdown` to whichever
+user is running `HAP-python`. For example, do:
+```sh
+$ sudo visudo # and add the line: "<hap-user> ALL=NOPASSWD: /sbin/shutdown".
+```
+
+## Notice <a name="Notice"></a>
+
+Some HAP know-how was taken from [HAP-NodeJS by KhaosT](https://github.com/KhaosT/HAP-NodeJS).
+
+I am not aware of any bugs, but I am more than confident that such exist. If you find any,
+please report and I will try to fix them.
+
+Suggestions are always welcome.
+
+Have fun!

HAP-python-1.0.7/pyhap/accessories/SDS011.py

@@ -0,0 +1,152 @@
+"""
+An Accessory wrapper for the SDS011 air particulate density sensor.
+
+The density sensor implementation can be found here:
+https://github.com/ikalchev/py-sds011
+Place the file under a package named sensors in your python path,
+or change the import alltogether.
+"""
+import time
+import logging
+
+from sensors.SDS011 import SDS011 as AirSensor
+from pyhap.accessory import Accessory, Category
+import pyhap.loader as loader
+
+logger = logging.getLogger(__name__)
+
+
+class SDS011(Accessory):
+    """Accessory wrapper for SDS011.
+    """
+
+    category = Category.SENSOR
+
+    SORTED_PM_QUALITY_MAP = ((200, 5), (150, 4), (100, 3), (50, 2), (0, 1))
+    """
+    Threshold-to-state tuples. These show the state for which the threshold is
+    lower boundry. Uses something like Air Quality Index (AQI).
+
+    The UI shows:
+        1 - Excellent
+        2 - Good
+        3 - Fair
+        4 - Inferior
+        5 - Poor
+    """
+
+    def __init__(self, serial_port, *args, sleep_duration_s=15*60, calib_duration_s=15,
+                 **kwargs):
+        """Initialise and start SDS011 on the given port.
+
+        @param serial_port: The SDS011 port, e.g. /dev/ttyUSB0.
+        @type serial_port: str
+
+        @param sleep_duration_s: The amount of time in seconds the sensor sleeps before
+            waking it up for reading. Defaults to 15 minutes.
+        @type sleep_duration_s: float
+
+        @param calib_duration_s: The amount of time in seconds to wait after the sensor
+            has been waken up before reading its data. Defaults to 15 seconds.
+        @type calib_duration_s: float
+        """
+        self.pm25_quality = None
+        self.pm25_density = None
+        self.pm10_quality = None
+        self.pm10_density = None
+        super(SDS011, self).__init__(*args, **kwargs)
+        self.sleep_duration_s = sleep_duration_s
+        self.calib_duration_s = calib_duration_s
+        self.serial_port = serial_port
+        self.sensor = AirSensor(serial_port)
+        self.sensor.sleep(sleep=False)
+
+    def _set_services(self):
+        """Add the AirQualitySensor services (one for PM2.5 and one for PM10).
+
+        Also adds and configures optional characteristics, such as Name,
+        AirParticulateSize, AirParticulateDensity.
+        """
+        super(SDS011, self)._set_services()
+        char_loader = loader.get_char_loader()
+
+        # PM2.5
+        air_quality_pm25 = loader.get_serv_loader().get("AirQualitySensor")
+        pm25_size = char_loader.get("AirParticulateSize")
+        pm25_size.set_value(0, should_notify=False)
+        self.pm25_density = char_loader.get("AirParticulateDensity")
+        pm25_name = char_loader.get("Name")
+        pm25_name.set_value("PM2.5", should_notify=False)
+        self.pm25_quality = air_quality_pm25.get_characteristic("AirQuality")
+        air_quality_pm25.add_opt_characteristic(pm25_name, pm25_size, self.pm25_density)
+
+        # PM10
+        air_quality_pm10 = loader.get_serv_loader().get("AirQualitySensor")
+        pm10_size = char_loader.get("AirParticulateSize")
+        pm10_size.set_value(1, should_notify=False)
+        self.pm10_density = char_loader.get("AirParticulateDensity")
+        pm10_name = char_loader.get("Name")
+        pm10_name.set_value("PM10", should_notify=False)
+        self.pm10_quality = air_quality_pm10.get_characteristic("AirQuality")
+        air_quality_pm10.add_opt_characteristic(pm10_name, pm10_size, self.pm10_density)
+
+        self.add_service(air_quality_pm25)
+        self.add_service(air_quality_pm10)
+
+    def __getstate__(self):
+        """Get the state, less the sensor.
+        """
+        state = super(SDS011, self).__getstate__()
+        state["sensor"] = None
+        return state
+
+    def __setstate__(self, state):
+        """Set the state of this Accessory and initialise the sensor
+            with the serial port in the state.
+        """
+        self.__dict__.update(state)
+        self.sensor = AirSensor(self.serial_port)
+
+    def get_quality_classification(self, pm, is_pm25=False):
+        """Get the air quality clasification based on the PM density.
+
+        Uses Air Quality Index (AQI), without averaging for an hour.
+
+        @see: SDS011.SORTED_PM_QUALITY_MAP
+
+        @rtype: int
+        """
+        assert pm >= 0
+        return next(state for threshold, state in self.SORTED_PM_QUALITY_MAP
+                    if threshold <= pm)
+
+    def run(self):
+        """Start updating the air quality readings.
+
+        Initially, we read from the sensor and update the values. Then we put
+        it in sleep mode and while the sentinel is not set:
+            - Sleep for `self.sleep_duration_s`.
+            - Wake up and wait `self.calib_duration_s` seconds.
+            - Get the sensor's readings and update.
+        """
+        pm25, pm10 = self.sensor.query()
+        self.pm25_density.set_value(pm25)
+        self.pm25_quality.set_value(
+            self.get_quality_classification(pm25, is_pm25=True))
+        self.pm10_density.set_value(pm10)
+        self.pm10_quality.set_value(
+            self.get_quality_classification(pm10, is_pm25=False))
+        self.sensor.sleep()
+        while not self.run_sentinel.wait(self.sleep_duration_s):
+            logger.debug("Waking up sensor.")
+            self.sensor.sleep(sleep=False)
+            time.sleep(self.calib_duration_s)
+            pm25, pm10 = self.sensor.query()
+            self.pm25_density.set_value(pm25)
+            self.pm25_quality.set_value(
+                self.get_quality_classification(pm25, is_pm25=True))
+            self.pm10_density.set_value(pm10)
+            self.pm10_quality.set_value(
+                self.get_quality_classification(pm10, is_pm25=False))
+            self.sensor.sleep()
+            logger.debug("Read cycle done. Sleeping.")

{usr/local/lib/python3.6/site-packages → HAP-python-1.0.7}/pyhap/accessory.py

@@ -146,7 +146,6 @@ class Accessory(object):
         The default implementation adds only the AccessoryInformation services
         and sets its Name characteristic to the Accessory's display name.
         """
-        # Info service
         info_service = get_serv_loader().get("AccessoryInformation")
         info_service.get_characteristic("Name")\
                     .set_value(self.display_name, False)
@@ -172,6 +171,22 @@ class Accessory(object):
         """
         self.run_sentinel = run_sentinel
 
+    def config_changed(self):
+        """Notify the accessory about configuration changes.
+
+        These include new services or updated characteristic values, e.g.
+        the Name of a service changed.
+
+        This method also notifies the broker about the change, so that it can
+        publish the changes to the world.
+
+        @note: If you are changing the configuration of a bridged accessory
+        (i.e. an Accessory that is contained in a Bridge),
+        you should call the `config_changed` method on the Bridge.
+        """
+        self.config_version += 1
+        self.broker.config_changed()
+
     def add_service(self, *servs):
         """Add the given services to this Accessory.
 

{usr/local/lib/python3.6/site-packages → HAP-python-1.0.7}/pyhap/accessory_driver.py

@@ -12,7 +12,8 @@ AccessoryDriver (all this happens through the publish() interface). The Accessor
 will then check if there is a client that subscribed for events from this exact
 Characteristic from this exact Accessory (remember, it could be a Bridge with more than
 one Accessory in it). If so, the event is put in a FIFO queue - the event queue. This
-terminates the call chain and concludes the publishing process from the Characteristic.
+terminates the call chain and concludes the publishing process from the Characteristic,
+the Characteristic does not block waiting for the actual send to happen.
 
 When the AccessoryDriver is started, it spawns an event dispatch thread. The purpose of
 this thread is to get events from the event queue and send them to subscribed clients.
@@ -217,6 +218,16 @@ class AccessoryDriver(object):
                 self.sent_events = 0
                 self.accumulated_qsize = 0
 
+    def config_changed(self):
+        """Notify the driver that the accessory's configuration has changed.
+
+        Updates the mDNS advertisment, so that iOS clients know they need to new data.
+        Also, persists the accessory, so that the new configuration is available on
+        restart.
+        """
+        self.update_advertisment()
+        self.persist()
+
     def update_advertisment(self):
         """Updates the mDNS service info for the accessory."""
         self.advertiser.unregister_service(self.mdns_service_info)
@@ -434,6 +445,10 @@ class AccessoryDriver(object):
         self.http_server.shutdown()
         self.http_server.server_close()
         self.http_server_thread.join()
+
+        logger.debug("Persisting accessory state")
+        self.persist()
+
         logger.debug("AccessoryDriver stopped successfully")
 
     def signal_handler(self, _signal, _frame):

{usr/local/lib/python3.6/site-packages → HAP-python-1.0.7}/pyhap/characteristic.py

@@ -1,5 +1,9 @@
-# All things for a HAP characteristic.
+"""
+All things for a HAP characteristic.
 
+A Characteristic is the smallest unit of the smart home, e.g.
+a temperature measuring or a device status.
+"""
 
 class HAP_FORMAT:
     BOOL = 'bool'
@@ -52,39 +56,59 @@ class CharacteristicError(Exception):
     pass
 
 
+_HAP_NUMERIC_FIELDS = {"maxValue", "minValue", "minStep", "unit"}
 """Fields that should be included in the HAP representation of the characteristic.
 
 That is, if they are present in the specification of a numeric-value characteristic.
 """
-_HAP_NUMERIC_FIELDS = {"maxValue", "minValue", "minStep", "unit"}
 
 
 class Characteristic(object):
+    """Represents a HAP characteristic, the smallest unit of the smart home.
+
+    A HAP characteristic is some measurement or state, like battery status or
+    the current temperature. Characteristics are contained in services.
+    Each charactaristic has a unique type UUID and a set of properties,
+    like format, min and max values, valid values and others.
+    """
 
     def __init__(self, display_name, type_id, properties, value=None, broker=None):
+        assert "Format" in properties and "Permissions" in properties
         self.display_name = display_name
         self.type_id = type_id
-        assert "Format" in properties and "Permissions" in properties
         self.properties = properties
-        self.allowed_values = self.properties.get("ValidValues")
+        self.has_valid_values = "ValidValues" in self.properties
         self.value = value or HAP_FORMAT.DEFAULT[properties["Format"]]
         self.broker = broker
         self.setter_callback = None
-        self.hap_value_template = self._create_value_HAP_template()
+        self.hap_template = self._create_hap_template()
+
+    def _create_hap_template(self):
+        """Create a HAP template for describing this Characteristic.
+
+        Contains properties that do not change or change rarely, e.g. the type.
+        """
+        template = dict()
+        if self.properties["Format"] in HAP_FORMAT.NUMERIC:
+            template = {k: self.properties[k]
+                        for k in self.properties.keys() & _HAP_NUMERIC_FIELDS}
+        return template
 
     def set_value(self, value, should_notify=True):
-        """Set the given value.
+        """Set the given raw value. It is checked if it is a valid value.
 
         @param value: The value to assign as this Characteristic's value.
         @type value: Depends on properties["Format"]
 
         @param should_notify: Whether a the change should be sent to subscribed clients.
+            The notification is called _after_ the setter callback.
         @type should_notify: bool
 
-        @raise ValueError: When the value being assigned is not one of the allowed values
+        @raise ValueError: When the value being assigned is not one of the valid values
             for this Characteristic.
         """
-        if self.allowed_values is not None and value not in self.allowed_values.values():
+        if (self.has_valid_values
+                and value not in self.properties["ValidValues"].values()):
             raise ValueError
         self.value = value
         if self.setter_callback is not None:
@@ -93,53 +117,49 @@ class Characteristic(object):
             self.notify()
 
     def get_value(self):
-        return self.value
-
-    def notify(self):
-        data = {
-          "type_id": self.type_id,
-          "value": self.value,
-        }
-        self.broker.publish(data, self)
+        """Get the raw value of this Characteristic.
 
-    def _create_value_HAP_template(self):
-        template = dict()
-        if self.properties["Format"] in HAP_FORMAT.NUMERIC:
-            template = {k: self.properties[k]
-                        for k in self.properties.keys() & _HAP_NUMERIC_FIELDS}
-        return template
-
-    def _value_to_HAP(self):
-        hap_rep = self.hap_value_template.copy()
+        @deprecated: Use self.value instead.
+        """
+        return self.value
 
+    def get_hap_value(self):
+        """Get the value of the characteristic, constrained with the HAP properties.
+        """
+        val = self.value
         if self.properties["Format"] == HAP_FORMAT.STRING:
-            val = self.value[:256]
-            if len(self.value) > 64:
-                hap_rep["maxLen"] = min(len(self.value), 256)
+            val = val[:256]
         elif self.properties["Format"] in HAP_FORMAT.NUMERIC:
-            val = self.value
-            if "maxValue" in hap_rep:
-                val = min(self.properties["maxValue"], self.value)
-            if "minValue" in hap_rep:
-                val = max(self.properties["minValue"], self.value)
-        else:
-            val = self.value
+            if "maxValue" in self.properties:
+                val = min(self.properties["maxValue"], val)
+            if "minValue" in self.properties:
+                val = max(self.properties["minValue"], val)
+        return val
 
-        if HAP_PERMISSIONS.READ in self.properties["Permissions"]:
-            hap_rep["value"] = val
+    def notify(self):
+        """Notify clients about a value change.
 
-        return hap_rep
+        @note: Non-blocking, i.e. does not wait for the update to be sent.
+        @note: Uses the `get_hap_value`, i.e. sends the HAP value.
+        @see: accessory_driver.publish
+        """
+        data = {
+            "type_id": self.type_id,
+            "value": self.get_hap_value(),
+        }
+        self.broker.publish(data, self)
 
-    def to_HAP(self, iid_manager=None):
+    def to_HAP(self, iid_manager):
         """Create a HAP representation of this Characteristic.
 
-        @param base_iid: The IID for this characteristic.
-        @type base_iid: int
+        @note: Uses the `get_hap_value`, i.e. sends the HAP value.
+
+        @param iid_manager: IID manager to query for this object's IID.
+        @type iid_manager: IIDManager
 
         @return: A HAP representation.
         @rtype: dict
         """
-        assert iid_manager is not None
         hap_rep = {
             "iid": iid_manager.get_iid(self),
             "type": str(self.type_id).upper(),
@@ -147,5 +167,14 @@ class Characteristic(object):
             "perms": self.properties["Permissions"],
             "format": self.properties["Format"],
         }
-        hap_rep.update(self._value_to_HAP())
+
+        value_info = self.hap_template.copy()
+        val = self.get_hap_value()
+        if self.properties["Format"] == HAP_FORMAT.STRING:
+            if len(val) > 64:
+                value_info["maxLen"] = min(len(val), 256)
+        if HAP_PERMISSIONS.READ in self.properties["Permissions"]:
+            value_info["value"] = val
+
+        hap_rep.update(value_info)
         return hap_rep

HAP-python-1.0.7/setup.cfg

@@ -0,0 +1,10 @@
+[metadata]
+description-file = README.md
+
+[pycodestyle]
+max-line-length = 90
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

HAP-python-1.0.7/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup
+
+setup(
+    name="HAP-python",
+    description="HomeKit Accessory Protocol implementation in python3",
+    author="Ivan Kalchev",
+    version="1.0.7",
+    url="https://github.com/ikalchev/HAP-python.git",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+        "Topic :: Home Automation",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: Apache Software License",
+        "Intended Audience :: Developers",
+    ],
+    license="Apache-2.0",
+    packages=[
+        "pyhap",
+        "pyhap.accessories"
+    ],
+    install_requires=[
+        "pycryptodome",
+        "tlslite-ng",
+        "ed25519",
+        "zeroconf",
+        "curve25519-donna"
+    ],
+    extras_require={
+        "dev": [
+            "pytest",
+            "tox",
+        ],
+    },
+    package_data={
+        "pyhap": ["resources/*"],
+    }
+)