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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: HAP-python
-Version: 1.0
+Version: 1.0.5
 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/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 → usr/local/lib/python3.6/site-packages}/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
@@ -298,8 +299,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/LICENSE

@@ -1,176 +0,0 @@
-                                 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/MANIFEST.in

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

HAP-python-1.0/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 1.1
-Name: HAP-python
-Version: 1.0
-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/README.md

@@ -1,214 +0,0 @@
-# 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, 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):
-
-```sh
-git clone https://github.com/ikalchev/HAP-python.git && cd HAP-python
-python3 setup.py install
-```
-or
-```
-pip3 install .
-```
-
-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:
-
-```
-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 [Http Accessory](pyhap/accessories/Http.py).
-
-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
-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)
-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:
-```json
-{ "TemperatureSensor" : {
-     "CurrentTemperature" : 20 }
-}
-```
-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
-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/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()

HAP-python-1.0/setup.cfg

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

HAP-python-1.0/setup.py

@@ -1,33 +0,0 @@
-from setuptools import setup
-
-setup(
-    name="HAP-python",
-    description="HomeKit Accessory Protocol implementation in python3",
-    author="Ivan Kalchev",
-    version="1.0",
-    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"
-    ],
-    package_data={
-        "pyhap": ["resources/*"],
-    }
-)