HAP-python 1.0__tar.gz → 1.0.6__tar.gz

{HAP-python-1.0 → HAP-python-1.0.6}/HAP_python.egg-info/PKG-INFO

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

{HAP-python-1.0 → HAP-python-1.0.6}/PKG-INFO

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

{HAP-python-1.0 → HAP-python-1.0.6}/README.md

@@ -1,3 +1,4 @@
+[![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).
@@ -28,23 +29,12 @@ 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, to install HAP-python, you will need `setuptools` or `pip3`.
-Just git clone this project and install it like (you will need `sudo` or `--user` for the install):
-
+`avahi-utils` may also fit the bill. Then, you can install with `pip3` (you will need `sudo` or `--user` for the install):
 ```sh
-git clone https://github.com/ikalchev/HAP-python.git && cd HAP-python
-python3 setup.py install
-```
-or
-```
-pip3 install .
+pip3 install HAP-python
 ```
 
-This will install HAP-python in your python packages, so that you can import it as `pyhap`.
-Alternatively, you can install only the dependencies and run with the root directory of this project in your `PYTHONPATH`.
-
-To uninstall, just do:
-
+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
 ```
@@ -125,30 +115,56 @@ class TemperatureSensor(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 [Http Accessory](pyhap/accessories/Http.py).
+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
-from pyhap.accessories.Http import Http
-from pyhap.accessory import STANDALONE_AID
+import pyhap.loader as loader
+from pyhap.accessories.Http import HttpBridge
+from pyhap.accessory import Accessory
 from pyhap.accessory_driver import AccessoryDriver
 
-http = Http(("", 51800), ["TemperatureSensor"], "HTTP bridge",
-            aid=STANDALONE_AID, mac=util.generate_mac(), pincode=b"203-23-999")
-driver = AccessoryDriver(http, 51826)
+# 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 51800) with the following content:
+accessory is running (port 51111) with the following content:
 ```json
-{ "TemperatureSensor" : {
-     "CurrentTemperature" : 20 }
+{
+    "aid": 2,
+    "services": {
+        "TemperatureSensor": {
+            "CurrentTemperature" : 20,
+            "StatusLowBattery": true,
+        }
+    }
 }
 ```
-This will update the value of the characteristic "CurrentTemperature" to 20 degrees C.
-Needless to say the communication to the Http Accessory poses a security risk, so
+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>

HAP-python-1.0.6/pyhap/accessories/Http.py

@@ -0,0 +1,207 @@
+"""This module provides HttpAccessory - an accessory that
+allows remote devices to provide HAP services by sending POST
+requests.
+"""
+import json
+import threading
+import logging
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+from pyhap.accessory import Bridge, Category
+
+logger = logging.getLogger(__name__)
+
+
+class HttpBridgeHandler(BaseHTTPRequestHandler):
+    """Handles requests and passes value updates to an HttpAccessory.
+
+    The POST request should contain json data with the format:
+    {   "aid": <aid>
+        "services": {
+            <service>: {
+                <characteristic>: value,
+            }
+        }
+    }
+
+    Example:
+    {   "aid": 2
+        "services": {
+            TemperatureSensor" : {
+                "CurrentTemperature": 20
+            }
+        }
+    }
+    """
+
+    def __init__(self, http_accessory, sock, client_addr, server):
+        """Create a handler that passes updates to the given HttpAccessory.
+        """
+        self.http_accessory = http_accessory
+        super(HttpBridgeHandler, self).__init__(sock, client_addr, server)
+
+    def respond_ok(self):
+        """Reply with code 200 (OK) and close the connection.
+        """
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.send_header("Content-Length", 0)
+        self.end_headers()
+        self.close_connection = 1
+
+    def respond_err(self):
+        """Reply with code 400 and close the connection.
+        """
+        self.send_response(400)
+        self.send_header("Content-Type", "text/html")
+        self.send_header("Content-Length", 0)
+        self.end_headers()
+        self.close_connection = 1
+
+    def do_POST(self):
+        """Read the payload as json and update the state of the accessory.
+        """
+        length = int(self.headers["Content-Length"])
+        try:
+            # The below decode is necessary only for python <3.6, because loads prior 3.6
+            # doesn't know bytes/bytearray.
+            content = self.rfile.read(length).decode("utf-8")
+            data = json.loads(content)
+        except Exception as e:
+            logger.error("Bad POST request; Error was: %s", str(e))
+            self.respond_err()
+        else:
+            self.http_accessory.update_state(data)
+            self.respond_ok()
+
+
+class HttpBridge(Bridge):
+    """An accessory that listens to HTTP requests containing characteristic updates.
+
+    Simple devices/implementations can just HTTP POST data as:
+
+    {
+        <aid>: int,
+        "services": {
+            <service1>: {
+                <characteristic1>: value
+                ...
+            }
+            ...
+        }
+    }
+
+    Then this accessory takes care of communicating this update to any HAP clients.
+
+    The way you configure a HttpBridge is by adding Accessory objects. In the
+    example below, we add three accessories to a HTTP Bridge:
+    >>> # get loaders
+    >>> service_loader = loader.get_serv_loader()
+    >>> char_loader = loader.get_char_loader()
+    >>>
+    >>> # Create an accessory with the temperature sensor service.
+    >>> temperature_acc_1 = Accessory("temp1", 2)
+    >>> temperature_acc_1.add_service(service_loader.get("TemperatureSensor"))
+    >>>
+    >>> # Create an accessory with the temperature sensor service.
+    >>> # Also, add an optional characteristic Name to the service.
+    >>> temperature_acc_2 = Accessory("temp2", 3)
+    >>> temp_service = service_loader.get("TemperatureSensor")
+    >>> temp_service.add_opt_characteristic(char_loader.get("StatusLowBattery"))
+    >>> temperature_acc_2.add_service(temp_service)
+    >>>
+    >>> # Create a lightbulb accessory.
+    >>> light_bulb_acc = Accessory("bulb", 4)
+    >>> light_bulb_acc.add_service(service_loader.get("Lightbulb"))
+    >>>
+    >>> # Finally, create the HTTP Bridge and add all accessories to it.
+    >>> http_bridge = HttpBridge("HTTP Bridge", address=("", 51111))
+    >>> for accessory in (temperature_acc_1, temperature_acc_2, light_bulb_acc):
+    ...     http_bridge.add_accessory(accessory)
+    >>>
+    >>> # add to an accessory driver and start as usual
+    """
+
+    category = Category.OTHER
+
+    def __init__(self, address, *args, **kwargs):
+        """Initialise and add the given services.
+
+        @param address: The address-port on which to listen for requests.
+        @type address: tuple(str, int)
+
+        @param accessories:
+        """
+        super(HttpBridge, self).__init__(*args, **kwargs)
+
+        # For exclusive access to updates. Slight overkill...
+        self.update_lock = None
+        self.server_thread = None
+        self._set_server(address)
+
+    def _set_server(self, address):
+        """Set up a HTTPServer to listen on the given address.
+        """
+        self.server = HTTPServer(address, lambda *a: HttpBridgeHandler(self, *a))
+        self.server_thread = threading.Thread(target=self.server.serve_forever)
+        self.update_lock = threading.Lock()
+
+    def __getstate__(self):
+        """Return the state of this instance, less the server and server thread.
+
+        Also add the server address. All this is because we cannot pickle such
+        objects and to allow to recover the server using the address.
+        """
+        state = super(HttpBridge, self).__getstate__()
+        state["server"] = None
+        state["server_thread"] = None
+        state["update_lock"] = None
+        state["address"] = self.server.server_address
+        return state
+
+    def __setstate__(self, state):
+        """Load the state  and set up the server with the address in the state.
+        """
+        self.__dict__.update(state)
+        self._set_server(state["address"])
+
+    def update_state(self, data):
+        """Update the characteristics from the received data.
+
+        Expected to be called from HapHttpHandler. Updates are thread-safe.
+
+        @param data: A dict of values that should be set, e.g.:
+            {
+                <aid>: int,
+                <service1 name> : {
+                    <characteristic1 name>: value
+                    ...
+                }
+                ...
+            }
+        @type data: dict
+        """
+        aid = data["aid"]
+        logger.debug("Got update from accessory with aid: %d", aid)
+        accessory = self.accessories[aid]
+        service_data = data["services"]
+        for service, char_data in service_data.items():
+            service_obj = accessory.get_service(service)
+            for char, value in char_data.items():
+                char_obj = service_obj.get_characteristic(char)
+                with self.update_lock:
+                    char_obj.set_value(value)
+
+    def stop(self):
+        """Stop the server.
+        """
+        super(HttpBridge, self).stop()
+        logger.debug("Stopping HTTP bridge server.")
+        self.server.shutdown()
+        self.server.server_close()
+
+    def run(self):
+        """Start the server - can listen for requests.
+        """
+        logger.debug("Starting HTTP bridge server.")
+        self.server_thread.start()

{HAP-python-1.0 → HAP-python-1.0.6}/pyhap/accessory.py

@@ -112,7 +112,8 @@ class Accessory(object):
         mac = util.generate_mac()
         return cls(display_name, aid=aid, mac=mac, pincode=pincode)
 
-    def __init__(self, display_name, aid=None, mac=None, pincode=None, iid_manager=None):
+    def __init__(self, display_name, aid=STANDALONE_AID, mac=None, pincode=None,
+                 iid_manager=None):
 
         self.display_name = display_name
         self.aid = aid
@@ -145,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)
@@ -171,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.
 
@@ -298,8 +314,13 @@ class Bridge(Accessory):
 
     category = Category.BRIDGE
 
-    def __init__(self, display_name, **kwargs):
-        super(Bridge, self).__init__(display_name, aid=STANDALONE_AID, **kwargs)
+    def __init__(self, display_name, mac=None, pincode=None, iid_manager=None):
+        aid = STANDALONE_AID
+        # A Bridge cannot be Bridge, hence talks directly to HAP clients.
+        # Thus, we need a mac.
+        mac = mac or util.generate_mac()
+        super(Bridge, self).__init__(display_name, aid=aid, mac=mac,
+                                     pincode=pincode, iid_manager=iid_manager)
         self.accessories = {}  # aid: acc
 
     def _set_services(self):

{HAP-python-1.0 → HAP-python-1.0.6}/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):

{HAP-python-1.0 → HAP-python-1.0.6}/setup.py

@@ -4,7 +4,7 @@ setup(
     name="HAP-python",
     description="HomeKit Accessory Protocol implementation in python3",
     author="Ivan Kalchev",
-    version="1.0",
+    version="1.0.6",
     url="https://github.com/ikalchev/HAP-python.git",
     classifiers=[
         "Development Status :: 5 - Production/Stable",

HAP-python-1.0/pyhap/accessories/Http.py

@@ -1,127 +0,0 @@
-"""An accessory that listens to HTTP requests containing characteristic updates.
-
-A more simple device/implementation can just HTTP POST data as:
-{   <service_name>: {
-        <characteristic_name>: value
-    }
-}
-Then this accessory takes care of communicating this update to any HAP clients.
-"""
-import json
-import threading
-import logging
-from http.server import HTTPServer, BaseHTTPRequestHandler
-
-from pyhap.accessory import Accessory, Category
-import pyhap.loader as loader
-
-logger = logging.getLogger(__name__)
-
-
-class HapHttpHandler(BaseHTTPRequestHandler):
-    """
-    Handles POST requests and passes characteristic value updates to an HttpAccessory.
-
-    The POST request should contain json data with the format:
-    {   <service_name>: {
-            <characteristic_name>: value,
-        }
-    }
-
-    Example:
-    {   "TemperatureSensor" : {
-            "CurrentTemperature": 20
-        }
-    }
-    """
-
-    def __init__(self, httpAccessory, sock, client_addr, server):
-        """
-        Creates a handler that passes updates to the given HttpAccessory.
-        """
-        self.httpAccessory = httpAccessory
-        super(HapHttpHandler, self).__init__(sock, client_addr, server)
-
-    def respond_ok(self):
-        self.send_response(200)
-        self.send_header("Content-Type", "text/html")
-        self.send_header("Content-Length", 0)
-        self.end_headers()
-        self.close_connection = 1
-
-    def respond_err(self):
-        self.send_response(400)
-        self.send_header("Content-Type", "text/html")
-        self.send_header("Content-Length", 0)
-        self.end_headers()
-        self.close_connection = 1
-
-    def do_POST(self):
-        """
-        Read the payload as json and update the state of the httpAccessory.
-        """
-        length = int(self.headers["Content-Length"])
-        try:
-            # The below decode is necessary only for python <3.6, because loads prior 3.6
-            # doesn't know bytes/bytearray.
-            content = self.rfile.read(length).decode("utf-8")
-            data = json.loads(content)
-        except Exception as e:
-            logger.error("Bad POST request; Error was: %s", str(e))
-            self.respond_err()
-        else:
-            self.httpAccessory.update_state(data)
-            self.respond_ok()
-
-
-'''TODO: should make it possible to init with {"aid" : [services]}
-or {"addr": [services]} etc., so that this accessory can bridge several
-other. In this way remote devices can use a simple interface and this module will do
-the hap magic.
-'''
-
-
-class Http(Accessory):
-
-    category = Category.OTHER
-
-    def __init__(self, address, hapServices, *args, **kwargs):
-        self.hapServices = hapServices
-        super(Http, self).__init__(*args, **kwargs)
-        self._set_server(address)
-
-    def _set_server(self, address):
-        self.server = HTTPServer(address, lambda *a: HapHttpHandler(self, *a))
-        self.serverThread = threading.Thread(target=self.server.serve_forever)
-
-    def _set_services(self):
-        super(Http, self)._set_services()
-        ldr = loader.get_serv_loader()
-        for s in self.hapServices:
-            self.add_service(ldr.get(s))
-
-    def __getstate__(self):
-        state = super(Http, self).__getstate__()
-        state["server"] = None
-        state["serverThread"] = None
-        state["address"] = self.server.server_address
-        return state
-
-    def __setstate__(self, state):
-        self.__dict__.update(state)
-        self._set_server(state["address"])
-
-    def update_state(self, data):
-        for service, charData in data.items():
-            serviceObj = self.get_service(service)
-            for char, value in charData.items():
-                charObj = serviceObj.get_characteristic(char)
-                charObj.set_value(value)
-
-    def stop(self):
-        super(Http, self).stop()
-        self.server.shutdown()
-        self.server.server_close()
-
-    def run(self):
-        self.serverThread.start()