diff --git a/.buildinfo b/.buildinfo new file mode 100644 index 00000000..5cc69d77 --- /dev/null +++ b/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file records the configuration used when building these files. When it is not found, a full rebuild will be done. +config: f8e806c09f03c7e4fb9b5f205359f136 +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/.doctrees/api_introduction.doctree b/.doctrees/api_introduction.doctree new file mode 100644 index 00000000..224407b5 Binary files /dev/null and b/.doctrees/api_introduction.doctree differ diff --git a/.doctrees/environment.pickle b/.doctrees/environment.pickle new file mode 100644 index 00000000..74941915 Binary files /dev/null and b/.doctrees/environment.pickle differ diff --git a/.doctrees/gettingstarted.doctree b/.doctrees/gettingstarted.doctree new file mode 100644 index 00000000..70c70f75 Binary files /dev/null and b/.doctrees/gettingstarted.doctree differ diff --git a/.doctrees/homematicip.aio.doctree b/.doctrees/homematicip.aio.doctree new file mode 100644 index 00000000..540c8860 Binary files /dev/null and b/.doctrees/homematicip.aio.doctree differ diff --git a/.doctrees/homematicip.base.doctree b/.doctrees/homematicip.base.doctree new file mode 100644 index 00000000..5cef5296 Binary files /dev/null and b/.doctrees/homematicip.base.doctree differ diff --git a/.doctrees/homematicip.doctree b/.doctrees/homematicip.doctree new file mode 100644 index 00000000..6aede4f2 Binary files /dev/null and b/.doctrees/homematicip.doctree differ diff --git a/.doctrees/index.doctree b/.doctrees/index.doctree new file mode 100644 index 00000000..29981a3f Binary files /dev/null and b/.doctrees/index.doctree differ diff --git a/.doctrees/modules.doctree b/.doctrees/modules.doctree new file mode 100644 index 00000000..cf3a79b6 Binary files /dev/null and b/.doctrees/modules.doctree differ diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 00000000..e69de29b diff --git a/_modules/homematicip.html b/_modules/homematicip.html new file mode 100644 index 00000000..00428e61 --- /dev/null +++ b/_modules/homematicip.html @@ -0,0 +1,185 @@ + + + + + + + + homematicip — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip

+# coding=utf-8
+import configparser
+import os
+import platform
+from collections import namedtuple
+
+# from ._version import get_versions
+
+# __version__ = get_versions()["version"]
+# del get_versions
+
+HmipConfig = namedtuple(
+    "HmipConfig", ["auth_token", "access_point", "log_level", "log_file", "raw_config"]
+)
+
+
+

+[docs]
+def find_and_load_config_file() -> HmipConfig:
+    for f in get_config_file_locations():
+        try:
+            return load_config_file(f)
+        except FileNotFoundError:
+            pass
+    return None

+
+
+
+

+[docs]
+def load_config_file(config_file: str) -> HmipConfig:
+    """Loads the config ini file.
+    :raises a FileNotFoundError when the config file does not exist."""
+    expanded_config_file = os.path.expanduser(config_file)
+    _config = configparser.ConfigParser()
+    with open(expanded_config_file, "r") as fl:
+        _config.read_file(fl)
+        logging_filename = _config.get("LOGGING", "FileName", fallback="hmip.log")
+        if logging_filename == "None":
+            logging_filename = None
+
+        _hmip_config = HmipConfig(
+            _config["AUTH"]["AuthToken"],
+            _config["AUTH"]["AccessPoint"],
+            int(_config.get("LOGGING", "Level", fallback=30)),
+            logging_filename,
+            _config._sections,
+        )
+        return _hmip_config

+
+
+
+

+[docs]
+def get_config_file_locations() -> []:
+    search_locations = ["./config.ini"]
+
+    os_name = platform.system()
+
+    if os_name == "Windows":
+        appdata = os.getenv("appdata")
+        programdata = os.getenv("programdata")
+        search_locations.append(
+            os.path.join(appdata, "homematicip-rest-api\\config.ini")
+        )
+        search_locations.append(
+            os.path.join(programdata, "homematicip-rest-api\\config.ini")
+        )
+    elif os_name == "Linux":
+        search_locations.append("~/.homematicip-rest-api/config.ini")
+        search_locations.append("/etc/homematicip-rest-api/config.ini")
+    elif os_name == "Darwin":  # MAC
+        # are these folders right?
+        search_locations.append("~/Library/Preferences/homematicip-rest-api/config.ini")
+        search_locations.append(
+            "/Library/Application Support/homematicip-rest-api/config.ini"
+        )
+    return search_locations

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/EventHook.html b/_modules/homematicip/EventHook.html new file mode 100644 index 00000000..91f31fc7 --- /dev/null +++ b/_modules/homematicip/EventHook.html @@ -0,0 +1,131 @@ + + + + + + + + homematicip.EventHook — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.EventHook

+# by Michael Foord http://www.voidspace.org.uk/python/weblog/arch_d7_2007_02_03.shtml#e616
+
+
+

+[docs]
+class EventHook:
+    def __init__(self):
+        self.__handlers = []
+
+    def __iadd__(self, handler):
+        self.__handlers.append(handler)
+        return self
+
+    def __isub__(self, handler):
+        self.__handlers.remove(handler)
+        return self
+
+

+[docs]
+    def fire(self, *args, **keywargs):
+        for handler in self.__handlers:
+            handler(*args, **keywargs)

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/access_point_update_state.html b/_modules/homematicip/access_point_update_state.html new file mode 100644 index 00000000..f4c07a8b --- /dev/null +++ b/_modules/homematicip/access_point_update_state.html @@ -0,0 +1,132 @@ + + + + + + + + homematicip.access_point_update_state — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.access_point_update_state

+from homematicip.base.homematicip_object import HomeMaticIPObject
+from homematicip.base.enums import DeviceUpdateState
+
+
+

+[docs]
+class AccessPointUpdateState(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.accessPointUpdateState = DeviceUpdateState.UP_TO_DATE
+        self.successfulUpdateTimestamp = None
+        self.updateStateChangedTimestamp = None
+
+

+[docs]
+    def from_json(self, js):
+        self.accessPointUpdateState = js["accessPointUpdateState"]
+        self.successfulUpdateTimestamp = self.fromtimestamp(
+            js["successfulUpdateTimestamp"]
+        )
+        self.updateStateChangedTimestamp = self.fromtimestamp(
+            js["updateStateChangedTimestamp"]
+        )

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/auth.html b/_modules/homematicip/aio/auth.html new file mode 100644 index 00000000..f58055a3 --- /dev/null +++ b/_modules/homematicip/aio/auth.html @@ -0,0 +1,205 @@ + + + + + + + + homematicip.aio.auth — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.auth

+import json
+import logging
+import uuid
+
+from homematicip.aio.connection import AsyncConnection
+from homematicip.auth import Auth
+from homematicip.base.base_connection import HmipWrongHttpStatusError
+
+LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+class AsyncAuthConnection(AsyncConnection):
+    def __init__(self, loop, session=None):
+        super().__init__(loop, session)
+        self.headers = {
+            "content-type": "application/json",
+            "accept": "application/json",
+            "VERSION": "12",
+            "CLIENTAUTH": self.clientauth_token,
+            "ACCESSPOINT-ID": self.accesspoint_id,
+        }

+
+
+
+# todo: make the overridden methods match signature and return types of the overridden class.
+
+
+

+[docs]
+class AsyncAuth(Auth):
+    """this class represents the 'Async Auth' of the homematic ip"""
+
+    def __init__(self, loop, websession=None):
+        self.uuid = str(uuid.uuid4())
+        self.pin = None
+        self._connection = AsyncAuthConnection(loop, websession)
+
+

+[docs]
+    async def init(self, access_point_id, lookup=True, lookup_url=None):
+        self.accesspoint = access_point_id
+        if lookup_url:
+            await self._connection.init(access_point_id, lookup, lookup_url)
+        else:
+            await self._connection.init(access_point_id, lookup)

+
+
+

+[docs]
+    async def connectionRequest(self, devicename="homematicip-async"):
+        data = {
+            "deviceId": self.uuid,
+            "deviceName": devicename,
+            "sgtin": self.accesspoint,
+        }
+        if self.pin is not None:
+            self._connection.headers["PIN"] = self.pin
+        json_state = await self._connection.api_call(
+            "auth/connectionRequest", json.dumps(data)
+        )
+        return json_state

+
+
+

+[docs]
+    async def isRequestAcknowledged(self):
+        data = {"deviceId": self.uuid, "accessPointId": self._connection.accesspoint_id}
+        try:
+            await self._connection.api_call(
+                "auth/isRequestAcknowledged", json.dumps(data)
+            )
+            return True
+        except HmipWrongHttpStatusError:
+            return False

+
+
+

+[docs]
+    async def requestAuthToken(self):
+        data = {"deviceId": self.uuid}
+        json_state = await self._connection.api_call(
+            "auth/requestAuthToken", json.dumps(data)
+        )
+        return json_state["authToken"]

+
+
+

+[docs]
+    async def confirmAuthToken(self, authToken):
+        data = {"deviceId": self.uuid, "authToken": authToken}
+        json_state = await self._connection.api_call(
+            "auth/confirmAuthToken", json.dumps(data)
+        )
+        return json_state["clientId"]

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/connection.html b/_modules/homematicip/aio/connection.html new file mode 100644 index 00000000..0e141b02 --- /dev/null +++ b/_modules/homematicip/aio/connection.html @@ -0,0 +1,322 @@ + + + + + + + + homematicip.aio.connection — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.connection

+import asyncio
+import json
+import logging
+from asyncio import CancelledError
+from json.decoder import JSONDecodeError
+
+import aiohttp
+import async_timeout
+from websockets.legacy.client import connect
+from websockets import ConnectionClosed
+
+from homematicip.base.base_connection import (
+    ATTR_AUTH_TOKEN,
+    ATTR_CLIENT_AUTH,
+    BaseConnection,
+    HmipConnectionError,
+    HmipThrottlingError,
+    HmipWrongHttpStatusError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+

+[docs]
+class AsyncConnection(BaseConnection):
+    """Handles async http and websocket traffic."""
+
+    connect_timeout = 20
+    ping_timeout = 3
+    ping_loop = 60
+
+    def __init__(self, loop, session=None):
+        super().__init__()
+        self._loop = loop
+        if session is None:
+            self._websession = aiohttp.ClientSession()
+        else:
+            self._websession = session
+        self.socket_connection = None  # ClientWebSocketResponse
+        self.ws_reader_task = None
+        self.ping_pong_task = None
+        # self.ws_close_lock = Lock()
+        self._closing_task = None
+
+    @property
+    def ws_connected(self):
+        """Websocket is connected."""
+        return self.socket_connection is not None
+
+

+[docs]
+    async def init(
+        self,
+        accesspoint_id,
+        lookup=True,
+        lookup_url="https://lookup.homematic.com:48335/getHost",
+        **kwargs
+    ):
+        self.set_token_and_characteristics(accesspoint_id)
+        self._lookup_url = lookup_url  # needed for testcases
+
+        if lookup:
+            result = await self.api_call(
+                lookup_url, json.dumps(self.clientCharacteristics), full_url=True
+            )
+
+            self._urlREST = result["urlREST"]
+            self._urlWebSocket = result["urlWebSocket"]
+        else:  # pragma: no cover
+            self._urlREST = "https://ps1.homematic.com:6969"
+            self._urlWebSocket = "wss://ps1.homematic.com:8888"

+
+
+    def _rest_call(self, path, body=None):
+        """Shadows the original restCalls"""
+        return path, body
+
+

+[docs]
+    def full_url(self, partial_url):
+        return "{}/hmip/{}".format(self._urlREST, partial_url)

+
+
+

+[docs]
+    async def api_call(self, path, body=None, full_url=False):
+        """Make the actual call to the HMIP server.
+
+        Throws `HmipWrongHttpStatusError` or `HmipConnectionError` if connection has failed or
+        response is not correct."""
+        result = None
+        if not full_url:
+            path = self.full_url(path)
+        for i in range(self._restCallRequestCounter):
+            try:
+                async with async_timeout.timeout(self._restCallTimout):
+                    result = await self._websession.post(
+                        path, data=body, headers=self.headers
+                    )
+                    if result.status == 200:
+                        if result.content_type == "application/json":
+                            ret = await result.json()
+                        else:
+                            ret = True
+                        return ret
+                    elif result.status == 429:
+                        raise HmipThrottlingError
+                    else:
+                        raise HmipWrongHttpStatusError(result.status)
+            except (asyncio.TimeoutError, aiohttp.ClientConnectionError):
+                # Both exceptions occur when connecting to the server does
+                # somehow not work.
+                logger.debug("Connection timed out or another error occurred %s" % path)
+            except JSONDecodeError as err:
+                logger.exception(err)
+            finally:
+                if result is not None:
+                    await result.release()
+        raise HmipConnectionError("Failed to connect to HomeMaticIp server")

+
+
+    async def _connect_to_websocket(self):
+        try:
+            self.socket_connection = await asyncio.wait_for(
+                connect(
+                    self._urlWebSocket,
+                    extra_headers={
+                        ATTR_AUTH_TOKEN: self._auth_token,
+                        ATTR_CLIENT_AUTH: self._clientauth_token,
+                    },
+                ),
+                timeout=self.connect_timeout,
+            )
+        except asyncio.TimeoutError:
+            raise HmipConnectionError("Connecting to hmip ws socket timed out.")
+        except Exception as err:
+            logger.exception(err)
+            raise HmipConnectionError()
+
+

+[docs]
+    async def ws_connect(self, *, on_message, on_error):
+        await self._connect_to_websocket()
+        self.ping_pong_task = self._loop.create_task(self._ws_ping_loop())
+        self.ws_reader_task = self._loop.create_task(
+            self._ws_loop(on_message, on_error)
+        )
+        return self.ws_reader_task

+
+
+

+[docs]
+    async def close_websocket_connection(self, source_is_reading_loop=False):
+        if self._closing_task is None or self._closing_task.done():
+            self._closing_task = self._loop.create_task(
+                self._shut_down(source_is_reading_loop)
+            )

+
+
+    async def _shut_down(self, source_is_reading_loop=False):
+        logger.debug("Closing connection")
+
+        if self.ws_reader_task and not source_is_reading_loop:
+            self.ws_reader_task.cancel()
+
+        if self.ping_pong_task:
+            self.ping_pong_task.cancel()
+
+        if self.ws_connected:
+            try:
+                await self.socket_connection.close()
+            except Exception as err:
+                logger.exception(err)
+        self.socket_connection = None
+
+    async def _ws_ping_loop(self):
+        try:
+            while True:
+                logger.debug("Sending out ping request.")
+                pong_waiter = await self.socket_connection.ping()
+                await asyncio.wait_for(pong_waiter, timeout=self.ping_timeout)
+                logger.debug("Pong received.")
+                await asyncio.sleep(self.ping_loop)
+        except CancelledError:
+            logger.debug("WS Ping pong task cancelled.")
+        except (asyncio.TimeoutError, ConnectionClosed):
+            logger.error("No Pong received from server.")
+        except Exception as err:
+            logger.debug("WS Ping pong task close.")
+            logger.exception(err)
+        finally:
+            await self.close_websocket_connection()
+
+    async def _ws_loop(self, on_message, on_error):
+        try:
+            while True:
+                msg = await self.socket_connection.recv()
+                logger.debug("incoming hmip message")
+                on_message(None, msg.decode())
+        except TypeError:
+            logger.error("Problem converting incoming bytes %s", msg)
+        except ConnectionClosed:
+            logger.debug("Connection closed by server")
+        except CancelledError:
+            logger.info("Reading task is cancelled.")
+        except Exception as err:
+            logger.debug("WS Reader task stop.")
+            logger.exception(err)
+        finally:
+            await self.close_websocket_connection(source_is_reading_loop=True)
+            await self._closing_task
+
+            raise HmipConnectionError()

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/device.html b/_modules/homematicip/aio/device.html new file mode 100644 index 00000000..475e2b38 --- /dev/null +++ b/_modules/homematicip/aio/device.html @@ -0,0 +1,1291 @@ + + + + + + + + homematicip.aio.device — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.device

+import logging
+
+from homematicip.base.enums import *
+from homematicip.device import *
+
+ERROR_CODE = "errorCode"
+
+_LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+class AsyncBaseDevice(BaseDevice):
+    """Async implementation of a generic homematic ip device (hmip and external)"""

+
+
+
+

+[docs]
+class AsyncExternalDevice(ExternalDevice):
+    """Async implementation of external device (hue)"""

+
+
+
+

+[docs]
+class AsyncDevice(Device):
+    """Async implementation of a genereric homematic ip device"""
+
+

+[docs]
+    async def set_label(self, label):
+        return await self._connection.api_call(*super().set_label(label))

+
+
+

+[docs]
+    async def authorizeUpdate(self):
+        return await self._connection.api_call(*super().authorizeUpdate())

+
+
+

+[docs]
+    async def delete(self):
+        return await self._connection.api_call(*super().delete())

+
+
+

+[docs]
+    async def set_router_module_enabled(self, enabled=True):
+        return await self._connection.api_call(
+            *super().set_router_module_enabled(enabled)
+        )

+
+
+

+[docs]
+    async def is_update_applicable(self):
+        return await self._connection.api_call(*super().is_update_applicable())

+

+
+
+
+

+[docs]
+class AsyncSwitch(Switch, AsyncDevice):
+    """Generic async switch"""
+
+

+[docs]
+    async def set_switch_state(self, on=True, channelIndex=1):
+        _LOGGER.debug("Async switch set_switch_state")
+        url, data = super().set_switch_state(on, channelIndex)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def turn_on(self, channelIndex=1):
+        _LOGGER.debug("Async switch turn_on")
+        return await self.set_switch_state(True, channelIndex)

+
+
+

+[docs]
+    async def turn_off(self, channelIndex=1):
+        _LOGGER.debug("Async switch turn_off")
+        return await self.set_switch_state(False, channelIndex)

+

+
+
+
+

+[docs]
+class AsyncCarbonDioxideSensor(CarbonDioxideSensor, AsyncSwitch):
+    """HmIP-SCTH230"""

+
+
+
+

+[docs]
+class AsyncSwitchMeasuring(SwitchMeasuring, AsyncSwitch):
+    """Generic async switch measuring"""
+
+

+[docs]
+    async def reset_energy_counter(self):
+        return await self._connection.api_call(*super().reset_energy_counter())

+

+
+
+
+

+[docs]
+class AsyncHeatingSwitch2(HeatingSwitch2, AsyncSwitch):
+    """HMIP-WHS2 (Switch Actuator for heating systems – 2x channels)"""

+
+
+
+

+[docs]
+class AsyncPlugableSwitch(PlugableSwitch, AsyncSwitch):
+    """Async implementation of HMIP-PS (Pluggable Switch)"""

+
+
+
+

+[docs]
+class AsyncPrintedCircuitBoardSwitchBattery(
+    PrintedCircuitBoardSwitchBattery, AsyncSwitch
+):
+    """HMIP-PCBS-BAT (Printed Circuit Board Switch Battery)"""

+
+
+
+

+[docs]
+class AsyncPrintedCircuitBoardSwitch2(PrintedCircuitBoardSwitch2, AsyncSwitch):
+    """Async implementation of HMIP-PCBS2 (Switch Circuit Board - 2x channels)"""

+
+
+
+

+[docs]
+class AsyncLightSensor(LightSensor, AsyncDevice):
+    """Async implementation of HMIP-SLO (Light Sensor outdoor)"""

+
+
+
+

+[docs]
+class AsyncSabotageDevice(SabotageDevice, AsyncDevice):
+    """Async implementation sabotage signaling devices"""

+
+
+
+

+[docs]
+class AsyncOpenCollector8Module(OpenCollector8Module, AsyncSwitch):
+    """Async implementation of HMIP-MOD-OC8 ( Open Collector Module )"""

+
+
+
+

+[docs]
+class AsyncOperationLockableDevice(OperationLockableDevice, AsyncDevice):
+

+[docs]
+    async def set_operation_lock(self, operationLock=True):
+        return await self._connection.api_call(
+            *super().set_operation_lock(operationLock=operationLock)
+        )

+

+
+
+
+

+[docs]
+class AsyncBrandSwitchNotificationLight(BrandSwitchNotificationLight, AsyncSwitch):
+    """HMIP-BSL (Switch Actuator for brand switches – with signal lamp)"""
+
+

+[docs]
+    async def set_rgb_dim_level(
+        self, channelIndex: int, rgb: RGBColorState, dimLevel: float
+    ):
+        return await self._connection.api_call(
+            *super().set_rgb_dim_level(channelIndex, rgb, dimLevel)
+        )

+
+
+

+[docs]
+    async def set_rgb_dim_level_with_time(
+        self,
+        channelIndex: int,
+        rgb: RGBColorState,
+        dimLevel: float,
+        onTime: float,
+        rampTime: float,
+    ):
+        return await self._connection.api_call(
+            *super().set_rgb_dim_level_with_time(
+                channelIndex, rgb, dimLevel, onTime, rampTime
+            )
+        )

+

+
+
+
+

+[docs]
+class AsyncPlugableSwitchMeasuring(PlugableSwitchMeasuring, AsyncSwitchMeasuring):
+    """HMIP-PSM (Pluggable Switch and Meter)"""

+
+
+
+

+[docs]
+class AsyncBrandSwitchMeasuring(BrandSwitchMeasuring, AsyncSwitchMeasuring):
+    """HMIP-BSM (Brand Switch and Meter)"""

+
+
+
+

+[docs]
+class AsyncFullFlushSwitchMeasuring(FullFlushSwitchMeasuring, AsyncSwitchMeasuring):
+    """HMIP-FSM (Full flush Switch and Meter)"""

+
+
+
+

+[docs]
+class AsyncShutterContact(ShutterContact, AsyncSabotageDevice):
+    """HMIP-SWDO (Door / Window Contact - optical) /
+    HMIP-SWDO-I (Door / Window Contact Invisible - optical)"""

+
+
+
+

+[docs]
+class AsyncShutterContactOpticalPlus(ShutterContactOpticalPlus, AsyncShutterContact):
+    """HmIP-SWDO-PL ( Window / Door Contact – optical, plus )"""

+
+
+
+

+[docs]
+class AsyncShutterContactMagnetic(ShutterContactMagnetic, AsyncDevice):
+    """HMIP-SWDM /  HMIP-SWDM-B2  (Door / Window Contact - magnetic"""

+
+
+
+

+[docs]
+class AsyncContactInterface(ContactInterface, AsyncSabotageDevice):
+    """HMIP-SCI (Contact Interface Sensor)"""

+
+
+
+

+[docs]
+class AsyncRotaryHandleSensor(RotaryHandleSensor, AsyncSabotageDevice):
+    """HMIP-SRH"""

+
+
+
+

+[docs]
+class AsyncTemperatureHumiditySensorOutdoor(
+    TemperatureHumiditySensorOutdoor, AsyncDevice
+):
+    """HMIP-STHO (Temperature and Humidity Sensor outdoor)"""

+
+
+
+

+[docs]
+class AsyncHeatingThermostat(HeatingThermostat, AsyncOperationLockableDevice):
+    """HMIP-eTRV (Radiator Thermostat)"""

+
+
+
+

+[docs]
+class AsyncHeatingThermostatCompact(HeatingThermostatCompact, AsyncSabotageDevice):
+    """HMIP-eTRV-C (Heating-thermostat compact without display)"""

+
+
+
+

+[docs]
+class AsyncHeatingThermostatEvo(HeatingThermostatEvo, AsyncOperationLockableDevice):
+    """HMIP-eTRV-E (Heating-thermostat new evo version)"""

+
+
+
+

+[docs]
+class AsyncTemperatureHumiditySensorWithoutDisplay(
+    TemperatureHumiditySensorWithoutDisplay, AsyncDevice
+):
+    """HMIP-STH (Temperature and Humidity Sensor without display - indoor)"""

+
+
+
+

+[docs]
+class AsyncTemperatureHumiditySensorDisplay(
+    TemperatureHumiditySensorDisplay, AsyncDevice
+):
+    """HMIP-STHD (Temperature and Humidity Sensor with display - indoor)"""
+
+

+[docs]
+    async def set_display(
+        self, display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL
+    ):
+        await self._connection.api_call(*super().set_display(display=display))

+

+
+
+
+

+[docs]
+class AsyncWallMountedThermostatPro(
+    WallMountedThermostatPro,
+    AsyncTemperatureHumiditySensorDisplay,
+    AsyncOperationLockableDevice,
+):
+    """HMIP-WTH, HMIP-WTH-2 (Wall Thermostat with Humidity Sensor)
+    / HMIP-BWTH (Brand Wall Thermostat with Humidity Sensor)"""

+
+
+
+

+[docs]
+class AsyncWallMountedThermostatBasicHumidity(AsyncWallMountedThermostatPro):
+    """HMIP-WTH-B (Wall Thermostat – basic)"""

+
+
+
+

+[docs]
+class AsyncSmokeDetector(SmokeDetector, AsyncDevice):
+    """HMIP-SWSD (Smoke Alarm with Q label)"""

+
+
+
+

+[docs]
+class AsyncFloorTerminalBlock6(FloorTerminalBlock6, AsyncDevice):
+    """HMIP-FAL230-C6 (Floor Heating Actuator - 6 channels, 230 V)"""

+
+
+
+

+[docs]
+class AsyncFloorTerminalBlock10(FloorTerminalBlock10, AsyncFloorTerminalBlock6):
+    """HMIP-FAL24-C10  (Floor Heating Actuator – 10x channels, 24V)"""

+
+
+
+

+[docs]
+class AsyncFloorTerminalBlock12(FloorTerminalBlock12, AsyncDevice):
+    """HMIP-FALMOT-C12 (Floor Heating Actuator – 12x channels, motorised)"""
+
+

+[docs]
+    async def set_minimum_floor_heating_valve_position(
+        self, minimumFloorHeatingValvePosition: float
+    ):
+        """sets the minimum floot heating valve position
+
+        Args:
+            minimumFloorHeatingValvePosition(float): the minimum valve position. must be between 0.0 and 1.0 AsyncFloorTerminalBlock12
+        Returns:
+            the result of the _restCall
+        """
+        await self._connection.api_call(
+            *super().set_minimum_floor_heating_valve_position(
+                minimumFloorHeatingValvePosition=minimumFloorHeatingValvePosition
+            )
+        )

+

+
+
+
+

+[docs]
+class AsyncWiredFloorTerminalBlock12(AsyncFloorTerminalBlock12):
+    """HmIPW-FALMOT-C12"""

+
+
+
+

+[docs]
+class AsyncPushButton(PushButton, AsyncDevice):
+    """HMIP-WRC2 (Wall-mount Remote Control - 2-button)"""

+
+
+
+

+[docs]
+class AsyncPushButton6(PushButton6, AsyncPushButton):
+    """HMIP-WRC6 (Wall-mount Remote Control - 6-button)"""

+
+
+
+

+[docs]
+class AsyncWiredPushButton(WiredPushButton, AsyncDevice):
+    """HmIPW-WRC6 and HmIPW-WRC2"""
+
+

+[docs]
+    async def set_optical_signal(
+        self,
+        channelIndex,
+        opticalSignalBehaviour: OpticalSignalBehaviour,
+        rgb: RGBColorState,
+        dimLevel=1.01,
+    ):
+        """sets the signal type for the leds
+
+        Args:
+            channelIndex(int): Channel which is affected
+            opticalSignalBehaviour(OpticalSignalBehaviour): LED signal behaviour
+            rgb(RGBColorState): Color
+            dimLevel(float): usally 1.01. Use set_dim_level instead
+
+        Returns:
+            Result of the _restCall
+
+        """
+        return await self._connection.api_call(
+            *super().set_optical_signal(
+                channelIndex, opticalSignalBehaviour, rgb, dimLevel
+            )
+        )

+
+
+

+[docs]
+    async def set_dim_level(self, channelIndex, dimLevel):
+        """sets the signal type for the leds
+        Args:
+            channelIndex(int): Channel which is affected
+            dimLevel(float): usally 1.01. Use set_dim_level instead
+
+        Returns:
+            Result of the _restCall
+
+        """
+        return await self._connection.api_call(
+            *super().set_dim_level(channelIndex, dimLevel)
+        )

+
+
+

+[docs]
+    async def set_switch_state(self, on=True, channelIndex=1):
+        _LOGGER.debug("Async set_switch_state")
+        url, data = super().set_switch_state(on, channelIndex)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def turn_on(self, channelIndex=1):
+        _LOGGER.debug("Async turn_on")
+        return await self.set_switch_state(True, channelIndex)

+
+
+

+[docs]
+    async def turn_off(self, channelIndex=1):
+        _LOGGER.debug("Async turn_off")
+        return await self.set_switch_state(False, channelIndex)

+

+
+
+
+

+[docs]
+class AsyncPushButtonFlat(PushButtonFlat, AsyncPushButton):
+    """HMIP-WRCC2 (Wall-mount Remote Control – flat)"""

+
+
+
+

+[docs]
+class AsyncBrandPushButton(BrandPushButton, AsyncPushButton):
+    """HMIP-BRC2 (Remote Control for brand switches – 2x channels)"""

+
+
+
+

+[docs]
+class AsyncKeyRemoteControl4(KeyRemoteControl4, AsyncPushButton):
+    """HMIP-KRC4 (Key Ring Remote Control - 4 buttons)"""

+
+
+
+

+[docs]
+class AsyncRemoteControl8(RemoteControl8, AsyncPushButton):
+    """HMIP-RC8 (Remote Control - 8 buttons)"""

+
+
+
+

+[docs]
+class AsyncRemoteControl8Module(RemoteControl8Module, AsyncRemoteControl8):
+    """HMIP-MOD-RC8 (Open Collector Module Sender - 8x)"""

+
+
+
+

+[docs]
+class AsyncRgbwDimmer(RgbwDimmer, AsyncDevice):
+    """HmIP-RGBW device."""

+
+    
+
+

+[docs]
+class AsyncAlarmSirenIndoor(AlarmSirenIndoor, AsyncSabotageDevice):
+    """HMIP-ASIR (Alarm Siren)"""

+
+
+
+

+[docs]
+class AsyncAlarmSirenOutdoor(AlarmSirenOutdoor, AsyncAlarmSirenIndoor):
+    """HMIP-ASIR-O (Alarm Siren Outdoor)"""

+
+
+
+

+[docs]
+class AsyncMotionDetectorIndoor(MotionDetectorIndoor, AsyncSabotageDevice):
+    """HMIP-SMI (Motion Detector with Brightness Sensor - indoor)"""

+
+
+
+

+[docs]
+class AsyncMotionDetectorOutdoor(MotionDetectorOutdoor, AsyncDevice):
+    """HMIP-SMO-A (Motion Detector with Brightness Sensor - outdoor)"""

+
+
+
+

+[docs]
+class AsyncMotionDetectorPushButton(MotionDetectorPushButton, AsyncDevice):
+    """HMIP-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2-button)"""

+
+
+
+

+[docs]
+class AsyncWiredMotionDetectorPushButton(WiredMotionDetectorPushButton, AsyncDevice):
+    """HMIPW-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2-button)"""

+
+
+
+

+[docs]
+class AsyncPresenceDetectorIndoor(PresenceDetectorIndoor, AsyncSabotageDevice):
+    """HMIP-SPI (Presence Sensor - indoor)"""

+
+
+
+

+[docs]
+class AsyncPassageDetector(PassageDetector, AsyncSabotageDevice):
+    """HMIP-SPDR (Passage Detector)"""

+
+
+
+

+[docs]
+class AsyncKeyRemoteControlAlarm(KeyRemoteControlAlarm, AsyncDevice):
+    """HMIP-KRCA (Key Ring Remote Control - alarm)"""

+
+
+
+

+[docs]
+class AsyncFullFlushContactInterface(FullFlushContactInterface, AsyncDevice):
+    """HMIP-FCI1 (Contact Interface flush-mount – 1 channel)"""

+
+
+
+

+[docs]
+class AsyncFullFlushContactInterface6(FullFlushContactInterface6, AsyncDevice):
+    """HMIP-FCI6 (Contact Interface flush-mount – 6 channels)"""

+
+
+
+

+[docs]
+class AsyncFullFlushInputSwitch(FullFlushInputSwitch, AsyncSwitch):
+    """HMIP-FSI16 (Switch Actuator with Push-button Input 230V, 16A)"""

+
+
+
+

+[docs]
+class AsyncDinRailSwitch(DinRailSwitch, AsyncFullFlushInputSwitch):
+    """HMIP-DRSI1 (Switch Actuator for DIN rail mount – 1x channel)"""

+
+
+
+

+[docs]
+class AsyncShutter(Shutter, AsyncDevice):
+    """Base class for async shutter devices"""
+
+

+[docs]
+    async def set_shutter_level(self, level=0.0, channelIndex=1):
+        return await self._connection.api_call(
+            *super().set_shutter_level(level, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_shutter_stop(self, channelIndex=1):
+        return await self._connection.api_call(*super().set_shutter_stop(channelIndex))

+

+
+
+
+

+[docs]
+class AsyncBlind(Blind, AsyncShutter):
+    """Base class for async blind devices"""
+
+

+[docs]
+    async def set_slats_level(self, slatsLevel=0.0, shutterLevel=None, channelIndex=1):
+        return await self._connection.api_call(
+            *super().set_slats_level(slatsLevel, shutterLevel, channelIndex)
+        )

+

+
+
+
+

+[docs]
+class AsyncFullFlushShutter(FullFlushShutter, AsyncShutter):
+    """HMIP-FROLL (Shutter Actuator - flush-mount) / HMIP-BROLL (Shutter Actuator - Brand-mount)"""

+
+
+
+

+[docs]
+class AsyncBrandSwitch2(BrandSwitch2, AsyncSwitch):
+    """ELV-SH-BS2 (ELV Smart Home ARR-Bausatz Schaltaktor für Markenschalter – 2-fach powered by Homematic IP)"""

+
+
+
+

+[docs]
+class AsyncFullFlushBlind(FullFlushBlind, AsyncBlind):
+    """HMIP-FBL (Blind Actuator - flush-mount)"""

+
+
+
+

+[docs]
+class AsyncBrandBlind(BrandBlind, AsyncFullFlushBlind):
+    """HMIP-BBL (Blind Actuator for brand switches)"""

+
+
+
+

+[docs]
+class AsyncDinRailBlind4(DinRailBlind4, AsyncBlind):
+    """HmIP-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)"""

+
+
+
+

+[docs]
+class AsyncWiredDinRailBlind4(WiredDinRailBlind4, AsyncBlind):
+    """HmIPW-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)"""

+
+
+
+

+[docs]
+class AsyncDimmer(Dimmer, AsyncDevice):
+    """Base dimmer device class"""
+
+

+[docs]
+    async def set_dim_level(self, dimLevel=0.0, channelIndex=1):
+        return await self._connection.api_call(
+            *super().set_dim_level(dimLevel=dimLevel, channelIndex=channelIndex)
+        )

+

+
+
+
+

+[docs]
+class AsyncBrandDimmer(AsyncDimmer):
+    """HMIP-BDT Brand Dimmer"""

+
+
+
+

+[docs]
+class AsyncDinRailDimmer3(DinRailDimmer3, AsyncDimmer):
+    """HmIP-DRDI3 (Din Rail Dimmer 3 Inbound)"""

+
+
+
+

+[docs]
+class AsyncFullFlushDimmer(AsyncDimmer):
+    """HMIP-FDT Dimming Actuator flush-mount"""

+
+
+
+

+[docs]
+class AsyncPluggableDimmer(AsyncDimmer):
+    """HMIP-PDT Pluggable Dimmer"""

+
+
+
+

+[docs]
+class AsyncWeatherSensor(WeatherSensor, AsyncDevice):
+    """HMIP-SWO-B"""

+
+
+
+

+[docs]
+class AsyncWeatherSensorPlus(WeatherSensorPlus, AsyncDevice):
+    """HMIP-SWO-PL"""

+
+
+
+

+[docs]
+class AsyncWeatherSensorPro(WeatherSensorPro, AsyncDevice):
+    """HMIP-SWO-PR"""

+
+
+
+

+[docs]
+class AsyncMultiIOBox(MultiIOBox, AsyncSwitch):
+    """HMIP-MIOB (Multi IO Box for floor heating & cooling)"""

+
+
+
+

+[docs]
+class AsyncWaterSensor(WaterSensor, AsyncDevice):
+    """HMIP-SWD"""
+
+

+[docs]
+    async def set_acoustic_alarm_signal(self, acousticAlarmSignal: AcousticAlarmSignal):
+        return await self._connection.api_call(
+            *super().set_acoustic_alarm_signal(acousticAlarmSignal=acousticAlarmSignal)
+        )

+
+
+

+[docs]
+    async def set_acoustic_alarm_timing(self, acousticAlarmTiming: AcousticAlarmTiming):
+        return await self._connection.api_call(
+            *super().set_acoustic_alarm_timing(acousticAlarmTiming=acousticAlarmTiming)
+        )

+
+
+

+[docs]
+    async def set_acoustic_water_alarm_trigger(
+        self, acousticWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        return await self._connection.api_call(
+            *super().set_acoustic_water_alarm_trigger(
+                acousticWaterAlarmTrigger=acousticWaterAlarmTrigger
+            )
+        )

+
+
+

+[docs]
+    async def set_inapp_water_alarm_trigger(
+        self, inAppWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        return await self._connection.api_call(
+            *super().set_inapp_water_alarm_trigger(
+                inAppWaterAlarmTrigger=inAppWaterAlarmTrigger
+            )
+        )

+
+
+

+[docs]
+    async def set_siren_water_alarm_trigger(
+        self, sirenWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        return await self._connection.api_call(
+            *super().set_siren_water_alarm_trigger(
+                sirenWaterAlarmTrigger=sirenWaterAlarmTrigger
+            )
+        )

+

+
+
+
+

+[docs]
+class AsyncAccelerationSensor(AccelerationSensor, AsyncDevice):
+    """HMIP-SAM"""
+
+

+[docs]
+    async def set_acceleration_sensor_mode(
+        self, mode: AccelerationSensorMode, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_mode(mode, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_neutral_position(
+        self, neutralPosition: AccelerationSensorNeutralPosition, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_neutral_position(
+                neutralPosition, channelIndex
+            )
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_sensitivity(
+        self, sensitivity: AccelerationSensorSensitivity, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_sensitivity(sensitivity, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_trigger_angle(self, angle: int, channelIndex=1):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_trigger_angle(angle, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_event_filter_period(
+        self, period: float, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_event_filter_period(period, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_notification_sound_type(
+        self, soundType: NotificationSoundType, isHighToLow: bool, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_notification_sound_type(soundType, isHighToLow, channelIndex)
+        )

+

+
+
+
+

+[docs]
+class AsyncDoorModule(DoorModule, AsyncDevice):
+    """Generic Door Module class"""
+
+

+[docs]
+    async def send_door_command(self, doorCommand=DoorCommand.STOP):
+        return await self._connection.api_call(*super().send_door_command(doorCommand))

+

+
+
+
+

+[docs]
+class AsyncGarageDoorModuleTormatic(GarageDoorModuleTormatic, AsyncDoorModule):
+    """HMIP-MOD-TM (Garage Door Module Tormatic)"""

+
+
+
+

+[docs]
+class AsyncHoermannDrivesModule(HoermannDrivesModule, AsyncDoorModule):
+    """HMIP-MOD-HO (Garage Door Module for Hörmann)"""

+
+
+
+

+[docs]
+class AsyncPluggableMainsFailureSurveillance(
+    PluggableMainsFailureSurveillance, AsyncDevice
+):
+    """[HMIP-PMFS] (Plugable Power Supply Monitoring)"""

+
+
+
+

+[docs]
+class AsyncRoomControlDevice(RoomControlDevice, AsyncWallMountedThermostatPro):
+    """ALPHA-IP-RBG    (Alpha IP Wall Thermostat Display)"""

+
+
+
+

+[docs]
+class AsyncRoomControlDeviceAnalog(AsyncDevice):
+    """ALPHA-IP-RBGa   (ALpha IP Wall Thermostat Display analog)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0.0
+        self.setPointTemperature = 0.0
+        self.temperatureOffset = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("ANALOG_ROOM_CONTROL_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("actualTemperature", c)
+            self.set_attr_from_dict("setPointTemperature", c)
+            self.set_attr_from_dict("temperatureOffset", c)

+

+
+
+
+

+[docs]
+class AsyncWiredDimmer3(WiredDimmer3, AsyncDimmer):
+    """HMIPW-DRD3 (Homematic IP Wired Dimming Actuator – 3x channels)"""

+
+
+
+

+[docs]
+class AsyncWiredInput32(WiredInput32, AsyncFullFlushContactInterface):
+    """HMIPW-DRI32 (Homematic IP Wired Inbound module – 32x channels)"""

+
+
+
+

+[docs]
+class AsyncWiredInputSwitch6(WiredInputSwitch6, AsyncSwitch):
+    """HmIPW-FIO6"""

+
+
+
+

+[docs]
+class AsyncWiredSwitch8(WiredSwitch8, AsyncSwitch):
+    """HMIPW-DRS8 (Homematic IP Wired Switch Actuator – 8x channels)"""

+
+
+
+

+[docs]
+class AsyncWiredSwitch4(WiredSwitch4, AsyncSwitch):
+    """HMIPW-DRS4 (Homematic IP Wired Switch Actuator – 4x channels)"""

+
+
+
+

+[docs]
+class AsyncDinRailSwitch4(DinRailSwitch4, AsyncSwitch):
+    """HMIP-DRSI4 (Homematic IP Switch Actuator for DIN rail mount – 4x channels)"""

+
+
+
+

+[docs]
+class AsyncTiltVibrationSensor(TiltVibrationSensor, AsyncDevice):
+    """HMIP-STV (Inclination and vibration Sensor)"""
+
+

+[docs]
+    async def set_acceleration_sensor_mode(
+        self, mode: AccelerationSensorMode, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_mode(mode, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_sensitivity(
+        self, sensitivity: AccelerationSensorSensitivity, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_sensitivity(sensitivity, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_trigger_angle(self, angle: int, channelIndex=1):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_trigger_angle(angle, channelIndex)
+        )

+
+
+

+[docs]
+    async def set_acceleration_sensor_event_filter_period(
+        self, period: float, channelIndex=1
+    ):
+        return await self._connection.api_call(
+            *super().set_acceleration_sensor_event_filter_period(period, channelIndex)
+        )

+

+
+
+

+[docs]
+class AsyncHomeControlUnit(HomeControlAccessPoint, AsyncDevice):
+    """HMIP-HCU"""

+
+
+

+[docs]
+class AsyncHomeControlAccessPoint(HomeControlAccessPoint, AsyncDevice):
+    """HMIP-HAP"""

+
+
+
+

+[docs]
+class AsyncWiredDinRailAccessPoint(WiredDinRailAccessPoint, AsyncDevice):
+    """HmIPW-DRAP"""

+
+
+
+

+[docs]
+class AsyncBlindModule(BlindModule, AsyncDevice):
+    """HMIP-HDM1 (Hunter Douglas & erfal window blinds)"""
+
+

+[docs]
+    async def set_primary_shading_level(self, primaryShadingLevel: float):
+        return await self._connection.api_call(
+            *super().set_primary_shading_level(primaryShadingLevel)
+        )

+
+
+

+[docs]
+    async def set_secondary_shading_level(
+        self, primaryShadingLevel: float, secondaryShadingLevel: float
+    ):
+        return await self._connection.api_call(
+            *super().set_secondary_shading_level(
+                primaryShadingLevel, secondaryShadingLevel
+            )
+        )

+
+
+

+[docs]
+    async def stop(self):
+        return await self._connection.api_call(*super().stop())

+

+
+
+
+

+[docs]
+class AsyncRainSensor(RainSensor, AsyncDevice):
+    """HMIP-SRD (Rain Sensor)"""

+
+
+
+

+[docs]
+class AsyncTemperatureDifferenceSensor2(TemperatureDifferenceSensor2, AsyncDevice):
+    """HmIP-STE2-PCB (Temperature Difference Sensors - 2x sensors)"""

+
+
+
+

+[docs]
+class AsyncWallMountedGarageDoorController(
+    WallMountedGarageDoorController, AsyncDevice
+):
+    """HmIP-WGC (Garage Door Controller)"""
+
+

+[docs]
+    async def send_start_impulse(self):
+        return await self._connection.api_call(*super().send_start_impulse())

+

+
+
+
+

+[docs]
+class AsyncDoorLockDrive(DoorLockDrive, AsyncDevice):
+    """HmIP-DLD (DoorLockDrive)"""
+
+

+[docs]
+    async def set_lock_state(self, doorLockState: LockState, pin="", channelIndex=1):
+        """sets the door lock state
+
+        Args:
+            doorLockState(float): the state of the door. See LockState from base/enums.py
+            pin(string): Pin, if specified.
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        return await self._connection.api_call(
+            *super().set_lock_state(doorLockState, pin, channelIndex)
+        )

+

+
+
+
+

+[docs]
+class AsyncDoorLockSensor(DoorLockSensor, AsyncDevice):
+    """HmIP-DLS"""

+
+
+
+

+[docs]
+class AsyncDoorBellButton(DoorBellButton, AsyncDevice):
+    pass

+
+
+
+

+[docs]
+class AsyncDoorBellContactInterface(DoorBellContactInterface, AsyncDevice):
+    pass

+
+
+
+

+[docs]
+class AsyncEnergySensorsInterface(EnergySensorsInterface, AsyncDevice):
+    pass

+
+
+
+

+[docs]
+class AsyncDaliGateway(DaliGateway, AsyncDevice):
+    pass

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/group.html b/_modules/homematicip/aio/group.html new file mode 100644 index 00000000..144b6906 --- /dev/null +++ b/_modules/homematicip/aio/group.html @@ -0,0 +1,602 @@ + + + + + + + + homematicip.aio.group — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.group

+import json
+
+from homematicip.base.enums import *
+from homematicip.group import (
+    AlarmSwitchingGroup,
+    AccessAuthorizationProfileGroup,
+    AccessControlGroup,
+    EnvironmentGroup,
+    ExtendedLinkedShutterGroup,
+    ExtendedLinkedSwitchingGroup,
+    ExtendedLinkedGarageDoorGroup,
+    Group,
+    HeatingChangeoverGroup,
+    HeatingCoolingDemandBoilerGroup,
+    HeatingCoolingDemandGroup,
+    HeatingCoolingDemandPumpGroup,
+    HeatingDehumidifierGroup,
+    HeatingExternalClockGroup,
+    HeatingFailureAlertRuleGroup,
+    HeatingGroup,
+    HeatingHumidyLimiterGroup,
+    HeatingTemperatureLimiterGroup,
+    HotWaterGroup,
+    HumidityWarningRuleGroup,
+    InboxGroup,
+    IndoorClimateGroup,
+    LinkedSwitchingGroup,
+    LockOutProtectionRule,
+    MetaGroup,
+    OverHeatProtectionRule,
+    SecurityGroup,
+    SecurityZoneGroup,
+    ShutterProfile,
+    ShutterWindProtectionRule,
+    SmokeAlarmDetectionRule,
+    SwitchGroupBase,
+    SwitchingGroup,
+    SwitchingProfileGroup,
+)
+
+
+

+[docs]
+class AsyncGroup(Group):
+

+[docs]
+    async def set_label(self, label):
+        return await self._connection.api_call(*super().set_label(label))

+
+
+

+[docs]
+    async def delete(self):
+        return await self._connection.api_call(*super().delete())

+

+
+
+
+

+[docs]
+class AsyncMetaGroup(MetaGroup, AsyncGroup):
+    """a meta group is a "Room" inside the homematic configuration"""
+
+    pass

+
+
+
+

+[docs]
+class AsyncSecurityGroup(SecurityGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncSwitchGroupBase(SwitchGroupBase, AsyncGroup):
+

+[docs]
+    async def turn_on(self):
+        return await self.set_switch_state(True)

+
+
+

+[docs]
+    async def turn_off(self):
+        return await self.set_switch_state(False)

+
+
+

+[docs]
+    async def set_switch_state(self, on=True):
+        url, data = super().set_switch_state(on=on)
+        return await self._connection.api_call(url, data)

+

+
+
+
+

+[docs]
+class AsyncSwitchingGroup(SwitchingGroup, AsyncSwitchGroupBase):
+

+[docs]
+    async def set_shutter_level(self, level):
+        url, data = super().set_shutter_level(level)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_shutter_stop(self):
+        url, data = super().set_shutter_stop()
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_slats_level(self, slatsLevel, shutterlevel):
+        url, data = super().set_slats_level(slatsLevel, shutterlevel)
+        return await self._connection.api_call(url, data)

+

+
+
+
+

+[docs]
+class AsyncShutterProfile(ShutterProfile, AsyncGroup):
+

+[docs]
+    async def set_shutter_level(self, level):
+        url, data = super().set_shutter_level(level)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_shutter_stop(self):
+        url, data = super().set_shutter_stop()
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_slats_level(self, slatsLevel, shutterlevel):
+        url, data = super().set_slats_level(slatsLevel, shutterlevel)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_profile_mode(self, profileMode: ProfileMode):
+        return await self._connection.api_call(*super().set_profile_mode(profileMode))

+

+
+
+
+

+[docs]
+class AsyncLinkedSwitchingGroup(LinkedSwitchingGroup, AsyncGroup):
+

+[docs]
+    async def set_light_group_switches(self, devices):
+        url, data = super().set_light_group_switches(devices)
+        return await self._connection.api_call(url, data)

+

+
+
+
+

+[docs]
+class AsyncExtendedLinkedSwitchingGroup(
+    ExtendedLinkedSwitchingGroup, AsyncSwitchGroupBase
+):
+

+[docs]
+    async def set_on_time(self, onTimeSeconds):
+        url, data = super().set_on_time(onTimeSeconds)
+        return await self._connection.api_call(url, data)

+

+
+
+
+

+[docs]
+class AsyncExtendedGarageDoorGroup(ExtendedLinkedGarageDoorGroup, AsyncGroup):
+    """Class which represents Extended Garage Door Group."""

+
+
+
+

+[docs]
+class AsyncExtendedLinkedShutterGroup(ExtendedLinkedShutterGroup, AsyncGroup):
+

+[docs]
+    async def set_shutter_level(self, level):
+        url, data = super().set_shutter_level(level)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_shutter_stop(self):
+        url, data = super().set_shutter_stop()
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_slats_level(self, slatsLevel=0.0, shutterLevel=None):
+        url, data = super().set_slats_level(slatsLevel, shutterLevel)
+        return await self._connection.api_call(url, data)

+

+
+
+
+

+[docs]
+class AsyncAlarmSwitchingGroup(AlarmSwitchingGroup, AsyncGroup):
+

+[docs]
+    async def set_on_time(self, onTimeSeconds):
+        url, data = super().set_on_time(onTimeSeconds)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def test_signal_optical(
+        self, signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING
+    ):
+        url, data = super().test_signal_optical(signalOptical=signalOptical)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_signal_optical(
+        self, signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING
+    ):
+        url, data = super().set_signal_optical(signalOptical=signalOptical)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def test_signal_acoustic(
+        self, signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING
+    ):
+        url, data = super().test_signal_acoustic(signalAcoustic=signalAcoustic)
+        return await self._connection.api_call(url, data)

+
+
+

+[docs]
+    async def set_signal_acoustic(
+        self, signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING
+    ):
+        url, data = super().set_signal_acoustic(signalAcoustic=signalAcoustic)
+        return await self._connection.api_call(url, data)

+

+
+
+
+# at the moment it doesn't look like this class has any special properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class AsyncHeatingHumidyLimiterGroup(HeatingHumidyLimiterGroup, AsyncGroup):
+    pass

+
+
+
+# at the moment it doesn't look like this class has any special properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class AsyncHeatingTemperatureLimiterGroup(HeatingTemperatureLimiterGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHeatingChangeoverGroup(HeatingChangeoverGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHeatingFailureAlertRuleGroup(HeatingFailureAlertRuleGroup, AsyncGroup):
+    pass

+
+
+
+# at the moment it doesn't look like this class has any special properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class AsyncInboxGroup(InboxGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncIndoorClimateGroup(IndoorClimateGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncSecurityZoneGroup(SecurityZoneGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHeatingGroup(HeatingGroup, AsyncGroup):
+

+[docs]
+    async def set_point_temperature(self, temperature):
+        return await self._connection.api_call(
+            *super().set_point_temperature(temperature)
+        )

+
+
+

+[docs]
+    async def set_boost(self, enable=True):
+        return await self._connection.api_call(*super().set_boost(enable=enable))

+
+
+

+[docs]
+    async def set_active_profile(self, index):
+        return await self._connection.api_call(*super().set_active_profile(index))

+
+
+

+[docs]
+    async def set_boost_duration(self, duration: int):
+        return await self._connection.api_call(*super().set_boost_duration(duration))

+
+
+

+[docs]
+    async def set_control_mode(self, mode=ClimateControlMode.AUTOMATIC):
+        return await self._connection.api_call(*super().set_control_mode(mode=mode))

+

+
+
+
+

+[docs]
+class AsyncHeatingDehumidifierGroup(HeatingDehumidifierGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHeatingCoolingDemandGroup(HeatingCoolingDemandGroup, AsyncGroup):
+    pass

+
+
+
+# at the moment it doesn't look like this class has any special properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class AsyncHeatingExternalClockGroup(HeatingExternalClockGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHeatingCoolingDemandBoilerGroup(HeatingCoolingDemandBoilerGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHeatingCoolingDemandPumpGroup(HeatingCoolingDemandPumpGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHumidityWarningRuleGroup(HumidityWarningRuleGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncSwitchingProfileGroup(SwitchingProfileGroup, AsyncGroup):
+

+[docs]
+    async def set_group_channels(self):
+        return await self._connection.api_call(*super().set_group_channels())

+
+
+

+[docs]
+    async def set_profile_mode(self, devices, automatic=True):
+        return await self._connection.api_call(
+            *super().set_profile_mode(devices, automatic=automatic)
+        )

+
+
+

+[docs]
+    async def create(self, label):
+        data = {"label": label}
+        result = await self._connection.api_call(
+            "group/switching/profile/createSwitchingProfileGroup", body=json.dumps(data)
+        )
+        if "groupId" in result:
+            self.id = result["groupId"]
+        return result

+

+
+
+
+

+[docs]
+class AsyncOverHeatProtectionRule(OverHeatProtectionRule, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncSmokeAlarmDetectionRule(SmokeAlarmDetectionRule, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncShutterWindProtectionRule(ShutterWindProtectionRule, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncLockOutProtectionRule(LockOutProtectionRule, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncEnvironmentGroup(EnvironmentGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncHotWaterGroup(HotWaterGroup, AsyncGroup):
+

+[docs]
+    async def set_profile_mode(self, profileMode: ProfileMode):
+        return await self._connection.api_call(*super().set_profile_mode(profileMode))

+

+
+
+
+

+[docs]
+class AsyncAccessAuthorizationProfileGroup(AccessAuthorizationProfileGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncAccessControlGroup(AccessControlGroup, AsyncGroup):
+    pass

+
+
+
+

+[docs]
+class AsyncEnergyGroup(AsyncGroup):
+    pass

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/home.html b/_modules/homematicip/aio/home.html new file mode 100644 index 00000000..98dc6bca --- /dev/null +++ b/_modules/homematicip/aio/home.html @@ -0,0 +1,336 @@ + + + + + + + + homematicip.aio.home — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.home

+import asyncio
+import json
+import logging
+
+from homematicip.aio.class_maps import (
+    TYPE_CLASS_MAP,
+    TYPE_GROUP_MAP,
+    TYPE_RULE_MAP,
+    TYPE_SECURITY_EVENT_MAP,
+)
+from homematicip.aio.connection import AsyncConnection
+from homematicip.aio.securityEvent import AsyncSecurityEvent
+from homematicip.base.enums import *
+from homematicip.home import Home, OAuthOTK
+
+LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+class AsyncHome(Home):
+    """this class represents the 'Async Home' of the homematic ip"""
+
+    _typeClassMap = TYPE_CLASS_MAP
+    _typeGroupMap = TYPE_GROUP_MAP
+    _typeSecurityEventMap = TYPE_SECURITY_EVENT_MAP
+    _typeRuleMap = TYPE_RULE_MAP
+
+    def __init__(self, loop, websession=None):
+        super().__init__(connection=AsyncConnection(loop, websession))
+
+

+[docs]
+    async def init(self, access_point_id, lookup=True):
+        await self._connection.init(access_point_id, lookup)

+
+
+

+[docs]
+    async def get_current_state(self, clearConfig: bool = False):
+        """downloads the current configuration and parses it into self
+
+        Args:
+            clearConfig(bool): if set to true, this function will remove all old objects
+            from self.devices, self.client, ... to have a fresh config instead of reparsing them
+        """
+        LOGGER.debug("get_current_state")
+        json_state = await self.download_configuration()
+        return self.update_home(json_state, clearConfig)

+
+
+

+[docs]
+    async def download_configuration(self):
+        return await self._connection.api_call(*super().download_configuration())

+
+
+

+[docs]
+    async def enable_events(self) -> asyncio.Task:
+        """Connects to the websocket. Returns a listening task."""
+        return await self._connection.ws_connect(
+            on_message=self._ws_on_message, on_error=self._ws_on_error
+        )

+
+
+

+[docs]
+    async def disable_events(self):
+        await self._connection.close_websocket_connection()

+
+
+

+[docs]
+    async def get_OAuth_OTK(self):
+        token = OAuthOTK(self._connection)
+        token.from_json(await self._connection.api_call("home/getOAuthOTK"))
+        return token

+
+
+

+[docs]
+    async def activate_absence_with_duration(self, duration):
+        return await self._connection.api_call(
+            *super().activate_absence_with_duration(duration)
+        )

+
+
+

+[docs]
+    async def set_powermeter_unit_price(self, price):
+        return await self._connection.api_call(
+            *super().set_powermeter_unit_price(price)
+        )

+
+
+

+[docs]
+    async def set_intrusion_alert_through_smoke_detectors(self, activate=True):
+        return await self._connection.api_call(
+            *super().set_intrusion_alert_through_smoke_detectors(activate)
+        )

+
+
+

+[docs]
+    async def set_timezone(self, timezone):
+        return await self._connection.api_call(*super().set_timezone(timezone))

+
+
+

+[docs]
+    async def set_zones_device_assignment(self, internal_devices, external_devices):
+        return await self._connection.api_call(
+            *super().set_zones_device_assignment(internal_devices, internal_devices)
+        )

+
+
+

+[docs]
+    async def set_pin(self, newPin, oldPin=None):
+        if newPin is None:
+            newPin = ""
+        data = {"pin": newPin}
+        if oldPin:
+            self._connection.headers["PIN"] = str(oldPin)
+        result = await self._connection.api_call("home/setPin", body=json.dumps(data))
+        if oldPin:
+            del self._connection.headers["PIN"]
+        return result

+
+
+

+[docs]
+    async def get_security_journal(self):
+        journal = await self._connection.api_call(
+            "home/security/getSecurityJournal",
+            json.dumps(self._connection.clientCharacteristics),
+        )
+        if journal is None or "errorCode" in journal:
+            LOGGER.error(
+                "Could not get the security journal. Error: %s", journal["errorCode"]
+            )
+            return None
+        ret = []
+        for entry in journal["entries"]:
+            try:
+                eventType = SecurityEventType(entry["eventType"])
+                if eventType in self._typeSecurityEventMap:
+                    j = self._typeSecurityEventMap[eventType](self._connection)
+            except:
+                j = AsyncSecurityEvent(self._connection)
+                LOGGER.warning("There is no class for %s yet", entry["eventType"])
+            j.from_json(entry)
+            ret.append(j)
+
+        return ret

+
+
+

+[docs]
+    async def activate_absence_with_period(self, endtime):
+        return await self._connection.api_call(
+            *super().activate_absence_with_period(endtime)
+        )

+
+
+

+[docs]
+    async def activate_absence_permanent(self):
+        return await self._connection.api_call(*super().activate_absence_permanent())

+
+
+

+[docs]
+    async def deactivate_absence(self):
+        return await self._connection.api_call(*super().deactivate_absence())

+
+
+

+[docs]
+    async def activate_vacation(self, endtime, temperature):
+        return await self._connection.api_call(
+            *super().activate_vacation(endtime, temperature)
+        )

+
+
+

+[docs]
+    async def deactivate_vacation(self):
+        return await self._connection.api_call(*super().deactivate_vacation())

+
+
+

+[docs]
+    async def set_zone_activation_delay(self, delay):
+        return await self._connection.api_call(
+            *super().set_zone_activation_delay(delay)
+        )

+
+
+

+[docs]
+    async def set_security_zones_activation(self, internal=True, external=True):
+        return await self._connection.api_call(
+            *super().set_security_zones_activation(internal, external)
+        )

+
+
+

+[docs]
+    async def delete_group(self, group):
+        return await group.delete()

+
+
+

+[docs]
+    async def set_location(self, city, latitude, longitude):
+        return await self._connection.api_call(
+            *super().set_location(city, latitude, longitude)
+        )

+
+
+

+[docs]
+    async def set_cooling(self, cooling):
+        return await self._connection.api_call(*super().set_cooling(cooling))

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/rule.html b/_modules/homematicip/aio/rule.html new file mode 100644 index 00000000..97233157 --- /dev/null +++ b/_modules/homematicip/aio/rule.html @@ -0,0 +1,158 @@ + + + + + + + + homematicip.aio.rule — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.rule

+import json
+
+from homematicip.base.enums import *
+from homematicip.rule import (
+    Rule,
+    SimpleRule,
+)
+
+
+

+[docs]
+class AsyncRule(Rule):
+    """Async implementation of a homematic ip rule"""
+
+

+[docs]
+    async def set_label(self, label):
+        return await self._connection.api_call(*super().set_label(label))

+

+
+
+
+

+[docs]
+class AsyncSimpleRule(SimpleRule, AsyncRule):
+    """Async implementation of a homematic ip simple rule"""
+
+

+[docs]
+    async def enable(self):
+        return await self.set_rule_enabled_state(True)

+
+
+

+[docs]
+    async def disable(self):
+        return await self.set_rule_enabled_state(False)

+
+
+

+[docs]
+    async def set_rule_enabled_state(self, enabled):
+        return await self._connection.api_call(*super().set_rule_enabled_state(enabled))

+
+
+

+[docs]
+    async def get_simple_rule(self):
+        return await self._connection.api_call(*super().get_simple_rule())

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/aio/securityEvent.html b/_modules/homematicip/aio/securityEvent.html new file mode 100644 index 00000000..cd8c69be --- /dev/null +++ b/_modules/homematicip/aio/securityEvent.html @@ -0,0 +1,221 @@ + + + + + + + + homematicip.aio.securityEvent — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.aio.securityEvent

+from datetime import datetime
+
+from homematicip.securityEvent import *
+
+
+

+[docs]
+class AsyncSecurityEvent(SecurityEvent):
+    """this class represents a security event"""
+
+    pass

+
+
+
+

+[docs]
+class AsyncSecurityZoneEvent(SecurityZoneEvent, AsyncSecurityEvent):
+    """This class will be used by other events which are just adding "securityZoneValues" """
+
+    pass

+
+
+
+

+[docs]
+class AsyncSensorEvent(SensorEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncAccessPointDisconnectedEvent(
+    AccessPointDisconnectedEvent, AsyncSecurityEvent
+):
+    pass

+
+
+
+

+[docs]
+class AsyncAccessPointConnectedEvent(AccessPointConnectedEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncActivationChangedEvent(ActivationChangedEvent, AsyncSecurityZoneEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncSilenceChangedEvent(SilenceChangedEvent, AsyncSecurityZoneEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncSabotageEvent(SabotageEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncMoistureDetectionEvent(MoistureDetectionEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncSmokeAlarmEvent(SmokeAlarmEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncExternalTriggeredEvent(ExternalTriggeredEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncOfflineAlarmEvent(OfflineAlarmEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncWaterDetectionEvent(WaterDetectionEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncMainsFailureEvent(MainsFailureEvent, AsyncSecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AsyncOfflineWaterDetectionEvent(OfflineWaterDetectionEvent, AsyncSecurityEvent):
+    pass

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/auth.html b/_modules/homematicip/auth.html new file mode 100644 index 00000000..b3e1c5b0 --- /dev/null +++ b/_modules/homematicip/auth.html @@ -0,0 +1,185 @@ + + + + + + + + homematicip.auth — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.auth

+# coding=utf-8
+import json
+import uuid
+
+import requests
+
+from homematicip.home import Home
+
+
+

+[docs]
+class Auth(object):
+    def __init__(self, home: Home):
+        self.uuid = str(uuid.uuid4())
+        self.headers = {
+            "content-type": "application/json",
+            "accept": "application/json",
+            "VERSION": "12",
+            "CLIENTAUTH": home._connection.clientauth_token,
+            "ACCESSPOINT-ID": home._connection.accesspoint_id,
+        }
+        self.url_rest = home._connection.urlREST
+        self.accesspoint_id = home._connection.accesspoint_id
+        self.pin = None
+
+

+[docs]
+    def connectionRequest(
+            self, access_point, devicename="homematicip-python"
+    ) -> requests.Response:
+        data = {"deviceId": self.uuid, "deviceName": devicename, "sgtin": access_point}
+        headers = self.headers
+        if self.pin != None:
+            headers["PIN"] = self.pin
+        response = requests.post(
+            "{}/hmip/auth/connectionRequest".format(self.url_rest),
+            json=data,
+            headers=headers,
+        )
+        return response

+
+
+

+[docs]
+    def isRequestAcknowledged(self):
+        data = {"deviceId": self.uuid, "accessPointId": self.accesspoint_id}
+        response = requests.post(
+            "{}/hmip/auth/isRequestAcknowledged".format(self.url_rest),
+            json=data,
+            headers=self.headers,
+        )
+        return response.status_code == 200

+
+
+

+[docs]
+    def requestAuthToken(self):
+        data = {"deviceId": self.uuid}
+        response = requests.post(
+            "{}/hmip/auth/requestAuthToken".format(self.url_rest),
+            json=data,
+            headers=self.headers,
+        )
+        return json.loads(response.text)["authToken"]

+
+
+

+[docs]
+    def confirmAuthToken(self, authToken):
+        data = {"deviceId": self.uuid, "authToken": authToken}
+        response = requests.post(
+            "{}/hmip/auth/confirmAuthToken".format(self.url_rest),
+            json=data,
+            headers=self.headers,
+        )
+        return json.loads(response.text)["clientId"]

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/base/base_connection.html b/_modules/homematicip/base/base_connection.html new file mode 100644 index 00000000..ec9f33eb --- /dev/null +++ b/_modules/homematicip/base/base_connection.html @@ -0,0 +1,245 @@ + + + + + + + + homematicip.base.base_connection — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.base.base_connection

+import hashlib
+import locale
+import platform
+import re
+
+ATTR_AUTH_TOKEN = "AUTHTOKEN"
+ATTR_CLIENT_AUTH = "CLIENTAUTH"
+
+
+

+[docs]
+class HmipConnectionError(Exception):
+    pass

+
+
+
+

+[docs]
+class HmipWrongHttpStatusError(HmipConnectionError):
+    def __init__(self, status_code=None):
+        self.status_code = status_code
+
+    def __str__(self):
+        return f"HmipWrongHttpStatusError({self.status_code})"

+
+
+
+

+[docs]
+class HmipServerCloseError(HmipConnectionError):
+    pass

+
+
+
+

+[docs]
+class HmipThrottlingError(HmipConnectionError):
+    pass

+
+
+
+

+[docs]
+class BaseConnection:
+    """Base connection class.
+
+    Threaded and Async connection class must inherit from this."""
+
+    _auth_token = ""
+    _clientauth_token = ""
+    _accesspoint_id = ""
+    _urlREST = ""
+    _urlWebSocket = ""
+    # the homematic ip cloud tends to time out. retry the call X times.
+    _restCallRequestCounter = 3
+    _restCallTimout = 6
+
+    def __init__(self):
+        self.headers = {
+            "content-type": "application/json",
+            "accept": "application/json",
+            "VERSION": "12",
+            ATTR_AUTH_TOKEN: None,
+            ATTR_CLIENT_AUTH: None,
+        }
+        lang = "en_US"
+        def_locale = locale.getlocale()
+        if def_locale != None and def_locale[0] != None:
+            lang = def_locale[0]
+
+        self._clientCharacteristics = {
+            "clientCharacteristics": {
+                "apiVersion": "10",
+                "applicationIdentifier": "homematicip-python",
+                "applicationVersion": "1.0",
+                "deviceManufacturer": "none",
+                "deviceType": "Computer",
+                "language": lang,
+                "osType": platform.system(),
+                "osVersion": platform.release(),
+            },
+            "id": None,
+        }
+
+    @property
+    def clientCharacteristics(self):
+        return self._clientCharacteristics
+
+    @property
+    def urlWebSocket(self):
+        return self._urlWebSocket
+
+    @property
+    def urlREST(self):
+        return self._urlREST
+
+    @property
+    def auth_token(self):
+        return self._auth_token
+
+    @property
+    def clientauth_token(self):
+        return self._clientauth_token
+
+    @property
+    def accesspoint_id(self):
+        return self._accesspoint_id
+
+

+[docs]
+    def set_token_and_characteristics(self, accesspoint_id):
+        self._accesspoint_id = re.sub(r"[^a-fA-F0-9 ]", "", accesspoint_id).upper()
+        self._clientCharacteristics["id"] = self._accesspoint_id
+        self._clientauth_token = (
+            hashlib.sha512(str(self._accesspoint_id + "jiLpVitHvWnIGD1yo7MA").encode("utf-8"))
+            .hexdigest()
+            .upper()
+        )
+        self.headers[ATTR_CLIENT_AUTH] = self._clientauth_token
+        self.headers["ACCESSPOINT-ID"] = self._accesspoint_id

+
+
+

+[docs]
+    def set_auth_token(self, auth_token):
+        self._auth_token = auth_token
+        self.headers[ATTR_AUTH_TOKEN] = auth_token

+
+
+

+[docs]
+    def init(self, accesspoint_id, lookup=True, **kwargs):
+        raise NotImplementedError

+
+
+    def _rest_call(self, path, body=None):
+        raise NotImplementedError

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/base/enums.html b/_modules/homematicip/base/enums.html new file mode 100644 index 00000000..0da3306f --- /dev/null +++ b/_modules/homematicip/base/enums.html @@ -0,0 +1,959 @@ + + + + + + + + homematicip.base.enums — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.base.enums

+# coding=utf-8
+import logging
+
+from enum import Enum, auto
+
+logger = logging.getLogger(__name__)
+
+
+

+[docs]
+class AutoNameEnum(str, Enum):
+    """auto() will generate the name of the attribute as value"""
+
+    def _generate_next_value_(name, start, count, last_values):
+        return name
+
+    def __str__(self):
+        return self.value
+
+

+[docs]
+    @classmethod
+    def from_str(cls, text: str, default=None):
+        """this function will create the enum object based on its string value
+
+        Args:
+            text(str): the string value of the enum
+            default(AutoNameEnum): a default value if text could not be used
+        Returns:
+            the enum object or None if the text is None or the default value
+        """
+        if text is None:
+            return None
+        try:
+            return cls(text)
+        except:
+            logger.warning(
+                "'%s' isn't a valid option for class '%s'", text, cls.__name__
+            )
+            return default

+

+
+
+
+

+[docs]
+class AcousticAlarmTiming(AutoNameEnum):
+    PERMANENT = auto()
+    THREE_MINUTES = auto()
+    SIX_MINUTES = auto()
+    ONCE_PER_MINUTE = auto()

+
+
+
+

+[docs]
+class WaterAlarmTrigger(AutoNameEnum):
+    NO_ALARM = auto()
+    MOISTURE_DETECTION = auto()
+    WATER_DETECTION = auto()
+    WATER_MOISTURE_DETECTION = auto()

+
+
+
+

+[docs]
+class AcousticAlarmSignal(AutoNameEnum):
+    DISABLE_ACOUSTIC_SIGNAL = auto()
+    FREQUENCY_RISING = auto()
+    FREQUENCY_FALLING = auto()
+    FREQUENCY_RISING_AND_FALLING = auto()
+    FREQUENCY_ALTERNATING_LOW_HIGH = auto()
+    FREQUENCY_ALTERNATING_LOW_MID_HIGH = auto()
+    FREQUENCY_HIGHON_OFF = auto()
+    FREQUENCY_HIGHON_LONGOFF = auto()
+    FREQUENCY_LOWON_OFF_HIGHON_OFF = auto()
+    FREQUENCY_LOWON_LONGOFF_HIGHON_LONGOFF = auto()
+    LOW_BATTERY = auto()
+    DISARMED = auto()
+    INTERNALLY_ARMED = auto()
+    EXTERNALLY_ARMED = auto()
+    DELAYED_INTERNALLY_ARMED = auto()
+    DELAYED_EXTERNALLY_ARMED = auto()
+    EVENT = auto()
+    ERROR = auto()

+
+
+
+

+[docs]
+class AlarmContactType(AutoNameEnum):
+    PASSIVE_GLASS_BREAKAGE_DETECTOR = auto()
+    WINDOW_DOOR_CONTACT = auto()

+
+
+
+

+[docs]
+class ClimateControlDisplay(AutoNameEnum):
+    ACTUAL = auto()
+    SETPOINT = auto()
+    ACTUAL_HUMIDITY = auto()

+
+
+
+

+[docs]
+class WindowState(AutoNameEnum):
+    OPEN = auto()
+    CLOSED = auto()
+    TILTED = auto()

+
+
+
+

+[docs]
+class ValveState(AutoNameEnum):
+    STATE_NOT_AVAILABLE = auto()
+    RUN_TO_START = auto()
+    WAIT_FOR_ADAPTION = auto()
+    ADAPTION_IN_PROGRESS = auto()
+    ADAPTION_DONE = auto()
+    TOO_TIGHT = auto()
+    ADJUSTMENT_TOO_BIG = auto()
+    ADJUSTMENT_TOO_SMALL = auto()
+    ERROR_POSITION = auto()

+
+
+
+

+[docs]
+class HeatingValveType(AutoNameEnum):
+    NORMALLY_CLOSE = auto()
+    NORMALLY_OPEN = auto()

+
+
+
+

+[docs]
+class ContactType(AutoNameEnum):
+    NORMALLY_CLOSE = auto()
+    NORMALLY_OPEN = auto()

+
+
+
+

+[docs]
+class RGBColorState(AutoNameEnum):
+    BLACK = auto()
+    BLUE = auto()
+    GREEN = auto()
+    TURQUOISE = auto()
+    RED = auto()
+    PURPLE = auto()
+    YELLOW = auto()
+    WHITE = auto()

+
+
+
+

+[docs]
+class DeviceUpdateStrategy(AutoNameEnum):
+    MANUALLY = auto()
+    AUTOMATICALLY_IF_POSSIBLE = auto()

+
+
+
+

+[docs]
+class ApExchangeState(AutoNameEnum):
+    NONE = auto()
+    REQUESTED = auto()
+    IN_PROGRESS = auto()
+    DONE = auto()
+    REJECTED = auto()

+
+
+
+

+[docs]
+class HomeUpdateState(AutoNameEnum):
+    UP_TO_DATE = auto()
+    UPDATE_AVAILABLE = auto()
+    PERFORM_UPDATE_SENT = auto()
+    PERFORMING_UPDATE = auto()

+
+
+
+

+[docs]
+class WeatherCondition(AutoNameEnum):
+    CLEAR = auto()
+    LIGHT_CLOUDY = auto()
+    CLOUDY = auto()
+    CLOUDY_WITH_RAIN = auto()
+    CLOUDY_WITH_SNOW_RAIN = auto()
+    HEAVILY_CLOUDY = auto()
+    HEAVILY_CLOUDY_WITH_RAIN = auto()
+    HEAVILY_CLOUDY_WITH_STRONG_RAIN = auto()
+    HEAVILY_CLOUDY_WITH_SNOW = auto()
+    HEAVILY_CLOUDY_WITH_SNOW_RAIN = auto()
+    HEAVILY_CLOUDY_WITH_THUNDER = auto()
+    HEAVILY_CLOUDY_WITH_RAIN_AND_THUNDER = auto()
+    FOGGY = auto()
+    STRONG_WIND = auto()
+    UNKNOWN = auto()

+
+
+
+

+[docs]
+class WeatherDayTime(AutoNameEnum):
+    DAY = auto()
+    TWILIGHT = auto()
+    NIGHT = auto()

+
+
+
+

+[docs]
+class ClimateControlMode(AutoNameEnum):
+    AUTOMATIC = auto()
+    MANUAL = auto()
+    ECO = auto()

+
+
+
+

+[docs]
+class AbsenceType(AutoNameEnum):
+    NOT_ABSENT = auto()
+    PERIOD = auto()
+    PERMANENT = auto()
+    VACATION = auto()
+    PARTY = auto()

+
+
+
+

+[docs]
+class EcoDuration(AutoNameEnum):
+    ONE = auto()
+    TWO = auto()
+    FOUR = auto()
+    SIX = auto()
+    PERMANENT = auto()

+
+
+
+

+[docs]
+class SecurityZoneActivationMode(AutoNameEnum):
+    ACTIVATION_WITH_DEVICE_IGNORELIST = auto()
+    ACTIVATION_IF_ALL_IN_VALID_STATE = auto()

+
+
+
+

+[docs]
+class ClientType(AutoNameEnum):
+    APP = auto()
+    C2C = auto()

+
+
+
+

+[docs]
+class DeviceType(AutoNameEnum):
+    DEVICE = auto()
+    BASE_DEVICE = auto()
+    EXTERNAL = auto()
+    ACCELERATION_SENSOR = auto()
+    ACCESS_POINT = auto()
+    ALARM_SIREN_INDOOR = auto()
+    ALARM_SIREN_OUTDOOR = auto()
+    BLIND_MODULE = auto()
+    BRAND_BLIND = auto()
+    BRAND_DIMMER = auto()
+    BRAND_PUSH_BUTTON = auto()
+    BRAND_SHUTTER = auto()
+    BRAND_SWITCH_2 = auto()
+    BRAND_SWITCH_MEASURING = auto()
+    BRAND_SWITCH_NOTIFICATION_LIGHT = auto()
+    BRAND_WALL_MOUNTED_THERMOSTAT = auto()
+    CARBON_DIOXIDE_SENSOR = auto()
+    DALI_GATEWAY = auto()
+    DIN_RAIL_BLIND_4 = auto()
+    DIN_RAIL_SWITCH = auto()
+    DIN_RAIL_SWITCH_4 = auto()
+    DIN_RAIL_DIMMER_3 = auto()
+    DOOR_BELL_BUTTON = auto()
+    DOOR_BELL_CONTACT_INTERFACE = auto()
+    DOOR_LOCK_DRIVE = auto()
+    DOOR_LOCK_SENSOR = auto()
+    ENERGY_SENSORS_INTERFACE = auto()
+    FLOOR_TERMINAL_BLOCK_6 = auto()
+    FLOOR_TERMINAL_BLOCK_10 = auto()
+    FLOOR_TERMINAL_BLOCK_12 = auto()
+    FULL_FLUSH_BLIND = auto()
+    FULL_FLUSH_CONTACT_INTERFACE = auto()
+    FULL_FLUSH_CONTACT_INTERFACE_6 = auto()
+    FULL_FLUSH_DIMMER = auto()
+    FULL_FLUSH_INPUT_SWITCH = auto()
+    FULL_FLUSH_SHUTTER = auto()
+    FULL_FLUSH_SWITCH_MEASURING = auto()
+    HEATING_SWITCH_2 = auto()
+    HEATING_THERMOSTAT = auto()
+    HEATING_THERMOSTAT_COMPACT = auto()
+    HEATING_THERMOSTAT_COMPACT_PLUS = auto()
+    HEATING_THERMOSTAT_EVO = auto()
+    HOME_CONTROL_ACCESS_POINT = auto()
+    HOERMANN_DRIVES_MODULE = auto()
+    KEY_REMOTE_CONTROL_4 = auto()
+    KEY_REMOTE_CONTROL_ALARM = auto()
+    LIGHT_SENSOR = auto()
+    MOTION_DETECTOR_INDOOR = auto()
+    MOTION_DETECTOR_OUTDOOR = auto()
+    MOTION_DETECTOR_PUSH_BUTTON = auto()
+    MULTI_IO_BOX = auto()
+    OPEN_COLLECTOR_8_MODULE = auto()
+    PASSAGE_DETECTOR = auto()
+    PLUGGABLE_MAINS_FAILURE_SURVEILLANCE = auto()
+    PLUGABLE_SWITCH = auto()
+    PLUGABLE_SWITCH_MEASURING = auto()
+    PLUGGABLE_DIMMER = auto()
+    PRESENCE_DETECTOR_INDOOR = auto()
+    PRINTED_CIRCUIT_BOARD_SWITCH_BATTERY = auto()
+    PRINTED_CIRCUIT_BOARD_SWITCH_2 = auto()
+    PUSH_BUTTON = auto()
+    PUSH_BUTTON_6 = auto()
+    PUSH_BUTTON_FLAT = auto()
+    RAIN_SENSOR = auto()
+    REMOTE_CONTROL_8 = auto()
+    REMOTE_CONTROL_8_MODULE = auto()
+    RGBW_DIMMER = auto()
+    ROOM_CONTROL_DEVICE = auto()
+    ROOM_CONTROL_DEVICE_ANALOG = auto()
+    ROTARY_HANDLE_SENSOR = auto()
+    SHUTTER_CONTACT = auto()
+    SHUTTER_CONTACT_INTERFACE = auto()
+    SHUTTER_CONTACT_INVISIBLE = auto()
+    SHUTTER_CONTACT_MAGNETIC = auto()
+    SHUTTER_CONTACT_OPTICAL_PLUS = auto()
+    SMOKE_DETECTOR = auto()
+    TEMPERATURE_HUMIDITY_SENSOR = auto()
+    TEMPERATURE_HUMIDITY_SENSOR_DISPLAY = auto()
+    TEMPERATURE_HUMIDITY_SENSOR_OUTDOOR = auto()
+    TEMPERATURE_SENSOR_2_EXTERNAL_DELTA = auto()
+    TILT_VIBRATION_SENSOR = auto()
+    TORMATIC_MODULE = auto()
+    WALL_MOUNTED_THERMOSTAT_BASIC_HUMIDITY = auto()
+    WALL_MOUNTED_THERMOSTAT_PRO = auto()
+    WALL_MOUNTED_GARAGE_DOOR_CONTROLLER = auto()
+    WALL_MOUNTED_UNIVERSAL_ACTUATOR = auto()
+    WATER_SENSOR = auto()
+    WEATHER_SENSOR = auto()
+    WEATHER_SENSOR_PLUS = auto()
+    WEATHER_SENSOR_PRO = auto()
+    WIRED_BLIND_4 = auto()
+    WIRED_DIMMER_3 = auto()
+    WIRED_DIN_RAIL_ACCESS_POINT = auto()
+    WIRED_FLOOR_TERMINAL_BLOCK_12 = auto()
+    WIRED_INPUT_32 = auto()
+    WIRED_INPUT_SWITCH_6 = auto()
+    WIRED_MOTION_DETECTOR_PUSH_BUTTON = auto()
+    WIRED_PRESENCE_DETECTOR_INDOOR = auto()
+    WIRED_PUSH_BUTTON_2 = auto()
+    WIRED_PUSH_BUTTON_6 = auto()
+    WIRED_SWITCH_8 = auto()
+    WIRED_SWITCH_4 = auto()
+    WIRED_WALL_MOUNTED_THERMOSTAT = auto()

+
+
+
+

+[docs]
+class GroupType(AutoNameEnum):
+    GROUP = auto()
+    ACCESS_AUTHORIZATION_PROFILE = auto()
+    ACCESS_CONTROL = auto()
+    ALARM_SWITCHING = auto()
+    ENERGY = auto()
+    ENVIRONMENT = auto()
+    EXTENDED_LINKED_GARAGE_DOOR = auto()
+    EXTENDED_LINKED_SHUTTER = auto()
+    EXTENDED_LINKED_SWITCHING = auto()
+    HEATING = auto()
+    HEATING_CHANGEOVER = auto()
+    HEATING_COOLING_DEMAND = auto()
+    HEATING_COOLING_DEMAND_BOILER = auto()
+    HEATING_COOLING_DEMAND_PUMP = auto()
+    HEATING_DEHUMIDIFIER = auto()
+    HEATING_EXTERNAL_CLOCK = auto()
+    HEATING_FAILURE_ALERT_RULE_GROUP = auto()
+    HEATING_HUMIDITY_LIMITER = auto()
+    HEATING_TEMPERATURE_LIMITER = auto()
+    HOT_WATER = auto()
+    HUMIDITY_WARNING_RULE_GROUP = auto()
+    INBOX = auto()
+    INDOOR_CLIMATE = auto()
+    LINKED_SWITCHING = auto()
+    LOCK_OUT_PROTECTION_RULE = auto()
+    OVER_HEAT_PROTECTION_RULE = auto()
+    SECURITY = auto()
+    SECURITY_BACKUP_ALARM_SWITCHING = auto()
+    SECURITY_ZONE = auto()
+    SHUTTER_PROFILE = auto()
+    SHUTTER_WIND_PROTECTION_RULE = auto()
+    SMOKE_ALARM_DETECTION_RULE = auto()
+    SWITCHING = auto()
+    SWITCHING_PROFILE = auto()

+
+
+
+

+[docs]
+class SecurityEventType(AutoNameEnum):
+    SENSOR_EVENT = auto()
+    ACCESS_POINT_DISCONNECTED = auto()
+    ACCESS_POINT_CONNECTED = auto()
+    ACTIVATION_CHANGED = auto()
+    SILENCE_CHANGED = auto()
+    SABOTAGE = auto()
+    MOISTURE_DETECTION_EVENT = auto()
+    SMOKE_ALARM = auto()
+    EXTERNAL_TRIGGERED = auto()
+    OFFLINE_ALARM = auto()
+    WATER_DETECTION_EVENT = auto()
+    MAINS_FAILURE_EVENT = auto()
+    OFFLINE_WATER_DETECTION_EVENT = auto()

+
+
+
+

+[docs]
+class AutomationRuleType(AutoNameEnum):
+    SIMPLE = auto()

+
+
+
+

+[docs]
+class FunctionalHomeType(AutoNameEnum):
+    ACCESS_CONTROL = auto()
+    INDOOR_CLIMATE = auto()
+    ENERGY = auto()
+    LIGHT_AND_SHADOW = auto()
+    SECURITY_AND_ALARM = auto()
+    WEATHER_AND_ENVIRONMENT = auto()

+
+
+
+

+[docs]
+class EventType(AutoNameEnum):
+    SECURITY_JOURNAL_CHANGED = auto()
+    GROUP_ADDED = auto()
+    GROUP_REMOVED = auto()
+    DEVICE_REMOVED = auto()
+    DEVICE_CHANGED = auto()
+    DEVICE_ADDED = auto()
+    DEVICE_CHANNEL_EVENT = auto()
+    CLIENT_REMOVED = auto()
+    CLIENT_CHANGED = auto()
+    CLIENT_ADDED = auto()
+    HOME_CHANGED = auto()
+    GROUP_CHANGED = auto()

+
+
+
+

+[docs]
+class MotionDetectionSendInterval(AutoNameEnum):
+    SECONDS_30 = auto()
+    SECONDS_60 = auto()
+    SECONDS_120 = auto()
+    SECONDS_240 = auto()
+    SECONDS_480 = auto()

+
+
+
+

+[docs]
+class SmokeDetectorAlarmType(AutoNameEnum):
+    IDLE_OFF = auto()
+    PRIMARY_ALARM = auto()
+    INTRUSION_ALARM = auto()
+    SECONDARY_ALARM = auto()

+
+
+
+

+[docs]
+class LiveUpdateState(AutoNameEnum):
+    UP_TO_DATE = auto()
+    UPDATE_AVAILABLE = auto()
+    UPDATE_INCOMPLETE = auto()
+    LIVE_UPDATE_NOT_SUPPORTED = auto()

+
+
+
+

+[docs]
+class OpticalAlarmSignal(AutoNameEnum):
+    DISABLE_OPTICAL_SIGNAL = auto()
+    BLINKING_ALTERNATELY_REPEATING = auto()
+    BLINKING_BOTH_REPEATING = auto()
+    DOUBLE_FLASHING_REPEATING = auto()
+    FLASHING_BOTH_REPEATING = auto()
+    CONFIRMATION_SIGNAL_0 = auto()
+    CONFIRMATION_SIGNAL_1 = auto()
+    CONFIRMATION_SIGNAL_2 = auto()

+
+
+
+

+[docs]
+class WindValueType(AutoNameEnum):
+    CURRENT_VALUE = auto()
+    MIN_VALUE = auto()
+    MAX_VALUE = auto()
+    AVERAGE_VALUE = auto()

+
+
+
+

+[docs]
+class FunctionalChannelType(AutoNameEnum):
+    FUNCTIONAL_CHANNEL = auto()
+    ACCELERATION_SENSOR_CHANNEL = auto()
+    ACCESS_AUTHORIZATION_CHANNEL = auto()
+    ACCESS_CONTROLLER_CHANNEL = auto()
+    ACCESS_CONTROLLER_WIRED_CHANNEL = auto()
+    ALARM_SIREN_CHANNEL = auto()
+    ANALOG_OUTPUT_CHANNEL = auto()
+    ANALOG_ROOM_CONTROL_CHANNEL = auto()
+    BLIND_CHANNEL = auto()
+    CHANGE_OVER_CHANNEL = auto()
+    CARBON_DIOXIDE_SENSOR_CHANNEL = auto()
+    CLIMATE_SENSOR_CHANNEL = auto()
+    CONTACT_INTERFACE_CHANNEL = auto()
+    DEHUMIDIFIER_DEMAND_CHANNEL = auto()
+    DEVICE_BASE = auto()
+    DEVICE_BASE_FLOOR_HEATING = auto()
+    DEVICE_GLOBAL_PUMP_CONTROL = auto()
+    DEVICE_INCORRECT_POSITIONED = auto()
+    DEVICE_OPERATIONLOCK = auto()
+    DEVICE_OPERATIONLOCK_WITH_SABOTAGE = auto()
+    DEVICE_PERMANENT_FULL_RX = auto()
+    DEVICE_RECHARGEABLE_WITH_SABOTAGE = auto()
+    DEVICE_SABOTAGE = auto()
+    DIMMER_CHANNEL = auto()
+    DOOR_CHANNEL = auto()
+    DOOR_LOCK_CHANNEL = auto()
+    DOOR_LOCK_SENSOR_CHANNEL = auto()
+    EXTERNAL_BASE_CHANNEL = auto()
+    EXTERNAL_UNIVERSAL_LIGHT_CHANNEL = auto()
+    ENERGY_SENSORS_INTERFACE_CHANNEL = auto()
+    FLOOR_TERMINAL_BLOCK_CHANNEL = auto()
+    FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL = auto()
+    FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL = auto()
+    GENERIC_INPUT_CHANNEL = auto()
+    HEAT_DEMAND_CHANNEL = auto()
+    HEATING_THERMOSTAT_CHANNEL = auto()
+    IMPULSE_OUTPUT_CHANNEL = auto()
+    INTERNAL_SWITCH_CHANNEL = auto()
+    LIGHT_SENSOR_CHANNEL = auto()
+    MAINS_FAILURE_CHANNEL = auto()
+    MOTION_DETECTION_CHANNEL = auto()
+    MULTI_MODE_INPUT_BLIND_CHANNEL = auto()
+    MULTI_MODE_INPUT_CHANNEL = auto()
+    MULTI_MODE_INPUT_DIMMER_CHANNEL = auto()
+    MULTI_MODE_INPUT_SWITCH_CHANNEL = auto()
+    NOTIFICATION_LIGHT_CHANNEL = auto()
+    OPTICAL_SIGNAL_CHANNEL = auto()
+    OPTICAL_SIGNAL_GROUP_CHANNEL = auto()
+    PASSAGE_DETECTOR_CHANNEL = auto()
+    PRESENCE_DETECTION_CHANNEL = auto()
+    RAIN_DETECTION_CHANNEL = auto()
+    ROTARY_HANDLE_CHANNEL = auto()
+    SHADING_CHANNEL = auto()
+    SHUTTER_CHANNEL = auto()
+    SHUTTER_CONTACT_CHANNEL = auto()
+    SINGLE_KEY_CHANNEL = auto()
+    SMOKE_DETECTOR_CHANNEL = auto()
+    SWITCH_CHANNEL = auto()
+    SWITCH_MEASURING_CHANNEL = auto()
+    TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL = auto()
+    TILT_VIBRATION_SENSOR_CHANNEL = auto()
+    UNIVERSAL_ACTUATOR_CHANNEL = auto()
+    UNIVERSAL_LIGHT_CHANNEL = auto()
+    UNIVERSAL_LIGHT_GROUP_CHANNEL = auto()
+    WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL = auto()
+    WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL = auto()
+    WATER_SENSOR_CHANNEL = auto()
+    WEATHER_SENSOR_CHANNEL = auto()
+    WEATHER_SENSOR_PLUS_CHANNEL = auto()
+    WEATHER_SENSOR_PRO_CHANNEL = auto()

+
+
+
+

+[docs]
+class ChannelEventTypes(AutoNameEnum):
+    DOOR_BELL_SENSOR_EVENT = auto()

+
+
+
+

+[docs]
+class HeatingLoadType(AutoNameEnum):
+    LOAD_BALANCING = auto()
+    LOAD_COLLECTION = auto()

+
+
+
+

+[docs]
+class DeviceUpdateState(AutoNameEnum):
+    UP_TO_DATE = auto()
+    TRANSFERING_UPDATE = auto()
+    UPDATE_AVAILABLE = auto()
+    UPDATE_AUTHORIZED = auto()
+    BACKGROUND_UPDATE_NOT_SUPPORTED = auto()

+
+
+
+

+[docs]
+class PassageDirection(AutoNameEnum):
+    LEFT = auto()
+    RIGHT = auto()

+
+
+
+

+[docs]
+class MultiModeInputMode(AutoNameEnum):
+    KEY_BEHAVIOR = auto()
+    SWITCH_BEHAVIOR = auto()
+    BINARY_BEHAVIOR = auto()

+
+
+
+

+[docs]
+class BinaryBehaviorType(AutoNameEnum):
+    NORMALLY_CLOSE = auto()
+    NORMALLY_OPEN = auto()

+
+
+
+

+[docs]
+class HeatingFailureValidationType(AutoNameEnum):
+    NO_HEATING_FAILURE = auto()
+    HEATING_FAILURE_WARNING = auto()
+    HEATING_FAILURE_ALARM = auto()

+
+
+
+

+[docs]
+class HumidityValidationType(AutoNameEnum):
+    LESSER_LOWER_THRESHOLD = auto()
+    GREATER_UPPER_THRESHOLD = auto()
+    GREATER_LOWER_LESSER_UPPER_THRESHOLD = auto()

+
+
+
+

+[docs]
+class AccelerationSensorMode(AutoNameEnum):
+    ANY_MOTION = auto()
+    FLAT_DECT = auto()

+
+
+
+

+[docs]
+class AccelerationSensorNeutralPosition(AutoNameEnum):
+    HORIZONTAL = auto()
+    VERTICAL = auto()

+
+
+
+

+[docs]
+class AccelerationSensorSensitivity(AutoNameEnum):
+    SENSOR_RANGE_16G = auto()
+    SENSOR_RANGE_8G = auto()
+    SENSOR_RANGE_4G = auto()
+    SENSOR_RANGE_2G = auto()
+    SENSOR_RANGE_2G_PLUS_SENS = auto()
+    SENSOR_RANGE_2G_2PLUS_SENSE = auto()

+
+
+
+

+[docs]
+class NotificationSoundType(AutoNameEnum):
+    SOUND_NO_SOUND = auto()
+    SOUND_SHORT = auto()
+    SOUND_SHORT_SHORT = auto()
+    SOUND_LONG = auto()

+
+
+
+

+[docs]
+class DoorState(AutoNameEnum):
+    CLOSED = auto()
+    OPEN = auto()
+    VENTILATION_POSITION = auto()
+    POSITION_UNKNOWN = auto()

+
+
+
+

+[docs]
+class DoorCommand(AutoNameEnum):
+    OPEN = auto()
+    STOP = auto()
+    CLOSE = auto()
+    PARTIAL_OPEN = auto()

+
+
+
+

+[docs]
+class ShadingStateType(AutoNameEnum):
+    NOT_POSSIBLE = auto()
+    NOT_EXISTENT = auto()
+    POSITION_USED = auto()
+    TILT_USED = auto()
+    NOT_USED = auto()
+    MIXED = auto()

+
+
+
+

+[docs]
+class GroupVisibility(AutoNameEnum):
+    INVISIBLE_GROUP_AND_CONTROL = auto()
+    INVISIBLE_CONTROL = auto()
+    VISIBLE = auto()

+
+
+
+

+[docs]
+class ProfileMode(AutoNameEnum):
+    AUTOMATIC = auto()
+    MANUAL = auto()

+
+
+
+

+[docs]
+class AlarmSignalType(AutoNameEnum):
+    NO_ALARM = auto()
+    SILENT_ALARM = auto()
+    FULL_ALARM = auto()

+
+
+
+

+[docs]
+class ConnectionType(AutoNameEnum):
+    EXTERNAL = auto()
+    HMIP_RF = auto()
+    HMIP_WIRED = auto()
+    HMIP_LAN = auto()
+    HMIP_WLAN = auto()

+
+
+
+

+[docs]
+class DeviceArchetype(AutoNameEnum):
+    EXTERNAL = auto()
+    HMIP = auto()

+
+
+
+

+[docs]
+class DriveSpeed(AutoNameEnum):
+    CREEP_SPEED = auto()
+    SLOW_SPEED = auto()
+    NOMINAL_SPEED = auto()
+    OPTIONAL_SPEED = auto()

+
+
+
+

+[docs]
+class ShadingPackagePosition(AutoNameEnum):
+    LEFT = auto()
+    RIGHT = auto()
+    CENTER = auto()
+    SPLIT = auto()
+    TOP = auto()
+    BOTTOM = auto()
+    TDBU = auto()
+    NOT_USED = auto()

+
+
+
+

+[docs]
+class LockState(AutoNameEnum):
+    OPEN = auto()
+    UNLOCKED = auto()
+    LOCKED = auto()
+    NONE = auto()

+
+
+
+

+[docs]
+class MotorState(AutoNameEnum):
+    STOPPED = auto()
+    CLOSING = auto()
+    OPENING = auto()

+
+
+
+

+[docs]
+class OpticalSignalBehaviour(AutoNameEnum):
+    ON = auto()
+    BLINKING_MIDDLE = auto()
+    FLASH_MIDDLE = auto()
+    BILLOW_MIDDLE = auto()
+    OFF = auto()

+
+
+
+

+[docs]
+class CliActions(AutoNameEnum):
+    SET_DIM_LEVEL = auto()
+    SET_LOCK_STATE = auto()
+    SET_SHUTTER_LEVEL = auto()
+    SET_SHUTTER_STOP = auto()
+    SET_SLATS_LEVEL = auto()
+    TOGGLE_GARAGE_DOOR = auto()
+    SET_SWITCH_STATE = auto()
+    RESET_ENERGY_COUNTER = auto()
+    SEND_DOOR_COMMAND = auto()

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/base/functionalChannels.html b/_modules/homematicip/base/functionalChannels.html new file mode 100644 index 00000000..a332afc5 --- /dev/null +++ b/_modules/homematicip/base/functionalChannels.html @@ -0,0 +1,2969 @@ + + + + + + + + homematicip.base.functionalChannels — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.base.functionalChannels

+import json
+from typing import Any, Iterable
+
+from homematicip.base.enums import *
+from homematicip.base.homematicip_object import HomeMaticIPObject
+from homematicip.group import Group
+
+LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+class FunctionalChannel(HomeMaticIPObject):
+    """this is the base class for the functional channels"""
+
+    def __init__(self, device, connection):
+        super().__init__(connection)
+        self._on_channel_event_handler = []
+        self.index = -1
+        self.groupIndex = -1
+        self.label = ""
+        self.groupIndex = -1
+        self.functionalChannelType: str = ""
+        self.groups = Iterable[Group]
+        self.device = device
+        self.channelRole: str = ""
+        self._connection = None
+
+

+[docs]
+    def add_on_channel_event_handler(self, handler):
+        """Adds an event handler to the update method. Fires when a device
+        is updated."""
+        self._on_channel_event_handler.append(handler)

+
+
+

+[docs]
+    def fire_channel_event(self, *args, **kwargs):
+        """Trigger the methods tied to _on_channel_event"""
+        for _handler in self._on_channel_event_handler:
+            _handler(*args, **kwargs)

+
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        """this function will load the functional channel object
+        from a json object and the given groups
+
+        Args:
+            js(dict): the json object
+            groups(Iterable[Group]): the groups for referencing
+        """
+        self._connection = self.device._connection
+        self.index = js["index"]
+        self.groupIndex = js["groupIndex"]
+        self.label = js["label"]
+        self.set_attr_from_dict("channelRole", js)
+        self.functionalChannelType = FunctionalChannelType.from_str(
+            js["functionalChannelType"], js["functionalChannelType"]
+        )
+        self.groups = []
+        for id in js["groups"]:
+            for g in groups:
+                if g.id == id:
+                    self.groups.append(g)
+                    break
+
+        super().from_json(js)

+
+
+    def __str__(self):
+        return "{} {} Index({})".format(
+            self.functionalChannelType,
+            self.label if self.label else "unknown",
+            self.index,
+        )

+
+
+
+

+[docs]
+class DeviceBaseChannel(FunctionalChannel):
+    """this is the representative of the DEVICE_BASE channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.unreach = None
+        self.lowBat = None
+        self.routerModuleSupported = False
+        self.routerModuleEnabled = False
+        self.rssiDeviceValue = 0
+        self.rssiPeerValue = 0
+        self.dutyCycle = False
+        self.configPending = False
+        self.coProFaulty = None
+        self.coProRestartNeeded = None
+        self.coProUpdateFailure = None
+        self.deviceOverheated = None
+        self.deviceOverloaded = None
+        self.deviceUndervoltage = None
+        self.temperatureOutOfRange = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.unreach = js["unreach"]
+        self.lowBat = js["lowBat"]
+        self.routerModuleSupported = js["routerModuleSupported"]
+        self.routerModuleEnabled = js["routerModuleEnabled"]
+        self.rssiDeviceValue = js["rssiDeviceValue"]
+        self.rssiPeerValue = js["rssiPeerValue"]
+        self.dutyCycle = js["dutyCycle"]
+        self.configPending = js["configPending"]
+        sof = js["supportedOptionalFeatures"]
+        if sof:
+            if sof["IFeatureDeviceCoProError"]:
+                self.coProFaulty = js["coProFaulty"]
+            if sof["IFeatureDeviceCoProRestart"]:
+                self.coProRestartNeeded = js["coProRestartNeeded"]
+            if sof["IFeatureDeviceCoProUpdate"]:
+                self.coProUpdateFailure = js["coProUpdateFailure"]
+            if sof["IFeatureDeviceOverheated"]:
+                self.deviceOverheated = js["deviceOverheated"]
+            if sof["IFeatureDeviceOverloaded"]:
+                self.deviceOverloaded = js["deviceOverloaded"]
+            if sof["IFeatureDeviceTemperatureOutOfRange"]:
+                self.temperatureOutOfRange = js["temperatureOutOfRange"]
+            if sof["IFeatureDeviceUndervoltage"]:
+                self.deviceUndervoltage = js["deviceUndervoltage"]

+

+
+
+
+

+[docs]
+class SwitchChannel(FunctionalChannel):
+    """this is the representative of the SWITCH_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.on = False
+        self.powerUpSwitchState = ""
+        self.profileMode = None
+        self.userDesiredProfileMode = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.on = js["on"]
+        self.powerUpSwitchState = (
+            js["powerUpSwitchState"] if "powerUpSwitchState" in js else ""
+        )
+        self.profileMode = js["profileMode"]
+        self.userDesiredProfileMode = js["userDesiredProfileMode"]

+
+
+

+[docs]
+    def set_switch_state(self, on=True):
+        data = {"channelIndex": self.index, "deviceId": self.device.id, "on": on}
+        return self._rest_call("device/control/setSwitchState", body=json.dumps(data))

+
+
+

+[docs]
+    def turn_on(self):
+        return self.set_switch_state(True)

+
+
+

+[docs]
+    def turn_off(self):
+        return self.set_switch_state(False)

+
+
+

+[docs]
+    async def async_set_switch_state(self, on=True):
+        return await self._connection.api_call(*self.set_switch_state(on))

+
+
+

+[docs]
+    async def async_turn_on(self):
+        return await self.async_set_switch_state(True)

+
+
+

+[docs]
+    async def async_turn_off(self):
+        return await self.async_set_switch_state(False)

+

+
+
+
+

+[docs]
+class AccelerationSensorChannel(FunctionalChannel):
+    """this is the representative of the ACCELERATION_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float:
+        self.accelerationSensorEventFilterPeriod = 100.0
+        #:AccelerationSensorMode:
+        self.accelerationSensorMode = AccelerationSensorMode.ANY_MOTION
+        #:AccelerationSensorNeutralPosition:
+        self.accelerationSensorNeutralPosition = (
+            AccelerationSensorNeutralPosition.HORIZONTAL
+        )
+        #:AccelerationSensorSensitivity:
+        self.accelerationSensorSensitivity = (
+            AccelerationSensorSensitivity.SENSOR_RANGE_2G
+        )
+        #:int:
+        self.accelerationSensorTriggerAngle = 0
+        #:bool:
+        self.accelerationSensorTriggered = False
+        #:NotificationSoundType:
+        self.notificationSoundTypeHighToLow = NotificationSoundType.SOUND_NO_SOUND
+        #:NotificationSoundType:
+        self.notificationSoundTypeLowToHigh = NotificationSoundType.SOUND_NO_SOUND
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("accelerationSensorEventFilterPeriod", js)
+        self.set_attr_from_dict("accelerationSensorMode", js, AccelerationSensorMode)
+        self.set_attr_from_dict(
+            "accelerationSensorNeutralPosition", js, AccelerationSensorNeutralPosition
+        )
+        self.set_attr_from_dict(
+            "accelerationSensorSensitivity", js, AccelerationSensorSensitivity
+        )
+        self.set_attr_from_dict("accelerationSensorTriggerAngle", js)
+        self.set_attr_from_dict("accelerationSensorTriggered", js)
+        self.set_attr_from_dict(
+            "notificationSoundTypeHighToLow", js, NotificationSoundType
+        )
+        self.set_attr_from_dict(
+            "notificationSoundTypeLowToHigh", js, NotificationSoundType
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_mode(self, mode: AccelerationSensorMode):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorMode": str(mode),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorMode", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_mode(self, mode):
+        return await self._connection.api_call(*self.set_acceleration_sensor_mode(mode))

+
+
+

+[docs]
+    def set_acceleration_sensor_neutral_position(
+            self, neutralPosition: AccelerationSensorNeutralPosition
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorNeutralPosition": str(neutralPosition),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorNeutralPosition",
+            json.dumps(data),
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_neutral_position(
+            self, neutralPosition: AccelerationSensorNeutralPosition
+    ):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_neutral_position(neutralPosition)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_sensitivity(
+            self, sensitivity: AccelerationSensorSensitivity
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorSensitivity": str(sensitivity),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorSensitivity", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_sensitivity(
+            self, sensitivity: AccelerationSensorSensitivity
+    ):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_sensitivity(sensitivity)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_trigger_angle(self, angle: int):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorTriggerAngle": angle,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorTriggerAngle", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_trigger_angle(self, angle: int):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_trigger_angle(angle)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_event_filter_period(self, period: float):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorEventFilterPeriod": period,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorEventFilterPeriod",
+            json.dumps(data),
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_event_filter_period(self, period: float):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_event_filter_period(period)
+        )

+
+
+

+[docs]
+    def set_notification_sound_type(
+            self, soundType: NotificationSoundType, isHighToLow: bool
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "notificationSoundType": str(soundType),
+            "isHighToLow": isHighToLow,
+        }
+        return self._rest_call(
+            "device/configuration/setNotificationSoundType", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_notification_sound_type(
+            self, soundType: NotificationSoundType, isHighToLow: bool
+    ):
+        return await self._connection.api_call(
+            *self.set_notification_sound_type(soundType, isHighToLow)
+        )

+

+
+
+
+

+[docs]
+class BlindChannel(FunctionalChannel):
+    """this is the representative of the BLIND_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.blindModeActive = False
+        self.bottomToTopReferenceTime = 0.0
+        self.changeOverDelay = 0.0
+        self.delayCompensationValue = 0.0
+        self.endpositionAutoDetectionEnabled = False
+        self.previousShutterLevel = None
+        self.previousSlatsLevel = None
+        self.processing = None
+        self.profileMode = None
+        self.shutterLevel = 0.0
+        self.selfCalibrationInProgress = None
+        self.supportingDelayCompensation = None
+        self.supportingEndpositionAutoDetection = None
+        self.supportingSelfCalibration = None
+        self.slatsLevel = 0.0
+        self.slatsReferenceTime = 0.0
+        self.topToBottomReferenceTime = 0.0
+        self.userDesiredProfileMode = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.blindModeActive = js["blindModeActive"]
+        self.bottomToTopReferenceTime = js["bottomToTopReferenceTime"]
+        self.changeOverDelay = js["changeOverDelay"]
+        self.delayCompensationValue = js["delayCompensationValue"]
+        self.endpositionAutoDetectionEnabled = js["endpositionAutoDetectionEnabled"]
+        self.previousShutterLevel = js["previousShutterLevel"]
+        self.previousSlatsLevel = js["previousSlatsLevel"]
+        self.processing = js["processing"]
+        self.profileMode = js["profileMode"]
+        self.shutterLevel = js["shutterLevel"]
+        self.slatsLevel = js["slatsLevel"]
+        self.selfCalibrationInProgress = js["selfCalibrationInProgress"]
+        self.supportingDelayCompensation = js["supportingDelayCompensation"]
+        self.supportingEndpositionAutoDetection = js[
+            "supportingEndpositionAutoDetection"
+        ]
+        self.supportingSelfCalibration = js["supportingSelfCalibration"]
+        self.slatsReferenceTime = js["slatsReferenceTime"]
+        self.topToBottomReferenceTime = js["topToBottomReferenceTime"]
+        self.userDesiredProfileMode = js["userDesiredProfileMode"]

+
+
+

+[docs]
+    def set_slats_level(self, slatsLevel=0.0, shutterLevel=None):
+        """sets the slats and shutter level
+
+        Args:
+            slatsLevel(float): the new level of the slats. 0.0 = open, 1.0 = closed,
+            shutterLevel(float): the new level of the shutter. 0.0 = open, 1.0 = closed, None = use the current value
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        if shutterLevel is None:
+            shutterLevel = self.shutterLevel
+
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "slatsLevel": slatsLevel,
+            "shutterLevel": shutterLevel,
+        }
+        return self._rest_call("device/control/setSlatsLevel", json.dumps(data))

+
+
+

+[docs]
+    async def async_set_slats_level(self, slatsLevel=0.0, shutterLevel=None):
+        return await self._connection.api_call(
+            *self.set_slats_level(slatsLevel, shutterLevel)
+        )

+
+
+

+[docs]
+    def set_shutter_level(self, level=0.0):
+        """sets the shutter level
+
+        Args:
+            level(float): the new level of the shutter. 0.0 = open, 1.0 = closed
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "shutterLevel": level,
+        }
+        return self._rest_call("device/control/setShutterLevel", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_set_shutter_level(self, level=0.0):
+        return await self._connection.api_call(*self.set_shutter_level(level))

+
+
+

+[docs]
+    def stop(self):
+        """stops the current shutter operation
+
+        Returns:
+            the result of the _restCall
+        """
+        self.set_shutter_stop()

+
+
+

+[docs]
+    async def async_stop(self):
+        return self.async_set_shutter_stop()

+
+
+

+[docs]
+    def set_shutter_stop(self):
+        """stops the current operation
+        Returns:
+            the result of the _restCall
+        """
+        data = {"channelIndex": self.index, "deviceId": self.device.id}
+        return self._rest_call("device/control/stop", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_set_shutter_stop(self):
+        return await self._connection.api_call(*self.stop())

+

+
+
+
+

+[docs]
+class DeviceBaseFloorHeatingChannel(DeviceBaseChannel):
+    """this is the representative of the DEVICE_BASE_FLOOR_HEATING channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.coolingEmergencyValue = 0
+        self.frostProtectionTemperature = 0.0
+        self.heatingEmergencyValue = 0.0
+        self.minimumFloorHeatingValvePosition = 0.0
+        self.temperatureOutOfRange = False
+        self.valveProtectionDuration = 0
+        self.valveProtectionSwitchingInterval = 20
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("coolingEmergencyValue", js)
+        self.set_attr_from_dict("frostProtectionTemperature", js)
+        self.set_attr_from_dict("heatingEmergencyValue", js)
+        self.set_attr_from_dict("minimumFloorHeatingValvePosition", js)
+        self.set_attr_from_dict("temperatureOutOfRange", js)
+        self.set_attr_from_dict("valveProtectionDuration", js)
+        self.set_attr_from_dict("valveProtectionSwitchingInterval", js)

+
+
+

+[docs]
+    def set_minimum_floor_heating_valve_position(
+            self, minimumFloorHeatingValvePosition: float
+    ):
+        """sets the minimum floot heating valve position
+
+        Args:
+            minimumFloorHeatingValvePosition(float): the minimum valve position. must be between 0.0 and 1.0
+
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "minimumFloorHeatingValvePosition": minimumFloorHeatingValvePosition,
+        }
+        return self._rest_call(
+            "device/configuration/setMinimumFloorHeatingValvePosition",
+            body=json.dumps(data),
+        )

+
+
+

+[docs]
+    async def async_set_minimum_floor_heating_valve_position(
+            self, minimumFloorHeatingValvePosition: float
+    ):
+        return await self._connection.api_call(
+            *self.set_minimum_floor_heating_valve_position(
+                minimumFloorHeatingValvePosition
+            )
+        )

+

+
+
+
+

+[docs]
+class DeviceOperationLockChannel(DeviceBaseChannel):
+    """this is the representative of the DEVICE_OPERATIONLOCK channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.operationLockActive = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.operationLockActive = js["operationLockActive"]

+
+
+

+[docs]
+    def set_operation_lock(self, operationLock=True):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "operationLock": operationLock,
+        }
+        return self._rest_call("device/configuration/setOperationLock", json.dumps(data))

+
+
+

+[docs]
+    async def async_set_operation_lock(self, operationLock=True):
+        return await self._connection.api_call(*self.set_operation_lock(operationLock))

+

+
+
+
+class DeviceOperationLockChannelWithSabotage(DeviceOperationLockChannel):
+    """this is the representation of the DeviceOperationLockChannelWithSabotage channel"""
+
+    pass
+
+
+

+[docs]
+class DeviceOperationLockChannelWithSabotage(DeviceOperationLockChannel):
+    """this is the representation of the DeviceOperationLockChannelWithSabotage channel"""
+
+    pass

+
+
+
+

+[docs]
+class DimmerChannel(FunctionalChannel):
+    """this is the representative of the DIMMER_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.dimLevel = 0
+        self.profileMode = None
+        self.userDesiredProfileMode = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.dimLevel = js["dimLevel"]
+        self.profileMode = js["profileMode"]
+        self.userDesiredProfileMode = js["userDesiredProfileMode"]

+
+
+

+[docs]
+    def set_dim_level(self, dimLevel=0.0):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "dimLevel": dimLevel,
+        }
+        return self._rest_call("device/control/setDimLevel", json.dumps(data))

+
+
+

+[docs]
+    async def async_set_dim_level(self, dimLevel=0.0):
+        return await self._connection.api_call(*self.set_dim_level(dimLevel))

+

+
+
+
+

+[docs]
+class DoorChannel(FunctionalChannel):
+    """this is the representative of the DoorChannel channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.doorState = DoorState.POSITION_UNKNOWN
+        self.on = False
+        self.processing = False
+        self.ventilationPositionSupported = True
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.doorState = js["doorState"]
+        self.on = js["on"]
+        self.processing = js["processing"]
+        self.ventilationPositionSupported = js["ventilationPositionSupported"]

+
+
+

+[docs]
+    def send_door_command(self, doorCommand=DoorCommand.STOP):
+        print(
+            f"Device: {self.device.id}; Channel: {self.index}; Command: {doorCommand}"
+        )
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "doorCommand": doorCommand,
+        }
+        return self._rest_call("device/control/sendDoorCommand", json.dumps(data))

+
+
+

+[docs]
+    async def async_send_door_command(self, doorCommand=DoorCommand.STOP):
+        return await self._connection.api_call(*self.send_door_command(doorCommand))

+

+
+
+
+

+[docs]
+class DoorLockChannel(FunctionalChannel):
+    """This respresents of the DoorLockChannel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.autoRelockDelay = False
+        self.doorHandleType = "UNKNOWN"
+        self.doorLockDirection = False
+        self.doorLockNeutralPosition = False
+        self.doorLockTurns = False
+        self.lockState = LockState.UNLOCKED
+        self.motorState = MotorState.STOPPED
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.autoRelockDelay = js["autoRelockDelay"]
+        self.doorHandleType = js["doorHandleType"]
+        self.doorLockDirection = js["doorLockDirection"]
+        self.doorLockNeutralPosition = js["doorLockNeutralPosition"]
+        self.doorLockTurns = js["doorLockTurns"]
+        self.lockState = LockState.from_str(js["lockState"])
+        self.motorState = MotorState.from_str(js["motorState"])

+
+
+

+[docs]
+    def set_lock_state(self, doorLockState: LockState, pin=""):
+        """sets the door lock state
+
+        Args:
+            doorLockState(float): the state of the door. See LockState from base/enums.py
+            pin(string): Pin, if specified.
+            channelIndex(int): the channel to control. Normally the channel from DOOR_LOCK_CHANNEL is used.
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "deviceId": self.device.id,
+            "channelIndex": self.index,
+            "authorizationPin": pin,
+            "targetLockState": doorLockState,
+        }
+        return self._rest_call("device/control/setLockState", json.dumps(data))

+
+
+

+[docs]
+    async def async_set_lock_state(self, doorLockState: LockState, pin=""):
+        """sets the door lock state
+
+        Args:
+            doorLockState(float): the state of the door. See LockState from base/enums.py
+            pin(string): Pin, if specified.
+            channelIndex(int): the channel to control. Normally the channel from DOOR_LOCK_CHANNEL is used.
+        Returns:
+            the result of the _restCall
+        """
+        return await self._connection.api_call(*self.set_lock_state(doorLockState, pin))

+

+
+
+
+

+[docs]
+class EnergySensorInterfaceChannel(FunctionalChannel):
+    """EnergySensorInterfaceChannel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.connectedEnergySensorType = None
+        self.currentGasFlow = None
+        self.currentPowerConsumption = None
+        self.energyCounterOne = 0.0
+        self.energyCounterOneType = ""
+        self.energyCounterThree = 0.0
+        self.energyCounterThreeType = ""
+        self.energyCounterTwo = 0.0
+        self.energyCounterTwoType = ""
+        self.gasVolume = None
+        self.gasVolumePerImpulse = None
+        self.impulsesPerKWH = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.connectedEnergySensorType = js["connectedEnergySensorType"]
+        self.currentGasFlow = js["currentGasFlow"]
+        self.currentPowerConsumption = js["currentPowerConsumption"]
+        self.energyCounterOne = js["energyCounterOne"]
+        self.energyCounterOneType = js["energyCounterOneType"]
+        self.energyCounterThree = js["energyCounterThree"]
+        self.energyCounterThreeType = js["energyCounterThreeType"]
+        self.energyCounterTwo = js["energyCounterTwo"]
+        self.energyCounterTwoType = js["energyCounterTwoType"]
+        self.gasVolume = js["gasVolume"]
+        self.gasVolumePerImpulse = js["gasVolumePerImpulse"]
+        self.impulsesPerKWH = js["impulsesPerKWH"]

+

+
+
+
+

+[docs]
+class ImpulseOutputChannel(FunctionalChannel):
+    """this is the representation of the IMPULSE_OUTPUT_CHANNEL"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.impulseDuration = js["impulseDuration"]
+        self.processing = js["processing"]

+
+
+

+[docs]
+    def send_start_impulse(self):
+        """Toggle Wall mounted Garage Door Controller."""
+        data = {"channelIndex": self.index, "deviceId": self.device.id}
+        return self._rest_call("device/control/startImpulse", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_send_start_impulse(self):
+        return await self._connection.api_call(*self.send_start_impulse())

+

+
+
+
+

+[docs]
+class MultiModeInputChannel(FunctionalChannel):
+    """this is the representative of the MULTI_MODE_INPUT_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.binaryBehaviorType = BinaryBehaviorType.NORMALLY_OPEN
+        self.multiModeInputMode = MultiModeInputMode.BINARY_BEHAVIOR
+        self.windowState = WindowState.OPEN
+        self.doorBellSensorEventTimestamp = None
+        self.corrosionPreventionActive = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("binaryBehaviorType", js, BinaryBehaviorType)
+        self.set_attr_from_dict("multiModeInputMode", js, MultiModeInputMode)
+        self.set_attr_from_dict("windowState", js, WindowState)
+        self.set_attr_from_dict("doorBellSensorEventTimestamp", js)
+        self.set_attr_from_dict("corrosionPreventionActive", js)

+
+
+    def __str__(self):
+        return "{} binaryBehaviorType({}) channelRole({}) multiModeInputMode({}) windowState({}) doorBellSensorEventTimestamp({}) corrosionPreventionActive({})".format(
+            super().__str__(),
+            self.binaryBehaviorType,
+            self.channelRole,
+            self.multiModeInputMode,
+            self.windowState,
+            self.doorBellSensorEventTimestamp,
+            self.corrosionPreventionActive,
+        )

+
+
+
+

+[docs]
+class MultiModeInputDimmerChannel(DimmerChannel):
+    """this is the representative of the MULTI_MODE_INPUT_DIMMER_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.binaryBehaviorType = BinaryBehaviorType.NORMALLY_CLOSE
+        self.dimLevel = 0
+        self.multiModeInputMode = MultiModeInputMode.KEY_BEHAVIOR
+        self.on = False
+        self.profileMode = ProfileMode.AUTOMATIC
+        self.userDesiredProfileMode = ProfileMode.AUTOMATIC
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("binaryBehaviorType", js, BinaryBehaviorType)
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("multiModeInputMode", js, MultiModeInputMode)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("profileMode", js, ProfileMode)
+        self.set_attr_from_dict("userDesiredProfileMode", js, ProfileMode)

+

+
+
+
+

+[docs]
+class MultiModeInputSwitchChannel(SwitchChannel):
+    """this is the representative of the MULTI_MODE_INPUT_SWITCH_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.binaryBehaviorType = BinaryBehaviorType.NORMALLY_OPEN
+        self.multiModeInputMode = MultiModeInputMode.SWITCH_BEHAVIOR
+        self.on = False
+        self.profileMode = ProfileMode.MANUAL
+        self.userDesiredProfileMode = ProfileMode.MANUAL
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("binaryBehaviorType", js, BinaryBehaviorType)
+        self.set_attr_from_dict("multiModeInputMode", js, MultiModeInputMode)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("profileMode", js, ProfileMode)
+        self.set_attr_from_dict("userDesiredProfileMode", js, ProfileMode)

+

+
+
+
+

+[docs]
+class NotificationLightChannel(DimmerChannel, SwitchChannel):
+    """this is the representative of the NOTIFICATION_LIGHT_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:boolean: is the light turned on?
+        self.on = False
+        #:RGBColorState:the color of the light
+        self.simpleRGBColorState = RGBColorState.BLACK
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.on = js["on"]
+        self.simpleRGBColorState = RGBColorState.from_str(js["simpleRGBColorState"])
+
+        if "opticalSignalBehaviour" in js:
+            self.opticalSignalBehaviour = OpticalSignalBehaviour.from_str(js["opticalSignalBehaviour"])

+
+
+

+[docs]
+    def set_optical_signal(
+            self,
+            opticalSignalBehaviour: OpticalSignalBehaviour,
+            rgb: RGBColorState,
+            dimLevel=1.01,
+    ):
+        """sets the signal type for the leds
+
+        Args:
+            opticalSignalBehaviour(OpticalSignalBehaviour): LED signal behaviour
+            rgb(RGBColorState): Color
+            dimLevel(float): usally 1.01. Use set_dim_level instead
+
+        Returns:
+            Result of the _restCall
+
+        """
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "dimLevel": dimLevel,
+            "opticalSignalBehaviour": opticalSignalBehaviour,
+            "simpleRGBColorState": rgb,
+        }
+        return self._rest_call("device/control/setOpticalSignal", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_set_optical_signal(
+            self,
+            opticalSignalBehaviour: OpticalSignalBehaviour,
+            rgb: RGBColorState,
+            dimLevel=1.01,
+    ):
+        return await self._connection.api_call(
+            *self.set_optical_signal(opticalSignalBehaviour, rgb, dimLevel)
+        )

+
+
+

+[docs]
+    def set_rgb_dim_level(self, rgb: RGBColorState, dimLevel: float):
+        """sets the color and dimlevel of the lamp
+
+        Args:
+            channelIndex(int): the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex
+            rgb(RGBColorState): the color of the lamp
+            dimLevel(float): the dimLevel of the lamp. 0.0 = off, 1.0 = MAX
+
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "simpleRGBColorState": rgb,
+            "dimLevel": dimLevel,
+        }
+        return self._rest_call(
+            "device/control/setSimpleRGBColorDimLevel", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_rgb_dim_level(self, rgb: RGBColorState, dimLevel: float):
+        return await self._connection.api_call(*self.set_rgb_dim_level(rgb, dimLevel))

+
+
+

+[docs]
+    def set_rgb_dim_level_with_time(
+            self,
+            rgb: RGBColorState,
+            dimLevel: float,
+            onTime: float,
+            rampTime: float,
+    ):
+        """sets the color and dimlevel of the lamp
+
+        Args:
+            channelIndex(int): the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex
+            rgb(RGBColorState): the color of the lamp
+            dimLevel(float): the dimLevel of the lamp. 0.0 = off, 1.0 = MAX
+            onTime(float):
+            rampTime(float):
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "simpleRGBColorState": rgb,
+            "dimLevel": dimLevel,
+            "onTime": onTime,
+            "rampTime": rampTime,
+        }
+        return self._rest_call(
+            "device/control/setSimpleRGBColorDimLevelWithTime", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_rgb_dim_level_with_time(
+            self,
+            rgb: RGBColorState,
+            dimLevel: float,
+            onTime: float,
+            rampTime: float,
+    ):
+        return await self._connection.api_call(
+            *self.set_rgb_dim_level_with_time(rgb, dimLevel, onTime, rampTime)
+        )

+

+
+
+
+

+[docs]
+class ShadingChannel(FunctionalChannel):
+    """this is the representative of the SHADING_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.automationDriveSpeed = DriveSpeed.CREEP_SPEED
+        self.manualDriveSpeed = DriveSpeed.CREEP_SPEED
+        self.favoritePrimaryShadingPosition = 0.0
+        self.favoriteSecondaryShadingPosition = 0.0
+        self.primaryShadingLevel = 0.0
+        self.secondaryShadingLevel = 0.0
+        self.previousPrimaryShadingLevel = 0.0
+        self.previousSecondaryShadingLevel = 0.0
+        self.identifyOemSupported = False
+        self.productId = 0
+        self.primaryCloseAdjustable = False
+        self.primaryOpenAdjustable = False
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.primaryCloseAdjustable = False
+        self.primaryOpenAdjustable = False
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.profileMode = ProfileMode.MANUAL
+        self.userDesiredProfileMode = ProfileMode.MANUAL
+        self.processing = False
+        self.shadingDriveVersion = None
+        self.shadingPackagePosition = ShadingPackagePosition.NOT_USED
+        self.shadingPositionAdjustmentActive = None
+        self.shadingPositionAdjustmentClientId = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.set_attr_from_dict("automationDriveSpeed", js, DriveSpeed)
+        self.set_attr_from_dict("manualDriveSpeed", js, DriveSpeed)
+
+        self.set_attr_from_dict("favoritePrimaryShadingPosition", js)
+        self.set_attr_from_dict("favoriteSecondaryShadingPosition", js)
+
+        self.set_attr_from_dict("primaryCloseAdjustable", js)
+        self.set_attr_from_dict("primaryOpenAdjustable", js)
+        self.set_attr_from_dict("primaryShadingStateType", js, ShadingStateType)
+        self.set_attr_from_dict("secondaryCloseAdjustable", js)
+        self.set_attr_from_dict("secondaryOpenAdjustable", js)
+        self.set_attr_from_dict("secondaryShadingStateType", js, ShadingStateType)
+
+        self.set_attr_from_dict("primaryShadingLevel", js)
+        self.set_attr_from_dict("secondaryShadingLevel", js)
+
+        self.set_attr_from_dict("previousPrimaryShadingLevel", js)
+        self.set_attr_from_dict("previousSecondaryShadingLevel", js)
+
+        self.set_attr_from_dict("identifyOemSupported", js)
+        self.set_attr_from_dict("productId", js)
+
+        self.set_attr_from_dict("profileMode", js, ProfileMode)
+        self.set_attr_from_dict("userDesiredProfileMode", js, ProfileMode)
+
+        self.set_attr_from_dict("shadingDriveVersion", js)
+        self.set_attr_from_dict("shadingPackagePosition", js, ShadingPackagePosition)
+        self.set_attr_from_dict("shadingPositionAdjustmentActive", js)
+        self.set_attr_from_dict("shadingPositionAdjustmentClientId", js)

+
+
+

+[docs]
+    def set_primary_shading_level(self, primaryShadingLevel: float):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "primaryShadingLevel": primaryShadingLevel,
+        }
+        return self._rest_call("device/control/setPrimaryShadingLevel", json.dumps(data))

+
+
+

+[docs]
+    async def async_set_primary_shading_level(self, primaryShadingLevel: float):
+        return await self._connection.api_call(
+            *self.set_primary_shading_level(primaryShadingLevel)
+        )

+
+
+

+[docs]
+    def set_secondary_shading_level(
+            self, primaryShadingLevel: float, secondaryShadingLevel: float
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "primaryShadingLevel": primaryShadingLevel,
+            "secondaryShadingLevel": secondaryShadingLevel,
+        }
+        return self._rest_call(
+            "device/control/setSecondaryShadingLevel", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_secondary_shading_level(
+            self, primaryShadingLevel: float, secondaryShadingLevel: float
+    ):
+        return await self._connection.api_call(
+            *self.set_secondary_shading_level(
+                primaryShadingLevel, secondaryShadingLevel
+            )
+        )

+
+
+

+[docs]
+    def set_shutter_stop(self):
+        """stops the current operation
+        Returns:
+            the result of the _restCall
+        """
+        data = {"channelIndex": self.index, "deviceId": self.device.id}
+        return self._rest_call("device/control/stop", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_set_shutter_stop(self):
+        return await self._connection.api_call(*self.stop())

+

+
+
+
+

+[docs]
+class ShutterChannel(FunctionalChannel):
+    """this is the representative of the SHUTTER_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.shutterLevel = 0
+        self.changeOverDelay = 0.0
+        self.bottomToTopReferenceTime = 0.0
+        self.topToBottomReferenceTime = 0.0
+        self.delayCompensationValue = 0
+        self.endpositionAutoDetectionEnabled = False
+        self.previousShutterLevel = None
+        self.processing = False
+        self.profileMode = "AUTOMATIC"
+        self.selfCalibrationInProgress = None
+        self.supportingDelayCompensation = False
+        self.supportingEndpositionAutoDetection = False
+        self.supportingSelfCalibration = False
+        self.userDesiredProfileMode = "AUTOMATIC"
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.shutterLevel = js["shutterLevel"]
+        self.changeOverDelay = js["changeOverDelay"]
+        self.delayCompensationValue = js["delayCompensationValue"]
+        self.bottomToTopReferenceTime = js["bottomToTopReferenceTime"]
+        self.topToBottomReferenceTime = js["topToBottomReferenceTime"]
+        self.endpositionAutoDetectionEnabled = js["endpositionAutoDetectionEnabled"]
+        self.previousShutterLevel = js["previousShutterLevel"]
+        self.processing = js["processing"]
+        self.profileMode = js["profileMode"]
+        self.selfCalibrationInProgress = js["selfCalibrationInProgress"]
+        self.supportingDelayCompensation = js["supportingDelayCompensation"]
+        self.supportingEndpositionAutoDetection = js[
+            "supportingEndpositionAutoDetection"
+        ]
+        self.supportingSelfCalibration = js["supportingSelfCalibration"]
+        self.userDesiredProfileMode = js["userDesiredProfileMode"]

+
+
+    def set_shutter_level(self, level=0.0, channelIndex=1):
+        """sets the shutter level
+
+        Args:
+            level(float): the new level of the shutter. 0.0 = open, 1.0 = closed
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "shutterLevel": level,
+        }
+        return self._rest_call("device/control/setShutterLevel", body=json.dumps(data))
+
+

+[docs]
+    def set_shutter_stop(self):
+        """stops the current shutter operation
+
+        Args:
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        data = {"channelIndex": self.index, "deviceId": self.device.id}
+        return self._rest_call("device/control/stop", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_set_shutter_stop(self):
+        return await self._connection.api_call(*self.set_shutter_stop())

+
+
+

+[docs]
+    def set_shutter_level(self, level=0.0):
+        """sets the shutter level
+
+        Args:
+            level(float): the new level of the shutter. 0.0 = open, 1.0 = closed
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "shutterLevel": level,
+        }
+        return self._rest_call("device/control/setShutterLevel", body=json.dumps(data))

+
+
+

+[docs]
+    async def async_set_shutter_level(self, level=0.0):
+        return await self._connection.api_call(*self.set_shutter_level(level))

+

+
+
+
+

+[docs]
+class SwitchMeasuringChannel(SwitchChannel):
+    """this is the representative of the SWITCH_MEASURING_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.energyCounter = 0
+        self.currentPowerConsumption = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.energyCounter = js["energyCounter"]
+        self.currentPowerConsumption = js["currentPowerConsumption"]

+
+
+

+[docs]
+    def reset_energy_counter(self):
+        data = {"channelIndex": self.index, "deviceId": self.device.id}
+        return self._rest_call(
+            "device/control/resetEnergyCounter", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_reset_energy_counter(self):
+        return await self._connection.api_call(*self.reset_energy_counter())

+

+
+
+
+

+[docs]
+class TiltVibrationSensorChannel(FunctionalChannel):
+    """this is the representative of the TILT_VIBRATION_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float:
+        self.accelerationSensorEventFilterPeriod = 100.0
+        #:AccelerationSensorMode:
+        self.accelerationSensorMode = AccelerationSensorMode.ANY_MOTION
+        #:AccelerationSensorSensitivity:
+        self.accelerationSensorSensitivity = (
+            AccelerationSensorSensitivity.SENSOR_RANGE_2G
+        )
+        self.accelerationSensorNeutralPosition = None
+        #:int:
+        self.accelerationSensorTriggerAngle = 0
+        #:bool:
+        self.accelerationSensorTriggered = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict(
+            "accelerationSensorNeutralPosition", js, AccelerationSensorNeutralPosition
+        )
+        self.set_attr_from_dict("accelerationSensorEventFilterPeriod", js)
+        self.set_attr_from_dict("accelerationSensorMode", js, AccelerationSensorMode)
+        self.set_attr_from_dict(
+            "accelerationSensorSensitivity", js, AccelerationSensorSensitivity
+        )
+        self.set_attr_from_dict("accelerationSensorTriggerAngle", js)
+        self.set_attr_from_dict("accelerationSensorTriggered", js)

+
+
+

+[docs]
+    def set_acceleration_sensor_mode(self, mode: AccelerationSensorMode):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorMode": str(mode),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorMode", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_mode(self, mode: AccelerationSensorMode):
+        return await self._connection.api_call(*self.set_acceleration_sensor_mode(mode))

+
+
+

+[docs]
+    def set_acceleration_sensor_sensitivity(
+            self, sensitivity: AccelerationSensorSensitivity
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorSensitivity": str(sensitivity),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorSensitivity", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_sensitivity(
+            self, sensitivity: AccelerationSensorSensitivity
+    ):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_sensitivity(sensitivity)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_trigger_angle(self, angle: int):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorTriggerAngle": angle,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorTriggerAngle", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_trigger_angle(self, angle: int):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_trigger_angle(angle)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_event_filter_period(self, period: float):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "accelerationSensorEventFilterPeriod": period,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorEventFilterPeriod",
+            json.dumps(data),
+        )

+
+
+

+[docs]
+    async def async_set_acceleration_sensor_event_filter_period(self, period: float):
+        return await self._connection.api_call(
+            *self.set_acceleration_sensor_event_filter_period(period)
+        )

+

+
+
+
+

+[docs]
+class WallMountedThermostatProChannel(FunctionalChannel):
+    """this is the representative of the WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.display = ClimateControlDisplay.ACTUAL
+        self.setPointTemperature = 0
+        self.temperatureOffset = 0
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.temperatureOffset = js["temperatureOffset"]
+        self.setPointTemperature = js["setPointTemperature"]
+        self.display = ClimateControlDisplay.from_str(js["display"])
+        self.actualTemperature = js["actualTemperature"]
+        self.humidity = js["humidity"]
+        self.vaporAmount = js["vaporAmount"]

+
+
+

+[docs]
+    def set_display(
+            self, display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "display": str(display),
+        }
+        return self._rest_call(
+            "device/configuration/setClimateControlDisplay", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_display(
+            self, display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL
+    ):
+        return await self._connection.api_call(*self.set_display(display))

+

+
+
+
+

+[docs]
+class WaterSensorChannel(FunctionalChannel):
+    """this is the representative of the WATER_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.acousticAlarmSignal = AcousticAlarmSignal.DISABLE_ACOUSTIC_SIGNAL
+        self.acousticAlarmTiming = AcousticAlarmTiming.PERMANENT
+        self.acousticWaterAlarmTrigger = WaterAlarmTrigger.NO_ALARM
+        self.inAppWaterAlarmTrigger = WaterAlarmTrigger.NO_ALARM
+        self.moistureDetected = False
+        self.sirenWaterAlarmTrigger = WaterAlarmTrigger.NO_ALARM
+        self.waterlevelDetected = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.acousticAlarmSignal = AcousticAlarmSignal.from_str(
+            js["acousticAlarmSignal"]
+        )
+        self.acousticAlarmTiming = AcousticAlarmTiming.from_str(
+            js["acousticAlarmTiming"]
+        )
+        self.acousticWaterAlarmTrigger = WaterAlarmTrigger.from_str(
+            js["acousticWaterAlarmTrigger"]
+        )
+        self.inAppWaterAlarmTrigger = WaterAlarmTrigger.from_str(
+            js["inAppWaterAlarmTrigger"]
+        )
+        self.moistureDetected = js["moistureDetected"]
+        self.sirenWaterAlarmTrigger = WaterAlarmTrigger.from_str(
+            js["sirenWaterAlarmTrigger"]
+        )
+        self.waterlevelDetected = js["waterlevelDetected"]

+
+
+

+[docs]
+    def set_acoustic_alarm_signal(self, acousticAlarmSignal: AcousticAlarmSignal):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "acousticAlarmSignal": str(acousticAlarmSignal),
+        }
+        return self._rest_call(
+            "device/configuration/setAcousticAlarmSignal", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acoustic_alarm_signal(
+            self, acousticAlarmSignal: AcousticAlarmSignal
+    ):
+        return await self._connection.api_call(
+            *self.set_acoustic_alarm_signal(acousticAlarmSignal)
+        )

+
+
+

+[docs]
+    def set_acoustic_alarm_timing(self, acousticAlarmTiming: AcousticAlarmTiming):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "acousticAlarmTiming": str(acousticAlarmTiming),
+        }
+        return self._rest_call(
+            "device/configuration/setAcousticAlarmTiming", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acoustic_alarm_timing(
+            self, acousticAlarmTiming: AcousticAlarmTiming
+    ):
+        return await self._connection.api_call(
+            *self.set_acoustic_alarm_timing(acousticAlarmTiming)
+        )

+
+
+

+[docs]
+    def set_acoustic_water_alarm_trigger(
+            self, acousticWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "acousticWaterAlarmTrigger": str(acousticWaterAlarmTrigger),
+        }
+        return self._rest_call(
+            "device/configuration/setAcousticWaterAlarmTrigger", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_acoustic_water_alarm_trigger(
+            self, acousticWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        return await self._connection.api_call(
+            *self.set_acoustic_water_alarm_trigger(acousticWaterAlarmTrigger)
+        )

+
+
+

+[docs]
+    def set_inapp_water_alarm_trigger(self, inAppWaterAlarmTrigger: WaterAlarmTrigger):
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "inAppWaterAlarmTrigger": str(inAppWaterAlarmTrigger),
+        }
+        return self._rest_call(
+            "device/configuration/setInAppWaterAlarmTrigger", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_inapp_water_alarm_trigger(
+            self, inAppWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        return await self._connection.api_call(
+            *self.set_inapp_water_alarm_trigger(inAppWaterAlarmTrigger)
+        )

+
+
+

+[docs]
+    def set_siren_water_alarm_trigger(self, sirenWaterAlarmTrigger: WaterAlarmTrigger):
+        LOGGER.warning(
+            "set_siren_water_alarm_trigger is currently not available in the HMIP App. It might not be available in the cloud yet"
+        )
+        data = {
+            "channelIndex": self.index,
+            "deviceId": self.device.id,
+            "sirenWaterAlarmTrigger": str(sirenWaterAlarmTrigger),
+        }
+        return self._rest_call(
+            "device/configuration/setSirenWaterAlarmTrigger", json.dumps(data)
+        )

+
+
+

+[docs]
+    async def async_set_siren_water_alarm_trigger(
+            self, sirenWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        return await self._connection.api_call(
+            *self.set_siren_water_alarm_trigger(sirenWaterAlarmTrigger)
+        )

+

+
+
+
+#################
+#################
+#################
+
+
+

+[docs]
+class AccessControllerChannel(DeviceBaseChannel):
+    """this is the representative of the ACCESS_CONTROLLER_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.dutyCycleLevel = 0.0
+        self.accessPointPriority = 0
+        self.signalBrightness = 0
+        self.filteredMulticastRoutingEnabled = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("dutyCycleLevel", js)
+        self.set_attr_from_dict("accessPointPriority", js)
+        self.set_attr_from_dict("signalBrightness", js)
+        self.set_attr_from_dict("filteredMulticastRoutingEnabled", js)

+

+
+
+
+

+[docs]
+class DeviceSabotageChannel(DeviceBaseChannel):
+    """this is the representative of the DEVICE_SABOTAGE channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.sabotage = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.sabotage = js["sabotage"]

+

+
+
+
+

+[docs]
+class DeviceIncorrectPositionedChannel(DeviceBaseChannel):
+    """this is the representative of the DEVICE_INCORRECT_POSITIONED channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.incorrectPositioned = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.incorrectPositioned = js["incorrectPositioned"]

+

+
+
+
+

+[docs]
+class DevicePermanentFullRxChannel(DeviceBaseChannel):
+    """this is the representative of the DEVICE_PERMANENT_FULL_RX channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.permanentFullRx = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.permanentFullRx = js["permanentFullRx"]

+

+
+
+
+

+[docs]
+class AccessAuthorizationChannel(FunctionalChannel):
+    """this represents ACCESS_AUTHORIZATION_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.authorized = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.authorized = js["authorized"]

+

+
+
+
+

+[docs]
+class HeatingThermostatChannel(FunctionalChannel):
+    """this is the representative of the HEATING_THERMOSTAT_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float: the offset temperature for the thermostat (+/- 3.5)
+        self.temperatureOffset = 0.0
+        #:float: the current position of the valve 0.0 = closed, 1.0 max opened
+        self.valvePosition = 0.0
+        #:ValveState: the current state of the valve
+        self.valveState = ValveState.ERROR_POSITION
+        #:float: the current temperature which should be reached in the room
+        self.setPointTemperature = 0.0
+        #:float: the current measured temperature at the valve
+        self.valveActualTemperature = 0.0
+        #:bool: must the adaption re-run?
+        self.automaticValveAdaptionNeeded = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.temperatureOffset = js["temperatureOffset"]
+        self.valvePosition = js["valvePosition"]
+        self.valveState = ValveState.from_str(js["valveState"])
+        self.setPointTemperature = js["setPointTemperature"]
+        self.valveActualTemperature = js["valveActualTemperature"]

+

+
+
+
+

+[docs]
+class ShutterContactChannel(FunctionalChannel):
+    """this is the representative of the SHUTTER_CONTACT_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.windowState = WindowState.CLOSED
+        self.eventDelay = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.windowState = WindowState.from_str(js["windowState"])
+        self.eventDelay = js["eventDelay"]

+

+
+
+
+

+[docs]
+class RotaryHandleChannel(ShutterContactChannel):
+    """this is the representative of the ROTARY_HANDLE_CHANNEL channel"""

+
+
+
+

+[docs]
+class ContactInterfaceChannel(ShutterContactChannel):
+    """this is the representative of the CONTACT_INTERFACE_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.alarmContactType = AlarmContactType.WINDOW_DOOR_CONTACT
+        self.contactType = ContactType.NORMALLY_CLOSE
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.alarmContactType = AlarmContactType.from_str(js["alarmContactType"])
+        self.contactType = ContactType.from_str(js["contactType"])

+

+
+
+
+

+[docs]
+class ClimateSensorChannel(FunctionalChannel):
+    """this is the representative of the CLIMATE_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.actualTemperature = js["actualTemperature"]
+        self.humidity = js["humidity"]
+        self.vaporAmount = js["vaporAmount"]

+

+
+
+
+

+[docs]
+class DoorLockSensorChannel(FunctionalChannel):
+    """This respresents of the DoorLockSensorChannel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.doorLockDirection = False
+        self.doorLockNeutralPosition = False
+        self.doorLockTurns = False
+        self.lockState = LockState.UNLOCKED
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.doorLockDirection = js["doorLockDirection"]
+        self.doorLockNeutralPosition = js["doorLockNeutralPosition"]
+        self.doorLockTurns = js["doorLockTurns"]
+        self.lockState = LockState.from_str(js["lockState"])

+

+
+
+
+

+[docs]
+class WallMountedThermostatWithoutDisplayChannel(ClimateSensorChannel):
+    """this is the representative of the WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.temperatureOffset = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.temperatureOffset = js["temperatureOffset"]

+

+
+
+
+

+[docs]
+class AnalogRoomControlChannel(FunctionalChannel):
+    """this is the representative of the ANALOG_ROOM_CONTROL_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.actualTemperature = 0
+        self.setPointTemperature = 0
+        self.temperatureOffset = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("actualTemperature", js)
+        self.set_attr_from_dict("setPointTemperature", js)
+        self.set_attr_from_dict("temperatureOffset", js)

+

+
+
+
+

+[docs]
+class SmokeDetectorChannel(FunctionalChannel):
+    """this is the representative of the SMOKE_DETECTOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.IDLE_OFF
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.from_str(
+            js["smokeDetectorAlarmType"]
+        )

+

+
+
+
+

+[docs]
+class DeviceGlobalPumpControlChannel(DeviceBaseChannel):
+    """this is the representative of the DEVICE_GLOBAL_PUMP_CONTROL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.globalPumpControl = False
+        self.heatingValveType = HeatingValveType.NORMALLY_CLOSE
+        self.heatingLoadType = HeatingLoadType.LOAD_BALANCING
+        self.frostProtectionTemperature = 0.0
+        self.heatingEmergencyValue = 0.0
+        self.valveProtectionDuration = 0
+        self.valveProtectionSwitchingInterval = 20
+        self.coolingEmergencyValue = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.globalPumpControl = js["globalPumpControl"]
+        self.heatingValveType = HeatingValveType.from_str(js["heatingValveType"])
+        self.heatingLoadType = HeatingLoadType.from_str(js["heatingLoadType"])
+        self.coolingEmergencyValue = js["coolingEmergencyValue"]
+
+        self.frostProtectionTemperature = js["frostProtectionTemperature"]
+        self.heatingEmergencyValue = js["heatingEmergencyValue"]
+        self.valveProtectionDuration = js["valveProtectionDuration"]
+        self.valveProtectionSwitchingInterval = js["valveProtectionSwitchingInterval"]

+

+
+
+
+

+[docs]
+class MotionDetectionChannel(FunctionalChannel):
+    """this is the representative of the MOTION_DETECTION_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.currentIllumination = None
+        self.motionDetected = None
+        self.illumination = None
+        self.motionBufferActive = False
+        self.motionDetected = False
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.SECONDS_30
+        self.numberOfBrightnessMeasurements = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.motionDetected = js["motionDetected"]
+        self.illumination = js["illumination"]
+        self.motionBufferActive = js["motionBufferActive"]
+        self.motionDetected = js["motionDetected"]
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.from_str(
+            js["motionDetectionSendInterval"]
+        )
+        self.numberOfBrightnessMeasurements = js["numberOfBrightnessMeasurements"]
+        self.currentIllumination = js["currentIllumination"]

+

+
+
+
+

+[docs]
+class PresenceDetectionChannel(FunctionalChannel):
+    """this is the representative of the PRESENCE_DETECTION_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.presenceDetected = False
+        self.currentIllumination = None
+        self.illumination = 0
+        self.motionBufferActive = False
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.SECONDS_30
+        self.numberOfBrightnessMeasurements = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.presenceDetected = js["presenceDetected"]
+        self.currentIllumination = js["currentIllumination"]
+        self.illumination = js["illumination"]
+        self.motionBufferActive = js["motionBufferActive"]
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.from_str(
+            js["motionDetectionSendInterval"]
+        )
+        self.numberOfBrightnessMeasurements = js["numberOfBrightnessMeasurements"]

+

+
+
+
+

+[docs]
+class MultiModeInputBlindChannel(BlindChannel):
+    """this is the representative of the MULTI_MODE_INPUT_BLIND_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.binaryBehaviorType = BinaryBehaviorType.NORMALLY_CLOSE
+        self.multiModeInputMode = MultiModeInputMode.KEY_BEHAVIOR
+        self.favoritePrimaryShadingPosition = 0.0
+        self.favoriteSecondaryShadingPosition = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.binaryBehaviorType = BinaryBehaviorType.from_str(js["binaryBehaviorType"])
+        self.multiModeInputMode = MultiModeInputMode.from_str(js["multiModeInputMode"])
+        self.favoritePrimaryShadingPosition = js["favoritePrimaryShadingPosition"]
+        self.favoriteSecondaryShadingPosition = js["favoriteSecondaryShadingPosition"]

+

+
+
+
+

+[docs]
+class WeatherSensorChannel(FunctionalChannel):
+    """this is the representative of the WEATHER_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.vaporAmount = 0.0
+        self.illumination = 0
+        self.illuminationThresholdSunshine = 0
+        self.storm = False
+        self.sunshine = False
+        self.todaySunshineDuration = 0
+        self.totalSunshineDuration = 0
+        self.windSpeed = 0
+        self.windValueType = WindValueType.AVERAGE_VALUE
+        self.yesterdaySunshineDuration = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.actualTemperature = js["actualTemperature"]
+        self.humidity = js["humidity"]
+        self.illumination = js["illumination"]
+        self.illuminationThresholdSunshine = js["illuminationThresholdSunshine"]
+        self.storm = js["storm"]
+        self.sunshine = js["sunshine"]
+        self.todaySunshineDuration = js["todaySunshineDuration"]
+        self.totalSunshineDuration = js["totalSunshineDuration"]
+        self.windSpeed = js["windSpeed"]
+        self.windValueType = WindValueType.from_str(js["windValueType"])
+        self.yesterdaySunshineDuration = js["yesterdaySunshineDuration"]
+        self.vaporAmount = js["vaporAmount"]

+

+
+
+
+

+[docs]
+class WeatherSensorPlusChannel(WeatherSensorChannel):
+    """this is the representative of the WEATHER_SENSOR_PLUS_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.raining = False
+        self.todayRainCounter = 0
+        self.totalRainCounter = 0
+        self.yesterdayRainCounter = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.raining = js["raining"]
+        self.todayRainCounter = js["todayRainCounter"]
+        self.totalRainCounter = js["totalRainCounter"]
+        self.yesterdayRainCounter = js["yesterdayRainCounter"]

+

+
+
+
+

+[docs]
+class WeatherSensorProChannel(WeatherSensorPlusChannel):
+    """this is the representative of the WEATHER_SENSOR_PRO_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.weathervaneAlignmentNeeded = False
+        self.windDirection = 0
+        self.windDirectionVariation = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.weathervaneAlignmentNeeded = js["weathervaneAlignmentNeeded"]
+        self.windDirection = js["windDirection"]
+        self.windDirectionVariation = js["windDirectionVariation"]

+

+
+
+
+

+[docs]
+class SingleKeyChannel(FunctionalChannel):
+    """this is the representative of the SINGLE_KEY_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.acousticSendStateEnabled = None
+        self.actionParameter = None
+        self.doorBellSensorEventTimestamp = None
+        self.doublePressTime = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("acousticSendStateEnabled", js)
+        self.set_attr_from_dict("actionParameter", js)
+        self.set_attr_from_dict("doorBellSensorEventTimestamp", js)
+        self.set_attr_from_dict("doublePressTime", js)

+

+
+
+
+

+[docs]
+class AlarmSirenChannel(FunctionalChannel):
+    """this is the representative of the ALARM_SIREN_CHANNEL channel"""

+
+
+
+

+[docs]
+class FloorTeminalBlockChannel(FunctionalChannel):
+    """this is the representative of the FLOOR_TERMINAL_BLOCK_CHANNEL channel"""

+
+
+
+

+[docs]
+class FloorTerminalBlockLocalPumpChannel(FunctionalChannel):
+    """this is the representative of the FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL  channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.pumpFollowUpTime = 0
+        self.pumpLeadTime = 0
+        self.pumpProtectionDuration = 0
+        self.pumpProtectionSwitchingInterval = 20
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.pumpFollowUpTime = js["pumpFollowUpTime"]
+        self.pumpLeadTime = js["pumpLeadTime"]
+        self.pumpProtectionDuration = js["pumpProtectionDuration"]
+        self.pumpProtectionSwitchingInterval = js["pumpProtectionSwitchingInterval"]

+

+
+
+
+

+[docs]
+class HeatDemandChannel(FunctionalChannel):
+    """this is the representative of the HEAT_DEMAND_CHANNEL channel"""

+
+
+
+

+[docs]
+class DehumidifierDemandChannel(FunctionalChannel):
+    """this is the representative of the DEHUMIDIFIER_DEMAND_CHANNEL channel"""

+
+
+
+

+[docs]
+class PassageDetectorChannel(FunctionalChannel):
+    """this is the representative of the PASSAGE_DETECTOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.leftCounter = 0
+        self.leftRightCounterDelta = 0
+        self.passageBlindtime = 0.0
+        self.passageDirection = PassageDirection.RIGHT
+        self.passageSensorSensitivity = 0.0
+        self.passageTimeout = 0.0
+        self.rightCounter = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.leftCounter = js["leftCounter"]
+        self.leftRightCounterDelta = js["leftRightCounterDelta"]
+        self.passageBlindtime = js["passageBlindtime"]
+        self.passageDirection = PassageDirection.from_str(js["passageDirection"])
+        self.passageSensorSensitivity = js["passageSensorSensitivity"]
+        self.passageTimeout = js["passageTimeout"]
+        self.rightCounter = js["rightCounter"]

+

+
+
+
+

+[docs]
+class InternalSwitchChannel(FunctionalChannel):
+    """this is the representative of the INTERNAL_SWITCH_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.frostProtectionTemperature = 0
+        self.heatingValveType = HeatingValveType.NORMALLY_CLOSE
+        self.internalSwitchOutputEnabled = False
+        self.valveProtectionDuration = 0
+        self.valveProtectionSwitchingInterval = 0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.frostProtectionTemperature = js["frostProtectionTemperature"]
+        self.heatingValveType = HeatingValveType.from_str(js["heatingValveType"])
+        self.internalSwitchOutputEnabled = js["internalSwitchOutputEnabled"]
+        self.valveProtectionDuration = js["valveProtectionDuration"]
+        self.valveProtectionSwitchingInterval = js["valveProtectionSwitchingInterval"]

+
+
+    def __str__(self):
+        return "{} frostProtectionTemperature({}) heatingValveType({}) internalSwitchOutputEnabled({}) valveProtectionDuration({}) valveProtectionSwitchingInterval({})".format(
+            super().__str__(),
+            self.frostProtectionTemperature,
+            self.heatingValveType,
+            self.internalSwitchOutputEnabled,
+            self.valveProtectionDuration,
+            self.valveProtectionSwitchingInterval,
+        )

+
+
+
+

+[docs]
+class LightSensorChannel(FunctionalChannel):
+    """this is the representative of the LIGHT_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float:the average illumination value
+        self.averageIllumination = 0.0
+        #:float:the current illumination value
+        self.currentIllumination = 0.0
+        #:float:the highest illumination value
+        self.highestIllumination = 0.0
+        #:float:the lowest illumination value
+        self.lowestIllumination = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.averageIllumination = js["averageIllumination"]
+        self.currentIllumination = js["currentIllumination"]
+        self.highestIllumination = js["highestIllumination"]
+        self.lowestIllumination = js["lowestIllumination"]

+

+
+
+
+

+[docs]
+class GenericInputChannel(FunctionalChannel):
+    """this is the representative of the GENERIC_INPUT_CHANNEL channel"""

+
+
+
+

+[docs]
+class AnalogOutputChannel(FunctionalChannel):
+    """this is the representative of the ANALOG_OUTPUT_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float:the analog output level (Volt?)
+        self.analogOutputLevel = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.analogOutputLevel = js["analogOutputLevel"]

+

+
+
+
+

+[docs]
+class DeviceRechargeableWithSabotage(DeviceSabotageChannel):
+    """this is the representative of the DEVICE_RECHARGEABLE_WITH_SABOTAGE channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:bool:is the battery in a bad condition
+        self.badBatteryHealth = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("badBatteryHealth", js)

+

+
+
+
+

+[docs]
+class FloorTerminalBlockMechanicChannel(FunctionalChannel):
+    """this is the representative of the class FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL(FunctionalChannel) channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:ValveState:the current valve state
+        self.valveState = ValveState.ADAPTION_DONE
+        self.valvePosition = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("valveState", js, ValveState)
+        if "valvePosition" in js:
+            self.set_attr_from_dict("valvePosition", js)

+

+
+
+
+

+[docs]
+class ChangeOverChannel(FunctionalChannel):
+    """this is the representative of the CHANGE_OVER_CHANNEL channel"""

+
+
+
+

+[docs]
+class MainsFailureChannel(FunctionalChannel):
+    """this is the representative of the MAINS_FAILURE_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.powerMainsFailure = False
+        self.genericAlarmSignal = AlarmSignalType.NO_ALARM
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("powerMainsFailure", js)
+        self.set_attr_from_dict("genericAlarmSignal", js, AlarmSignalType)

+

+
+
+
+

+[docs]
+class UniversalActuatorChannel(FunctionalChannel):
+    """this is the representative of the UniversalActuatorChannel UNIVERSAL_ACTUATOR_CHANNEL"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.dimLevel = 0.0
+        self.on = True
+        self.profileMode = None  # String "AUTOMATIC",
+        self.relayMode = None  # "RELAY_INACTIVE"
+        self.userDesiredProfileMode = None  # "AUTOMATIC"
+        self.ventilationLevel = 0.0  # 0.35,
+        self.ventilationState = None  # "VENTILATION"
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.dimLevel = js["dimLevel"]
+        self.on = js["on"]
+        self.profileMode = js["profileMode"]
+        self.relayMode = js["relayMode"]
+        self.userDesiredProfileMode = js["userDesiredProfileMode"]
+        self.ventilationLevel = js["ventilationLevel"]
+        self.ventilationState = js["ventilationState"]

+
+
+    def __str__(self):
+        return "{} channelRole({}) dimLevel({}) ventilationLevel({}) ventilationState({}) on({}) profileMode({}) relayMode({})".format(
+            super().__str__(),
+            self.channelRole,
+            self.dimLevel,
+            self.ventilationLevel,
+            self.ventilationState,
+            self.on,
+            self.profileMode,
+            self.relayMode,
+        )

+
+
+
+

+[docs]
+class RainDetectionChannel(FunctionalChannel):
+    """this is the representative of the TILT_VIBRATION_SENSOR_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float:
+        self.rainSensorSensitivity = 0
+        #:bool:
+        self.raining = False
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("rainSensorSensitivity", js)
+        self.set_attr_from_dict("raining", js)

+

+
+
+
+

+[docs]
+class TemperatureDifferenceSensor2Channel(FunctionalChannel):
+    """this is the representative of the TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        #:float:
+        self.temperatureExternalDelta = 0.0
+        #:float:
+        self.temperatureExternalOne = 0.0
+        #:float:
+        self.temperatureExternalTwo = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("temperatureExternalDelta", js)
+        self.set_attr_from_dict("temperatureExternalOne", js)
+        self.set_attr_from_dict("temperatureExternalTwo", js)

+

+
+
+
+

+[docs]
+class ExternalBaseChannel(FunctionalChannel):
+    """this represents the EXTERNAL_BASE_CHANNEL function-channel for external devices"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)

+

+
+
+
+

+[docs]
+class ExternalUniversalLightChannel(FunctionalChannel):
+    """this represents the EXTERNAL_UNIVERSAL_LIGHT_CHANNEL function-channel for external devices"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.colorTemperature = 0
+        self.dimLevel = 0.0
+        self.hue = None
+        self.maximumColorTemperature = 0
+        self.minimalColorTemperature = 0
+        self.on = None
+        self.saturationLevel = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.set_attr_from_dict("colorTemperature", js)
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("hue", js)
+        self.set_attr_from_dict("maximumColorTemperature", js)
+        self.set_attr_from_dict("minimalColorTemperature", js)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("saturationLevel", js)

+

+
+
+
+

+[docs]
+class OpticalSignalChannel(FunctionalChannel):
+    """this class represents the OPTICAL_SIGNAL_CHANNEL"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.dimLevel = -1
+        self.on = None
+        self.opticalSignalBehaviour = None
+        self.powerUpSwitchState = None
+        self.profileMode = None
+        self.simpleRGBColorState = None
+        self.profileMode = None
+        self.userDesiredProfileMode = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("opticalSignalBehaviour", js, OpticalSignalBehaviour)
+        self.set_attr_from_dict("powerUpSwitchState", js)
+        self.set_attr_from_dict("profileMode", js)
+        self.simpleRGBColorState = RGBColorState.from_str(js["simpleRGBColorState"])
+        self.set_attr_from_dict("userDesiredProfileMode", js)

+
+
+    def __str__(self):
+        return "{} dimLevel({}) on({}) opticalSignalBehaviour({}) powerUpSwitchState({}) profileMode({}) simpleRGBColorState({}) userDesiredProfileMode({})".format(
+            super().__str__(),
+            self.dimLevel,
+            self.on,
+            self.opticalSignalBehaviour,
+            self.powerUpSwitchState,
+            self.profileMode,
+            self.simpleRGBColorState,
+            self.userDesiredProfileMode,
+        )

+
+
+
+

+[docs]
+class CarbonDioxideSensorChannel(FunctionalChannel):
+    """Representation of the CarbonDioxideSensorChannel Channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.actualTemperature = None
+        self.carbonDioxideConcentration = None
+        self.carbonDioxideVisualisationEnabled = None
+        self.humidity = None
+        self.vaporAmount = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("actualTemperature", js)
+        self.set_attr_from_dict("carbonDioxideConcentration", js)
+        self.set_attr_from_dict("carbonDioxideVisualisationEnabled", js)
+        self.set_attr_from_dict("humidity", js)
+        self.set_attr_from_dict("vaporAmount", js)

+

+
+
+
+

+[docs]
+class AccessControllerWiredChannel(DeviceBaseChannel):
+    """this is the representative of the ACCESS_CONTROLLER_WIRED_CHANNEL channel"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+        self.accessPointPriority = None
+        self.busConfigMismatch = None
+        self.busMode = None
+        self.controlsMountingOrientation = None
+        self.deviceCommunicationError = None
+        self.deviceDriveError = None
+        self.deviceDriveModeError = None
+        self.deviceOperationMode = None
+        self.devicePowerFailureDetected = None
+        self.displayContrast = None
+        self.index = None
+        self.label = None
+        self.lockJammed = None
+        self.mountingOrientation = None
+        self.multicastRoutingEnabled = None
+        self.particulateMatterSensorCommunicationError = None
+        self.particulateMatterSensorError = None
+        self.powerShortCircuit = None
+        self.powerSupplyCurrent = None
+        self.profilePeriodLimitReached = None
+        self.shortCircuitDataLine = None
+        self.signalBrightness = 0.0
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+        self.set_attr_from_dict("accessPointPriority", js)
+        self.set_attr_from_dict("busConfigMismatch", js)
+        self.set_attr_from_dict("busMode", js)
+        self.set_attr_from_dict("controlsMountingOrientation", js)
+        self.set_attr_from_dict("deviceCommunicationError", js)
+        self.set_attr_from_dict("deviceDriveError", js)
+        self.set_attr_from_dict("deviceDriveModeError", js)
+        self.set_attr_from_dict("deviceOperationMode", js)
+        self.set_attr_from_dict("devicePowerFailureDetected", js)
+        self.set_attr_from_dict("displayContrast", js)
+        self.set_attr_from_dict("index", js)
+        self.set_attr_from_dict("label", js)
+        self.set_attr_from_dict("lockJammed", js)
+        self.set_attr_from_dict("mountingOrientation", js)
+        self.set_attr_from_dict("multicastRoutingEnabled", js)
+        self.set_attr_from_dict("particulateMatterSensorCommunicationError", js)
+        self.set_attr_from_dict("particulateMatterSensorError", js)
+        self.set_attr_from_dict("powerShortCircuit", js)
+        self.set_attr_from_dict("powerSupplyCurrent", js)
+        self.set_attr_from_dict("profilePeriodLimitReached", js)
+        self.set_attr_from_dict("shortCircuitDataLine", js)
+        self.set_attr_from_dict("signalBrightness", js)

+

+
+
+
+

+[docs]
+class OpticalSignalGroupChannel(FunctionalChannel):
+    """this class represents the OPTICAL_SIGNAL_GROUP_CHANNEL"""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.dimLevel = -1
+        self.on = None
+        self.opticalSignalBehaviour = None
+        self.powerUpSwitchState = None
+        self.profileMode = None
+        self.simpleRGBColorState = None
+        self.profileMode = None
+        self.userDesiredProfileMode = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("opticalSignalBehaviour", js, OpticalSignalBehaviour)
+        self.set_attr_from_dict("powerUpSwitchState", js)
+        self.set_attr_from_dict("profileMode", js)
+        self.simpleRGBColorState = RGBColorState.from_str(js["simpleRGBColorState"])
+        self.set_attr_from_dict("userDesiredProfileMode", js)

+
+
+    def __str__(self):
+        return "{} dimLevel({}) on({}) opticalSignalBehaviour({}) powerUpSwitchState({}) profileMode({}) simpleRGBColorState({}) userDesiredProfileMode({})".format(
+            super().__str__(),
+            self.dimLevel,
+            self.on,
+            self.opticalSignalBehaviour,
+            self.powerUpSwitchState,
+            self.profileMode,
+            self.simpleRGBColorState,
+            self.userDesiredProfileMode,
+        )

+
+
+
+

+[docs]
+class UniversalLightChannel(FunctionalChannel):
+    """Represents Universal Light Channel."""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.colorTemperature: int = None
+        self.controlGearFailure: str = None
+        self.dim2WarmActive: bool = None
+        self.dimLevel: float = None
+        self.hardwareColorTemperatureColdWhite: int = None
+        self.hardwareColorTemperatureWarmWhite: int = None
+        self.hue: bool = None
+        self.humanCentricLightActive: bool = None
+        self.lampFailure: bool = None
+        self.lightSceneId: int = None
+        self.limitFailure: Any = None
+        self.maximumColorTemperature: int = None
+        self.minimalColorTemperature: int = None
+        self.on: bool = None
+        self.onMinLevel: float = None
+        self.profileMode: ProfileMode = None
+        self.saturationLevel: float = None
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.set_attr_from_dict("colorTemperature", js)
+        self.set_attr_from_dict("controlGearFailure", js)
+        self.set_attr_from_dict("dim2WarmActive", js)
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("hardwareColorTemperatureColdWhite", js)
+        self.set_attr_from_dict("hardwareColorTemperatureWarmWhite", js)
+        self.set_attr_from_dict("hue", js)
+        self.set_attr_from_dict("humanCentricLightActive", js)
+        self.set_attr_from_dict("lampFailure", js)
+        self.set_attr_from_dict("lightSceneId", js)
+        self.set_attr_from_dict("limitFailure", js)
+        self.set_attr_from_dict("maximumColorTemperature", js)
+        self.set_attr_from_dict("minimalColorTemperature", js)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("onMinLevel", js)
+        self.set_attr_from_dict("profileMode", js, ProfileMode)
+        self.set_attr_from_dict("saturationLevel", js)

+

+
+
+
+

+[docs]
+class UniversalLightChannelGroup(UniversalLightChannel):
+    """Universal-Light-Channel-Group."""
+
+    def __init__(self, device, connection):
+        super().__init__(device, connection)
+
+        self.channelSelections: list = []
+
+

+[docs]
+    def from_json(self, js, groups: Iterable[Group]):
+        super().from_json(js, groups)
+
+        self.set_attr_from_dict("channelSelections", js)

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/base/helpers.html b/_modules/homematicip/base/helpers.html new file mode 100644 index 00000000..71c064cb --- /dev/null +++ b/_modules/homematicip/base/helpers.html @@ -0,0 +1,235 @@ + + + + + + + + homematicip.base.helpers — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.base.helpers

+import codecs
+import json
+import logging
+import re
+from datetime import datetime
+
+LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+def get_functional_channel(channel_type, js):
+    for channel in js["functionalChannels"].values():
+        if channel["functionalChannelType"] == channel_type:
+            return channel
+    return None

+
+
+
+

+[docs]
+def get_functional_channels(channel_type, js):
+    result = []
+    for channel in js["functionalChannels"].values():
+        if channel["functionalChannelType"] == channel_type:
+            result.append(channel)
+    return result

+
+
+# from https://bugs.python.org/file43513/json_detect_encoding_3.patch
+

+[docs]
+def detect_encoding(b):
+    bstartswith = b.startswith
+    if bstartswith((codecs.BOM_UTF32_BE, codecs.BOM_UTF32_LE)):
+        return "utf-32"
+    if bstartswith((codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE)):
+        return "utf-16"
+    if bstartswith(codecs.BOM_UTF8):
+        return "utf-8-sig"
+
+    if len(b) >= 4:
+        if not b[0]:
+            # 00 00 -- -- - utf-32-be
+            # 00 XX -- -- - utf-16-be
+            return "utf-16-be" if b[1] else "utf-32-be"
+        if not b[1]:
+            # XX 00 00 00 - utf-32-le
+            # XX 00 XX XX - utf-16-le
+            return "utf-16-le" if b[2] or b[3] else "utf-32-le"
+    elif len(b) == 2:
+        if not b[0]:
+            # 00 XX - utf-16-be
+            return "utf-16-be"
+        if not b[1]:
+            # XX 00 - utf-16-le
+            return "utf-16-le"
+    # default
+    return "utf-8"

+
+
+
+

+[docs]
+def bytes2str(b):
+    if isinstance(b, (bytes, bytearray)):
+        return b.decode(detect_encoding(b), "surrogatepass")
+    if isinstance(b, str):
+        return b
+    raise TypeError(
+        "the object must be str, bytes or bytearray, not {!r}".format(
+            b.__class__.__name__
+        )
+    )

+
+
+
+

+[docs]
+def handle_config(json_state: str, anonymize: bool) -> str:
+    if "errorCode" in json_state:
+        LOGGER.error(
+            "Could not get the current configuration. Error: %s",
+            json_state["errorCode"],
+        )
+        return None
+    else:
+        c = json.dumps(json_state, indent=4, sort_keys=True)
+        if anonymize:
+            # generate dummy guids
+            c = anonymizeConfig(
+                c,
+                "[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}",
+                "00000000-0000-0000-0000-{0:0>12}",
+            )
+            # generate dummy SGTIN
+            c = anonymizeConfig(c, '"[A-Z0-9]{24}"', '"3014F711{0:0>16}"', flags=0)
+            # remove refresh Token
+            c = anonymizeConfig(c, '"refreshToken": ?"[^"]+"', '"refreshToken": null')
+            # location
+            c = anonymizeConfig(
+                c, '"city": ?"[^"]+"', '"city": "1010, Vienna, Austria"'
+            )
+            c = anonymizeConfig(c, '"latitude": ?"[^"]+"', '"latitude": "48.208088"')
+            c = anonymizeConfig(c, '"longitude": ?"[^"]+"', '"longitude": "16.358608"')
+
+        return c

+
+
+
+

+[docs]
+def anonymizeConfig(config, pattern, format, flags=re.IGNORECASE):
+    m = re.findall(pattern, config, flags=flags)
+    if m is None:
+        return config
+    map = {}
+    i = 0
+    for s in m:
+        if s in map.keys():
+            continue
+        map[s] = format.format(i)
+        i = i + 1
+
+    for k, v in map.items():
+        config = config.replace(k, v)
+    return config

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/client.html b/_modules/homematicip/client.html new file mode 100644 index 00000000..b63d0029 --- /dev/null +++ b/_modules/homematicip/client.html @@ -0,0 +1,146 @@ + + + + + + + + homematicip.client — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.client

+from homematicip.base.homematicip_object import HomeMaticIPObject
+from homematicip.base.enums import ClientType
+
+
+

+[docs]
+class Client(HomeMaticIPObject):
+    """A client is an app which has access to the access point.
+    e.g. smartphone, 3th party apps, google home, conrad connect
+    """
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:str: the unique id of the client
+        self.id = ""
+        #:str: a human understandable name of the client
+        self.label = ""
+        #:str: the home where the client belongs to
+        self.homeId = ""
+        #:str: the c2c service name
+        self.c2cServiceIdentifier = ""
+        #:ClientType: the type of this client
+        self.clientType = ClientType.APP
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.id = js["id"]
+        self.label = js["label"]
+        self.homeId = js["homeId"]
+        self.clientType = ClientType.from_str(js["clientType"])
+        if "c2cServiceIdentifier" in js:
+            self.c2cServiceIdentifier = js["c2cServiceIdentifier"]

+
+
+    def __str__(self):
+        return "label({})".format(self.label)

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/connection.html b/_modules/homematicip/connection.html new file mode 100644 index 00000000..e58ffb7e --- /dev/null +++ b/_modules/homematicip/connection.html @@ -0,0 +1,182 @@ + + + + + + + + homematicip.connection — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.connection

+import hashlib
+import json
+import locale
+import logging
+import platform
+
+import requests
+
+from homematicip.base.base_connection import BaseConnection, HmipThrottlingError
+
+logger = logging.getLogger(__name__)
+
+
+

+[docs]
+class Connection(BaseConnection):
+

+[docs]
+    def init(
+        self,
+        accesspoint_id,
+        lookup=True,
+        lookup_url="https://lookup.homematic.com:48335/getHost",
+        **kwargs,
+    ):
+        self.set_token_and_characteristics(accesspoint_id)
+
+        if lookup:
+            while True:
+                try:
+                    result = requests.post(
+                        lookup_url, json=self.clientCharacteristics, timeout=3
+                    )
+                    js = json.loads(result.text)
+                    self._urlREST = js["urlREST"]
+                    self._urlWebSocket = js["urlWebSocket"]
+                    break
+                except Exception as e:
+                    pass
+        else:  # pragma: no cover
+            self._urlREST = "https://ps1.homematic.com:6969"
+            self._urlWebSocket = "wss://ps1.homematic.com:8888"

+
+
+    def _rest_call(self, path, body=None):
+        result = None
+        requestPath = "{}/hmip/{}".format(self._urlREST, path)
+        logger.debug("_restcall path(%s) body(%s)", requestPath, body)
+        for i in range(0, self._restCallRequestCounter):
+            try:
+                result = requests.post(
+                    requestPath,
+                    data=body,
+                    headers=self.headers,
+                    timeout=self._restCallTimout,
+                )
+
+                # The HMIP cloud returns a 429 Error when it has received too
+                # many requests from a given client
+                if result.status_code == 429:
+                    logger.warning(f"_restcall {requestPath} returned 429 status code.")
+                    raise HmipThrottlingError
+
+                ret = result.json() if len(result.content) != 0 else ""
+                logger.debug(
+                    "_restcall result: Errorcode=%s content(%s)",
+                    result.status_code,
+                    ret,
+                )
+                return ret
+            except requests.Timeout:
+                logger.error("call to '%s' failed due Timeout", requestPath)
+                pass
+        return {"errorCode": "TIMEOUT"}

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/device.html b/_modules/homematicip/device.html new file mode 100644 index 00000000..176c6589 --- /dev/null +++ b/_modules/homematicip/device.html @@ -0,0 +1,3169 @@ + + + + + + + + homematicip.device — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.device

+# coding=utf-8
+from dataclasses import dataclass
+import json
+import logging
+from collections import Counter
+from typing import Iterable
+
+from homematicip.base.enums import *
+from homematicip.base.functionalChannels import FunctionalChannel
+from homematicip.base.helpers import get_functional_channel, get_functional_channels
+from homematicip.base.homematicip_object import HomeMaticIPObject
+from homematicip.group import Group
+
+LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+class BaseDevice(HomeMaticIPObject):
+    """Base device class. This is the foundation for homematicip and external (hue) devices"""
+
+    _supportedFeatureAttributeMap = {}
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.id = None
+        self.homeId = None
+        self.label = None
+        self.connectionType = ConnectionType.HMIP_LAN
+        self.deviceArchetype = DeviceArchetype.HMIP
+        self.lastStatusUpdate = None
+        self.firmwareVersion = None
+        self.modelType = ""
+        self.permanentlyReachable = False
+        self.functionalChannels = []
+        self.functionalChannelCount = Counter()
+        self.deviceType = None
+
+        # must be imported in init. otherwise we have cross import issues
+        from homematicip.class_maps import TYPE_FUNCTIONALCHANNEL_MAP
+
+        self._typeFunctionalChannelMap = TYPE_FUNCTIONALCHANNEL_MAP
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.id = js["id"]
+        self.homeId = js["homeId"]
+        self.label = js["label"]
+
+        self.lastStatusUpdate = self.fromtimestamp(js["lastStatusUpdate"])
+        self.firmwareVersion = js["firmwareVersion"]
+        self.modelType = js["modelType"]
+        self.permanentlyReachable = js["permanentlyReachable"]
+        self.deviceType = js["type"]
+
+        self.connectionType = ConnectionType.from_str(js["connectionType"])
+
+        if "deviceArchetype" in js:
+            self.deviceArchetype = DeviceArchetype.from_str(js["deviceArchetype"])

+
+
+

+[docs]
+    def load_functionalChannels(
+        self, groups: Iterable[Group], channels: Iterable[FunctionalChannel]
+    ):
+        """this function will load the functionalChannels into the device"""
+        for channel in self._rawJSONData["functionalChannels"].values():
+            items = [
+                ch for ch in self.functionalChannels if ch.index == channel["index"]
+            ]
+            fc = items[0] if items else None
+
+            if fc is not None:
+                fc.from_json(channel, groups)
+            else:
+                fc = self._parse_functionalChannel(channel, groups)
+                channels.append(fc)
+                self.functionalChannels.append(fc)
+
+        self.functionalChannelCount = Counter(
+            x.functionalChannelType for x in self.functionalChannels
+        )

+
+
+    def _parse_functionalChannel(self, json_state, groups: Iterable[Group]):
+        fc = None
+        try:
+            channelType = FunctionalChannelType.from_str(
+                json_state["functionalChannelType"]
+            )
+            fc = self._typeFunctionalChannelMap[channelType](self, self._connection)
+            fc.from_json(json_state, groups)
+        except:
+            fc = self._typeFunctionalChannelMap[
+                FunctionalChannelType.FUNCTIONAL_CHANNEL
+            ](self, self._connection)
+            fc.from_json(json_state, groups)
+            fc.device = self
+            LOGGER.warning(
+                "There is no class for functionalChannel '%s' yet",
+                json_state["functionalChannelType"],
+            )
+        return fc

+
+
+
+

+[docs]
+class Device(BaseDevice):
+    """this class represents a generic homematic ip device"""
+
+    _supportedFeatureAttributeMap = {
+        "IFeatureBusConfigMismatch": ["busConfigMismatch"],
+        "IFeatureDeviceCoProError": ["coProFaulty"],
+        "IFeatureDeviceCoProRestart": ["coProRestartNeeded"],
+        "IFeatureDeviceCoProUpdate": ["coProUpdateFailure"],
+        "IFeatureDeviceIdentify": [],
+        "IFeatureDeviceOverheated": ["deviceOverheated"],
+        "IFeatureDeviceOverloaded": ["deviceOverloaded"],
+        "IFeatureDeviceParticulateMatterSensorCommunicationError": "particulateMatterSensorCommunicationError",
+        "IFeatureDeviceParticulateMatterSensorError": "particulateMatterSensorError",
+        "IFeatureDevicePowerFailure": ["devicePowerFailureDetected"],
+        "IFeatureDeviceSensorCommunicationError": ["sensorCommunicationError"],
+        "IFeatureDeviceSensorError": ["sensorError"],
+        "IFeatureDeviceTemperatureHumiditySensorCommunicationError": "temperatureHumiditySensorCommunicationError",
+        "IFeatureDeviceTemperatureHumiditySensorError": "temperatureHumiditySensorError",
+        "IFeatureDeviceTemperatureOutOfRange": ["temperatureOutOfRange"],
+        "IFeatureDeviceUndervoltage": ["deviceUndervoltage"],
+        "IFeatureMinimumFloorHeatingValvePosition": ["minimumFloorHeatingValvePosition"],
+        "IFeatureMulticastRouter": ["multicastRoutingEnabled"],
+        "IFeaturePowerShortCircuit": ["powerShortCircuit"],
+        "IFeatureProfilePeriodLimit": [],
+        "IFeaturePulseWidthModulationAtLowFloorHeatingValvePosition": ["pulseWidthModulationAtLowFloorHeatingValvePositionEnabled"],
+        "IFeatureRssiValue": ["rssiDeviceValue"],
+        "IFeatureShortCircuitDataLine": ["shortCircuitDataLine"],
+        "IOptionalFeatureColorTemperature": "colorTemperature",
+        # "IOptionalFeatureColorTemperatureDim2Warm": false,
+        # "IOptionalFeatureColorTemperatureDynamicDaylight": false,
+        "IOptionalFeatureControlsMountingOrientation": ["controlsMountingOrientation"],
+        "IOptionalFeatureDeviceErrorLockJammed": ["lockJammed"],
+        "IOptionalFeatureDisplayContrast": [],
+        "IOptionalFeatureDutyCycle": ["dutyCycle"],
+        "IOptionalFeatureFilteredMulticastRouter": ["filteredMulticastRoutingEnabled"],
+        # "IOptionalFeatureHardwareColorTemperature": false,
+        # "IOptionalFeatureHueSaturationValue": false,
+        # "IOptionalFeatureLightScene": false,
+        # "IOptionalFeatureLightSceneWithShortTimes": false,
+        "IOptionalFeatureLowBat": ["lowBat"],
+        "IOptionalFeatureMountingOrientation": ["mountingOrientation"],
+    }
+
+    def __init__(self, connection):
+        super().__init__(connection)
+
+        self.updateState = DeviceUpdateState.UP_TO_DATE
+        self.availableFirmwareVersion = None
+        self.firmwareVersionInteger = (
+            0  # firmwareVersion = A.B.C -> firmwareVersionInteger ((A<<16)|(B<<8)|C)
+        )
+        self.unreach = False
+        self.lowBat = False
+        self.routerModuleSupported = False
+        self.routerModuleEnabled = False
+        self.modelId = 0
+        self.oem = ""
+        self.manufacturerCode = 0
+        self.serializedGlobalTradeItemNumber = ""
+        self.rssiDeviceValue = 0
+        self.rssiPeerValue = 0
+        self.dutyCycle = False
+        self.configPending = False
+
+        self._baseChannel = "DEVICE_BASE"
+
+        self.deviceOverheated = False
+        self.deviceOverloaded = False
+        self.deviceUndervoltage = False
+        self.temperatureOutOfRange = False
+        self.coProFaulty = False
+        self.coProRestartNeeded = False
+        self.coProUpdateFailure = False
+        self.busConfigMismatch = False
+        self.shortCircuitDataLine = False
+        self.powerShortCircuit = False
+        self.deviceUndervoltage = False
+        self.devicePowerFailureDetected = False
+        self.deviceIdentifySupported = (
+            False  # just placeholder at the moment the feature doesn't set any values
+        )
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+
+        self.updateState = DeviceUpdateState.from_str(js["updateState"])
+        self.firmwareVersionInteger = js["firmwareVersionInteger"]
+        self.availableFirmwareVersion = js["availableFirmwareVersion"]
+        self.modelId = js["modelId"]
+        self.oem = js["oem"]
+        self.manufacturerCode = js["manufacturerCode"]
+        self.serializedGlobalTradeItemNumber = js["serializedGlobalTradeItemNumber"]
+        self.liveUpdateState = LiveUpdateState.from_str(js["liveUpdateState"])
+        c = get_functional_channel(self._baseChannel, js)
+        if c:
+            self.set_attr_from_dict("lowBat", c)
+            self.set_attr_from_dict("unreach", c)
+            self.set_attr_from_dict("rssiDeviceValue", c)
+            self.set_attr_from_dict("rssiPeerValue", c)
+            self.set_attr_from_dict("configPending", c)
+            self.set_attr_from_dict("dutyCycle", c)
+            self.routerModuleSupported = c["routerModuleSupported"]
+            self.routerModuleEnabled = c["routerModuleEnabled"]
+
+            sof = c.get("supportedOptionalFeatures")
+            if sof:
+                for k, v in sof.items():
+                    if v:
+                        if k in Device._supportedFeatureAttributeMap:
+                            for attribute in Device._supportedFeatureAttributeMap[k]:
+                                self.set_attr_from_dict(attribute, c)
+                        else:  # pragma: no cover
+                            LOGGER.warning(
+                                "Optional Device Feature '%s' is not yet supported",
+                                k,
+                            )

+
+
+    def __str__(self):
+        return f"{self.modelType} {self.label} {self.str_from_attr_map()}"
+
+

+[docs]
+    def set_label(self, label):
+        data = {"deviceId": self.id, "label": label}
+        return self._rest_call("device/setDeviceLabel", json.dumps(data))

+
+
+

+[docs]
+    def is_update_applicable(self):
+        data = {"deviceId": self.id}
+        return self._rest_call("device/isUpdateApplicable", json.dumps(data))

+
+
+

+[docs]
+    def authorizeUpdate(self):
+        data = {"deviceId": self.id}
+        return self._rest_call("device/authorizeUpdate", json.dumps(data))

+
+
+

+[docs]
+    def delete(self):
+        data = {"deviceId": self.id}
+        return self._rest_call("device/deleteDevice", json.dumps(data))

+
+
+

+[docs]
+    def set_router_module_enabled(self, enabled=True):
+        if not self.routerModuleSupported:
+            return False
+        data = {"deviceId": self.id, "channelIndex": 0, "routerModuleEnabled": enabled}
+        return self._rest_call(
+            "device/configuration/setRouterModuleEnabled", json.dumps(data)
+        )

+

+
+
+
+

+[docs]
+class ExternalDevice(BaseDevice):
+    """Represents devices with archtetype EXTERNAL"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.hasCustomLabel = None
+        self.externalService = ""
+        self.supported = None
+        self._baseChannel = "EXTERNAL_BASE_CHANNEL"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+
+        self.hasCustomLabel = js["hasCustomLabel"]
+        self.externalService = js["externalService"]
+        self.supported = js["supported"]

+

+
+
+

+[docs]
+class HomeControlUnit(Device):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.dutyCycleLevel = 0.0
+        self.accessPointPriority = 0
+        self.signalBrightness = 0
+        self._baseChannel = "ACCESS_CONTROLLER_CHANNEL"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel(self._baseChannel, js)
+        if c:
+            self.set_attr_from_dict("dutyCycleLevel", c)
+            self.set_attr_from_dict("accessPointPriority", c)
+            self.set_attr_from_dict("signalBrightness", c)

+

+
+
+
+

+[docs]
+class HomeControlAccessPoint(Device):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.dutyCycleLevel = 0.0
+        self.accessPointPriority = 0
+        self.signalBrightness = 0
+        self._baseChannel = "ACCESS_CONTROLLER_CHANNEL"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel(self._baseChannel, js)
+        if c:
+            self.set_attr_from_dict("dutyCycleLevel", c)
+            self.set_attr_from_dict("accessPointPriority", c)
+            self.set_attr_from_dict("signalBrightness", c)

+

+
+
+
+

+[docs]
+class WiredDinRailAccessPoint(Device):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.accessPointPriority = 0
+        self.signalBrightness = 0
+        self._baseChannel = "ACCESS_CONTROLLER_WIRED_CHANNEL"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel(self._baseChannel, js)
+        if c:
+            self.set_attr_from_dict("accessPointPriority", c)
+            self.set_attr_from_dict("signalBrightness", c)

+

+
+
+
+

+[docs]
+class SabotageDevice(Device):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.sabotage = None
+        self._baseChannel = "DEVICE_SABOTAGE"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel(self._baseChannel, js)
+        if c:
+            self.set_attr_from_dict("sabotage", c)

+

+
+
+
+

+[docs]
+class OperationLockableDevice(Device):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.operationLockActive = None
+        self._baseChannel = "DEVICE_OPERATIONLOCK"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel(self._baseChannel, js)
+        if c:
+            self.set_attr_from_dict("operationLockActive", c)

+
+
+

+[docs]
+    def set_operation_lock(self, operationLock=True):
+        data = {"channelIndex": 0, "deviceId": self.id, "operationLock": operationLock}
+        return self._rest_call("device/configuration/setOperationLock", json.dumps(data))

+

+
+
+
+

+[docs]
+class HeatingThermostat(OperationLockableDevice):
+    """HMIP-eTRV (Radiator Thermostat)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float: the offset temperature for the thermostat (+/- 3.5)
+        self.temperatureOffset = 0.0
+        #:float: the current position of the valve 0.0 = closed, 1.0 max opened
+        self.valvePosition = 0.0
+        #:ValveState: the current state of the valve
+        self.valveState = ValveState.ERROR_POSITION
+        #:float: the current temperature which should be reached in the room
+        self.setPointTemperature = 0.0
+        #:float: the current measured temperature at the valve
+        self.valveActualTemperature = 0.0
+        #:bool: must the adaption re-run?
+        self.automaticValveAdaptionNeeded = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        automaticValveAdaptionNeeded = js["automaticValveAdaptionNeeded"]
+        c = get_functional_channel("HEATING_THERMOSTAT_CHANNEL", js)
+        if c:
+            self.temperatureOffset = c["temperatureOffset"]
+            self.valvePosition = c["valvePosition"]
+            self.valveState = ValveState.from_str(c["valveState"])
+            self.setPointTemperature = c["setPointTemperature"]
+            self.valveActualTemperature = c["valveActualTemperature"]

+
+
+    def __str__(self):
+        return "{} valvePosition({}) valveState({}) temperatureOffset({}) setPointTemperature({}) valveActualTemperature({})".format(
+            super().__str__(),
+            self.valvePosition,
+            self.valveState,
+            self.temperatureOffset,
+            self.setPointTemperature,
+            self.valveActualTemperature,
+        )

+
+
+
+

+[docs]
+class HeatingThermostatCompact(SabotageDevice):
+    """HMIP-eTRV-C (Heating-thermostat compact without display)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float: the offset temperature for the thermostat (+/- 3.5)
+        self.temperatureOffset = 0.0
+        #:float: the current position of the valve 0.0 = closed, 1.0 max opened
+        self.valvePosition = 0.0
+        #:ValveState: the current state of the valve
+        self.valveState = ValveState.ERROR_POSITION
+        #:float: the current temperature which should be reached in the room
+        self.setPointTemperature = 0.0
+        #:float: the current measured temperature at the valve
+        self.valveActualTemperature = 0.0
+        #:bool: must the adaption re-run?
+        self.automaticValveAdaptionNeeded = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        automaticValveAdaptionNeeded = js["automaticValveAdaptionNeeded"]
+        c = get_functional_channel("HEATING_THERMOSTAT_CHANNEL", js)
+        if c:
+            self.temperatureOffset = c["temperatureOffset"]
+            self.valvePosition = c["valvePosition"]
+            self.valveState = ValveState.from_str(c["valveState"])
+            self.setPointTemperature = c["setPointTemperature"]
+            self.valveActualTemperature = c["valveActualTemperature"]

+
+
+    def __str__(self):
+        return "{} valvePosition({}) valveState({}) temperatureOffset({}) setPointTemperature({}) valveActualTemperature({})".format(
+            super().__str__(),
+            self.valvePosition,
+            self.valveState,
+            self.temperatureOffset,
+            self.setPointTemperature,
+            self.valveActualTemperature,
+        )

+
+
+
+

+[docs]
+class HeatingThermostatEvo(OperationLockableDevice):
+    """HMIP-eTRV-E (Heating-thermostat new evo version)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float: the offset temperature for the thermostat (+/- 3.5)
+        self.temperatureOffset = 0.0
+        #:float: the current position of the valve 0.0 = closed, 1.0 max opened
+        self.valvePosition = 0.0
+        #:ValveState: the current state of the valve
+        self.valveState = ValveState.ERROR_POSITION
+        #:float: the current temperature which should be reached in the room
+        self.setPointTemperature = 0.0
+        #:float: the current measured temperature at the valve
+        self.valveActualTemperature = 0.0
+        #:bool: must the adaption re-run?
+        self.automaticValveAdaptionNeeded = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        automaticValveAdaptionNeeded = js["automaticValveAdaptionNeeded"]
+        c = get_functional_channel("HEATING_THERMOSTAT_CHANNEL", js)
+        if c:
+            self.temperatureOffset = c["temperatureOffset"]
+            self.valvePosition = c["valvePosition"]
+            self.valveState = ValveState.from_str(c["valveState"])
+            self.setPointTemperature = c["setPointTemperature"]
+            self.valveActualTemperature = c["valveActualTemperature"]

+
+
+    def __str__(self):
+        return "{} valvePosition({}) valveState({}) temperatureOffset({}) setPointTemperature({}) valveActualTemperature({})".format(
+            super().__str__(),
+            self.valvePosition,
+            self.valveState,
+            self.temperatureOffset,
+            self.setPointTemperature,
+            self.valveActualTemperature,
+        )

+
+
+
+

+[docs]
+class ShutterContact(SabotageDevice):
+    """HMIP-SWDO (Door / Window Contact - optical) / HMIP-SWDO-I (Door / Window Contact Invisible - optical)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windowState = WindowState.CLOSED
+        self.eventDelay = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SHUTTER_CONTACT_CHANNEL", js)
+        if c:
+            self.windowState = WindowState.from_str(c["windowState"])
+            self.eventDelay = c["eventDelay"]

+
+
+    def __str__(self):
+        return "{} windowState({})".format(super().__str__(), self.windowState)

+
+
+
+

+[docs]
+class ShutterContactMagnetic(Device):
+    """HMIP-SWDM /  HMIP-SWDM-B2  (Door / Window Contact - magnetic )"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windowState = WindowState.CLOSED
+        self.eventDelay = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SHUTTER_CONTACT_CHANNEL", js)
+        if c:
+            self.windowState = WindowState.from_str(c["windowState"])
+            self.eventDelay = c["eventDelay"]

+
+
+    def __str__(self):
+        return "{} windowState({})".format(super().__str__(), self.windowState)

+
+
+
+

+[docs]
+class ShutterContactOpticalPlus(ShutterContact):
+    """HmIP-SWDO-PL ( Window / Door Contact – optical, plus )"""

+
+
+
+

+[docs]
+class ContactInterface(SabotageDevice):
+    """HMIP-SCI (Contact Interface Sensor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windowState = WindowState.CLOSED
+        self.eventDelay = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("CONTACT_INTERFACE_CHANNEL", js)
+        if c:
+            self.windowState = WindowState.from_str(c["windowState"])
+            self.eventDelay = c["eventDelay"]

+
+
+    def __str__(self):
+        return "{} windowState({})".format(super().__str__(), self.windowState)

+
+
+
+

+[docs]
+class RotaryHandleSensor(SabotageDevice):
+    """HMIP-SRH"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windowState = WindowState.CLOSED
+        self.eventDelay = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("ROTARY_HANDLE_CHANNEL", js)
+        if c:
+            self.windowState = WindowState.from_str(c["windowState"])
+            self.eventDelay = c["eventDelay"]

+
+
+    def __str__(self):
+        return "{} windowState({})".format(super().__str__(), self.windowState)

+
+
+
+

+[docs]
+class TemperatureHumiditySensorOutdoor(Device):
+    """HMIP-STHO (Temperature and Humidity Sensor outdoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("CLIMATE_SENSOR_CHANNEL", js)
+        if c:
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.vaporAmount = c["vaporAmount"]

+
+
+    def __str__(self):
+        return "{} actualTemperature({}) humidity({}) vaporAmount({})".format(
+            super().__str__(), self.actualTemperature, self.humidity, self.vaporAmount
+        )

+
+
+
+

+[docs]
+class TemperatureHumiditySensorWithoutDisplay(Device):
+    """HMIP-STH (Temperature and Humidity Sensor without display - indoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.temperatureOffset = 0
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel(
+            "WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL", js
+        )
+        if c:
+            self.temperatureOffset = c["temperatureOffset"]
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.vaporAmount = c["vaporAmount"]

+
+
+    def __str__(self):
+        return "{} actualTemperature({}) humidity({}) vaporAmount({})".format(
+            super().__str__(), self.actualTemperature, self.humidity, self.vaporAmount
+        )

+
+
+
+

+[docs]
+class TemperatureHumiditySensorDisplay(Device):
+    """HMIP-STHD (Temperature and Humidity Sensor with display - indoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.temperatureOffset = 0
+        self.display = ClimateControlDisplay.ACTUAL
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.setPointTemperature = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL", js)
+        if c:
+            self.temperatureOffset = c["temperatureOffset"]
+            self.display = ClimateControlDisplay.from_str(c["display"])
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.setPointTemperature = c["setPointTemperature"]
+            self.vaporAmount = c["vaporAmount"]

+
+
+

+[docs]
+    def set_display(
+        self, display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL
+    ):
+        data = {"channelIndex": 1, "deviceId": self.id, "display": str(display)}
+        return self._rest_call(
+            "device/configuration/setClimateControlDisplay", json.dumps(data)
+        )

+
+
+    def __str__(self):
+        return "{} actualTemperature({}) humidity({}) vaporAmount({}) setPointTemperature({})".format(
+            super().__str__(),
+            self.actualTemperature,
+            self.humidity,
+            self.vaporAmount,
+            self.setPointTemperature,
+        )

+
+
+
+

+[docs]
+class WallMountedThermostatPro(
+    TemperatureHumiditySensorDisplay, OperationLockableDevice
+):
+    """HMIP-WTH, HMIP-WTH-2 (Wall Thermostat with Humidity Sensor) / HMIP-BWTH (Brand Wall Thermostat with Humidity Sensor)"""
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL", js)
+        if c:
+            self.temperatureOffset = c["temperatureOffset"]
+            self.display = ClimateControlDisplay.from_str(c["display"])
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.setPointTemperature = c["setPointTemperature"]

+

+
+
+
+

+[docs]
+class RoomControlDevice(WallMountedThermostatPro):
+    """ALPHA-IP-RBG    (Alpha IP Wall Thermostat Display)"""
+
+    pass

+
+
+
+

+[docs]
+class RoomControlDeviceAnalog(Device):
+    """ALPHA-IP-RBGa   (ALpha IP Wall Thermostat Display analog)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0.0
+        self.setPointTemperature = 0.0
+        self.temperatureOffset = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("ANALOG_ROOM_CONTROL_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("actualTemperature", c)
+            self.set_attr_from_dict("setPointTemperature", c)
+            self.set_attr_from_dict("temperatureOffset", c)

+

+
+
+
+

+[docs]
+class WallMountedThermostatBasicHumidity(WallMountedThermostatPro):
+    """HMIP-WTH-B (Wall Thermostat – basic)"""
+
+    pass

+
+
+
+

+[docs]
+class SmokeDetector(Device):
+    """HMIP-SWSD (Smoke Alarm with Q label)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.IDLE_OFF
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SMOKE_DETECTOR_CHANNEL", js)
+        if c:
+            self.smokeDetectorAlarmType = SmokeDetectorAlarmType.from_str(
+                c["smokeDetectorAlarmType"]
+            )

+
+
+    def __str__(self):
+        return "{} smokeDetectorAlarmType({})".format(
+            super().__str__(), self.smokeDetectorAlarmType
+        )

+
+
+
+

+[docs]
+class FloorTerminalBlock6(Device):
+    """HMIP-FAL230-C6 (Floor Heating Actuator - 6 channels, 230 V)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.globalPumpControl = False
+        self.heatingValveType = HeatingValveType.NORMALLY_CLOSE
+        self.heatingLoadType = HeatingLoadType.LOAD_BALANCING
+        self.frostProtectionTemperature = 0.0
+        self.heatingEmergencyValue = 0.0
+        self.valveProtectionDuration = 0
+        self.valveProtectionSwitchingInterval = 20
+        self.coolingEmergencyValue = 0
+
+        self.pumpFollowUpTime = 0
+        self.pumpLeadTime = 0
+        self.pumpProtectionDuration = 0
+        self.pumpProtectionSwitchingInterval = 20
+
+        self._baseChannel = "DEVICE_GLOBAL_PUMP_CONTROL"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DEVICE_GLOBAL_PUMP_CONTROL", js)
+        if c:
+            self.globalPumpControl = c["globalPumpControl"]
+            self.heatingValveType = HeatingValveType.from_str(c["heatingValveType"])
+            self.heatingLoadType = HeatingLoadType.from_str(c["heatingLoadType"])
+            self.coolingEmergencyValue = c["coolingEmergencyValue"]
+
+            self.frostProtectionTemperature = c["frostProtectionTemperature"]
+            self.heatingEmergencyValue = c["heatingEmergencyValue"]
+            self.valveProtectionDuration = c["valveProtectionDuration"]
+            self.valveProtectionSwitchingInterval = c[
+                "valveProtectionSwitchingInterval"
+            ]
+
+        c = get_functional_channel("FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL", js)
+        if c:
+            self.pumpFollowUpTime = c["pumpFollowUpTime"]
+            self.pumpLeadTime = c["pumpLeadTime"]
+            self.pumpProtectionDuration = c["pumpProtectionDuration"]
+            self.pumpProtectionSwitchingInterval = c["pumpProtectionSwitchingInterval"]

+
+
+    def __str__(self):
+        return (
+            "{} globalPumpControl({}) heatingValveType({}) heatingLoadType({}) coolingEmergencyValue({}) frostProtectionTemperature({}) heatingEmergencyValue({}) "
+            "valveProtectionDuration({}) valveProtectionSwitchingInterval({}) pumpFollowUpTime({}) pumpLeadTime({}) pumpProtectionDuration({}) "
+            "pumpProtectionSwitchingInterval({})"
+        ).format(
+            super().__str__(),
+            self.globalPumpControl,
+            self.heatingValveType,
+            self.heatingLoadType,
+            self.coolingEmergencyValue,
+            self.frostProtectionTemperature,
+            self.heatingEmergencyValue,
+            self.valveProtectionDuration,
+            self.valveProtectionSwitchingInterval,
+            self.pumpFollowUpTime,
+            self.pumpLeadTime,
+            self.pumpProtectionDuration,
+            self.pumpProtectionSwitchingInterval,
+        )

+
+
+
+

+[docs]
+class FloorTerminalBlock10(FloorTerminalBlock6):
+    """HMIP-FAL24-C10  (Floor Heating Actuator – 10x channels, 24V)"""

+
+
+
+

+[docs]
+class FloorTerminalBlock12(Device):
+    """HMIP-FALMOT-C12 (Floor Heating Actuator – 12x channels, motorised)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.frostProtectionTemperature = 0.0
+        self.valveProtectionDuration = 0
+        self.valveProtectionSwitchingInterval = 20
+        self.coolingEmergencyValue = 0
+        self.minimumFloorHeatingValvePosition = 0.0
+        self.pulseWidthModulationAtLowFloorHeatingValvePositionEnabled = False
+
+        self._baseChannel = "DEVICE_BASE_FLOOR_HEATING"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DEVICE_BASE_FLOOR_HEATING", js)
+        if c:
+            self.set_attr_from_dict("coolingEmergencyValue", c)
+            self.set_attr_from_dict("frostProtectionTemperature", c)
+            self.set_attr_from_dict("valveProtectionDuration", c)
+            self.set_attr_from_dict("valveProtectionSwitchingInterval", c)

+
+
+

+[docs]
+    def set_minimum_floor_heating_valve_position(
+        self, minimumFloorHeatingValvePosition: float
+    ):
+        """sets the minimum floot heating valve position
+
+        Args:
+            minimumFloorHeatingValvePosition(float): the minimum valve position. must be between 0.0 and 1.0
+
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": 0,
+            "deviceId": self.id,
+            "minimumFloorHeatingValvePosition": minimumFloorHeatingValvePosition,
+        }
+        return self._rest_call(
+            "device/configuration/setMinimumFloorHeatingValvePosition",
+            body=json.dumps(data),
+        )

+

+
+
+
+

+[docs]
+class WiredFloorTerminalBlock12(FloorTerminalBlock12):
+    """Implementation of HmIPW-FALMOT-C12"""

+
+
+
+

+[docs]
+class Switch(Device):
+    """Generic Switch class"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.profileMode = None
+        self.userDesiredProfileMode = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SWITCH_CHANNEL", js)
+        if c:
+            self.on = c["on"]
+            self.profileMode = c["profileMode"]
+            self.userDesiredProfileMode = c["userDesiredProfileMode"]

+
+
+    def __str__(self):
+        return "{} on({}) profileMode({}) userDesiredProfileMode({})".format(
+            super().__str__(), self.on, self.profileMode, self.userDesiredProfileMode
+        )
+
+

+[docs]
+    def set_switch_state(self, on=True, channelIndex=1):
+        data = {"channelIndex": channelIndex, "deviceId": self.id, "on": on}
+        return self._rest_call("device/control/setSwitchState", body=json.dumps(data))

+
+
+

+[docs]
+    def turn_on(self, channelIndex=1):
+        return self.set_switch_state(True, channelIndex)

+
+
+

+[docs]
+    def turn_off(self, channelIndex=1):
+        return self.set_switch_state(False, channelIndex)

+

+
+
+
+

+[docs]
+class CarbonDioxideSensor(Switch):
+    """HmIP-SCTH230"""

+
+
+
+

+[docs]
+class PlugableSwitch(Switch):
+    """HMIP-PS (Pluggable Switch), HMIP-PCBS (Switch Circuit Board - 1 channel)"""

+
+
+
+

+[docs]
+class PrintedCircuitBoardSwitchBattery(Switch):
+    """HMIP-PCBS-BAT (Printed Circuit Board Switch Battery)"""

+
+
+
+

+[docs]
+class PrintedCircuitBoardSwitch2(Switch):
+    """HMIP-PCBS2 (Switch Circuit Board - 2x channels)"""

+
+
+
+

+[docs]
+class OpenCollector8Module(Switch):
+    """HMIP-MOD-OC8 ( Open Collector Module )"""

+
+
+
+

+[docs]
+class HeatingSwitch2(Switch):
+    """HMIP-WHS2 (Switch Actuator for heating systems – 2x channels)"""

+
+
+
+

+[docs]
+class WiredInputSwitch6(Switch):
+    """HmIPW-FIO6"""

+
+
+
+

+[docs]
+class WiredSwitch8(Switch):
+    """HMIPW-DRS8 (Homematic IP Wired Switch Actuator – 8x channels)"""

+
+
+
+

+[docs]
+class WiredSwitch4(Switch):
+    """HMIPW-DRS4 (Homematic IP Wired Switch Actuator – 4x channels)"""

+
+
+
+

+[docs]
+class DinRailSwitch4(Switch):
+    """HMIP-DRSI4 (Homematic IP Switch Actuator for DIN rail mount – 4x channels)"""

+
+
+
+

+[docs]
+class BrandSwitch2(Switch):
+    """ELV-SH-BS2 (ELV Smart Home ARR-Bausatz Schaltaktor für Markenschalter – 2-fach powered by Homematic IP)"""

+
+
+
+

+[docs]
+class SwitchMeasuring(Switch):
+    """Generic class for Switch and Meter"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.energyCounter = 0
+        self.currentPowerConsumption = 0
+
+

+[docs]
+    def reset_energy_counter(self):
+        data = {"channelIndex": 1, "deviceId": self.id}
+        return self._rest_call(
+            "device/control/resetEnergyCounter", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SWITCH_MEASURING_CHANNEL", js)
+        if c:
+            self.on = c["on"]
+            self.energyCounter = c["energyCounter"]
+            self.currentPowerConsumption = c["currentPowerConsumption"]
+            self.profileMode = c["profileMode"]
+            self.userDesiredProfileMode = c["userDesiredProfileMode"]

+
+
+    def __str__(self):
+        return "{} energyCounter({}) currentPowerConsumption({}W)".format(
+            super().__str__(), self.energyCounter, self.currentPowerConsumption
+        )

+
+
+
+

+[docs]
+class MultiIOBox(Switch):
+    """HMIP-MIOB (Multi IO Box for floor heating & cooling)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.analogOutputLevel = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("ANALOG_OUTPUT_CHANNEL", js)
+        if c:
+            self.analogOutputLevel = c["analogOutputLevel"]

+
+
+    def __str__(self):
+        return "{} analogOutputLevel({})".format(
+            super().__str__(), self.analogOutputLevel
+        )

+
+
+
+

+[docs]
+class DoorBellContactInterface(Device):
+    """HMIP-DSD-PCB (Door Bell Contact Interface)"""

+
+
+
+

+[docs]
+class BrandSwitchNotificationLight(Switch):
+    """HMIP-BSL (Switch Actuator for brand switches – with signal lamp)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:int:the channel number for the top light
+        self.topLightChannelIndex = 2
+        #:int:the channel number for the bottom light
+        self.bottomLightChannelIndex = 3
+
+    def __str__(self):
+        top = self.functionalChannels[self.topLightChannelIndex]
+        bottom = self.functionalChannels[self.bottomLightChannelIndex]
+        return (
+            "{} topDimLevel({}) topColor({}) bottomDimLevel({}) bottomColor({})".format(
+                super().__str__(),
+                top.dimLevel,
+                top.simpleRGBColorState,
+                bottom.dimLevel,
+                bottom.simpleRGBColorState,
+            )
+        )
+
+

+[docs]
+    def set_rgb_dim_level(self, channelIndex: int, rgb: RGBColorState, dimLevel: float):
+        """sets the color and dimlevel of the lamp
+
+        Args:
+            channelIndex(int): the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex
+            rgb(RGBColorState): the color of the lamp
+            dimLevel(float): the dimLevel of the lamp. 0.0 = off, 1.0 = MAX
+
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "simpleRGBColorState": rgb,
+            "dimLevel": dimLevel,
+        }
+        return self._rest_call(
+            "device/control/setSimpleRGBColorDimLevel", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_rgb_dim_level_with_time(
+        self,
+        channelIndex: int,
+        rgb: RGBColorState,
+        dimLevel: float,
+        onTime: float,
+        rampTime: float,
+    ):
+        """sets the color and dimlevel of the lamp
+
+        Args:
+            channelIndex(int): the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex
+            rgb(RGBColorState): the color of the lamp
+            dimLevel(float): the dimLevel of the lamp. 0.0 = off, 1.0 = MAX
+            onTime(float):
+            rampTime(float):
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "simpleRGBColorState": rgb,
+            "dimLevel": dimLevel,
+            "onTime": onTime,
+            "rampTime": rampTime,
+        }
+        return self._rest_call(
+            "device/control/setSimpleRGBColorDimLevelWithTime", body=json.dumps(data)
+        )

+

+
+
+
+

+[docs]
+class PlugableSwitchMeasuring(SwitchMeasuring):
+    """HMIP-PSM (Pluggable Switch and Meter)"""

+
+
+
+

+[docs]
+class BrandSwitchMeasuring(SwitchMeasuring):
+    """HMIP-BSM (Brand Switch and Meter)"""

+
+
+
+

+[docs]
+class FullFlushSwitchMeasuring(SwitchMeasuring):
+    """HMIP-FSM, HMIP-FSM16 (Full flush Switch and Meter)"""

+
+
+
+

+[docs]
+class PushButton(Device):
+    """HMIP-WRC2 (Wall-mount Remote Control - 2-button)"""

+
+
+
+

+[docs]
+class DoorBellButton(PushButton):
+    """HmIP-DBB"""

+
+
+
+

+[docs]
+class PushButton6(PushButton):
+    """HMIP-WRC6 (Wall-mount Remote Control - 6-button)"""

+
+
+
+

+[docs]
+class PushButtonFlat(PushButton):
+    """HmIP-WRCC2 (Wall-mount Remote Control – flat)"""

+
+
+
+

+[docs]
+class BrandPushButton(PushButton):
+    """HMIP-BRC2 (Remote Control for brand switches – 2x channels)"""

+
+
+
+

+[docs]
+class KeyRemoteControl4(PushButton):
+    """HMIP-KRC4 (Key Ring Remote Control - 4 buttons)"""

+
+
+
+

+[docs]
+class RemoteControl8(PushButton):
+    """HMIP-RC8 (Remote Control - 8 buttons)"""

+
+
+
+

+[docs]
+class RemoteControl8Module(RemoteControl8):
+    """HMIP-MOD-RC8 (Open Collector Module Sender - 8x)"""

+
+
+
+

+[docs]
+class RgbwDimmer(Device):
+    """HmIP-RGBW"""
+
+    fastColorChangeSupported: bool = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+
+        self.set_attr_from_dict("fastColorChangeSupported", js)

+

+
+
+
+

+[docs]
+class AlarmSirenIndoor(SabotageDevice):
+    """HMIP-ASIR (Alarm Siren)"""
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("ALARM_SIREN_CHANNEL", js)
+        if c:
+            # The ALARM_SIREN_CHANNEL doesn't have any values yet.
+            pass

+

+
+
+
+

+[docs]
+class AlarmSirenOutdoor(AlarmSirenIndoor):
+    """HMIP-ASIR-O (Alarm Siren Outdoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.badBatteryHealth = False
+        self._baseChannel = "DEVICE_RECHARGEABLE_WITH_SABOTAGE"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DEVICE_RECHARGEABLE_WITH_SABOTAGE", js)
+        if c:
+            self.set_attr_from_dict("badBatteryHealth", c)

+

+
+
+
+

+[docs]
+class MotionDetectorIndoor(SabotageDevice):
+    """HMIP-SMI (Motion Detector with Brightness Sensor - indoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.currentIllumination = None
+        self.motionDetected = None
+        self.illumination = None
+        self.motionBufferActive = False
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.SECONDS_30
+        self.numberOfBrightnessMeasurements = 0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("MOTION_DETECTION_CHANNEL", js)
+        if c:
+            self.motionDetected = c["motionDetected"]
+            self.illumination = c["illumination"]
+            self.motionBufferActive = c["motionBufferActive"]
+            self.motionDetectionSendInterval = MotionDetectionSendInterval.from_str(
+                c["motionDetectionSendInterval"]
+            )
+            self.numberOfBrightnessMeasurements = c["numberOfBrightnessMeasurements"]
+            self.currentIllumination = c["currentIllumination"]

+
+
+    def __str__(self):
+        return "{} motionDetected({}) illumination({}) motionBufferActive({}) motionDetectionSendInterval({}) numberOfBrightnessMeasurements({})".format(
+            super().__str__(),
+            self.motionDetected,
+            self.illumination,
+            self.motionBufferActive,
+            self.motionDetectionSendInterval,
+            self.numberOfBrightnessMeasurements,
+        )

+
+
+
+

+[docs]
+class MotionDetectorOutdoor(Device):
+    """HMIP-SMO-A (Motion Detector with Brightness Sensor - outdoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.currentIllumination = None
+        self.motionDetected = None
+        self.illumination = None
+        self.motionBufferActive = False
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.SECONDS_30
+        self.numberOfBrightnessMeasurements = 0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("MOTION_DETECTION_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("motionDetected", c)
+            self.set_attr_from_dict("illumination", c)
+            self.set_attr_from_dict("motionBufferActive", c)
+            self.set_attr_from_dict("motionDetectionSendInterval", c)
+            self.set_attr_from_dict("numberOfBrightnessMeasurements", c)
+            self.set_attr_from_dict("currentIllumination", c)

+

+
+
+
+

+[docs]
+class MotionDetectorPushButton(MotionDetectorOutdoor):
+    """HMIP-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2-button)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self._baseChannel = "DEVICE_PERMANENT_FULL_RX"
+        self.permanentFullRx = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DEVICE_PERMANENT_FULL_RX", js)
+        if c:
+            self.set_attr_from_dict("permanentFullRx", c)

+

+
+
+
+

+[docs]
+class WiredMotionDetectorPushButton(MotionDetectorOutdoor):
+    """HmIPW-SMI55"""

+
+
+
+

+[docs]
+class PresenceDetectorIndoor(SabotageDevice):
+    """HMIP-SPI (Presence Sensor - indoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.presenceDetected = False
+        self.currentIllumination = None
+        self.illumination = 0
+        self.motionBufferActive = False
+        self.motionDetectionSendInterval = MotionDetectionSendInterval.SECONDS_30
+        self.numberOfBrightnessMeasurements = 0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("PRESENCE_DETECTION_CHANNEL", js)
+        if c:
+            self.presenceDetected = c["presenceDetected"]
+            self.currentIllumination = c["currentIllumination"]
+            self.illumination = c["illumination"]
+            self.motionBufferActive = c["motionBufferActive"]
+            self.motionDetectionSendInterval = MotionDetectionSendInterval.from_str(
+                c["motionDetectionSendInterval"]
+            )
+            self.numberOfBrightnessMeasurements = c["numberOfBrightnessMeasurements"]

+
+
+    def __str__(self):
+        return "{} presenceDetected({}) illumination({}) motionBufferActive({}) motionDetectionSendInterval({}) numberOfBrightnessMeasurements({})".format(
+            super().__str__(),
+            self.presenceDetected,
+            self.illumination,
+            self.motionBufferActive,
+            self.motionDetectionSendInterval,
+            self.numberOfBrightnessMeasurements,
+        )

+
+
+
+

+[docs]
+class PassageDetector(SabotageDevice):
+    """HMIP-SPDR (Passage Detector)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.leftCounter = 0
+        self.leftRightCounterDelta = 0
+        self.passageBlindtime = 0.0
+        self.passageDirection = PassageDirection.RIGHT
+        self.passageSensorSensitivity = 0.0
+        self.passageTimeout = 0.0
+        self.rightCounter = 0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("PASSAGE_DETECTOR_CHANNEL", js)
+        if c:
+            self.leftCounter = c["leftCounter"]
+            self.leftRightCounterDelta = c["leftRightCounterDelta"]
+            self.passageBlindtime = c["passageBlindtime"]
+            self.passageDirection = PassageDirection.from_str(c["passageDirection"])
+            self.passageSensorSensitivity = c["passageSensorSensitivity"]
+            self.passageTimeout = c["passageTimeout"]
+            self.rightCounter = c["rightCounter"]

+
+
+    def __str__(self):
+        return "{} leftCounter({}) leftRightCounterDelta({}) passageBlindtime({}) passageDirection({}) passageSensorSensitivity({}) passageTimeout({}) rightCounter({})".format(
+            super().__str__(),
+            self.leftCounter,
+            self.leftRightCounterDelta,
+            self.passageBlindtime,
+            self.passageDirection,
+            self.passageSensorSensitivity,
+            self.passageTimeout,
+            self.rightCounter,
+        )

+
+
+
+

+[docs]
+class KeyRemoteControlAlarm(Device):
+    """HMIP-KRCA (Key Ring Remote Control - alarm)"""

+
+
+
+

+[docs]
+class Shutter(Device):
+    """Base class for shutter devices"""
+
+

+[docs]
+    def set_shutter_level(self, level=0.0, channelIndex=1):
+        """sets the shutter level
+
+        Args:
+            level(float): the new level of the shutter. 0.0 = open, 1.0 = closed
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "shutterLevel": level,
+        }
+        return self._rest_call("device/control/setShutterLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_shutter_stop(self, channelIndex=1):
+        """stops the current shutter operation
+
+        Args:
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        data = {"channelIndex": channelIndex, "deviceId": self.id}
+        return self._rest_call("device/control/stop", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class Blind(Shutter):
+    """Base class for blind devices"""
+
+

+[docs]
+    def set_slats_level(self, slatsLevel=0.0, shutterLevel=None, channelIndex=1):
+        """sets the slats and shutter level
+
+        Args:
+            slatsLevel(float): the new level of the slats. 0.0 = open, 1.0 = closed,
+            shutterLevel(float): the new level of the shutter. 0.0 = open, 1.0 = closed, None = use the current value
+            channelIndex(int): the channel to control
+        Returns:
+            the result of the _restCall
+        """
+        if shutterLevel is None:
+            shutterLevel = self.functionalChannels[channelIndex].shutterLevel
+
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "slatsLevel": slatsLevel,
+            "shutterLevel": shutterLevel,
+        }
+        return self._rest_call("device/control/setSlatsLevel", json.dumps(data))

+

+
+
+
+

+[docs]
+class FullFlushShutter(Shutter):
+    """HMIP-FROLL (Shutter Actuator - flush-mount) / HMIP-BROLL (Shutter Actuator - Brand-mount)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.shutterLevel = 0
+        self.changeOverDelay = 0.0
+        self.bottomToTopReferenceTime = 0.0
+        self.topToBottomReferenceTime = 0.0
+        self.delayCompensationValue = 0
+        self.endpositionAutoDetectionEnabled = False
+        self.previousShutterLevel = None
+        self.processing = False
+        self.profileMode = "AUTOMATIC"
+        self.selfCalibrationInProgress = None
+        self.supportingDelayCompensation = False
+        self.supportingEndpositionAutoDetection = False
+        self.supportingSelfCalibration = False
+        self.userDesiredProfileMode = "AUTOMATIC"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SHUTTER_CHANNEL", js)
+        if c:
+            self.shutterLevel = c["shutterLevel"]
+            self.changeOverDelay = c["changeOverDelay"]
+            self.delayCompensationValue = c["delayCompensationValue"]
+            self.bottomToTopReferenceTime = c["bottomToTopReferenceTime"]
+            self.topToBottomReferenceTime = c["topToBottomReferenceTime"]
+            self.endpositionAutoDetectionEnabled = c["endpositionAutoDetectionEnabled"]
+            self.previousShutterLevel = c["previousShutterLevel"]
+            self.processing = c["processing"]
+            self.profileMode = c["profileMode"]
+            self.selfCalibrationInProgress = c["selfCalibrationInProgress"]
+            self.supportingDelayCompensation = c["supportingDelayCompensation"]
+            self.supportingEndpositionAutoDetection = c[
+                "supportingEndpositionAutoDetection"
+            ]
+            self.supportingSelfCalibration = c["supportingSelfCalibration"]
+            self.userDesiredProfileMode = c["userDesiredProfileMode"]

+
+
+    def __str__(self):
+        return "{} shutterLevel({}) topToBottom({}) bottomToTop({})".format(
+            super().__str__(),
+            self.shutterLevel,
+            self.topToBottomReferenceTime,
+            self.bottomToTopReferenceTime,
+        )

+
+
+
+

+[docs]
+class FullFlushBlind(FullFlushShutter, Blind):
+    """HMIP-FBL (Blind Actuator - flush-mount)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.slatsLevel = 0
+        self.slatsReferenceTime = 0.0
+        self.previousSlatsLevel = 0
+        self.blindModeActive = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("BLIND_CHANNEL", js)
+        if c:
+            self.shutterLevel = c["shutterLevel"]
+            self.changeOverDelay = c["changeOverDelay"]
+            self.delayCompensationValue = c["delayCompensationValue"]
+            self.bottomToTopReferenceTime = c["bottomToTopReferenceTime"]
+            self.topToBottomReferenceTime = c["topToBottomReferenceTime"]
+            self.endpositionAutoDetectionEnabled = c["endpositionAutoDetectionEnabled"]
+            self.previousShutterLevel = c["previousShutterLevel"]
+            self.processing = c["processing"]
+            self.profileMode = c["profileMode"]
+            self.selfCalibrationInProgress = c["selfCalibrationInProgress"]
+            self.supportingDelayCompensation = c["supportingDelayCompensation"]
+            self.supportingEndpositionAutoDetection = c[
+                "supportingEndpositionAutoDetection"
+            ]
+            self.supportingSelfCalibration = c["supportingSelfCalibration"]
+            self.userDesiredProfileMode = c["userDesiredProfileMode"]
+
+            self.slatsLevel = c["slatsLevel"]
+            self.slatsReferenceTime = c["slatsReferenceTime"]
+            self.previousSlatsLevel = c["previousSlatsLevel"]
+            self.blindModeActive = c["blindModeActive"]

+
+
+    def __str__(self):
+        return "{} slatsLevel({}) blindModeActive({})".format(
+            super().__str__(), self.slatsLevel, self.blindModeActive
+        )

+
+
+
+

+[docs]
+class BrandBlind(FullFlushBlind):
+    """HMIP-BBL (Blind Actuator for brand switches)"""

+
+
+
+

+[docs]
+class DinRailBlind4(Blind):
+    """HmIP-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)"""

+
+
+
+

+[docs]
+class WiredDinRailBlind4(Blind):
+    """HmIPW-DRBL4"""

+
+
+
+

+[docs]
+class WiredPushButton(PushButton):
+    """HmIPW-WRC6 and HmIPW-WRC2"""
+
+

+[docs]
+    def set_optical_signal(
+        self,
+        channelIndex,
+        opticalSignalBehaviour: OpticalSignalBehaviour,
+        rgb: RGBColorState,
+        dimLevel=1.01,
+    ):
+        """sets the signal type for the leds
+
+        Args:
+            channelIndex(int): Channel which is affected
+            opticalSignalBehaviour(OpticalSignalBehaviour): LED signal behaviour
+            rgb(RGBColorState): Color
+            dimLevel(float): usally 1.01. Use set_dim_level instead
+
+        Returns:
+            Result of the _restCall
+
+        """
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "dimLevel": dimLevel,
+            "opticalSignalBehaviour": opticalSignalBehaviour,
+            "simpleRGBColorState": rgb,
+        }
+        return self._rest_call("device/control/setOpticalSignal", body=json.dumps(data))

+
+
+

+[docs]
+    def set_dim_level(self, channelIndex, dimLevel):
+        """sets the signal type for the leds
+        Args:
+            channelIndex(int): Channel which is affected
+            dimLevel(float): usally 1.01. Use set_dim_level instead
+
+        Returns:
+            Result of the _restCall
+
+        """
+        data = {"channelIndex": channelIndex, "deviceId": self.id, "dimLevel": dimLevel}
+        return self._rest_call("device/control/setDimLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_switch_state(self, on, channelIndex):
+        data = {"channelIndex": channelIndex, "deviceId": self.id, "on": on}
+        return self._rest_call("device/control/setSwitchState", body=json.dumps(data))

+
+
+

+[docs]
+    def turn_on(self, channelIndex):
+        return self.set_switch_state(True, channelIndex)

+
+
+

+[docs]
+    def turn_off(self, channelIndex):
+        return self.set_switch_state(False, channelIndex)

+

+
+
+
+

+[docs]
+class BlindModule(Device):
+    """HMIP-HDM1 (Hunter Douglas & erfal window blinds)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.automationDriveSpeed = DriveSpeed.CREEP_SPEED
+        self.manualDriveSpeed = DriveSpeed.CREEP_SPEED
+        self.favoritePrimaryShadingPosition = 0.0
+        self.favoriteSecondaryShadingPosition = 0.0
+        self.primaryShadingLevel = 0.0
+        self.secondaryShadingLevel = 0.0
+        self.previousPrimaryShadingLevel = 0.0
+        self.previousSecondaryShadingLevel = 0.0
+        self.identifyOemSupported = False
+        self.productId = 0
+        self.primaryCloseAdjustable = False
+        self.primaryOpenAdjustable = False
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.primaryCloseAdjustable = False
+        self.primaryOpenAdjustable = False
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.profileMode = ProfileMode.MANUAL
+        self.userDesiredProfileMode = ProfileMode.MANUAL
+        self.processing = False
+        self.shadingDriveVersion = None
+        self.shadingPackagePosition = ShadingPackagePosition.NOT_USED
+        self.shadingPositionAdjustmentActive = None
+        self.shadingPositionAdjustmentClientId = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("SHADING_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("automationDriveSpeed", c, DriveSpeed)
+            self.set_attr_from_dict("manualDriveSpeed", c, DriveSpeed)
+
+            self.set_attr_from_dict("favoritePrimaryShadingPosition", c)
+            self.set_attr_from_dict("favoriteSecondaryShadingPosition", c)
+
+            self.set_attr_from_dict("primaryCloseAdjustable", c)
+            self.set_attr_from_dict("primaryOpenAdjustable", c)
+            self.set_attr_from_dict("primaryShadingStateType", c, ShadingStateType)
+            self.set_attr_from_dict("secondaryCloseAdjustable", c)
+            self.set_attr_from_dict("secondaryOpenAdjustable", c)
+            self.set_attr_from_dict("secondaryShadingStateType", c, ShadingStateType)
+
+            self.set_attr_from_dict("primaryShadingLevel", c)
+            self.set_attr_from_dict("secondaryShadingLevel", c)
+
+            self.set_attr_from_dict("previousPrimaryShadingLevel", c)
+            self.set_attr_from_dict("previousSecondaryShadingLevel", c)
+
+            self.set_attr_from_dict("identifyOemSupported", c)
+            self.set_attr_from_dict("productId", c)
+
+            self.set_attr_from_dict("profileMode", c, ProfileMode)
+            self.set_attr_from_dict("userDesiredProfileMode", c, ProfileMode)
+
+            self.set_attr_from_dict("shadingDriveVersion", c)
+            self.set_attr_from_dict("shadingPackagePosition", c, ShadingPackagePosition)
+            self.set_attr_from_dict("shadingPositionAdjustmentActive", c)
+            self.set_attr_from_dict("shadingPositionAdjustmentClientId", c)

+
+
+

+[docs]
+    def set_primary_shading_level(self, primaryShadingLevel: float):
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "primaryShadingLevel": primaryShadingLevel,
+        }
+        return self._rest_call("device/control/setPrimaryShadingLevel", json.dumps(data))

+
+
+

+[docs]
+    def set_secondary_shading_level(
+        self, primaryShadingLevel: float, secondaryShadingLevel: float
+    ):
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "primaryShadingLevel": primaryShadingLevel,
+            "secondaryShadingLevel": secondaryShadingLevel,
+        }
+        return self._rest_call(
+            "device/control/setSecondaryShadingLevel", json.dumps(data)
+        )

+
+
+

+[docs]
+    def stop(self):
+        """stops the current operation
+        Returns:
+            the result of the _restCall
+        """
+        data = {"channelIndex": 1, "deviceId": self.id}
+        return self._rest_call("device/control/stop", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class LightSensor(Device):
+    """HMIP-SLO (Light Sensor outdoor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float:the average illumination value
+        self.averageIllumination = 0.0
+        #:float:the current illumination value
+        self.currentIllumination = 0.0
+        #:float:the highest illumination value
+        self.highestIllumination = 0.0
+        #:float:the lowest illumination value
+        self.lowestIllumination = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("LIGHT_SENSOR_CHANNEL", js)
+        if c:
+            self.averageIllumination = c["averageIllumination"]
+            self.currentIllumination = c["currentIllumination"]
+            self.highestIllumination = c["highestIllumination"]
+            self.lowestIllumination = c["lowestIllumination"]

+
+
+    def __str__(self):
+        return "{} averageIllumination({}) currentIllumination({}) highestIllumination({}) lowestIllumination({})".format(
+            super().__str__(),
+            self.averageIllumination,
+            self.currentIllumination,
+            self.highestIllumination,
+            self.lowestIllumination,
+        )

+
+
+
+

+[docs]
+class Dimmer(Device):
+    """Base dimmer device class"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.dimLevel = 0.0
+        self.profileMode = ""
+        self.userDesiredProfileMode = ""
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DIMMER_CHANNEL", js)
+        if c:
+            self.dimLevel = c["dimLevel"]
+            self.profileMode = c["profileMode"]
+            self.userDesiredProfileMode = c["userDesiredProfileMode"]

+
+
+    def __str__(self):
+        return "{} dimLevel({}) profileMode({}) userDesiredProfileMode({})".format(
+            super().__str__(),
+            self.dimLevel,
+            self.profileMode,
+            self.userDesiredProfileMode,
+        )
+
+

+[docs]
+    def set_dim_level(self, dimLevel=0.0, channelIndex=1):
+        data = {"channelIndex": channelIndex, "deviceId": self.id, "dimLevel": dimLevel}
+        return self._rest_call("device/control/setDimLevel", json.dumps(data))

+

+
+
+
+

+[docs]
+class PluggableDimmer(Dimmer):
+    """HMIP-PDT Pluggable Dimmer"""

+
+
+
+

+[docs]
+class BrandDimmer(Dimmer):
+    """HMIP-BDT Brand Dimmer"""

+
+
+
+

+[docs]
+class FullFlushDimmer(Dimmer):
+    """HMIP-FDT Dimming Actuator flush-mount"""

+
+
+
+

+[docs]
+class WiredDimmer3(Dimmer):
+    """HMIPW-DRD3 (Homematic IP Wired Dimming Actuator – 3x channels)"""

+
+
+
+

+[docs]
+class DinRailDimmer3(Dimmer):
+    """HMIP-DRDI3 (Dimming Actuator Inbound 230V – 3x channels, 200W per channel) electrical DIN rail"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.c1dimLevel = 0.0
+        self.c2dimLevel = 0.0
+        self.c3dimLevel = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        channels = get_functional_channels("MULTI_MODE_INPUT_DIMMER_CHANNEL", js)
+        if channels:
+            self.c1dimLevel = channels[0]["dimLevel"]
+            self.dimLevel = self.c1dimLevel
+            self.c2dimLevel = channels[1]["dimLevel"]
+            self.c3dimLevel = channels[2]["dimLevel"]

+
+
+    def __str__(self):
+        return "{} c1DimLevel({}) c2DimLevel({}) c3DimLevel({})".format(
+            super().__str__(), self.c1dimLevel, self.c2dimLevel, self.c3dimLevel
+        )

+
+
+
+

+[docs]
+class WeatherSensor(Device):
+    """HMIP-SWO-B"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.illumination = 0
+        self.illuminationThresholdSunshine = 0
+        self.storm = False
+        self.sunshine = False
+        self.todaySunshineDuration = 0
+        self.totalSunshineDuration = 0
+        self.windSpeed = 0
+        self.windValueType = WindValueType.AVERAGE_VALUE
+        self.yesterdaySunshineDuration = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+
+        c = get_functional_channel("WEATHER_SENSOR_CHANNEL", js)
+        if c:
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.illumination = c["illumination"]
+            self.illuminationThresholdSunshine = c["illuminationThresholdSunshine"]
+            self.storm = c["storm"]
+            self.sunshine = c["sunshine"]
+            self.todaySunshineDuration = c["todaySunshineDuration"]
+            self.totalSunshineDuration = c["totalSunshineDuration"]
+            self.windSpeed = c["windSpeed"]
+            self.windValueType = WindValueType.from_str(c["windValueType"])
+            self.yesterdaySunshineDuration = c["yesterdaySunshineDuration"]
+            self.vaporAmount = c["vaporAmount"]

+
+
+    def __str__(self):
+        return (
+            "{} actualTemperature({}) humidity({}) vaporAmount({}) illumination({}) illuminationThresholdSunshine({}) storm({}) sunshine({}) "
+            "todaySunshineDuration({}) totalSunshineDuration({}) "
+            "windSpeed({}) windValueType({}) "
+            "yesterdaySunshineDuration({})"
+        ).format(
+            super().__str__(),
+            self.actualTemperature,
+            self.humidity,
+            self.vaporAmount,
+            self.illumination,
+            self.illuminationThresholdSunshine,
+            self.storm,
+            self.sunshine,
+            self.todaySunshineDuration,
+            self.totalSunshineDuration,
+            self.windSpeed,
+            self.windValueType,
+            self.yesterdaySunshineDuration,
+        )

+
+
+
+

+[docs]
+class WeatherSensorPlus(Device):
+    """HMIP-SWO-PL"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.illumination = 0
+        self.illuminationThresholdSunshine = 0
+        self.raining = False
+        self.storm = False
+        self.sunshine = False
+        self.todayRainCounter = 0
+        self.todaySunshineDuration = 0
+        self.totalRainCounter = 0
+        self.totalSunshineDuration = 0
+        self.windSpeed = 0
+        self.windValueType = WindValueType.AVERAGE_VALUE
+        self.yesterdayRainCounter = 0
+        self.yesterdaySunshineDuration = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+
+        c = get_functional_channel("WEATHER_SENSOR_PLUS_CHANNEL", js)
+        if c:
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.illumination = c["illumination"]
+            self.illuminationThresholdSunshine = c["illuminationThresholdSunshine"]
+            self.raining = c["raining"]
+            self.storm = c["storm"]
+            self.sunshine = c["sunshine"]
+            self.todayRainCounter = c["todayRainCounter"]
+            self.todaySunshineDuration = c["todaySunshineDuration"]
+            self.totalRainCounter = c["totalRainCounter"]
+            self.totalSunshineDuration = c["totalSunshineDuration"]
+            self.windSpeed = c["windSpeed"]
+            self.windValueType = WindValueType.from_str(c["windValueType"])
+            self.yesterdayRainCounter = c["yesterdayRainCounter"]
+            self.yesterdaySunshineDuration = c["yesterdaySunshineDuration"]
+            self.vaporAmount = c["vaporAmount"]

+
+
+    def __str__(self):
+        return (
+            "{} actualTemperature({}) humidity({}) vaporAmount({}) illumination({}) illuminationThresholdSunshine({}) raining({}) storm({}) sunshine({}) "
+            "todayRainCounter({}) todaySunshineDuration({}) totalRainCounter({}) totalSunshineDuration({}) "
+            "windSpeed({}) windValueType({}) yesterdayRainCounter({}) yesterdaySunshineDuration({})"
+        ).format(
+            super().__str__(),
+            self.actualTemperature,
+            self.humidity,
+            self.vaporAmount,
+            self.illumination,
+            self.illuminationThresholdSunshine,
+            self.raining,
+            self.storm,
+            self.sunshine,
+            self.todayRainCounter,
+            self.todaySunshineDuration,
+            self.totalRainCounter,
+            self.totalSunshineDuration,
+            self.windSpeed,
+            self.windValueType,
+            self.yesterdayRainCounter,
+            self.yesterdaySunshineDuration,
+        )

+
+
+
+

+[docs]
+class WeatherSensorPro(Device):
+    """HMIP-SWO-PR"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0
+        self.humidity = 0
+        self.illumination = 0
+        self.illuminationThresholdSunshine = 0
+        self.raining = False
+        self.storm = False
+        self.sunshine = False
+        self.todayRainCounter = 0
+        self.todaySunshineDuration = 0
+        self.totalRainCounter = 0
+        self.totalSunshineDuration = 0
+        self.weathervaneAlignmentNeeded = False
+        self.windDirection = 0
+        self.windDirectionVariation = 0
+        self.windSpeed = 0
+        self.windValueType = WindValueType.AVERAGE_VALUE
+        self.yesterdayRainCounter = 0
+        self.yesterdaySunshineDuration = 0
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+
+        c = get_functional_channel("WEATHER_SENSOR_PRO_CHANNEL", js)
+        if c:
+            self.actualTemperature = c["actualTemperature"]
+            self.humidity = c["humidity"]
+            self.illumination = c["illumination"]
+            self.illuminationThresholdSunshine = c["illuminationThresholdSunshine"]
+            self.raining = c["raining"]
+            self.storm = c["storm"]
+            self.sunshine = c["sunshine"]
+            self.todayRainCounter = c["todayRainCounter"]
+            self.todaySunshineDuration = c["todaySunshineDuration"]
+            self.totalRainCounter = c["totalRainCounter"]
+            self.totalSunshineDuration = c["totalSunshineDuration"]
+            self.weathervaneAlignmentNeeded = c["weathervaneAlignmentNeeded"]
+            self.windDirection = c["windDirection"]
+            self.windDirectionVariation = c["windDirectionVariation"]
+            self.windSpeed = c["windSpeed"]
+            self.windValueType = WindValueType.from_str(c["windValueType"])
+            self.yesterdayRainCounter = c["yesterdayRainCounter"]
+            self.yesterdaySunshineDuration = c["yesterdaySunshineDuration"]
+            self.vaporAmount = c["vaporAmount"]

+
+
+    def __str__(self):
+        return (
+            "{} actualTemperature({}) humidity({}) vaporAmount({}) illumination({}) illuminationThresholdSunshine({}) raining({}) storm({}) sunshine({}) "
+            "todayRainCounter({}) todaySunshineDuration({}) totalRainCounter({}) totalSunshineDuration({}) "
+            "weathervaneAlignmentNeeded({}) windDirection({}) windDirectionVariation({}) windSpeed({}) windValueType({}) "
+            "yesterdayRainCounter({}) yesterdaySunshineDuration({})"
+        ).format(
+            super().__str__(),
+            self.actualTemperature,
+            self.humidity,
+            self.vaporAmount,
+            self.illumination,
+            self.illuminationThresholdSunshine,
+            self.raining,
+            self.storm,
+            self.sunshine,
+            self.todayRainCounter,
+            self.todaySunshineDuration,
+            self.totalRainCounter,
+            self.totalSunshineDuration,
+            self.weathervaneAlignmentNeeded,
+            self.windDirection,
+            self.windDirectionVariation,
+            self.windSpeed,
+            self.windValueType,
+            self.yesterdayRainCounter,
+            self.yesterdaySunshineDuration,
+        )

+
+
+    # Any set/calibration functions?
+
+
+

+[docs]
+class WaterSensor(Device):
+    """HMIP-SWD ( Water Sensor )"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.incorrectPositioned = False
+        self.acousticAlarmSignal = AcousticAlarmSignal.DISABLE_ACOUSTIC_SIGNAL
+        self.acousticAlarmTiming = AcousticAlarmTiming.PERMANENT
+        self.acousticWaterAlarmTrigger = WaterAlarmTrigger.NO_ALARM
+        self.inAppWaterAlarmTrigger = WaterAlarmTrigger.NO_ALARM
+        self.moistureDetected = False
+        self.sirenWaterAlarmTrigger = WaterAlarmTrigger.NO_ALARM
+        self.waterlevelDetected = False
+        self._baseChannel = "DEVICE_INCORRECT_POSITIONED"
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DEVICE_INCORRECT_POSITIONED", js)
+        if c:
+            self.incorrectPositioned = c["incorrectPositioned"]
+
+        c = get_functional_channel("WATER_SENSOR_CHANNEL", js)
+        if c:
+            self.acousticAlarmSignal = AcousticAlarmSignal.from_str(
+                c["acousticAlarmSignal"]
+            )
+            self.acousticAlarmTiming = AcousticAlarmTiming.from_str(
+                c["acousticAlarmTiming"]
+            )
+            self.acousticWaterAlarmTrigger = WaterAlarmTrigger.from_str(
+                c["acousticWaterAlarmTrigger"]
+            )
+            self.inAppWaterAlarmTrigger = WaterAlarmTrigger.from_str(
+                c["inAppWaterAlarmTrigger"]
+            )
+            self.moistureDetected = c["moistureDetected"]
+            self.sirenWaterAlarmTrigger = WaterAlarmTrigger.from_str(
+                c["sirenWaterAlarmTrigger"]
+            )
+            self.waterlevelDetected = c["waterlevelDetected"]

+
+
+    def __str__(self):
+        return (
+            "{} incorrectPositioned({}) acousticAlarmSignal({}) acousticAlarmTiming({}) acousticWaterAlarmTrigger({})"
+            " inAppWaterAlarmTrigger({}) moistureDetected({}) sirenWaterAlarmTrigger({}) waterlevelDetected({})"
+        ).format(
+            super().__str__(),
+            self.incorrectPositioned,
+            self.acousticAlarmSignal,
+            self.acousticAlarmTiming,
+            self.acousticWaterAlarmTrigger,
+            self.inAppWaterAlarmTrigger,
+            self.moistureDetected,
+            self.sirenWaterAlarmTrigger,
+            self.waterlevelDetected,
+        )
+
+

+[docs]
+    def set_acoustic_alarm_signal(self, acousticAlarmSignal: AcousticAlarmSignal):
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "acousticAlarmSignal": str(acousticAlarmSignal),
+        }
+        return self._rest_call(
+            "device/configuration/setAcousticAlarmSignal", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acoustic_alarm_timing(self, acousticAlarmTiming: AcousticAlarmTiming):
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "acousticAlarmTiming": str(acousticAlarmTiming),
+        }
+        return self._rest_call(
+            "device/configuration/setAcousticAlarmTiming", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acoustic_water_alarm_trigger(
+        self, acousticWaterAlarmTrigger: WaterAlarmTrigger
+    ):
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "acousticWaterAlarmTrigger": str(acousticWaterAlarmTrigger),
+        }
+        return self._rest_call(
+            "device/configuration/setAcousticWaterAlarmTrigger", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_inapp_water_alarm_trigger(self, inAppWaterAlarmTrigger: WaterAlarmTrigger):
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "inAppWaterAlarmTrigger": str(inAppWaterAlarmTrigger),
+        }
+        return self._rest_call(
+            "device/configuration/setInAppWaterAlarmTrigger", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_siren_water_alarm_trigger(self, sirenWaterAlarmTrigger: WaterAlarmTrigger):
+        LOGGER.warning(
+            "set_siren_water_alarm_trigger is currently not available in the HMIP App. It might not be available in the cloud yet"
+        )
+        data = {
+            "channelIndex": 1,
+            "deviceId": self.id,
+            "sirenWaterAlarmTrigger": str(sirenWaterAlarmTrigger),
+        }
+        return self._rest_call(
+            "device/configuration/setSirenWaterAlarmTrigger", json.dumps(data)
+        )

+

+
+
+
+

+[docs]
+class FullFlushContactInterface(Device):
+    """HMIP-FCI1 (Contact Interface flush-mount – 1 channel)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.binaryBehaviorType = BinaryBehaviorType.NORMALLY_OPEN
+        self.multiModeInputMode = MultiModeInputMode.BINARY_BEHAVIOR
+        self.windowState = WindowState.OPEN
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("MULTI_MODE_INPUT_CHANNEL", js)
+        if c:
+            self.binaryBehaviorType = BinaryBehaviorType.from_str(
+                c["binaryBehaviorType"]
+            )
+            self.multiModeInputMode = MultiModeInputMode.from_str(
+                c["multiModeInputMode"]
+            )
+            self.windowState = WindowState.from_str(c["windowState"])

+
+
+    def __str__(self):
+        return (
+            "{} binaryBehaviorType({}) multiModeInputMode({}) windowState({})".format(
+                super().__str__(),
+                self.binaryBehaviorType,
+                self.multiModeInputMode,
+                self.windowState,
+            )
+        )

+
+
+
+

+[docs]
+class FullFlushContactInterface6(Device):
+    """HMIP-FCI6 (Contact Interface flush-mount – 6 channels)"""

+
+
+
+

+[docs]
+class WiredInput32(FullFlushContactInterface):
+    """HMIPW-DRI32 (Homematic IP Wired Inbound module – 32x channels)"""

+
+
+
+

+[docs]
+class FullFlushInputSwitch(Switch):
+    """HMIP-FSI16 (Switch Actuator with Push-button Input 230V, 16A)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.binaryBehaviorType = BinaryBehaviorType.NORMALLY_OPEN
+        self.multiModeInputMode = MultiModeInputMode.SWITCH_BEHAVIOR
+        self.on = False
+        self.profileMode = ProfileMode.MANUAL
+        self.userDesiredProfileMode = ProfileMode.MANUAL
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("MULTI_MODE_INPUT_SWITCH_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("binaryBehaviorType", c, BinaryBehaviorType)
+            self.set_attr_from_dict("multiModeInputMode", c, MultiModeInputMode)
+            self.set_attr_from_dict("on", c)
+            self.set_attr_from_dict("profileMode", c, ProfileMode)
+            self.set_attr_from_dict("userDesiredProfileMode", c, ProfileMode)

+

+
+
+
+

+[docs]
+class DinRailSwitch(FullFlushInputSwitch):
+    """HMIP-DRSI1 (Switch Actuator for DIN rail mount – 1x channel)"""

+
+
+
+

+[docs]
+class AccelerationSensor(Device):
+    """HMIP-SAM (Contact Interface flush-mount – 1 channel)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float:
+        self.accelerationSensorEventFilterPeriod = 100.0
+        #:AccelerationSensorMode:
+        self.accelerationSensorMode = AccelerationSensorMode.ANY_MOTION
+        #:AccelerationSensorNeutralPosition:
+        self.accelerationSensorNeutralPosition = (
+            AccelerationSensorNeutralPosition.HORIZONTAL
+        )
+        #:AccelerationSensorSensitivity:
+        self.accelerationSensorSensitivity = (
+            AccelerationSensorSensitivity.SENSOR_RANGE_2G
+        )
+        #:int:
+        self.accelerationSensorTriggerAngle = 0
+        #:bool:
+        self.accelerationSensorTriggered = False
+        #:NotificationSoundType:
+        self.notificationSoundTypeHighToLow = NotificationSoundType.SOUND_NO_SOUND
+        #:NotificationSoundType:
+        self.notificationSoundTypeLowToHigh = NotificationSoundType.SOUND_NO_SOUND
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("ACCELERATION_SENSOR_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("accelerationSensorEventFilterPeriod", c)
+            self.set_attr_from_dict("accelerationSensorMode", c, AccelerationSensorMode)
+            self.set_attr_from_dict(
+                "accelerationSensorNeutralPosition",
+                c,
+                AccelerationSensorNeutralPosition,
+            )
+            self.set_attr_from_dict(
+                "accelerationSensorSensitivity", c, AccelerationSensorSensitivity
+            )
+            self.set_attr_from_dict("accelerationSensorTriggerAngle", c)
+            self.set_attr_from_dict("accelerationSensorTriggered", c)
+            self.set_attr_from_dict(
+                "notificationSoundTypeHighToLow", c, NotificationSoundType
+            )
+            self.set_attr_from_dict(
+                "notificationSoundTypeLowToHigh", c, NotificationSoundType
+            )

+
+
+

+[docs]
+    def set_acceleration_sensor_mode(
+        self, mode: AccelerationSensorMode, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorMode": str(mode),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorMode", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_neutral_position(
+        self, neutralPosition: AccelerationSensorNeutralPosition, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorNeutralPosition": str(neutralPosition),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorNeutralPosition",
+            json.dumps(data),
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_sensitivity(
+        self, sensitivity: AccelerationSensorSensitivity, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorSensitivity": str(sensitivity),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorSensitivity", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_trigger_angle(self, angle: int, channelIndex=1):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorTriggerAngle": angle,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorTriggerAngle", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_event_filter_period(
+        self, period: float, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorEventFilterPeriod": period,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorEventFilterPeriod",
+            json.dumps(data),
+        )

+
+
+

+[docs]
+    def set_notification_sound_type(
+        self, soundType: NotificationSoundType, isHighToLow: bool, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "notificationSoundType": str(soundType),
+            "isHighToLow": isHighToLow,
+        }
+        return self._rest_call(
+            "device/configuration/setNotificationSoundType", json.dumps(data)
+        )

+

+
+
+
+

+[docs]
+class DoorModule(Device):
+    """Generic class for a door module"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.doorState = DoorState.POSITION_UNKNOWN
+        self.on = False
+        self.processing = False
+        self.ventilationPositionSupported = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DOOR_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("doorState", c, DoorState)
+            self.set_attr_from_dict("on", c)
+            self.set_attr_from_dict("processing", c)
+            self.set_attr_from_dict("ventilationPositionSupported", c)

+
+
+

+[docs]
+    def send_door_command(self, doorCommand=DoorCommand.STOP):
+        data = {"channelIndex": 1, "deviceId": self.id, "doorCommand": doorCommand}
+        return self._rest_call("device/control/sendDoorCommand", json.dumps(data))

+

+
+
+
+

+[docs]
+class GarageDoorModuleTormatic(DoorModule):
+    """HMIP-MOD-TM (Garage Door Module Tormatic)"""

+
+
+
+

+[docs]
+class HoermannDrivesModule(DoorModule):
+    """HMIP-MOD-HO (Garage Door Module for Hörmann)"""

+
+
+
+

+[docs]
+class PluggableMainsFailureSurveillance(Device):
+    """HMIP-PMFS (Plugable Power Supply Monitoring)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.powerMainsFailure = False
+        self.genericAlarmSignal = AlarmSignalType.NO_ALARM
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("MAINS_FAILURE_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("powerMainsFailure", c)
+            self.set_attr_from_dict("genericAlarmSignal", c, AlarmSignalType)

+

+
+
+
+

+[docs]
+class WallMountedGarageDoorController(Device):
+    """HmIP-WGC Wall mounted Garage Door Controller"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.impulseDuration = 0
+        self.processing = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("IMPULSE_OUTPUT_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("impulseDuration", c)
+            self.set_attr_from_dict("processing", c)

+
+
+

+[docs]
+    def send_start_impulse(self, channelIndex=2):
+        """Toggle Wall mounted Garage Door Controller."""
+        data = {"channelIndex": channelIndex, "deviceId": self.id}
+        return self._rest_call("device/control/startImpulse", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class TiltVibrationSensor(Device):
+    """HMIP-STV (Inclination and vibration Sensor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float:
+        self.accelerationSensorEventFilterPeriod = 100.0
+        #:AccelerationSensorMode:
+        self.accelerationSensorMode = AccelerationSensorMode.ANY_MOTION
+        #:AccelerationSensorSensitivity:
+        self.accelerationSensorSensitivity = (
+            AccelerationSensorSensitivity.SENSOR_RANGE_2G
+        )
+        #:int:
+        self.accelerationSensorTriggerAngle = 0
+        #:bool:
+        self.accelerationSensorTriggered = False
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("TILT_VIBRATION_SENSOR_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("accelerationSensorEventFilterPeriod", c)
+            self.set_attr_from_dict("accelerationSensorMode", c, AccelerationSensorMode)
+            self.set_attr_from_dict(
+                "accelerationSensorSensitivity", c, AccelerationSensorSensitivity
+            )
+            self.set_attr_from_dict("accelerationSensorTriggerAngle", c)
+            self.set_attr_from_dict("accelerationSensorTriggered", c)

+
+
+

+[docs]
+    def set_acceleration_sensor_mode(
+        self, mode: AccelerationSensorMode, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorMode": str(mode),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorMode", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_sensitivity(
+        self, sensitivity: AccelerationSensorSensitivity, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorSensitivity": str(sensitivity),
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorSensitivity", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_trigger_angle(self, angle: int, channelIndex=1):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorTriggerAngle": angle,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorTriggerAngle", json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_acceleration_sensor_event_filter_period(
+        self, period: float, channelIndex=1
+    ):
+        data = {
+            "channelIndex": channelIndex,
+            "deviceId": self.id,
+            "accelerationSensorEventFilterPeriod": period,
+        }
+        return self._rest_call(
+            "device/configuration/setAccelerationSensorEventFilterPeriod",
+            json.dumps(data),
+        )

+

+
+
+
+

+[docs]
+class RainSensor(Device):
+    """HMIP-SRD (Rain Sensor)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:bool:
+        self.raining = False
+        #:float:
+        self.rainSensorSensitivity = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("RAIN_DETECTION_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("rainSensorSensitivity", c)
+            self.set_attr_from_dict("raining", c)

+

+
+
+
+

+[docs]
+class TemperatureDifferenceSensor2(Device):
+    """HmIP-STE2-PCB (Temperature Difference Sensors - 2x sensors)"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float:
+        self.temperatureExternalDelta = 0.0
+        #:float:
+        self.temperatureExternalOne = 0.0
+        #:float:
+        self.temperatureExternalTwo = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("temperatureExternalDelta", c)
+            self.set_attr_from_dict("temperatureExternalOne", c)
+            self.set_attr_from_dict("temperatureExternalTwo", c)

+

+
+
+
+

+[docs]
+class DoorLockDrive(OperationLockableDevice):
+    """HmIP-DLD"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.autoRelockDelay = False
+        self.doorHandleType = "UNKNOWN"
+        self.doorLockDirection = False
+        self.doorLockNeutralPosition = False
+        self.doorLockTurns = False
+        self.lockState = LockState.UNLOCKED
+        self.motorState = MotorState.STOPPED
+
+        self.door_lock_channel = 1
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DOOR_LOCK_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("autoRelockDelay", c)
+            self.set_attr_from_dict("doorHandleType", c)
+            self.set_attr_from_dict("doorLockDirection", c)
+            self.set_attr_from_dict("doorLockNeutralPosition", c)
+            self.set_attr_from_dict("doorLockTurns", c)
+            self.set_attr_from_dict("lockState", c, LockState)
+            self.set_attr_from_dict("motorState", c, MotorState)
+            self.door_lock_channel = c["index"]

+
+
+

+[docs]
+    def set_lock_state(self, doorLockState: LockState, pin="", channelIndex=1):
+        """sets the door lock state
+
+        Args:
+            doorLockState(float): the state of the door. See LockState from base/enums.py
+            pin(string): Pin, if specified.
+            channelIndex(int): the channel to control. Normally the channel from DOOR_LOCK_CHANNEL is used.
+        Returns:
+            the result of the _restCall
+        """
+        if channelIndex == 1:
+            channelIndex = self.door_lock_channel
+
+        data = {
+            "deviceId": self.id,
+            "channelIndex": channelIndex,
+            "authorizationPin": pin,
+            "targetLockState": doorLockState,
+        }
+        return self._rest_call("device/control/setLockState", json.dumps(data))

+

+
+
+
+

+[docs]
+class DoorLockSensor(Device):
+    """HmIP-DLS"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.doorLockDirection = ""
+        self.doorLockNeutralPosition = ""
+        self.doorLockTurns = 0
+        self.lockState = LockState.OPEN
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        c = get_functional_channel("DOOR_LOCK_SENSOR_CHANNEL", js)
+        if c:
+            self.set_attr_from_dict("doorLockDirection", c)
+            self.set_attr_from_dict("doorLockNeutralPosition", c)
+            self.set_attr_from_dict("doorLockTurns", c)
+            self.set_attr_from_dict("lockState", c, LockState)
+            self.door_lock_channel = c["index"]

+

+
+
+
+

+[docs]
+class EnergySensorsInterface(Device):
+    """HmIP-ESI"""
+
+    def __init__(self, connection):
+        super().__init__(connection)

+
+
+
+

+[docs]
+class DaliGateway(Device):
+    """HmIP-DRG-DALI Dali Gateway device."""
+    pass

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/functionalHomes.html b/_modules/homematicip/functionalHomes.html new file mode 100644 index 00000000..33538ab3 --- /dev/null +++ b/_modules/homematicip/functionalHomes.html @@ -0,0 +1,304 @@ + + + + + + + + homematicip.functionalHomes — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.functionalHomes

+from datetime import datetime
+from typing import List
+
+from homematicip.base.enums import *
+from homematicip.base.homematicip_object import HomeMaticIPObject
+from homematicip.group import Group
+
+
+

+[docs]
+class FunctionalHome(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+
+        self.functionalGroups = List[Group]
+        self.solution = ""
+        self.active = False
+
+

+[docs]
+    def from_json(self, js, groups: List[Group]):
+        super().from_json(js)
+
+        self.solution = js["solution"]
+        self.active = js["active"]
+
+        self.functionalGroups = self.assignGroups(js["functionalGroups"], groups)

+
+
+

+[docs]
+    def assignGroups(self, gids, groups: List[Group]):
+        ret = []
+        for gid in gids:
+            for g in groups:
+                if g.id == gid:
+                    ret.append(g)
+        return ret

+

+
+
+
+

+[docs]
+class IndoorClimateHome(FunctionalHome):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.absenceEndTime = None
+        self.absenceType = AbsenceType.NOT_ABSENT
+        self.coolingEnabled = False
+        self.ecoDuration = EcoDuration.PERMANENT
+        self.ecoTemperature = 0.0
+        self.optimumStartStopEnabled = False
+        self.floorHeatingSpecificGroups = []
+
+

+[docs]
+    def from_json(self, js, groups: List[Group]):
+        super().from_json(js, groups)
+        if js["absenceEndTime"] is None:
+            self.absenceEndTime = None
+        else:
+            # Why can't EQ-3 use the timestamp here like everywhere else -.-
+            self.absenceEndTime = datetime.strptime(
+                js["absenceEndTime"], "%Y_%m_%d %H:%M"
+            )
+        self.absenceType = AbsenceType.from_str(js["absenceType"])
+        self.coolingEnabled = js["coolingEnabled"]
+        self.ecoDuration = EcoDuration.from_str(js["ecoDuration"])
+        self.ecoTemperature = js["ecoTemperature"]
+        self.optimumStartStopEnabled = js["optimumStartStopEnabled"]
+
+        self.floorHeatingSpecificGroups = self.assignGroups(
+            js["floorHeatingSpecificGroups"].values(), groups
+        )

+

+
+
+
+

+[docs]
+class EnergyHome(FunctionalHome):
+    pass

+
+
+
+

+[docs]
+class WeatherAndEnvironmentHome(FunctionalHome):
+    pass

+
+
+
+

+[docs]
+class LightAndShadowHome(FunctionalHome):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.extendedLinkedShutterGroups = []
+        self.extendedLinkedSwitchingGroups = []
+        self.shutterProfileGroups = []
+        self.switchingProfileGroups = []
+
+

+[docs]
+    def from_json(self, js, groups: List[Group]):
+        super().from_json(js, groups)
+
+        self.extendedLinkedShutterGroups = self.assignGroups(
+            js["extendedLinkedShutterGroups"], groups
+        )
+        self.extendedLinkedSwitchingGroups = self.assignGroups(
+            js["extendedLinkedSwitchingGroups"], groups
+        )
+        self.shutterProfileGroups = self.assignGroups(
+            js["shutterProfileGroups"], groups
+        )
+        self.switchingProfileGroups = self.assignGroups(
+            js["switchingProfileGroups"], groups
+        )

+

+
+
+
+

+[docs]
+class SecurityAndAlarmHome(FunctionalHome):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.activationInProgress = False
+        self.alarmActive = False
+        self.alarmEventDeviceId = ""
+        self.alarmEventTimestamp = None
+        self.intrusionAlertThroughSmokeDetectors = False
+        self.zoneActivationDelay = 0.0
+        self.securityZoneActivationMode = (
+            SecurityZoneActivationMode.ACTIVATION_WITH_DEVICE_IGNORELIST
+        )
+
+        self.securitySwitchingGroups = []
+        self.securityZones = []
+
+

+[docs]
+    def from_json(self, js, groups: List[Group]):
+        super().from_json(js, groups)
+        self.activationInProgress = js["activationInProgress"]
+        self.alarmActive = js["alarmActive"]
+        if js["alarmEventDeviceChannel"] != None:
+            self.alarmEventDeviceId = js["alarmEventDeviceChannel"]["deviceId"]
+        self.alarmEventTimestamp = self.fromtimestamp(js["alarmEventTimestamp"])
+        self.intrusionAlertThroughSmokeDetectors = js[
+            "intrusionAlertThroughSmokeDetectors"
+        ]
+        self.zoneActivationDelay = js["zoneActivationDelay"]
+        self.securityZoneActivationMode = SecurityZoneActivationMode.from_str(
+            js["securityZoneActivationMode"]
+        )
+
+        self.securitySwitchingGroups = self.assignGroups(
+            js["securitySwitchingGroups"].values(), groups
+        )
+        self.securityZones = self.assignGroups(js["securityZones"].values(), groups)

+

+
+
+
+

+[docs]
+class AccessControlHome(FunctionalHome):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.accessAuthorizationProfileGroups = []
+        self.lockProfileGroups = []
+        self.autoRelockProfileGroups = []
+        self.extendedLinkedGarageDoorGroups = []
+        self.extendedLinkedNotificationGroups = []
+
+

+[docs]
+    def from_json(self, js, groups: List[Group]):
+        super().from_json(js, groups)
+        self.accessAuthorizationProfileGroups = self.assignGroups(
+            js["accessAuthorizationProfileGroups"], groups
+        )
+        self.lockProfileGroups = self.assignGroups(js["lockProfileGroups"], groups)
+        self.autoRelockProfileGroups = self.assignGroups(
+            js["autoRelockProfileGroups"], groups
+        )
+        self.extendedLinkedGarageDoorGroups = self.assignGroups(
+            js["extendedLinkedGarageDoorGroups"], groups
+        )
+        self.extendedLinkedNotificationGroups = self.assignGroups(
+            js["extendedLinkedNotificationGroups"], groups
+        )

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/group.html b/_modules/homematicip/group.html new file mode 100644 index 00000000..06cf2657 --- /dev/null +++ b/_modules/homematicip/group.html @@ -0,0 +1,1689 @@ + + + + + + + + homematicip.group — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.group

+# coding=utf-8
+import calendar
+import json
+from datetime import datetime
+from operator import attrgetter
+
+from homematicip.base.enums import *
+from homematicip.base.homematicip_object import HomeMaticIPObject
+
+
+

+[docs]
+class Group(HomeMaticIPObject):
+    """this class represents a group"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.id = None
+        self.homeId = None
+        self.label = None
+        self.lastStatusUpdate = None
+        self.groupType = None
+        self.unreach = None
+        self.metaGroup = None
+        self.devices = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js)
+        self.id = js["id"]
+        self.homeId = js["homeId"]
+        self.label = js["label"]
+        self.unreach = js["unreach"]
+
+        time = js["lastStatusUpdate"]
+        if time > 0:
+            self.lastStatusUpdate = datetime.fromtimestamp(time / 1000.0)
+        else:
+            self.lastStatusUpdate = None
+
+        self.groupType = js["type"]
+
+        self.devices = []
+        for channel in js["channels"]:
+            for d in devices:
+                if d.id == channel["deviceId"]:
+                    self.devices.append(d)

+
+
+    def __str__(self):
+        return "{} {}".format(self.groupType, self.label)
+
+

+[docs]
+    def set_label(self, label):
+        data = {"groupId": self.id, "label": label}
+        return self._rest_call("group/setGroupLabel", json.dumps(data))

+
+
+

+[docs]
+    def delete(self):
+        data = {"groupId": self.id}
+        return self._rest_call("group/deleteGroup", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class MetaGroup(Group):
+    """a meta group is a "Room" inside the homematic configuration"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.groups = None
+        self.lowBat = False
+        self.sabotage = False
+        self.configPending = False
+        self.dutyCycle = False
+        self.incorrectPositioned = None
+
+

+[docs]
+    def from_json(self, js, devices, groups):
+        super().from_json(js, devices)
+
+        self.lowBat = js["lowBat"]
+        self.sabotage = js["sabotage"]
+        self.configPending = js["configPending"]
+        self.dutyCycle = js["dutyCycle"]
+        self.incorrectPositioned = js["incorrectPositioned"]
+
+        self.groups = []
+        for group in js["groups"]:
+            for g in groups:
+                if g.id == group:
+                    g.metaGroup = self
+                    self.groups.append(g)

+

+
+
+
+

+[docs]
+class SecurityGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windowState = None
+        self.motionDetected = None
+        self.presenceDetected = None
+        self.sabotage = None
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.IDLE_OFF
+        self.dutyCycle = None
+        self.lowBat = None
+        self.moistureDetected = None
+        self.powerMainsFailure = None
+        self.waterlevelDetected = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.windowState = js["windowState"]
+        self.motionDetected = js["motionDetected"]
+        self.presenceDetected = js["presenceDetected"]
+        self.sabotage = js["sabotage"]
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.from_str(
+            js["smokeDetectorAlarmType"]
+        )
+        self.dutyCycle = js["dutyCycle"]
+        self.lowBat = js["lowBat"]
+        self.moistureDetected = js["moistureDetected"]
+        self.powerMainsFailure = js["powerMainsFailure"]
+        self.waterlevelDetected = js["waterlevelDetected"]

+
+
+    def __str__(self):
+        return "{} windowState({}) motionDetected({}) presenceDetected({}) sabotage({}) smokeDetectorAlarmType({}) dutyCycle({}) lowBat({}) powerMainsFailure({}) moistureDetected({}) waterlevelDetected({})".format(
+            super().__str__(),
+            self.windowState,
+            self.motionDetected,
+            self.presenceDetected,
+            self.sabotage,
+            self.smokeDetectorAlarmType,
+            self.dutyCycle,
+            self.lowBat,
+            self.powerMainsFailure,
+            self.moistureDetected,
+            self.waterlevelDetected,
+        )

+
+
+
+

+[docs]
+class SwitchGroupBase(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.dimLevel = None
+        self.dutyCycle = None
+        self.lowBat = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("dutyCycle", js)
+        self.set_attr_from_dict("lowBat", js)

+
+
+

+[docs]
+    def set_switch_state(self, on=True):
+        data = {"groupId": self.id, "on": on}
+        return self._rest_call("group/switching/setState", body=json.dumps(data))

+
+
+

+[docs]
+    def turn_on(self):
+        return self.set_switch_state(True)

+
+
+

+[docs]
+    def turn_off(self):
+        return self.set_switch_state(False)

+
+
+    def __str__(self):
+        return f"{super().__str__()} on({self.on}) dimLevel({self.dimLevel}) dutyCycle({self.dutyCycle}) lowBat({self.lowBat})"

+
+
+
+

+[docs]
+class SwitchingGroup(SwitchGroupBase):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.processing = None
+        self.shutterLevel = None
+        self.slatsLevel = None
+        self.primaryShadingLevel = 0.0
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.processing = None
+        self.secondaryShadingLevel = 0.0
+        self.secondaryShadingStateType = ShadingStateType.NOT_EXISTENT
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("processing", js)
+        self.set_attr_from_dict("shutterLevel", js)
+        self.set_attr_from_dict("slatsLevel", js)
+        self.set_attr_from_dict("primaryShadingLevel", js)
+        self.set_attr_from_dict("primaryShadingStateType", js, ShadingStateType)
+        self.set_attr_from_dict("secondaryShadingLevel", js)
+        self.set_attr_from_dict("secondaryShadingStateType", js, ShadingStateType)

+
+
+

+[docs]
+    def set_shutter_level(self, level):
+        data = {"groupId": self.id, "shutterLevel": level}
+        return self._rest_call("group/switching/setShutterLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_slats_level(self, slatsLevel, shutterlevel=None):
+        if shutterlevel is None:
+            shutterlevel = self.shutterLevel
+
+        data = {
+            "groupId": self.id,
+            "shutterLevel": shutterlevel,
+            "slatsLevel": slatsLevel,
+        }
+        return self._rest_call("group/switching/setSlatsLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_shutter_stop(self):
+        data = {"groupId": self.id}
+        return self._rest_call("group/switching/stop", body=json.dumps(data))

+
+
+    def __str__(self):
+        return f"{super().__str__()} processing({self.processing}) shutterLevel({self.shutterLevel}) slatsLevel({self.slatsLevel})"

+
+
+
+

+[docs]
+class ShutterProfile(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.dutyCycle = None
+        self.lowBat = None
+        self.unreach = None
+
+        self.processing = None
+        self.shutterLevel = None
+        self.slatsLevel = None
+        self.primaryShadingLevel = 0.0
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.processing = None
+        self.secondaryShadingLevel = 0.0
+        self.secondaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.profileMode = ProfileMode.MANUAL
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("dutyCycle", js)
+        self.set_attr_from_dict("lowBat", js)
+        self.set_attr_from_dict("unreach", js)
+
+        self.set_attr_from_dict("profileMode", js, ProfileMode)
+
+        self.set_attr_from_dict("processing", js)
+        self.set_attr_from_dict("shutterLevel", js)
+        self.set_attr_from_dict("slatsLevel", js)
+        self.set_attr_from_dict("primaryShadingLevel", js)
+        self.set_attr_from_dict("primaryShadingStateType", js, ShadingStateType)
+        self.set_attr_from_dict("secondaryShadingLevel", js)
+        self.set_attr_from_dict("secondaryShadingStateType", js, ShadingStateType)

+
+
+

+[docs]
+    def set_profile_mode(self, profileMode: ProfileMode):
+        data = {"groupId": self.id, "profileMode": profileMode}
+        return self._rest_call("group/heating/setProfileMode", body=json.dumps(data))

+
+
+

+[docs]
+    def set_shutter_level(self, level):
+        data = {"groupId": self.id, "shutterLevel": level}
+        return self._rest_call("group/switching/setShutterLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_slats_level(self, slatsLevel, shutterlevel=None):
+        if shutterlevel is None:
+            shutterlevel = self.shutterLevel
+
+        data = {
+            "groupId": self.id,
+            "shutterLevel": shutterlevel,
+            "slatsLevel": slatsLevel,
+        }
+        return self._rest_call("group/switching/setSlatsLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_shutter_stop(self):
+        data = {"groupId": self.id}
+        return self._rest_call("group/switching/stop", body=json.dumps(data))

+
+
+    def __str__(self):
+        return (
+            f"{super().__str__()} processing({self.processing}) shutterLevel({self.shutterLevel}) "
+            f"slatsLevel({self.slatsLevel}) profileMode({self.profileMode})"
+        )

+
+
+
+

+[docs]
+class LinkedSwitchingGroup(Group):
+

+[docs]
+    def set_light_group_switches(self, devices):
+        switchChannels = []
+        for d in devices:
+            channel = {"channelIndex": 1, "deviceId": d.id}
+            switchChannels.append(channel)
+        data = {"groupId": self.id, "switchChannels": switchChannels}
+        return self._rest_call(
+            "home/security/setLightGroupSwitches", body=json.dumps(data)
+        )

+

+
+
+
+

+[docs]
+class ExtendedLinkedSwitchingGroup(SwitchGroupBase):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.onTime = None
+        self.onLevel = None
+        self.sensorSpecificParameters = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.onTime = js["onTime"]
+        self.onLevel = js["onLevel"]
+        self.sensorSpecificParameters = js["sensorSpecificParameters"]

+
+
+    def __str__(self):
+        return "{} onTime({}) onLevel({})".format(
+            super().__str__(), self.onTime, self.onLevel
+        )
+
+

+[docs]
+    def set_on_time(self, onTimeSeconds):
+        data = {"groupId": self.id, "onTime": onTimeSeconds}
+        return self._rest_call("group/switching/linked/setOnTime", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class ExtendedLinkedShutterGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.dutyCycle = None
+        self.lowBat = None
+        self.shutterLevel = None
+        self.slatsLevel = None
+        self.topSlatsLevel = None
+        self.bottomSlatsLevel = None
+        self.topShutterLevel = None
+        self.bottomShutterLevel = None
+        self.processing = None
+        self.primaryShadingLevel = 0.0
+        self.primaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.secondaryShadingLevel = 0.0
+        self.secondaryShadingStateType = ShadingStateType.NOT_EXISTENT
+        self.groupVisibility = GroupVisibility.INVISIBLE_GROUP_AND_CONTROL
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("dutyCycle", js)
+        self.set_attr_from_dict("lowBat", js)
+        self.set_attr_from_dict("groupVisibility", js, GroupVisibility)
+        self.set_attr_from_dict("topSlatsLevel", js)
+        self.set_attr_from_dict("bottomSlatsLevel", js)
+        self.set_attr_from_dict("topShutterLevel", js)
+        self.set_attr_from_dict("bottomShutterLevel", js)
+        self.set_attr_from_dict("processing", js)
+        self.set_attr_from_dict("shutterLevel", js)
+        self.set_attr_from_dict("slatsLevel", js)
+        self.set_attr_from_dict("primaryShadingLevel", js)
+        self.set_attr_from_dict("primaryShadingStateType", js, ShadingStateType)
+        self.set_attr_from_dict("secondaryShadingLevel", js)
+        self.set_attr_from_dict("secondaryShadingStateType", js, ShadingStateType)

+
+
+    def __str__(self):
+        return "{} shutterLevel({}) slatsLevel({})".format(
+            super().__str__(), self.shutterLevel, self.slatsLevel
+        )
+
+

+[docs]
+    def set_shutter_level(self, level):
+        data = {"groupId": self.id, "shutterLevel": level}
+        return self._rest_call("group/switching/setShutterLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_slats_level(self, slatsLevel=0.0, shutterLevel=None):
+        if shutterLevel is None:
+            shutterLevel = self.shutterLevel
+
+        data = {
+            "groupId": self.id,
+            "shutterLevel": shutterLevel,
+            "slatsLevel": slatsLevel,
+        }
+        return self._rest_call("group/switching/setSlatsLevel", body=json.dumps(data))

+
+
+

+[docs]
+    def set_shutter_stop(self):
+        data = {"groupId": self.id}
+        return self._rest_call("group/switching/stop", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class ExtendedLinkedGarageDoorGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.doorState = None
+        self.dutyCycle = None
+        self.groupVisibility = GroupVisibility.INVISIBLE_GROUP_AND_CONTROL
+        self.lowBat = None
+        self.processing = None
+        self.unreach = None
+        self.ventilationPositionSupported = False
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("doorState", js)
+        self.set_attr_from_dict("dutyCycle", js)
+        self.set_attr_from_dict("groupVisibility", js, GroupVisibility)
+        self.set_attr_from_dict("lowBat", js)
+        self.set_attr_from_dict("processing", js)
+        self.set_attr_from_dict("unreach", js)
+        self.set_attr_from_dict("ventilationPositionSupported", js)

+
+
+    def __str__(self):
+        return "{} doorState({}) dutyCycle({}) lowBat({}) ventilationPositionSupported({})".format(
+            super().__str__(),
+            self.doorState,
+            self.dutyCycle,
+            self.lowBat,
+            self.ventilationPositionSupported,
+        )

+
+
+
+

+[docs]
+class AlarmSwitchingGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.dimLevel = None
+        self.onTime = None
+        self.signalAcoustic = AcousticAlarmSignal.DISABLE_ACOUSTIC_SIGNAL
+        self.signalOptical = OpticalAlarmSignal.DISABLE_OPTICAL_SIGNAL
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.IDLE_OFF
+        self.acousticFeedbackEnabled = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.onTime = js["onTime"]
+        self.on = js["on"]
+        self.dimLevel = js["dimLevel"]
+        self.signalAcoustic = AcousticAlarmSignal.from_str(js["signalAcoustic"])
+        self.signalOptical = OpticalAlarmSignal.from_str(js["signalOptical"])
+        self.smokeDetectorAlarmType = SmokeDetectorAlarmType.from_str(
+            js["smokeDetectorAlarmType"]
+        )
+        self.acousticFeedbackEnabled = js["acousticFeedbackEnabled"]

+
+
+

+[docs]
+    def set_on_time(self, onTimeSeconds):
+        data = {"groupId": self.id, "onTime": onTimeSeconds}
+        return self._rest_call("group/switching/alarm/setOnTime", body=json.dumps(data))

+
+
+    def __str__(self):
+        return "{} on({}) dimLevel({}) onTime({}) signalAcoustic({}) signalOptical({}) smokeDetectorAlarmType({}) acousticFeedbackEnabled({})".format(
+            super().__str__(),
+            self.on,
+            self.dimLevel,
+            self.onTime,
+            self.signalAcoustic,
+            self.signalOptical,
+            self.smokeDetectorAlarmType,
+            self.acousticFeedbackEnabled,
+        )
+
+

+[docs]
+    def test_signal_optical(
+        self, signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING
+    ):
+        data = {"groupId": self.id, "signalOptical": str(signalOptical)}
+        return self._rest_call(
+            "group/switching/alarm/testSignalOptical", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_signal_optical(
+        self, signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING
+    ):
+        data = {"groupId": self.id, "signalOptical": str(signalOptical)}
+        return self._rest_call(
+            "group/switching/alarm/setSignalOptical", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def test_signal_acoustic(
+        self, signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING
+    ):
+        data = {"groupId": self.id, "signalAcoustic": str(signalAcoustic)}
+        return self._rest_call(
+            "group/switching/alarm/testSignalAcoustic", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_signal_acoustic(self, signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING):
+        data = {"groupId": self.id, "signalAcoustic": str(signalAcoustic)}
+        return self._rest_call(
+            "group/switching/alarm/setSignalAcoustic", body=json.dumps(data)
+        )

+

+
+
+
+# at the moment it doesn't look like this class has any special
+# properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class HeatingHumidyLimiterGroup(Group):
+    pass

+
+
+
+# at the moment it doesn't look like this class has any special
+# properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class HeatingTemperatureLimiterGroup(Group):
+    pass

+
+
+
+

+[docs]
+class HeatingChangeoverGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.dimLevel = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.on = js["on"]

+
+
+    def __str__(self):
+        return "{} on({})".format(super().__str__(), self.on)

+
+
+
+# at the moment it doesn't look like this class has any special
+# properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class InboxGroup(Group):
+    pass

+
+
+
+

+[docs]
+class IndoorClimateGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.sabotage = None
+        self.ventilationLevel = None
+        self.ventilationState = None
+        self.windowState = ""
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.sabotage = js["sabotage"]
+        self.ventilationLevel = js["ventilationLevel"]
+        self.ventilationState = js["ventilationState"]
+        self.windowState = js["windowState"]

+
+
+    def __str__(self):
+        return "{} sabotage({}) ventilationLevel({}) ventilationState({}) windowState({})".format(
+            super().__str__(),
+            self.sabotage,
+            self.ventilationLevel,
+            self.ventilationState,
+            self.windowState,
+        )

+
+
+
+

+[docs]
+class SecurityZoneGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.active = False
+        self.silent = False
+        self.ignorableDevices = []
+        self.windowState = ""
+        self.motionDetected = None
+        self.sabotage = None
+        self.presenceDetected = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.active = js["active"]
+        self.silent = js["silent"]
+        self.windowState = js["windowState"]
+        self.motionDetected = js["motionDetected"]
+        self.sabotage = js["sabotage"]
+        self.ignorableDevices = []
+        for channel in js["ignorableDeviceChannels"]:
+            # there are multiple channels per device and we only need each deviceId once
+            # as each device has at least channel 0, we skip the other ones
+            if channel["channelIndex"] == 0:
+                self.ignorableDevices.append(
+                    [d for d in devices if d.id == channel["deviceId"]][0]
+                )

+
+
+    def __str__(self):
+        return "{} active({}) silent({}) windowState({}) motionDetected({}) sabotage({}) presenceDetected({}) ignorableDevices(#{})".format(
+            super().__str__(),
+            self.active,
+            self.silent,
+            self.windowState,
+            self.motionDetected,
+            self.sabotage,
+            self.presenceDetected,
+            len(self.ignorableDevices),
+        )

+
+
+
+

+[docs]
+class HeatingCoolingPeriod(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.starttime = None
+        self.endtime = None
+        self.value = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.starttime = js["starttime"]
+        self.endtime = js["endtime"]
+        self.value = js["value"]

+

+
+
+
+

+[docs]
+class HeatingCoolingProfileDay(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.baseValue = None
+        self.periods = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.baseValue = js["baseValue"]
+        self.periods = []
+        for p in js["periods"]:
+            period = HeatingCoolingPeriod(self._connection)
+            period.from_json(p)
+            self.periods.append(period)

+

+
+
+
+

+[docs]
+class HeatingCoolingProfile(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.id = None
+        self.homeId = None
+
+        self.groupId = None
+        self.index = None
+        self.visible = None
+        self.enabled = None
+
+        self.name = None
+        self.type = None
+        self.profileDays = None
+
+

+[docs]
+    def get_details(self):
+        data = {
+            "groupId": self.groupId,
+            "profileIndex": self.index,
+            "profileName": self.name,
+        }
+        js = self._rest_call("group/heating/getProfile", body=json.dumps(data))
+        self.homeId = js["homeId"]
+        self.type = js["type"]
+        self.profileDays = {}
+
+        for i in range(0, 7):
+            day = HeatingCoolingProfileDay(self._connection)
+            day.from_json(js["profileDays"][calendar.day_name[i].upper()])
+            self.profileDays[i] = day

+
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.id = js["profileId"]
+        self.groupId = js["groupId"]
+        self.index = js["index"]
+        self.name = js["name"]
+        self.visible = js["visible"]
+        self.enabled = js["enabled"]

+
+
+    def _time_to_totalminutes(self, time):
+        s = time.split(":")
+        return int(s[0]) * 60 + int(s[1])
+
+

+[docs]
+    def update_profile(self):
+        days = {}
+        for i in range(0, 7):
+            periods = []
+            day = self.profileDays[i]
+            for p in day.periods:
+                periods.append(
+                    {
+                        "endtime": p.endtime,
+                        "starttime": p.starttime,
+                        "value": p.value,
+                        "endtimeAsMinutesOfDay": self._time_to_totalminutes(p.endtime),
+                        "starttimeAsMinutesOfDay": self._time_to_totalminutes(
+                            p.starttime
+                        ),
+                    }
+                )
+
+            dayOfWeek = calendar.day_name[i].upper()
+            days[dayOfWeek] = {
+                "baseValue": day.baseValue,
+                "dayOfWeek": dayOfWeek,
+                "periods": periods,
+            }
+
+        data = {
+            "groupId": self.groupId,
+            "profile": {
+                "groupId": self.groupId,
+                "homeId": self.homeId,
+                "id": self.id,
+                "index": self.index,
+                "name": self.name,
+                "profileDays": days,
+                "type": self.type,
+            },
+            "profileIndex": self.index,
+        }
+        return self._rest_call("group/heating/updateProfile", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class HeatingGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windowOpenTemperature = None
+        self.setPointTemperature = None
+        self.windowState = None
+        self.maxTemperature = None
+        self.minTemperature = None
+        self.cooling = None
+        self.partyMode = None
+        self.controlMode = ClimateControlMode.AUTOMATIC
+        self.activeProfile = None
+        self.boostMode = None
+        self.boostDuration = None
+        self.actualTemperature = None
+        self.humidity = None
+        self.coolingAllowed = None
+        self.coolingIgnored = None
+        self.ecoAllowed = None
+        self.ecoIgnored = None
+        self.controllable = None
+        self.floorHeatingMode = None
+        self.humidityLimitEnabled = None
+        self.humidityLimitValue = None
+        self.externalClockEnabled = None
+        self.externalClockHeatingTemperature = None
+        self.externalClockCoolingTemperature = None
+        self.profiles = None
+        self.dutyCycle = False
+        self.lowBat = False
+        self.valvePosition = 0.0
+        self.heatingFailureSupported = False
+        self.valveSilentModeEnabled = False
+        self.valveSilentModeSupported = False
+        self.lastSetPointReachedTimestamp = None
+        self.lastSetPointUpdatedTimestamp = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.windowOpenTemperature = js["windowOpenTemperature"]
+        self.setPointTemperature = js["setPointTemperature"]
+        self.windowState = js["windowState"]
+        self.maxTemperature = js["maxTemperature"]
+        self.minTemperature = js["minTemperature"]
+        self.cooling = js["cooling"]
+        self.partyMode = js["partyMode"]
+        self.controlMode = ClimateControlMode.from_str(js["controlMode"])
+        self.boostMode = js["boostMode"]
+        self.boostDuration = js["boostDuration"]
+        self.actualTemperature = js["actualTemperature"]
+        self.humidity = js["humidity"]
+        self.coolingAllowed = js["coolingAllowed"]
+        self.coolingIgnored = js["coolingIgnored"]
+        self.ecoAllowed = js["ecoAllowed"]
+        self.ecoIgnored = js["ecoIgnored"]
+        self.controllable = js["controllable"]
+        self.floorHeatingMode = js["floorHeatingMode"]
+        self.humidityLimitEnabled = js["humidityLimitEnabled"]
+        self.humidityLimitValue = js["humidityLimitValue"]
+        self.externalClockEnabled = js["externalClockEnabled"]
+        self.externalClockHeatingTemperature = js["externalClockHeatingTemperature"]
+        self.externalClockCoolingTemperature = js["externalClockCoolingTemperature"]
+        self.dutyCycle = js["dutyCycle"]
+        self.lowBat = js["lowBat"]
+        self.valvePosition = js["valvePosition"]
+        self.heatingFailureSupported = js["heatingFailureSupported"]
+        self.valveSilentModeEnabled = js["valveSilentModeEnabled"]
+        self.valveSilentModeSupported = js["valveSilentModeSupported"]
+        self.lastSetPointReachedTimestamp = self.fromtimestamp(
+            js["lastSetPointReachedTimestamp"]
+        )
+        self.lastSetPointUpdatedTimestamp = self.fromtimestamp(
+            js["lastSetPointUpdatedTimestamp"]
+        )
+
+        profiles = []
+        activeProfile = js["activeProfile"]  # not self.!!!!
+        for k, v in js["profiles"].items():
+            profile = HeatingCoolingProfile(self._connection)
+            profile.from_json(v)
+            profiles.append(profile)
+            if activeProfile == k:
+                self.activeProfile = profile
+        self.profiles = sorted(profiles, key=attrgetter("index"))

+
+
+    def __str__(self):
+        return "{} windowOpenTemperature({}) setPointTemperature({}) windowState({}) motionDetected({}) sabotage({}) cooling({}) partyMode({}) controlMode({}) actualTemperature({}) valvePosition({})".format(
+            super().__str__(),
+            self.windowOpenTemperature,
+            self.setPointTemperature,
+            self.windowState,
+            self.maxTemperature,
+            self.minTemperature,
+            self.cooling,
+            self.partyMode,
+            self.controlMode,
+            self.actualTemperature,
+            self.valvePosition,
+        )
+
+

+[docs]
+    def set_point_temperature(self, temperature):
+        data = {"groupId": self.id, "setPointTemperature": temperature}
+        return self._rest_call(
+            "group/heating/setSetPointTemperature", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_boost(self, enable=True):
+        data = {"groupId": self.id, "boost": enable}
+        return self._rest_call("group/heating/setBoost", body=json.dumps(data))

+
+
+

+[docs]
+    def set_boost_duration(self, duration: int):
+        data = {"groupId": self.id, "boostDuration": duration}
+        return self._rest_call("group/heating/setBoostDuration", body=json.dumps(data))

+
+
+

+[docs]
+    def set_active_profile(self, index):
+        data = {"groupId": self.id, "profileIndex": index}
+        return self._rest_call("group/heating/setActiveProfile", body=json.dumps(data))

+
+
+

+[docs]
+    def set_control_mode(self, mode=ClimateControlMode.AUTOMATIC):
+        data = {"groupId": self.id, "controlMode": str(mode)}
+        return self._rest_call("group/heating/setControlMode", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class HeatingDehumidifierGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.on = js["on"]

+
+
+    def __str__(self):
+        return "{} on({})".format(super().__str__(), self.on)

+
+
+
+

+[docs]
+class HeatingCoolingDemandGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.dimLevel = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.on = js["on"]
+        self.dimLevel = js["dimLevel"]

+
+
+    def __str__(self):
+        return "{} on({}) dimLevel({}) ".format(
+            super().__str__(), self.on, self.dimLevel
+        )

+
+
+
+

+[docs]
+class HeatingFailureAlertRuleGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:bool: is this rule active
+        self.enabled = False
+        #:HeatingFailureValidationType: the heating failure value
+        self.heatingFailureValidationResult = (
+            HeatingFailureValidationType.NO_HEATING_FAILURE
+        )
+        #:int:how often the system will check for an error
+        self.checkInterval = 0
+        #:int:time in ms for the validation period. default 24Hours
+        self.validationTimeout = 0
+        #:datetime: last time of execution
+        self.lastExecutionTimestamp = 0
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.enabled = js["enabled"]
+        self.heatingFailureValidationResult = HeatingFailureValidationType.from_str(
+            js["heatingFailureValidationResult"]
+        )
+        self.checkInterval = js["checkInterval"]
+        self.validationTimeout = js["validationTimeout"]
+        self.lastExecutionTimestamp = self.fromtimestamp(js["lastExecutionTimestamp"])

+
+
+    def __str__(self):
+        return (
+            "{} enabled({}) heatingFailureValidationResult({}) "
+            "checkInterval({}) validationTimeout({}) lastExecutionTimestamp({})"
+        ).format(
+            super().__str__(),
+            self.enabled,
+            self.heatingFailureValidationResult,
+            self.checkInterval,
+            self.validationTimeout,
+            self.lastExecutionTimestamp,
+        )

+
+
+
+

+[docs]
+class HumidityWarningRuleGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:bool: is this rule active
+        self.enabled = False
+        #:HumidityValidationType: the current humidity result
+        self.humidityValidationResult = (
+            HumidityValidationType.GREATER_LOWER_LESSER_UPPER_THRESHOLD
+        )
+        #:int:the lower humidity threshold
+        self.humidityLowerThreshold = 0
+        #:int:the upper humidity threshold
+        self.humidityUpperThreshold = 0
+        #:bool:is it currently triggered?
+        self.triggered = False
+        #:bool:should the windows be opened?
+        self.ventilationRecommended = False
+        #:datetime: last time of execution
+        self.lastExecutionTimestamp = None
+        #:datetime: last time the humidity got updated
+        self.lastStatusUpdate = None
+        #:Device: the climate sensor which get used as an outside reference. None if OpenWeatherMap will be used
+        self.outdoorClimateSensor = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.enabled = js["enabled"]
+        self.humidityValidationResult = HumidityValidationType.from_str(
+            js["humidityValidationResult"]
+        )
+        self.humidityLowerThreshold = js["humidityLowerThreshold"]
+        self.humidityUpperThreshold = js["humidityUpperThreshold"]
+        self.triggered = js["triggered"]
+        self.ventilationRecommended = js["ventilationRecommended"]
+        self.lastExecutionTimestamp = self.fromtimestamp(js["lastExecutionTimestamp"])
+        self.lastStatusUpdate = self.fromtimestamp(js["lastStatusUpdate"])
+
+        jsOutdoorClimateSensor = js["outdoorClimateSensor"]
+        if jsOutdoorClimateSensor != None:
+            did = jsOutdoorClimateSensor["deviceId"]
+            for d in devices:
+                if d.id == did:
+                    self.outdoorClimateSensor = d
+                    break

+
+
+    def __str__(self):
+        return (
+            "{} enabled({}) humidityValidationResult({}) "
+            "humidityLowerThreshold({}) humidityUpperThreshold({}) "
+            "triggered({}) lastExecutionTimestamp({}) "
+            "lastStatusUpdate({}) ventilationRecommended({})"
+        ).format(
+            super().__str__(),
+            self.enabled,
+            self.humidityValidationResult,
+            self.humidityLowerThreshold,
+            self.humidityUpperThreshold,
+            self.triggered,
+            self.lastExecutionTimestamp,
+            self.lastStatusUpdate,
+            self.ventilationRecommended,
+        )

+
+
+
+# at the moment it doesn't look like this class has any special
+# properties/functions
+# keep it as a placeholder in the meantime
+

+[docs]
+class HeatingExternalClockGroup(Group):
+    pass

+
+
+
+

+[docs]
+class HeatingCoolingDemandBoilerGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.boilerFollowUpTime = None
+        self.boilerLeadTime = None
+        self.on = None
+        self.dimLevel = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.on = js["on"]
+        self.boilerLeadTime = js["boilerLeadTime"]
+        self.boilerFollowUpTime = js["boilerFollowUpTime"]

+
+
+    def __str__(self):
+        return "{} on({}) boilerFollowUpTime({}) boilerLeadTime({})".format(
+            super().__str__(), self.on, self.boilerFollowUpTime, self.boilerLeadTime
+        )

+
+
+
+

+[docs]
+class HeatingCoolingDemandPumpGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.pumpProtectionDuration = 0
+        self.pumpProtectionSwitchingInterval = 0
+        self.pumpFollowUpTime = 0
+        self.pumpLeadTime = 0
+        self.on = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.on = js["on"]
+        self.pumpProtectionSwitchingInterval = js["pumpProtectionSwitchingInterval"]
+        self.pumpProtectionDuration = js["pumpProtectionDuration"]
+        self.pumpFollowUpTime = js["pumpFollowUpTime"]
+        self.pumpLeadTime = js["pumpLeadTime"]

+
+
+    def __str__(self):
+        return (
+            "{} on({}) pumpProtectionDuration({}) pumpProtectionSwitchingInterval({}) pumpFollowUpTime({}) "
+            "pumpLeadTime({})".format(
+                super().__str__(),
+                self.on,
+                self.pumpProtectionDuration,
+                self.pumpProtectionSwitchingInterval,
+                self.pumpFollowUpTime,
+                self.pumpLeadTime,
+            )
+        )

+
+
+
+

+[docs]
+class TimeProfilePeriod(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.weekdays = []
+        self.hour = 0
+        self.minute = 0
+        self.astroOffset = 0
+        self.astroLimitationType = (
+            "NO_LIMITATION"  # NOT_EARLIER_THAN_TIME, NOT_LATER_THAN_TIME
+        )
+        self.switchTimeMode = (
+            "REGULAR_SWITCH_TIME"  # ASTRO_SUNRISE_SWITCH_TIME, ASTRO_SUNSET_SWITCH_TIME
+        )
+        self.dimLevel = 1.0
+        self.rampTime = 0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.weekdays = js["weekdays"]
+        self.hour = js["hour"]
+        self.minute = js["minute"]
+        self.astroOffset = js["astroOffset"]
+        self.astroLimitationType = js["astroLimitationType"]
+        self.switchTimeMode = js["switchTimeMode"]
+        self.dimLevel = js["dimLevel"]
+        self.rampTime = js["rampTime"]

+

+
+
+
+

+[docs]
+class TimeProfile(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.id = None
+        self.homeId = None
+        self.groupId = None
+        self.type = None
+        self.periods = []
+
+

+[docs]
+    def get_details(self):
+        data = {"groupId": self.groupId}
+        js = self._rest_call("group/switching/profile/getProfile", body=json.dumps(data))
+        self.homeId = js["homeId"]
+        self.type = js["type"]
+        self.id = js["id"]
+        self.periods = []
+        for p in js["periods"]:
+            period = TimeProfilePeriod(self._connection)
+            period.from_json(p)
+            self.periods.append(period)

+

+
+
+
+

+[docs]
+class SwitchingProfileGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.dimLevel = None
+        self.profileId = (
+            None  # Not sure why it is there.  You can't use it to query something.
+        )
+        self.profileMode = ProfileMode.MANUAL
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("dimLevel", js)
+        self.set_attr_from_dict("profileId", js)
+        self.set_attr_from_dict("profileMode", js, ProfileMode)

+
+
+    def __str__(self):
+        return "{} on({}) dimLevel({}) profileMode({})".format(
+            super().__str__(), self.on, self.dimLevel, self.profileMode
+        )
+
+

+[docs]
+    def set_group_channels(self):
+        channels = []
+        for d in self.devices:
+            channels.append[{"channelIndex": 1, "deviceId": d.id}]
+        data = {"groupId": self.id, "channels": channels}
+        return self._rest_call(
+            "group/switching/profile/setGroupChannels", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def set_profile_mode(self, devices, automatic=True):
+        channels = []
+        for d in devices:
+            channels.append[{"channelIndex": 1, "deviceId": d.id}]
+        data = {
+            "groupId": self.id,
+            "channels": channels,
+            "profileMode": ProfileMode.AUTOMATIC if automatic else ProfileMode.MANUAL,
+        }
+        return self._rest_call(
+            "group/switching/profile/setProfileMode", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def create(self, label):
+        data = {"label": label}
+        result = self._rest_call(
+            "group/switching/profile/createSwitchingProfileGroup", body=json.dumps(data)
+        )
+        if "groupId" in result:
+            self.id = result["groupId"]
+        return result

+

+
+
+
+

+[docs]
+class OverHeatProtectionRule(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.temperatureLowerThreshold = None
+        self.temperatureUpperThreshold = None
+        self.targetShutterLevel = None
+        self.targetSlatsLevel = None
+        self.startHour = None
+        self.startMinute = None
+        self.startSunrise = None
+        self.endHour = None
+        self.endMinute = None
+        self.endSunset = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.temperatureLowerThreshold = js["temperatureLowerThreshold"]
+        self.temperatureUpperThreshold = js["temperatureUpperThreshold"]
+        self.targetShutterLevel = js["targetShutterLevel"]
+        self.targetSlatsLevel = js["targetSlatsLevel"]
+        self.startHour = js["startHour"]
+        self.startMinute = js["startMinute"]
+        self.startSunrise = js["startSunrise"]
+        self.endHour = js["endHour"]
+        self.endMinute = js["endMinute"]
+        self.endSunset = js["endSunset"]

+
+
+    def __str__(self):
+        return "{} tempLower({}) tempUpper({}) targetShutterLevel({}) targetSlatsLevel({})".format(
+            super().__str__(),
+            self.temperatureLowerThreshold,
+            self.temperatureUpperThreshold,
+            self.targetShutterLevel,
+            self.targetSlatsLevel,
+        )

+
+
+
+

+[docs]
+class SmokeAlarmDetectionRule(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.smokeDetectorAlarmType = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.smokeDetectorAlarmType = js["smokeDetectorAlarmType"]

+
+
+    def __str__(self):
+        return "{} smokeDetectorAlarmType({})".format(
+            super().__str__(), self.smokeDetectorAlarmType
+        )

+
+
+
+

+[docs]
+class ShutterWindProtectionRule(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.windSpeedThreshold = None
+        self.targetShutterLevel = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.windSpeedThreshold = js["windSpeedThreshold"]
+        self.targetShutterLevel = js["targetShutterLevel"]

+
+
+    def __str__(self):
+        return "{} windSpeedThreshold({}) targetShutterLevel({})".format(
+            super().__str__(), self.windSpeedThreshold, self.targetShutterLevel
+        )

+
+
+
+

+[docs]
+class LockOutProtectionRule(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.triggered = None
+        self.windowState = None
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.triggered = js["triggered"]
+        self.windowState = js["windowState"]

+
+
+    def __str__(self):
+        return "{} triggered({}) windowState({})".format(
+            super().__str__(), self.triggered, self.windowState
+        )

+
+
+
+

+[docs]
+class EnvironmentGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.actualTemperature = 0.0
+        self.illumination = 0.0
+        self.raining = False
+        self.windSpeed = 0.0
+        self.humidity = 0.0
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.actualTemperature = js["actualTemperature"]
+        self.illumination = js["illumination"]
+        self.raining = js["raining"]
+        self.windSpeed = js["windSpeed"]
+        self.humidity = js["humidity"]

+
+
+    def __str__(self):
+        return "{} actualTemperature({}) illumination({}) raining({}) windSpeed({}) humidity({})".format(
+            super().__str__(),
+            self.actualTemperature,
+            self.illumination,
+            self.raining,
+            self.windSpeed,
+            self.humidity,
+        )

+
+
+
+

+[docs]
+class HotWaterGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.on = None
+        self.onTime = 0.0
+        self.profileId = (
+            None  # Not sure why it is there.  You can't use it to query something.
+        )
+        self.profileMode = ProfileMode.MANUAL
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.set_attr_from_dict("on", js)
+        self.set_attr_from_dict("onTime", js)
+        self.set_attr_from_dict("profileId", js)
+        self.set_attr_from_dict("profileMode", js, ProfileMode)

+
+
+    def __str__(self):
+        return f"{super().__str__()} on({self.on}) onTime({self.onTime}) profileMode({self.profileMode})"
+
+

+[docs]
+    def set_profile_mode(self, profileMode: ProfileMode):
+        data = {"groupId": self.id, "profileMode": profileMode}
+        return self._rest_call("group/heating/setProfileMode", body=json.dumps(data))

+

+
+
+
+

+[docs]
+class AccessAuthorizationProfileGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.active = False
+        self.authorizationPinAssigned = False
+        self.authorized = False
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)
+        self.active = js["active"]
+        self.authorizationPinAssigned = js["authorizationPinAssigned"]
+        self.authorized = js["authorized"]

+

+
+
+
+

+[docs]
+class AccessControlGroup(Group):
+    def __init__(self, connection):
+        super().__init__(connection)
+
+

+[docs]
+    def from_json(self, js, devices):
+        super().from_json(js, devices)

+

+
+
+
+

+[docs]
+class EnergyGroup(Group):
+    pass

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/home.html b/_modules/homematicip/home.html new file mode 100644 index 00000000..0d761a6e --- /dev/null +++ b/_modules/homematicip/home.html @@ -0,0 +1,1028 @@ + + + + + + + + homematicip.home — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.home

+import logging
+import ssl
+import sys
+import threading
+from typing import List
+
+from homematicip.base.channel_event import ChannelEvent
+import websocket
+
+from homematicip.access_point_update_state import AccessPointUpdateState
+from homematicip.base.enums import *
+from homematicip.base.helpers import bytes2str
+from homematicip.class_maps import *
+from homematicip.client import Client
+from homematicip.connection import Connection
+from homematicip.device import *
+from homematicip.EventHook import *
+from homematicip.group import *
+from homematicip.location import Location
+from homematicip.oauth_otk import OAuthOTK
+from homematicip.rule import *
+from homematicip.securityEvent import *
+from homematicip.weather import Weather
+
+LOGGER = logging.getLogger(__name__)
+
+
+

+[docs]
+class Home(HomeMaticIPObject):
+    """this class represents the 'Home' of the homematic ip"""
+
+    _typeClassMap = TYPE_CLASS_MAP
+    _typeGroupMap = TYPE_GROUP_MAP
+    _typeSecurityEventMap = TYPE_SECURITY_EVENT_MAP
+    _typeRuleMap = TYPE_RULE_MAP
+    _typeFunctionalHomeMap = TYPE_FUNCTIONALHOME_MAP
+
+    def __init__(self, connection=None):
+        if connection is None:
+            connection = Connection()
+        super().__init__(connection)
+
+        # List with create handlers.
+        self._on_create = []
+        # EventHandler for channel events
+        self._on_channel_event = []
+
+        self.apExchangeClientId = None
+        self.apExchangeState = ApExchangeState.NONE
+        self.availableAPVersion = None
+        self.carrierSense = None
+        #:bool:displays if the access point is connected to the hmip cloud or
+        # not
+        self.connected = None
+        #:str:the current version of the access point
+        self.currentAPVersion = None
+        self.deviceUpdateStrategy = DeviceUpdateStrategy.MANUALLY
+        self.dutyCycle = None
+        #:str:the SGTIN of the access point
+        self.id = None
+        self.lastReadyForUpdateTimestamp = None
+        #:Location:the location of the AP
+        self.location = None
+        #:bool:determines if a pin is set on this access point
+        self.pinAssigned = None
+        self.powerMeterCurrency = None
+        self.powerMeterUnitPrice = None
+        self.timeZoneId = None
+        self.updateState = HomeUpdateState.UP_TO_DATE
+        #:Weather:the current weather
+        self.weather = None
+
+        self.__webSocket = None
+        self.__webSocketThread = None
+        self.onEvent = EventHook()
+        self.onWsError = EventHook()
+        #:bool:switch to enable/disable automatic reconnection of the websocket (default=True)
+        self.websocket_reconnect_on_error = True
+
+        #:List[Device]: a collection of all devices in home
+        self.devices = []
+        #:List[Client]: a collection of all clients in home
+        self.clients = []
+        #:List[Group]: a collection of all groups in the home
+        self.groups = []
+        #:List[FunctionalChannel]: a collection of all channels in the home
+        self.channels = []
+        #:List[Rule]: a collection of all rules in the home
+        self.rules = []
+        #: a collection of all functionalHomes in the home
+        self.functionalHomes = []
+        #:Map: a map of all access points and their updateStates
+        self.accessPointUpdateStates = {}
+
+

+[docs]
+    def init(self, access_point_id, lookup=True):
+        self._connection.init(access_point_id, lookup)

+
+
+

+[docs]
+    def set_auth_token(self, auth_token):
+        self._connection.set_auth_token(auth_token)

+
+
+

+[docs]
+    def from_json(self, js_home):
+        super().from_json(js_home)
+
+        self.weather = Weather(self._connection)
+        self.weather.from_json(js_home["weather"])
+        if js_home["location"] != None:
+            self.location = Location(self._connection)
+            self.location.from_json(js_home["location"])
+
+        self.connected = js_home["connected"]
+        self.currentAPVersion = js_home["currentAPVersion"]
+        self.availableAPVersion = js_home["availableAPVersion"]
+        self.timeZoneId = js_home["timeZoneId"]
+        self.pinAssigned = js_home["pinAssigned"]
+        self.dutyCycle = js_home["dutyCycle"]
+        self.updateState = HomeUpdateState.from_str(js_home["updateState"])
+        self.powerMeterUnitPrice = js_home["powerMeterUnitPrice"]
+        self.powerMeterCurrency = js_home["powerMeterCurrency"]
+        self.deviceUpdateStrategy = DeviceUpdateStrategy.from_str(
+            js_home["deviceUpdateStrategy"]
+        )
+        self.lastReadyForUpdateTimestamp = js_home["lastReadyForUpdateTimestamp"]
+        self.apExchangeClientId = js_home["apExchangeClientId"]
+        self.apExchangeState = ApExchangeState.from_str(js_home["apExchangeState"])
+        self.id = js_home["id"]
+        self.carrierSense = js_home["carrierSense"]
+
+        for ap, state in js_home["accessPointUpdateStates"].items():
+            ap_state = AccessPointUpdateState(self._connection)
+            ap_state.from_json(state)
+            self.accessPointUpdateStates[ap] = ap_state
+
+        self._get_rules(js_home)

+
+
+

+[docs]
+    def on_create(self, handler):
+        """Adds an event handler to the create method. Fires when a device
+        is created."""
+        self._on_create.append(handler)

+
+
+

+[docs]
+    def fire_create_event(self, *args, **kwargs):
+        """Trigger the method tied to _on_create"""
+        for _handler in self._on_create:
+            _handler(*args, **kwargs)

+
+
+

+[docs]
+    def fire_channel_event(self, *args, **kwargs):
+        """Trigger the method tied to _on_channel_event"""
+        for _handler in self._on_channel_event:
+            _handler(*args, **kwargs)

+
+
+

+[docs]
+    def remove_callback(self, handler):
+        """Remove event handler."""
+        super().remove_callback(handler)
+        if handler in self._on_create:
+            self._on_create.remove(handler)

+
+
+

+[docs]
+    def on_channel_event(self, handler):
+        """Adds an event handler to the channel event method. Fires when a channel event
+        is received."""
+        self._on_channel_event.append(handler)

+
+
+

+[docs]
+    def remove_channel_event_handler(self, handler):
+        """Remove event handler."""
+        if handler in self._on_channel_event:
+            self._on_channel_event.remove(handler)

+
+
+

+[docs]
+    def download_configuration(self) -> str:
+        """downloads the current configuration from the cloud
+
+        Returns
+            the downloaded configuration or an errorCode
+        """
+        return self._rest_call(
+            "home/getCurrentState", json.dumps(self._connection.clientCharacteristics)
+        )

+
+
+

+[docs]
+    def get_current_state(self, clearConfig: bool = False):
+        """downloads the current configuration and parses it into self
+
+        Args:
+            clearConfig(bool): if set to true, this function will remove all old objects
+            from self.devices, self.client, ... to have a fresh config instead of reparsing them
+        """
+        json_state = self.download_configuration()
+        return self.update_home(json_state, clearConfig)

+
+
+

+[docs]
+    def update_home(self, json_state, clearConfig: bool = False):
+        """parse a given json configuration into self.
+        This will update the whole home including devices, clients and groups.
+
+        Args:
+            clearConfig(bool): if set to true, this function will remove all old objects
+            from self.devices, self.client, ... to have a fresh config instead of reparsing them
+        """
+        if "errorCode" in json_state:
+            LOGGER.error(
+                "Could not get the current configuration. Error: %s",
+                json_state["errorCode"],
+            )
+            return False
+
+        if clearConfig:
+            self.devices = []
+            self.clients = []
+            self.groups = []
+            self.channels = []
+
+        self._get_devices(json_state)
+        self._get_clients(json_state)
+        self._get_groups(json_state)
+        self._load_functionalChannels()
+
+        js_home = json_state["home"]
+
+        return self.update_home_only(js_home, clearConfig)

+
+
+

+[docs]
+    def update_home_only(self, js_home, clearConfig: bool = False):
+        """parse a given home json configuration into self.
+        This will update only the home without updating devices, clients and groups.
+
+        Args:
+            clearConfig(bool): if set to true, this function will remove all old objects
+            from self.devices, self.client, ... to have a fresh config instead of reparsing them
+        """
+        if "errorCode" in js_home:
+            LOGGER.error(
+                "Could not get the current configuration. Error: %s",
+                js_home["errorCode"],
+            )
+            return False
+
+        if clearConfig:
+            self.rules = []
+            self.functionalHomes = []
+
+        self.from_json(js_home)
+        self._get_functionalHomes(js_home)
+
+        return True

+
+
+    def _get_devices(self, json_state):
+        self.devices = [x for x in self.devices if x.id in json_state["devices"].keys()]
+        for id_, raw in json_state["devices"].items():
+            try:
+                _device = self.search_device_by_id(id_)
+                if _device:
+                    _device.from_json(raw)
+                else:
+                    self.devices.append(self._parse_device(raw))
+            except Exception as err:
+                LOGGER.error(
+                    f"An exception in _get_devices (device-id {id_}) of type {type(err).__name__} occurred: {err}"
+                )
+                return None
+
+    def _parse_device(self, json_state):
+        try:
+            deviceType = DeviceType.from_str(json_state["type"])
+            d = self._typeClassMap[deviceType](self._connection)
+            d.from_json(json_state)
+            return d
+        except:
+            d = self._typeClassMap[DeviceType.BASE_DEVICE](self._connection)
+            d.from_json(json_state)
+            LOGGER.warning("There is no class for device '%s' yet", json_state["type"])
+            return d
+
+    def _get_rules(self, json_state):
+        self.rules = [
+            x for x in self.rules if x.id in json_state["ruleMetaDatas"].keys()
+        ]
+        for id_, raw in json_state["ruleMetaDatas"].items():
+            _rule = self.search_rule_by_id(id_)
+            if _rule:
+                _rule.from_json(raw)
+            else:
+                self.rules.append(self._parse_rule(raw))
+
+    def _parse_rule(self, json_state):
+        try:
+            ruleType = AutomationRuleType.from_str(json_state["type"])
+            r = self._typeRuleMap[ruleType](self._connection)
+            r.from_json(json_state)
+            return r
+        except:
+            r = Rule(self._connection)
+            r.from_json(json_state)
+            LOGGER.warning("There is no class for rule  '%s' yet", json_state["type"])
+            return r
+
+    def _get_clients(self, json_state):
+        self.clients = [x for x in self.clients if x.id in json_state["clients"].keys()]
+        for id_, raw in json_state["clients"].items():
+            _client = self.search_client_by_id(id_)
+            if _client:
+                _client.from_json(raw)
+            else:
+                c = Client(self._connection)
+                c.from_json(raw)
+                self.clients.append(c)
+
+    def _parse_group(self, json_state):
+        g = None
+        if json_state["type"] == "META":
+            g = MetaGroup(self._connection)
+            g.from_json(json_state, self.devices, self.groups)
+        else:
+            try:
+                groupType = GroupType.from_str(json_state["type"])
+                g = self._typeGroupMap[groupType](self._connection)
+                g.from_json(json_state, self.devices)
+            except:
+                g = self._typeGroupMap[GroupType.GROUP](self._connection)
+                g.from_json(json_state, self.devices)
+                LOGGER.warning(
+                    "There is no class for group '%s' yet", json_state["type"]
+                )
+        return g
+
+    def _get_groups(self, json_state):
+        self.groups = [x for x in self.groups if x.id in json_state["groups"].keys()]
+        metaGroups = []
+        for id_, raw in json_state["groups"].items():
+            _group = self.search_group_by_id(id_)
+            if _group:
+                if isinstance(_group, MetaGroup):
+                    _group.from_json(raw, self.devices, self.groups)
+                else:
+                    _group.from_json(raw, self.devices)
+            else:
+                group_type = raw["type"]
+                if group_type == "META":
+                    metaGroups.append(raw)
+                else:
+                    self.groups.append(self._parse_group(raw))
+        for mg in metaGroups:
+            self.groups.append(self._parse_group(mg))
+
+    def _get_functionalHomes(self, json_state):
+        for solution, functionalHome in json_state["functionalHomes"].items():
+            try:
+                solutionType = FunctionalHomeType.from_str(solution)
+                h = None
+                for fh in self.functionalHomes:
+                    if fh.solution == solution:
+                        h = fh
+                        break
+                if h is None:
+                    h = self._typeFunctionalHomeMap[solutionType](self._connection)
+                    self.functionalHomes.append(h)
+                h.from_json(functionalHome, self.groups)
+            except:
+                h = FunctionalHome(self._connection)
+                h.from_json(functionalHome, self.groups)
+                LOGGER.warning(
+                    "There is no class for functionalHome '%s' yet", solution
+                )
+                self.functionalHomes.append(h)
+
+    def _load_functionalChannels(self):
+        for d in self.devices:
+            d.load_functionalChannels(self.groups, self.channels)
+
+

+[docs]
+    def get_functionalHome(self, functionalHomeType: type) -> FunctionalHome:
+        """gets the specified functionalHome
+
+        Args:
+            functionalHome(type): the type of the functionalHome which should be returned
+
+        Returns:
+            the FunctionalHome or None if it couldn't be found
+        """
+        for x in self.functionalHomes:
+            if isinstance(x, functionalHomeType):
+                return x
+
+        return None

+
+
+

+[docs]
+    def search_device_by_id(self, deviceID) -> Device:
+        """searches a device by given id
+
+        Args:
+          deviceID(str): the device to search for
+
+        Returns
+          the Device object or None if it couldn't find a device
+        """
+        for d in self.devices:
+            if d.id == deviceID:
+                return d
+        return None

+
+
+

+[docs]
+    def search_channel(self, deviceID, channelIndex) -> FunctionalChannel:
+        """searches a channel by given deviceID and channelIndex"""
+        foundD = [d for d in self.devices if d.id == deviceID]
+        d = foundD[0] if foundD else None
+        if d is not None:
+            foundC = [ch for ch in d.functionalChannels if ch.index == channelIndex]
+            return foundC[0] if foundC else None
+        return None

+
+
+

+[docs]
+    def search_group_by_id(self, groupID) -> Group:
+        """searches a group by given id
+
+        Args:
+          groupID(str): groupID the group to search for
+
+        Returns
+          the group object or None if it couldn't find a group
+        """
+        for g in self.groups:
+            if g.id == groupID:
+                return g
+        return None

+
+
+

+[docs]
+    def search_client_by_id(self, clientID) -> Client:
+        """searches a client by given id
+
+        Args:
+          clientID(str): the client to search for
+
+        Returns
+          the client object or None if it couldn't find a client
+        """
+        for c in self.clients:
+            if c.id == clientID:
+                return c
+        return None

+
+
+

+[docs]
+    def search_rule_by_id(self, ruleID) -> Rule:
+        """searches a rule by given id
+
+        Args:
+          ruleID(str): the rule to search for
+
+        Returns
+          the rule object or None if it couldn't find a rule
+        """
+        for r in self.rules:
+            if r.id == ruleID:
+                return r
+        return None

+
+
+

+[docs]
+    def get_security_zones_activation(self) -> (bool, bool):
+        """returns the value of the security zones if they are armed or not
+
+        Returns
+            internal
+              True if the internal zone is armed
+            external
+              True if the external zone is armed
+        """
+        internal_active = False
+        external_active = False
+        for g in self.groups:
+            if isinstance(g, SecurityZoneGroup):
+                if g.label == "EXTERNAL":
+                    external_active = g.active
+                elif g.label == "INTERNAL":
+                    internal_active = g.active
+        return internal_active, external_active

+
+
+

+[docs]
+    def set_security_zones_activation(self, internal=True, external=True):
+        """this function will set the alarm system to armed or disable it
+
+        Args:
+          internal(bool): activates/deactivates the internal zone
+          external(bool): activates/deactivates the external zone
+
+        Examples:
+          arming while being at home
+
+          >>> home.set_security_zones_activation(False,True)
+
+          arming without being at home
+
+          >>> home.set_security_zones_activation(True,True)
+
+          disarming the alarm system
+
+          >>> home.set_security_zones_activation(False,False)
+        """
+        data = {"zonesActivation": {"EXTERNAL": external, "INTERNAL": internal}}
+        return self._rest_call("home/security/setZonesActivation", json.dumps(data))

+
+
+

+[docs]
+    def set_silent_alarm(self, internal=True, external=True):
+        """this function will set the silent alarm for interal or external
+
+        Args:
+          internal(bool): activates/deactivates the silent alarm for internal zone
+          external(bool): activates/deactivates the silent alarm for the external zone
+        """
+        data = {"zonesSilentAlarm": {"EXTERNAL": external, "INTERNAL": internal}}
+        return self._rest_call("home/security/setZonesSilentAlarm", json.dumps(data))

+
+
+

+[docs]
+    def set_location(self, city, latitude, longitude):
+        data = {"city": city, "latitude": latitude, "longitude": longitude}
+        return self._rest_call("home/setLocation", json.dumps(data))

+
+
+

+[docs]
+    def set_cooling(self, cooling):
+        data = {"cooling": cooling}
+        return self._rest_call("home/heating/setCooling", json.dumps(data))

+
+
+

+[docs]
+    def set_intrusion_alert_through_smoke_detectors(self, activate: bool = True):
+        """activate or deactivate if smoke detectors should "ring" during an alarm
+
+        Args:
+            activate(bool): True will let the smoke detectors "ring" during an alarm
+        """
+        data = {"intrusionAlertThroughSmokeDetectors": activate}
+        return self._rest_call(
+            "home/security/setIntrusionAlertThroughSmokeDetectors", json.dumps(data)
+        )

+
+
+

+[docs]
+    def activate_absence_with_period(self, endtime: datetime):
+        """activates the absence mode until the given time
+
+        Args:
+            endtime(datetime): the time when the absence should automatically be disabled
+        """
+        data = {"endTime": endtime.strftime("%Y_%m_%d %H:%M")}
+        return self._rest_call(
+            "home/heating/activateAbsenceWithPeriod", json.dumps(data)
+        )

+
+
+

+[docs]
+    def activate_absence_permanent(self):
+        """activates the absence forever"""
+        return self._rest_call("home/heating/activateAbsencePermanent")

+
+
+

+[docs]
+    def activate_absence_with_duration(self, duration: int):
+        """activates the absence mode for a given time
+
+        Args:
+            duration(int): the absence duration in minutes
+        """
+        data = {"duration": duration}
+        return self._rest_call(
+            "home/heating/activateAbsenceWithDuration", json.dumps(data)
+        )

+
+
+

+[docs]
+    def deactivate_absence(self):
+        """deactivates the absence mode immediately"""
+        return self._rest_call("home/heating/deactivateAbsence")

+
+
+

+[docs]
+    def activate_vacation(self, endtime: datetime, temperature: float):
+        """activates the vatation mode until the given time
+
+        Args:
+            endtime(datetime): the time when the vatation mode should automatically be disabled
+            temperature(float): the settemperature during the vacation mode
+        """
+        data = {
+            "endTime": endtime.strftime("%Y_%m_%d %H:%M"),
+            "temperature": temperature,
+        }
+        return self._rest_call("home/heating/activateVacation", json.dumps(data))

+
+
+

+[docs]
+    def deactivate_vacation(self):
+        """deactivates the vacation mode immediately"""
+        return self._rest_call("home/heating/deactivateVacation")

+
+
+

+[docs]
+    def set_pin(self, newPin: str, oldPin: str = None) -> dict:
+        """sets a new pin for the home
+
+        Args:
+            newPin(str): the new pin
+            oldPin(str): optional, if there is currently a pin active it must be given here.
+                        Otherwise it will not be possible to set the new pin
+
+        Returns:
+            the result of the call
+        """
+        if newPin is None:
+            newPin = ""
+        data = {"pin": newPin}
+        if oldPin:
+            self._connection.headers["PIN"] = str(oldPin)
+        result = self._rest_call("home/setPin", body=json.dumps(data))
+        if oldPin:
+            del self._connection.headers["PIN"]
+        return result

+
+
+

+[docs]
+    def set_zone_activation_delay(self, delay):
+        data = {"zoneActivationDelay": delay}
+        return self._rest_call(
+            "home/security/setZoneActivationDelay", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def get_security_journal(self):
+        journal = self._rest_call("home/security/getSecurityJournal")
+        if "errorCode" in journal:
+            LOGGER.error(
+                "Could not get the security journal. Error: %s", journal["errorCode"]
+            )
+            return None
+        ret = []
+        for entry in journal["entries"]:
+            try:
+                eventType = SecurityEventType(entry["eventType"])
+                if eventType in self._typeSecurityEventMap:
+                    j = self._typeSecurityEventMap[eventType](self._connection)
+            except:
+                j = SecurityEvent(self._connection)
+                LOGGER.warning("There is no class for %s yet", entry["eventType"])
+
+            j.from_json(entry)
+            ret.append(j)
+
+        return ret

+
+
+

+[docs]
+    def delete_group(self, group: Group):
+        """deletes the given group from the cloud
+
+        Args:
+            group(Group):the group to delete
+        """
+        return group.delete()

+
+
+

+[docs]
+    def get_OAuth_OTK(self):
+        token = OAuthOTK(self._connection)
+        token.from_json(self._rest_call("home/getOAuthOTK"))
+        return token

+
+
+

+[docs]
+    def set_timezone(self, timezone: str):
+        """sets the timezone for the AP. e.g. "Europe/Berlin"
+        Args:
+            timezone(str): the new timezone
+        """
+        data = {"timezoneId": timezone}
+        return self._rest_call("home/setTimezone", body=json.dumps(data))

+
+
+

+[docs]
+    def set_powermeter_unit_price(self, price):
+        data = {"powerMeterUnitPrice": price}
+        return self._rest_call("home/setPowerMeterUnitPrice", body=json.dumps(data))

+
+
+

+[docs]
+    def set_zones_device_assignment(self, internal_devices, external_devices) -> dict:
+        """sets the devices for the security zones
+        Args:
+            internal_devices(List[Device]): the devices which should be used for the internal zone
+            external_devices(List[Device]):  the devices which should be used for the external(hull) zone
+
+        Returns:
+            the result of _restCall
+        """
+        internal = [x.id for x in internal_devices]
+        external = [x.id for x in external_devices]
+        data = {"zonesDeviceAssignment": {"INTERNAL": internal, "EXTERNAL": external}}
+        return self._rest_call(
+            "home/security/setZonesDeviceAssignment", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def start_inclusion(self, deviceId):
+        """start inclusion mode for specific device
+        Args:
+            deviceId: sgtin of device
+        """
+        data = {"deviceId": deviceId}
+        return self._rest_call(
+            "home/startInclusionModeForDevice", body=json.dumps(data)
+        )

+
+
+

+[docs]
+    def enable_events(self, enable_trace=False, ping_interval=20):
+        websocket.enableTrace(enable_trace)
+
+        self.__webSocket = websocket.WebSocketApp(
+            self._connection.urlWebSocket,
+            header=[
+                "AUTHTOKEN: {}".format(self._connection.auth_token),
+                "CLIENTAUTH: {}".format(self._connection.clientauth_token),
+                "ACCESSPOINT-ID: {}".format(self._connection.accesspoint_id),
+            ],
+            on_message=self._ws_on_message,
+            on_error=self._ws_on_error,
+            on_close=self._ws_on_close,
+        )
+
+        websocket_kwargs = {"ping_interval": ping_interval}
+        if hasattr(sys, "_called_from_test"):  # disable ssl during a test run
+            sslopt = {"cert_reqs": ssl.CERT_NONE}
+            websocket_kwargs = {"sslopt": sslopt, "ping_interval": 2, "ping_timeout": 1}
+
+        self.__webSocketThread = threading.Thread(
+            name="hmip-websocket",
+            target=self.__webSocket.run_forever,
+            kwargs=websocket_kwargs,
+        )
+        self.__webSocketThread.daemon = True
+        self.__webSocketThread.start()

+
+
+

+[docs]
+    def disable_events(self):
+        if self.__webSocket:
+            self.__webSocket.close()
+            self.__webSocket = None

+
+
+    def _ws_on_close(self, *_):
+        self.__webSocket = None
+
+    def _ws_on_error(self, _, err):
+        LOGGER.exception(err)
+        self.onWsError.fire(err)
+        if self.websocket_reconnect_on_error:
+            logger.debug("Trying to reconnect websocket")
+            self.disable_events()
+            self.enable_events()
+
+    def _ws_on_message(self, _, message):
+        # json.loads doesn't support bytes as parameter before python 3.6
+        js = json.loads(bytes2str(message))
+        # LOGGER.debug(js)
+        eventList = []
+        for event in js["events"].values():
+            try:
+                pushEventType = EventType(event["pushEventType"])
+                LOGGER.debug(pushEventType)
+                obj = None
+                if pushEventType == EventType.GROUP_CHANGED:
+                    data = event["group"]
+                    obj = self.search_group_by_id(data["id"])
+                    if obj is None:
+                        obj = self._parse_group(data)
+                        self.groups.append(obj)
+                        pushEventType = EventType.GROUP_ADDED
+                        self.fire_create_event(obj, event_type=pushEventType, obj=obj)
+                    if type(obj) is MetaGroup:
+                        obj.from_json(data, self.devices, self.groups)
+                    else:
+                        obj.from_json(data, self.devices)
+                    obj.fire_update_event(data, event_type=pushEventType, obj=obj)
+                elif pushEventType == EventType.HOME_CHANGED:
+                    data = event["home"]
+                    obj = self
+                    obj.update_home_only(data)
+                    obj.fire_update_event(data, event_type=pushEventType, obj=obj)
+                elif pushEventType == EventType.CLIENT_ADDED:
+                    data = event["client"]
+                    obj = Client(self._connection)
+                    obj.from_json(data)
+                    self.clients.append(obj)
+                elif pushEventType == EventType.CLIENT_CHANGED:
+                    data = event["client"]
+                    obj = self.search_client_by_id(data["id"])
+                    obj.from_json(data)
+                elif pushEventType == EventType.CLIENT_REMOVED:
+                    obj = self.search_client_by_id(event["id"])
+                    self.clients.remove(obj)
+                elif pushEventType == EventType.DEVICE_ADDED:
+                    data = event["device"]
+                    obj = self._parse_device(data)
+                    obj.load_functionalChannels(self.groups, self.channels)
+                    self.devices.append(obj)
+                    self.fire_create_event(data, event_type=pushEventType, obj=obj)
+                elif pushEventType == EventType.DEVICE_CHANGED:
+                    data = event["device"]
+                    obj = self.search_device_by_id(data["id"])
+                    if obj is None:  # no DEVICE_ADDED Event?
+                        obj = self._parse_device(data)
+                        self.devices.append(obj)
+                        pushEventType = EventType.DEVICE_ADDED
+                        self.fire_create_event(data, event_type=pushEventType, obj=obj)
+                    else:
+                        obj.from_json(data)
+                    obj.load_functionalChannels(self.groups, self.channels)
+                    obj.fire_update_event(data, event_type=pushEventType, obj=obj)
+                elif pushEventType == EventType.DEVICE_REMOVED:
+                    obj = self.search_device_by_id(event["id"])
+                    obj.fire_remove_event(obj, event_type=pushEventType, obj=obj)
+                    self.devices.remove(obj)
+                elif pushEventType == EventType.DEVICE_CHANNEL_EVENT:
+                    channel_event = ChannelEvent(**event)
+                    ch = self.search_channel(channel_event.deviceId, channel_event.channelIndex)
+                    if ch is not None:
+                        ch.fire_channel_event(channel_event)
+                elif pushEventType == EventType.GROUP_REMOVED:
+                    obj = self.search_group_by_id(event["id"])
+                    obj.fire_remove_event(obj, event_type=pushEventType, obj=obj)
+                    self.groups.remove(obj)
+                elif pushEventType == EventType.GROUP_ADDED:
+                    group = event["group"]
+                    obj = self._parse_group(group)
+                    self.groups.append(obj)
+                    self.fire_create_event(obj, event_type=pushEventType, obj=obj)
+                elif pushEventType == EventType.SECURITY_JOURNAL_CHANGED:
+                    pass  # data is just none so nothing to do here
+
+                # TODO: implement INCLUSION_REQUESTED, NONE
+                eventList.append({"eventType": pushEventType, "data": obj})
+            except ValueError as valerr:  # pragma: no cover
+                LOGGER.warning(
+                    "Uknown EventType '%s' Data: %s", event["pushEventType"], event
+                )
+
+            except Exception as err:  # pragma: no cover
+                LOGGER.exception(err)
+        self.onEvent.fire(eventList)

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/location.html b/_modules/homematicip/location.html new file mode 100644 index 00000000..22995923 --- /dev/null +++ b/_modules/homematicip/location.html @@ -0,0 +1,138 @@ + + + + + + + + homematicip.location — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.location

+from homematicip.base.homematicip_object import HomeMaticIPObject
+
+
+

+[docs]
+class Location(HomeMaticIPObject):
+    """This class represents the possible location"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:str: the name of the city
+        self.city = "London"
+        #:float: the latitude of the location
+        self.latitude = 51.509865
+        #:float: the longitue of the location
+        self.longitude = -0.118092
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.city = js["city"]
+        self.latitude = js["latitude"]
+        self.longitude = js["longitude"]

+
+
+    def __str__(self):
+        return "city({}) latitude({}) longitude({})".format(
+            self.city, self.latitude, self.longitude
+        )

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/oauth_otk.html b/_modules/homematicip/oauth_otk.html new file mode 100644 index 00000000..d5ca1e18 --- /dev/null +++ b/_modules/homematicip/oauth_otk.html @@ -0,0 +1,126 @@ + + + + + + + + homematicip.oauth_otk — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.oauth_otk

+from homematicip.base.homematicip_object import HomeMaticIPObject
+
+
+

+[docs]
+class OAuthOTK(HomeMaticIPObject):
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.authToken = None
+        self.expirationTimestamp = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.authToken = js["authToken"]
+        self.expirationTimestamp = self.fromtimestamp(js["expirationTimestamp"])

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/rule.html b/_modules/homematicip/rule.html new file mode 100644 index 00000000..0712c8ef --- /dev/null +++ b/_modules/homematicip/rule.html @@ -0,0 +1,210 @@ + + + + + + + + homematicip.rule — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.rule

+import json
+
+from homematicip.base.homematicip_object import HomeMaticIPObject
+
+
+

+[docs]
+class Rule(HomeMaticIPObject):
+    """this class represents the automation rule """
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.id = None
+        self.homeId = None
+        self.label = ""
+        self.active = False
+        self.ruleErrorCategories = []
+        self.ruleType = ""
+        # these 3 fill be filled from subclasses
+        self.errorRuleTriggerItems = []
+        self.errorRuleConditionItems = []
+        self.errorRuleActionItems = []
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.id = js["id"]
+        self.homeId = js["homeId"]
+        self.label = js["label"]
+        self.active = js["active"]
+        self.ruleType = js["type"]
+
+        self.devices = []
+        for errorCategory in js["ruleErrorCategories"]:
+            pass  # at the moment this was always empty

+
+
+

+[docs]
+    def set_label(self, label):
+        """ sets the label of the rule """
+        data = {"ruleId": self.id, "label": label}
+        return self._rest_call("rule/setRuleLabel", json.dumps(data))

+
+
+    def __str__(self):
+        return "{} {} active({})".format(self.ruleType, self.label, self.active)

+
+
+
+

+[docs]
+class SimpleRule(Rule):
+    """ This class represents a "Simple" automation rule """
+
+

+[docs]
+    def enable(self):
+        """ enables the rule """
+        return self.set_rule_enabled_state(True)

+
+
+

+[docs]
+    def disable(self):
+        """ disables the rule """
+        return self.set_rule_enabled_state(False)

+
+
+

+[docs]
+    def set_rule_enabled_state(self, enabled):
+        """ enables/disables this rule"""
+        data = {"ruleId": self.id, "enabled": enabled}
+        return self._rest_call("rule/enableSimpleRule", json.dumps(data))

+
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)

+
+        # self.get_simple_rule()
+
+

+[docs]
+    def get_simple_rule(self):
+        data = {"ruleId": self.id}
+        js = self._rest_call("rule/getSimpleRule", json.dumps(data))
+
+        for errorRuleTriggerItem in js["errorRuleTriggerItems"]:
+            pass  # at the moment this was always empty
+
+        for errorRuleConditionItem in js["errorRuleConditionItems"]:
+            pass  # at the moment this was always empty
+
+        for errorRuleActionItem in js["errorRuleActionItems"]:
+            pass  # at the moment this was always empty
+
+        sr = js["simpleRule"]

+

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/securityEvent.html b/_modules/homematicip/securityEvent.html new file mode 100644 index 00000000..3e08b089 --- /dev/null +++ b/_modules/homematicip/securityEvent.html @@ -0,0 +1,261 @@ + + + + + + + + homematicip.securityEvent — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.securityEvent

+# coding=utf-8
+import json
+from datetime import datetime
+
+from homematicip.base.homematicip_object import HomeMaticIPObject
+
+
+

+[docs]
+class SecurityEvent(HomeMaticIPObject):
+    """this class represents a security event """
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.eventTimestamp = None
+        self.eventType = None
+        self.label = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.label = js["label"]
+        time = js["eventTimestamp"]
+        if time > 0:
+            self.eventTimestamp = datetime.fromtimestamp(time / 1000.0)
+        else:
+            self.eventTimestamp = None
+        self.eventType = js["eventType"]

+
+
+    def __str__(self):
+        return "{} {} {}".format(
+            self.eventType,
+            self.label,
+            self.eventTimestamp.strftime("%Y.%m.%d %H:%M:%S"),
+        )

+
+
+
+

+[docs]
+class SecurityZoneEvent(SecurityEvent):
+    """ This class will be used by other events which are just adding "securityZoneValues" """
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self.external_zone = None
+        self.internal_zone = None
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.external_zone = js["securityZoneValues"]["EXTERNAL"]
+        self.internal_zone = js["securityZoneValues"]["INTERNAL"]

+
+
+    def __str__(self):
+        return "{} external_zone({}) internal_zone({}) ".format(
+            super().__str__(), self.external_zone, self.internal_zone
+        )

+
+
+
+

+[docs]
+class SensorEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AccessPointDisconnectedEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class AccessPointConnectedEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class ActivationChangedEvent(SecurityZoneEvent):
+    pass

+
+
+
+

+[docs]
+class SilenceChangedEvent(SecurityZoneEvent):
+    pass

+
+
+
+

+[docs]
+class SabotageEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class MoistureDetectionEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class SmokeAlarmEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class ExternalTriggeredEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class OfflineAlarmEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class WaterDetectionEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class MainsFailureEvent(SecurityEvent):
+    pass

+
+
+
+

+[docs]
+class OfflineWaterDetectionEvent(SecurityEvent):
+    pass

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/homematicip/weather.html b/_modules/homematicip/weather.html new file mode 100644 index 00000000..aee4fd79 --- /dev/null +++ b/_modules/homematicip/weather.html @@ -0,0 +1,165 @@ + + + + + + + + homematicip.weather — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for homematicip.weather

+from homematicip.base.homematicip_object import HomeMaticIPObject
+from homematicip.base.enums import WeatherCondition, WeatherDayTime
+
+
+

+[docs]
+class Weather(HomeMaticIPObject):
+    """this class represents the weather of the home location"""
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        #:float: the current temperature
+        self.temperature = 0.0
+        #:WeatherCondition: the current weather
+        self.weatherCondition = WeatherCondition.UNKNOWN
+        #:datetime: the current datime
+        self.weatherDayTime = WeatherDayTime.DAY
+        #:float: the minimum temperature of the day
+        self.minTemperature = 0.0
+        #:float: the maximum temperature of the day
+        self.maxTemperature = 0.0
+        #:float: the current humidity
+        self.humidity = 0
+        #:float: the current windspeed
+        self.windSpeed = 0.0
+        #:int: the current wind direction in 360° where 0° is north
+        self.windDirection = 0
+        #:float: the current vapor
+        self.vaporAmount = 0.0
+
+

+[docs]
+    def from_json(self, js):
+        super().from_json(js)
+        self.temperature = js["temperature"]
+        self.weatherCondition = WeatherCondition.from_str(js["weatherCondition"])
+        self.weatherDayTime = WeatherDayTime.from_str(js["weatherDayTime"])
+        self.minTemperature = js["minTemperature"]
+        self.maxTemperature = js["maxTemperature"]
+        self.humidity = js["humidity"]
+        self.windSpeed = js["windSpeed"]
+        self.windDirection = js["windDirection"]
+        self.vaporAmount = js["vaporAmount"]

+
+
+    def __str__(self):
+        return "temperature({}) weatherCondition({}) weatherDayTime({}) minTemperature({}) maxTemperature({}) humidity({}) vaporAmount({}) windSpeed({}) windDirection({})".format(
+            self.temperature,
+            self.weatherCondition,
+            self.weatherDayTime,
+            self.minTemperature,
+            self.maxTemperature,
+            self.humidity,
+            self.vaporAmount,
+            self.windSpeed,
+            self.windDirection,
+        )

+
+
+ +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_modules/index.html b/_modules/index.html new file mode 100644 index 00000000..83fc1dfc --- /dev/null +++ b/_modules/index.html @@ -0,0 +1,131 @@ + + + + + + + + Overview: module code — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Overview: module code
    • +
  • +
    • +
+
+
+
+ +
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/_sources/api_introduction.rst.txt b/_sources/api_introduction.rst.txt new file mode 100644 index 00000000..986ae329 --- /dev/null +++ b/_sources/api_introduction.rst.txt @@ -0,0 +1,17 @@ +API Introduction +**************** + +There are a few key classes for communication with the Rest API of HomematicIP. + +| **Home:** is the most important object as it has the "overview" of the installation +| **Group:** a group of devices for a specific need. E.g. Heating group, security group, ... +| **MetaGroup:** a collection of groups. In the HomematicIP App this is called a "Room" +| **Device:** a hardware device e.g. shutter contact, heating thermostat, alarm siren, ... +| **FunctionChannel:** a channel of a device. For example DoorLockChannel for DoorLockDrive or **DimmerChannel**. A device has multiple channels - depending on its functions. + +| For example: +| The device HmIP-DLD is represented by the class **DoorLockDrive** (or AsyncDoorLockDrive). The device has multiple channels. +| The base channel holds informations about the device and has the index 0. +| The device has also a channel called **DoorLockChannel** which contains the functions "set_lock_state" and "async_set_lock_state". These are functions to set the lock state of that device. + +If you have dimmer with multiple I/Os, there are multiple channels. For each I/O a unique channel. \ No newline at end of file diff --git a/_sources/gettingstarted.rst.txt b/_sources/gettingstarted.rst.txt new file mode 100644 index 00000000..ddc1a80b --- /dev/null +++ b/_sources/gettingstarted.rst.txt @@ -0,0 +1,66 @@ +Getting Started +*************** + +Installation +============ + +Just run **pip3 install -U homematicip** in the command line to get the package. +This will install (and update) the library and all required packages + +Getting the AUTH-TOKEN +====================== +Before you can start using the library you will need an auth-token. Otherwise the HMIP Cloud will not trust you. + +You will need: + +- Access to an active Access Point (it must glow blue) +- the SGTIN of the Access Point +- [optional] the PIN + +Now you have to run `hmip_generate_auth_token` from terminal and follow it's instructions. +It will generate a **config.ini** in your current working directory. The scripts which are using this library are looking +for this file to load the auth-token and SGTIN of the Access Point. You can either place it in the working directory when you are +running the scripts or depending on your OS in different "global" folders: + +- General + + - current working directory + +- Windows + + - %APPDATA%\\homematicip-rest-api\ + - %PROGRAMDATA%\\homematicip-rest-api\ + +- Linux + + - ~/.homematicip-rest-api/ + - /etc/homematicip-rest-api/ + +- MAC OS + + - ~/Library/Preferences/homematicip-rest-api/ + - /Library/Application Support/homematicip-rest-api/ + +Using the CLI +============= + +You can send commands to homematicIP using the `hmip_cli` script. To get an overview, use -h or --help param. To address devices, use the argument -d in combination with the 24-digit ID (301400000000000000000000) from --list-devices. + +Get Information about devices and groups +---------------------------------------- + +Commands are bound to the channel type. To get a list of all allowed actions for a device you can write `hmip_cli -d {deviceid} --print-allowed-commands` or `hmip_cli -d {deviceid} -ac`. + +To get infos for a device and its channels use the `--print-infos` argument in combination with -d for a device or -g for a group. + +Examples +-------- + +A few examples: + +- `hmip_cli --help` to get help +- `hmip_cli --list-devices` to get a list of your devices. +- `hmip_cli -d --toggle-garage-door` to toogle the garage door with HmIP-WGC. +- `hmip_cli --list-events` to listen to events and changes in your homematicIP system +- `hmip_cli -d --set-lock-state LOCKED --pin 1234` to lock a door with HmIP-DLD +- `hmip_cli --dump-configuration --anonymize` to dump the current config and anonymize it. diff --git a/_sources/homematicip.aio.rst.txt b/_sources/homematicip.aio.rst.txt new file mode 100644 index 00000000..314e7479 --- /dev/null +++ b/_sources/homematicip.aio.rst.txt @@ -0,0 +1,77 @@ +homematicip.aio package +======================= + +Submodules +---------- + +homematicip.aio.auth module +--------------------------- + +.. automodule:: homematicip.aio.auth + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.class\_maps module +---------------------------------- + +.. automodule:: homematicip.aio.class_maps + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.connection module +--------------------------------- + +.. automodule:: homematicip.aio.connection + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.device module +----------------------------- + +.. automodule:: homematicip.aio.device + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.group module +---------------------------- + +.. automodule:: homematicip.aio.group + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.home module +--------------------------- + +.. automodule:: homematicip.aio.home + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.rule module +--------------------------- + +.. automodule:: homematicip.aio.rule + :members: + :undoc-members: + :show-inheritance: + +homematicip.aio.securityEvent module +------------------------------------ + +.. automodule:: homematicip.aio.securityEvent + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: homematicip.aio + :members: + :undoc-members: + :show-inheritance: diff --git a/_sources/homematicip.base.rst.txt b/_sources/homematicip.base.rst.txt new file mode 100644 index 00000000..78f57488 --- /dev/null +++ b/_sources/homematicip.base.rst.txt @@ -0,0 +1,61 @@ +homematicip.base package +======================== + +Submodules +---------- + +homematicip.base.HomeMaticIPObject module +----------------------------------------- + +.. automodule:: homematicip.base.HomeMaticIPObject + :members: + :undoc-members: + :show-inheritance: + +homematicip.base.base\_connection module +---------------------------------------- + +.. automodule:: homematicip.base.base_connection + :members: + :undoc-members: + :show-inheritance: + +homematicip.base.constants module +--------------------------------- + +.. automodule:: homematicip.base.constants + :members: + :undoc-members: + :show-inheritance: + +homematicip.base.enums module +----------------------------- + +.. automodule:: homematicip.base.enums + :members: + :undoc-members: + :show-inheritance: + +homematicip.base.functionalChannels module +------------------------------------------ + +.. automodule:: homematicip.base.functionalChannels + :members: + :undoc-members: + :show-inheritance: + +homematicip.base.helpers module +------------------------------- + +.. automodule:: homematicip.base.helpers + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: homematicip.base + :members: + :undoc-members: + :show-inheritance: diff --git a/_sources/homematicip.rst.txt b/_sources/homematicip.rst.txt new file mode 100644 index 00000000..d451a541 --- /dev/null +++ b/_sources/homematicip.rst.txt @@ -0,0 +1,150 @@ +homematicip package +=================== + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + homematicip.aio + homematicip.base + +Submodules +---------- + +homematicip.EventHook module +---------------------------- + +.. automodule:: homematicip.EventHook + :members: + :undoc-members: + :show-inheritance: + +homematicip.HomeMaticIPObject module +------------------------------------ + +.. automodule:: homematicip.HomeMaticIPObject + :members: + :undoc-members: + :show-inheritance: + +homematicip.access\_point\_update\_state module +----------------------------------------------- + +.. automodule:: homematicip.access_point_update_state + :members: + :undoc-members: + :show-inheritance: + +homematicip.auth module +----------------------- + +.. automodule:: homematicip.auth + :members: + :undoc-members: + :show-inheritance: + +homematicip.class\_maps module +------------------------------ + +.. automodule:: homematicip.class_maps + :members: + :undoc-members: + :show-inheritance: + +homematicip.client module +------------------------- + +.. automodule:: homematicip.client + :members: + :undoc-members: + :show-inheritance: + +homematicip.connection module +----------------------------- + +.. automodule:: homematicip.connection + :members: + :undoc-members: + :show-inheritance: + +homematicip.device module +------------------------- + +.. automodule:: homematicip.device + :members: + :undoc-members: + :show-inheritance: + +homematicip.functionalHomes module +---------------------------------- + +.. automodule:: homematicip.functionalHomes + :members: + :undoc-members: + :show-inheritance: + +homematicip.group module +------------------------ + +.. automodule:: homematicip.group + :members: + :undoc-members: + :show-inheritance: + +homematicip.home module +----------------------- + +.. automodule:: homematicip.home + :members: + :undoc-members: + :show-inheritance: + +homematicip.location module +--------------------------- + +.. automodule:: homematicip.location + :members: + :undoc-members: + :show-inheritance: + +homematicip.oauth\_otk module +----------------------------- + +.. automodule:: homematicip.oauth_otk + :members: + :undoc-members: + :show-inheritance: + +homematicip.rule module +----------------------- + +.. automodule:: homematicip.rule + :members: + :undoc-members: + :show-inheritance: + +homematicip.securityEvent module +-------------------------------- + +.. automodule:: homematicip.securityEvent + :members: + :undoc-members: + :show-inheritance: + +homematicip.weather module +-------------------------- + +.. automodule:: homematicip.weather + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: homematicip + :members: + :undoc-members: + :show-inheritance: diff --git a/_sources/index.rst.txt b/_sources/index.rst.txt new file mode 100644 index 00000000..d390474d --- /dev/null +++ b/_sources/index.rst.txt @@ -0,0 +1,31 @@ +.. HomematicIP-Rest-API documentation master file, created by + sphinx-quickstart on Fri Jan 12 11:14:32 2024. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to Homematic IP Rest API's documentation! +================================================= + +This documentation is for a **Python 3** wrapper for the homematicIP REST API (Access Point Based) +Since there is no official documentation about this API everything was +done via reverse engineering. Use at your own risk. + +.. toctree:: + :maxdepth: 2 + :caption: Getting started + + gettingstarted + +.. toctree:: + :maxdepth: 4 + :caption: API Documentation + + api_introduction + modules + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/_sources/modules.rst.txt b/_sources/modules.rst.txt new file mode 100644 index 00000000..d9426b42 --- /dev/null +++ b/_sources/modules.rst.txt @@ -0,0 +1,7 @@ +homematicip +=========== + +.. toctree:: + :maxdepth: 4 + + homematicip diff --git a/_static/_sphinx_javascript_frameworks_compat.js b/_static/_sphinx_javascript_frameworks_compat.js new file mode 100644 index 00000000..81415803 --- /dev/null +++ b/_static/_sphinx_javascript_frameworks_compat.js @@ -0,0 +1,123 @@ +/* Compatability shim for jQuery and underscores.js. + * + * Copyright Sphinx contributors + * Released under the two clause BSD licence + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} diff --git a/_static/basic.css b/_static/basic.css new file mode 100644 index 00000000..7ebbd6d0 --- /dev/null +++ b/_static/basic.css @@ -0,0 +1,914 @@ +/* + * Sphinx stylesheet -- basic theme. + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin-top: 10px; +} + +ul.search li { + padding: 5px 0; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 360px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a:visited { + color: #551A8B; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +nav.contents, +aside.topic, +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +nav.contents, +aside.topic, +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +nav.contents > :last-child, +aside.topic > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +nav.contents::after, +aside.topic::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +aside.footnote > span, +div.citation > span { + float: left; +} +aside.footnote > span:last-of-type, +div.citation > span:last-of-type { + padding-right: 0.5em; +} +aside.footnote > p { + margin-left: 2em; +} +div.citation > p { + margin-left: 4em; +} +aside.footnote > p:last-of-type, +div.citation > p:last-of-type { + margin-bottom: 0em; +} +aside.footnote > p:last-of-type:after, +div.citation > p:last-of-type:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +.sig dd { + margin-top: 0px; + margin-bottom: 0px; +} + +.sig dl { + margin-top: 0px; + margin-bottom: 0px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +.translated { + background-color: rgba(207, 255, 207, 0.2) +} + +.untranslated { + background-color: rgba(255, 207, 207, 0.2) +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/_static/css/badge_only.css b/_static/css/badge_only.css new file mode 100644 index 00000000..88ba55b9 --- /dev/null +++ b/_static/css/badge_only.css @@ -0,0 +1 @@ +.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions .rst-other-versions .rtd-current-item{font-weight:700}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}#flyout-search-form{padding:6px} \ No newline at end of file diff --git a/_static/css/fonts/Roboto-Slab-Bold.woff b/_static/css/fonts/Roboto-Slab-Bold.woff new file mode 100644 index 00000000..6cb60000 Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Bold.woff differ diff --git a/_static/css/fonts/Roboto-Slab-Bold.woff2 b/_static/css/fonts/Roboto-Slab-Bold.woff2 new file mode 100644 index 00000000..7059e231 Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Bold.woff2 differ diff --git a/_static/css/fonts/Roboto-Slab-Regular.woff b/_static/css/fonts/Roboto-Slab-Regular.woff new file mode 100644 index 00000000..f815f63f Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Regular.woff differ diff --git a/_static/css/fonts/Roboto-Slab-Regular.woff2 b/_static/css/fonts/Roboto-Slab-Regular.woff2 new file mode 100644 index 00000000..f2c76e5b Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Regular.woff2 differ diff --git a/_static/css/fonts/fontawesome-webfont.eot b/_static/css/fonts/fontawesome-webfont.eot new file mode 100644 index 00000000..e9f60ca9 Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.eot differ diff --git a/_static/css/fonts/fontawesome-webfont.svg b/_static/css/fonts/fontawesome-webfont.svg new file mode 100644 index 00000000..855c845e --- /dev/null +++ b/_static/css/fonts/fontawesome-webfont.svg @@ -0,0 +1,2671 @@ + + + + +Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016 + By ,,, +Copyright Dave Gandy 2016. All rights reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/_static/css/fonts/fontawesome-webfont.ttf b/_static/css/fonts/fontawesome-webfont.ttf new file mode 100644 index 00000000..35acda2f Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.ttf differ diff --git a/_static/css/fonts/fontawesome-webfont.woff b/_static/css/fonts/fontawesome-webfont.woff new file mode 100644 index 00000000..400014a4 Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.woff differ diff --git a/_static/css/fonts/fontawesome-webfont.woff2 b/_static/css/fonts/fontawesome-webfont.woff2 new file mode 100644 index 00000000..4d13fc60 Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.woff2 differ diff --git a/_static/css/fonts/lato-bold-italic.woff b/_static/css/fonts/lato-bold-italic.woff new file mode 100644 index 00000000..88ad05b9 Binary files /dev/null and b/_static/css/fonts/lato-bold-italic.woff differ diff --git a/_static/css/fonts/lato-bold-italic.woff2 b/_static/css/fonts/lato-bold-italic.woff2 new file mode 100644 index 00000000..c4e3d804 Binary files /dev/null and b/_static/css/fonts/lato-bold-italic.woff2 differ diff --git a/_static/css/fonts/lato-bold.woff b/_static/css/fonts/lato-bold.woff new file mode 100644 index 00000000..c6dff51f Binary files /dev/null and b/_static/css/fonts/lato-bold.woff differ diff --git a/_static/css/fonts/lato-bold.woff2 b/_static/css/fonts/lato-bold.woff2 new file mode 100644 index 00000000..bb195043 Binary files /dev/null and b/_static/css/fonts/lato-bold.woff2 differ diff --git a/_static/css/fonts/lato-normal-italic.woff b/_static/css/fonts/lato-normal-italic.woff new file mode 100644 index 00000000..76114bc0 Binary files /dev/null and b/_static/css/fonts/lato-normal-italic.woff differ diff --git a/_static/css/fonts/lato-normal-italic.woff2 b/_static/css/fonts/lato-normal-italic.woff2 new file mode 100644 index 00000000..3404f37e Binary files /dev/null and b/_static/css/fonts/lato-normal-italic.woff2 differ diff --git a/_static/css/fonts/lato-normal.woff b/_static/css/fonts/lato-normal.woff new file mode 100644 index 00000000..ae1307ff Binary files /dev/null and b/_static/css/fonts/lato-normal.woff differ diff --git a/_static/css/fonts/lato-normal.woff2 b/_static/css/fonts/lato-normal.woff2 new file mode 100644 index 00000000..3bf98433 Binary files /dev/null and b/_static/css/fonts/lato-normal.woff2 differ diff --git a/_static/css/theme.css b/_static/css/theme.css new file mode 100644 index 00000000..0f14f106 --- /dev/null +++ b/_static/css/theme.css @@ -0,0 +1,4 @@ +html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search .wy-dropdown>aactive,.wy-side-nav-search .wy-dropdown>afocus,.wy-side-nav-search>a:hover,.wy-side-nav-search>aactive,.wy-side-nav-search>afocus{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon,.wy-side-nav-search>a.icon{display:block}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.switch-menus{position:relative;display:block;margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-side-nav-search>div.switch-menus>div.language-switch,.wy-side-nav-search>div.switch-menus>div.version-switch{display:inline-block;padding:.2em}.wy-side-nav-search>div.switch-menus>div.language-switch select,.wy-side-nav-search>div.switch-menus>div.version-switch select{display:inline-block;margin-right:-2rem;padding-right:2rem;max-width:240px;text-align-last:center;background:none;border:none;border-radius:0;box-shadow:none;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-size:1em;font-weight:400;color:hsla(0,0%,100%,.3);cursor:pointer;appearance:none;-webkit-appearance:none;-moz-appearance:none}.wy-side-nav-search>div.switch-menus>div.language-switch select:active,.wy-side-nav-search>div.switch-menus>div.language-switch select:focus,.wy-side-nav-search>div.switch-menus>div.language-switch select:hover,.wy-side-nav-search>div.switch-menus>div.version-switch select:active,.wy-side-nav-search>div.switch-menus>div.version-switch select:focus,.wy-side-nav-search>div.switch-menus>div.version-switch select:hover{background:hsla(0,0%,100%,.1);color:hsla(0,0%,100%,.5)}.wy-side-nav-search>div.switch-menus>div.language-switch select option,.wy-side-nav-search>div.switch-menus>div.version-switch select option{color:#000}.wy-side-nav-search>div.switch-menus>div.language-switch:has(>select):after,.wy-side-nav-search>div.switch-menus>div.version-switch:has(>select):after{display:inline-block;width:1.5em;height:100%;padding:.1em;content:"\f0d7";font-size:1em;line-height:1.2em;font-family:FontAwesome;text-align:center;pointer-events:none;box-sizing:border-box}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions .rst-other-versions .rtd-current-item{font-weight:700}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}#flyout-search-form{padding:6px}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .citation-reference>span.fn-bracket,.rst-content .footnote-reference>span.fn-bracket{display:none}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:auto minmax(80%,95%)}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{display:inline-grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{display:grid;grid-template-columns:auto auto minmax(.65rem,auto) minmax(40%,95%)}html.writer-html5 .rst-content aside.citation>span.label,html.writer-html5 .rst-content aside.footnote>span.label,html.writer-html5 .rst-content div.citation>span.label{grid-column-start:1;grid-column-end:2}html.writer-html5 .rst-content aside.citation>span.backrefs,html.writer-html5 .rst-content aside.footnote>span.backrefs,html.writer-html5 .rst-content div.citation>span.backrefs{grid-column-start:2;grid-column-end:3;grid-row-start:1;grid-row-end:3}html.writer-html5 .rst-content aside.citation>p,html.writer-html5 .rst-content aside.footnote>p,html.writer-html5 .rst-content div.citation>p{grid-column-start:4;grid-column-end:5}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{margin-bottom:24px}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a{word-break:keep-all}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a:not(:first-child):before,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p{font-size:.9rem}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{padding-left:1rem;padding-right:1rem;font-size:.9rem;line-height:1.2rem}html.writer-html5 .rst-content aside.citation p,html.writer-html5 .rst-content aside.footnote p,html.writer-html5 .rst-content div.citation p{font-size:.9rem;line-height:1.2rem;margin-bottom:12px}html.writer-html5 .rst-content aside.citation span.backrefs,html.writer-html5 .rst-content aside.footnote span.backrefs,html.writer-html5 .rst-content div.citation span.backrefs{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content aside.citation span.backrefs>a,html.writer-html5 .rst-content aside.footnote span.backrefs>a,html.writer-html5 .rst-content div.citation span.backrefs>a{word-break:keep-all}html.writer-html5 .rst-content aside.citation span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content aside.footnote span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content div.citation span.backrefs>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content aside.citation span.label,html.writer-html5 .rst-content aside.footnote span.label,html.writer-html5 .rst-content div.citation span.label{line-height:1.2rem}html.writer-html5 .rst-content aside.citation-list,html.writer-html5 .rst-content aside.footnote-list,html.writer-html5 .rst-content div.citation-list{margin-bottom:24px}html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content aside.footnote-list aside.footnote,html.writer-html5 .rst-content div.citation-list>div.citation,html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content aside.footnote-list aside.footnote code,html.writer-html5 .rst-content aside.footnote-list aside.footnote tt,html.writer-html5 .rst-content aside.footnote code,html.writer-html5 .rst-content aside.footnote tt,html.writer-html5 .rst-content div.citation-list>div.citation code,html.writer-html5 .rst-content div.citation-list>div.citation tt,html.writer-html5 .rst-content dl.citation code,html.writer-html5 .rst-content dl.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel,.rst-content .menuselection{font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .guilabel,.rst-content .menuselection{border:1px solid #7fbbe3;background:#e7f2fa}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block} \ No newline at end of file diff --git a/_static/doctools.js b/_static/doctools.js new file mode 100644 index 00000000..0398ebb9 --- /dev/null +++ b/_static/doctools.js @@ -0,0 +1,149 @@ +/* + * Base JavaScript utilities for all Sphinx HTML documentation. + */ +"use strict"; + +const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([ + "TEXTAREA", + "INPUT", + "SELECT", + "BUTTON", +]); + +const _ready = (callback) => { + if (document.readyState !== "loading") { + callback(); + } else { + document.addEventListener("DOMContentLoaded", callback); + } +}; + +/** + * Small JavaScript module for the documentation. + */ +const Documentation = { + init: () => { + Documentation.initDomainIndexTable(); + Documentation.initOnKeyListeners(); + }, + + /** + * i18n support + */ + TRANSLATIONS: {}, + PLURAL_EXPR: (n) => (n === 1 ? 0 : 1), + LOCALE: "unknown", + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext: (string) => { + const translated = Documentation.TRANSLATIONS[string]; + switch (typeof translated) { + case "undefined": + return string; // no translation + case "string": + return translated; // translation exists + default: + return translated[0]; // (singular, plural) translation tuple exists + } + }, + + ngettext: (singular, plural, n) => { + const translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated !== "undefined") + return translated[Documentation.PLURAL_EXPR(n)]; + return n === 1 ? singular : plural; + }, + + addTranslations: (catalog) => { + Object.assign(Documentation.TRANSLATIONS, catalog.messages); + Documentation.PLURAL_EXPR = new Function( + "n", + `return (${catalog.plural_expr})` + ); + Documentation.LOCALE = catalog.locale; + }, + + /** + * helper function to focus on search bar + */ + focusSearchBar: () => { + document.querySelectorAll("input[name=q]")[0]?.focus(); + }, + + /** + * Initialise the domain index toggle buttons + */ + initDomainIndexTable: () => { + const toggler = (el) => { + const idNumber = el.id.substr(7); + const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`); + if (el.src.substr(-9) === "minus.png") { + el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`; + toggledRows.forEach((el) => (el.style.display = "none")); + } else { + el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`; + toggledRows.forEach((el) => (el.style.display = "")); + } + }; + + const togglerElements = document.querySelectorAll("img.toggler"); + togglerElements.forEach((el) => + el.addEventListener("click", (event) => toggler(event.currentTarget)) + ); + togglerElements.forEach((el) => (el.style.display = "")); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler); + }, + + initOnKeyListeners: () => { + // only install a listener if it is really needed + if ( + !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && + !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS + ) + return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.altKey || event.ctrlKey || event.metaKey) return; + + if (!event.shiftKey) { + switch (event.key) { + case "ArrowLeft": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const prevLink = document.querySelector('link[rel="prev"]'); + if (prevLink && prevLink.href) { + window.location.href = prevLink.href; + event.preventDefault(); + } + break; + case "ArrowRight": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const nextLink = document.querySelector('link[rel="next"]'); + if (nextLink && nextLink.href) { + window.location.href = nextLink.href; + event.preventDefault(); + } + break; + } + } + + // some keyboard layouts may need Shift to get / + switch (event.key) { + case "/": + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; + Documentation.focusSearchBar(); + event.preventDefault(); + } + }); + }, +}; + +// quick alias for translations +const _ = Documentation.gettext; + +_ready(Documentation.init); diff --git a/_static/documentation_options.js b/_static/documentation_options.js new file mode 100644 index 00000000..bced8aa3 --- /dev/null +++ b/_static/documentation_options.js @@ -0,0 +1,13 @@ +const DOCUMENTATION_OPTIONS = { + VERSION: '0.0.post1.dev1', + LANGUAGE: 'en', + COLLAPSE_INDEX: false, + BUILDER: 'html', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '.txt', + NAVIGATION_WITH_KEYS: false, + SHOW_SEARCH_SUMMARY: true, + ENABLE_SEARCH_SHORTCUTS: true, +}; \ No newline at end of file diff --git a/_static/file.png b/_static/file.png new file mode 100644 index 00000000..a858a410 Binary files /dev/null and b/_static/file.png differ diff --git a/_static/fonts/Lato/lato-bold.eot b/_static/fonts/Lato/lato-bold.eot new file mode 100644 index 00000000..3361183a Binary files /dev/null and b/_static/fonts/Lato/lato-bold.eot differ diff --git a/_static/fonts/Lato/lato-bold.ttf b/_static/fonts/Lato/lato-bold.ttf new file mode 100644 index 00000000..29f691d5 Binary files /dev/null and b/_static/fonts/Lato/lato-bold.ttf differ diff --git a/_static/fonts/Lato/lato-bold.woff b/_static/fonts/Lato/lato-bold.woff new file mode 100644 index 00000000..c6dff51f Binary files /dev/null and b/_static/fonts/Lato/lato-bold.woff differ diff --git a/_static/fonts/Lato/lato-bold.woff2 b/_static/fonts/Lato/lato-bold.woff2 new file mode 100644 index 00000000..bb195043 Binary files /dev/null and b/_static/fonts/Lato/lato-bold.woff2 differ diff --git a/_static/fonts/Lato/lato-bolditalic.eot b/_static/fonts/Lato/lato-bolditalic.eot new file mode 100644 index 00000000..3d415493 Binary files /dev/null and b/_static/fonts/Lato/lato-bolditalic.eot differ diff --git a/_static/fonts/Lato/lato-bolditalic.ttf b/_static/fonts/Lato/lato-bolditalic.ttf new file mode 100644 index 00000000..f402040b Binary files /dev/null and b/_static/fonts/Lato/lato-bolditalic.ttf differ diff --git a/_static/fonts/Lato/lato-bolditalic.woff b/_static/fonts/Lato/lato-bolditalic.woff new file mode 100644 index 00000000..88ad05b9 Binary files /dev/null and b/_static/fonts/Lato/lato-bolditalic.woff differ diff --git a/_static/fonts/Lato/lato-bolditalic.woff2 b/_static/fonts/Lato/lato-bolditalic.woff2 new file mode 100644 index 00000000..c4e3d804 Binary files /dev/null and b/_static/fonts/Lato/lato-bolditalic.woff2 differ diff --git a/_static/fonts/Lato/lato-italic.eot b/_static/fonts/Lato/lato-italic.eot new file mode 100644 index 00000000..3f826421 Binary files /dev/null and b/_static/fonts/Lato/lato-italic.eot differ diff --git a/_static/fonts/Lato/lato-italic.ttf b/_static/fonts/Lato/lato-italic.ttf new file mode 100644 index 00000000..b4bfc9b2 Binary files /dev/null and b/_static/fonts/Lato/lato-italic.ttf differ diff --git a/_static/fonts/Lato/lato-italic.woff b/_static/fonts/Lato/lato-italic.woff new file mode 100644 index 00000000..76114bc0 Binary files /dev/null and b/_static/fonts/Lato/lato-italic.woff differ diff --git a/_static/fonts/Lato/lato-italic.woff2 b/_static/fonts/Lato/lato-italic.woff2 new file mode 100644 index 00000000..3404f37e Binary files /dev/null and b/_static/fonts/Lato/lato-italic.woff2 differ diff --git a/_static/fonts/Lato/lato-regular.eot b/_static/fonts/Lato/lato-regular.eot new file mode 100644 index 00000000..11e3f2a5 Binary files /dev/null and b/_static/fonts/Lato/lato-regular.eot differ diff --git a/_static/fonts/Lato/lato-regular.ttf b/_static/fonts/Lato/lato-regular.ttf new file mode 100644 index 00000000..74decd9e Binary files /dev/null and b/_static/fonts/Lato/lato-regular.ttf differ diff --git a/_static/fonts/Lato/lato-regular.woff b/_static/fonts/Lato/lato-regular.woff new file mode 100644 index 00000000..ae1307ff Binary files /dev/null and b/_static/fonts/Lato/lato-regular.woff differ diff --git a/_static/fonts/Lato/lato-regular.woff2 b/_static/fonts/Lato/lato-regular.woff2 new file mode 100644 index 00000000..3bf98433 Binary files /dev/null and b/_static/fonts/Lato/lato-regular.woff2 differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-bold.eot b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.eot new file mode 100644 index 00000000..79dc8efe Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.eot differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-bold.ttf b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.ttf new file mode 100644 index 00000000..df5d1df2 Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.ttf differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff new file mode 100644 index 00000000..6cb60000 Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff2 b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff2 new file mode 100644 index 00000000..7059e231 Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff2 differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-regular.eot b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.eot new file mode 100644 index 00000000..2f7ca78a Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.eot differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-regular.ttf b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.ttf new file mode 100644 index 00000000..eb52a790 Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.ttf differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff new file mode 100644 index 00000000..f815f63f Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff differ diff --git a/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff2 b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff2 new file mode 100644 index 00000000..f2c76e5b Binary files /dev/null and b/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff2 differ diff --git a/_static/jquery.js b/_static/jquery.js new file mode 100644 index 00000000..c4c6022f --- /dev/null +++ b/_static/jquery.js @@ -0,0 +1,2 @@ +/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="
",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0"),n("table.docutils.footnote").wrap("
"),n("table.docutils.citation").wrap("
"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n(''),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}if(t.length>0){$(".wy-menu-vertical .current").removeClass("current").attr("aria-expanded","false"),t.addClass("current").attr("aria-expanded","true"),t.closest("li.toctree-l1").parent().addClass("current").attr("aria-expanded","true");for(let n=1;n<=10;n++)t.closest("li.toctree-l"+n).addClass("current").attr("aria-expanded","true");t[0].scrollIntoView()}}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current").attr("aria-expanded","false"),e.siblings().find("li.current").removeClass("current").attr("aria-expanded","false");var t=e.find("> ul li");t.length&&(t.removeClass("current").attr("aria-expanded","false"),e.toggleClass("current").attr("aria-expanded",(function(n,e){return"true"==e?"false":"true"})))}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t a.language.name.localeCompare(b.language.name)); + + const languagesHTML = ` +
+
Languages
+ ${languages + .map( + (translation) => ` +
+ ${translation.language.code} +
+ `, + ) + .join("\n")} +
+ `; + return languagesHTML; + } + + function renderVersions(config) { + if (!config.versions.active.length) { + return ""; + } + const versionsHTML = ` +
+
Versions
+ ${config.versions.active + .map( + (version) => ` +
+ ${version.slug} +
+ `, + ) + .join("\n")} +
+ `; + return versionsHTML; + } + + function renderDownloads(config) { + if (!Object.keys(config.versions.current.downloads).length) { + return ""; + } + const downloadsNameDisplay = { + pdf: "PDF", + epub: "Epub", + htmlzip: "HTML", + }; + + const downloadsHTML = ` +
+
Downloads
+ ${Object.entries(config.versions.current.downloads) + .map( + ([name, url]) => ` +
+ ${downloadsNameDisplay[name]} +
+ `, + ) + .join("\n")} +
+ `; + return downloadsHTML; + } + + document.addEventListener("readthedocs-addons-data-ready", function (event) { + const config = event.detail.data(); + + const flyout = ` +
+ + Read the Docs + v: ${config.versions.current.slug} + + +
+
+ ${renderLanguages(config)} + ${renderVersions(config)} + ${renderDownloads(config)} +
+
On Read the Docs
+
+ Project Home +
+
+ Builds +
+
+ Downloads +
+
+
+
Search
+
+
+ +
+
+
+
+ + Hosted by Read the Docs + +
+
+ `; + + // Inject the generated flyout into the body HTML element. + document.body.insertAdjacentHTML("beforeend", flyout); + + // Trigger the Read the Docs Addons Search modal when clicking on the "Search docs" input from inside the flyout. + document + .querySelector("#flyout-search-form") + .addEventListener("focusin", () => { + const event = new CustomEvent("readthedocs-search-show"); + document.dispatchEvent(event); + }); + }) +} + +if (themeLanguageSelector || themeVersionSelector) { + function onSelectorSwitch(event) { + const option = event.target.selectedIndex; + const item = event.target.options[option]; + window.location.href = item.dataset.url; + } + + document.addEventListener("readthedocs-addons-data-ready", function (event) { + const config = event.detail.data(); + + const versionSwitch = document.querySelector( + "div.switch-menus > div.version-switch", + ); + if (themeVersionSelector) { + let versions = config.versions.active; + if (config.versions.current.hidden || config.versions.current.type === "external") { + versions.unshift(config.versions.current); + } + const versionSelect = ` + + `; + + versionSwitch.innerHTML = versionSelect; + versionSwitch.firstElementChild.addEventListener("change", onSelectorSwitch); + } + + const languageSwitch = document.querySelector( + "div.switch-menus > div.language-switch", + ); + + if (themeLanguageSelector) { + if (config.projects.translations.length) { + // Add the current language to the options on the selector + let languages = config.projects.translations.concat( + config.projects.current, + ); + languages = languages.sort((a, b) => + a.language.name.localeCompare(b.language.name), + ); + + const languageSelect = ` + + `; + + languageSwitch.innerHTML = languageSelect; + languageSwitch.firstElementChild.addEventListener("change", onSelectorSwitch); + } + else { + languageSwitch.remove(); + } + } + }); +} + +document.addEventListener("readthedocs-addons-data-ready", function (event) { + // Trigger the Read the Docs Addons Search modal when clicking on "Search docs" input from the topnav. + document + .querySelector("[role='search'] input") + .addEventListener("focusin", () => { + const event = new CustomEvent("readthedocs-search-show"); + document.dispatchEvent(event); + }); +}); \ No newline at end of file diff --git a/_static/language_data.js b/_static/language_data.js new file mode 100644 index 00000000..c7fe6c6f --- /dev/null +++ b/_static/language_data.js @@ -0,0 +1,192 @@ +/* + * This script contains the language-specific data used by searchtools.js, + * namely the list of stopwords, stemmer, scorer and splitter. + */ + +var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"]; + + +/* Non-minified version is copied as a separate JS file, if available */ + +/** + * Porter Stemmer + */ +var Stemmer = function() { + + var step2list = { + ational: 'ate', + tional: 'tion', + enci: 'ence', + anci: 'ance', + izer: 'ize', + bli: 'ble', + alli: 'al', + entli: 'ent', + eli: 'e', + ousli: 'ous', + ization: 'ize', + ation: 'ate', + ator: 'ate', + alism: 'al', + iveness: 'ive', + fulness: 'ful', + ousness: 'ous', + aliti: 'al', + iviti: 'ive', + biliti: 'ble', + logi: 'log' + }; + + var step3list = { + icate: 'ic', + ative: '', + alize: 'al', + iciti: 'ic', + ical: 'ic', + ful: '', + ness: '' + }; + + var c = "[^aeiou]"; // consonant + var v = "[aeiouy]"; // vowel + var C = c + "[^aeiouy]*"; // consonant sequence + var V = v + "[aeiou]*"; // vowel sequence + + var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0 + var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 + var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 + var s_v = "^(" + C + ")?" + v; // vowel in stem + + this.stemWord = function (w) { + var stem; + var suffix; + var firstch; + var origword = w; + + if (w.length < 3) + return w; + + var re; + var re2; + var re3; + var re4; + + firstch = w.substr(0,1); + if (firstch == "y") + w = firstch.toUpperCase() + w.substr(1); + + // Step 1a + re = /^(.+?)(ss|i)es$/; + re2 = /^(.+?)([^s])s$/; + + if (re.test(w)) + w = w.replace(re,"$1$2"); + else if (re2.test(w)) + w = w.replace(re2,"$1$2"); + + // Step 1b + re = /^(.+?)eed$/; + re2 = /^(.+?)(ed|ing)$/; + if (re.test(w)) { + var fp = re.exec(w); + re = new RegExp(mgr0); + if (re.test(fp[1])) { + re = /.$/; + w = w.replace(re,""); + } + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = new RegExp(s_v); + if (re2.test(stem)) { + w = stem; + re2 = /(at|bl|iz)$/; + re3 = new RegExp("([^aeiouylsz])\\1$"); + re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re2.test(w)) + w = w + "e"; + else if (re3.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + else if (re4.test(w)) + w = w + "e"; + } + } + + // Step 1c + re = /^(.+?)y$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(s_v); + if (re.test(stem)) + w = stem + "i"; + } + + // Step 2 + re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step2list[suffix]; + } + + // Step 3 + re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step3list[suffix]; + } + + // Step 4 + re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + re2 = /^(.+?)(s|t)(ion)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + if (re.test(stem)) + w = stem; + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = new RegExp(mgr1); + if (re2.test(stem)) + w = stem; + } + + // Step 5 + re = /^(.+?)e$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + re2 = new RegExp(meq1); + re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) + w = stem; + } + re = /ll$/; + re2 = new RegExp(mgr1); + if (re.test(w) && re2.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + + // and turn initial Y back to y + if (firstch == "y") + w = firstch.toLowerCase() + w.substr(1); + return w; + } +} + diff --git a/_static/minus.png b/_static/minus.png new file mode 100644 index 00000000..d96755fd Binary files /dev/null and b/_static/minus.png differ diff --git a/_static/plus.png b/_static/plus.png new file mode 100644 index 00000000..7107cec9 Binary files /dev/null and b/_static/plus.png differ diff --git a/_static/pygments.css b/_static/pygments.css new file mode 100644 index 00000000..84ab3030 --- /dev/null +++ b/_static/pygments.css @@ -0,0 +1,75 @@ +pre { line-height: 125%; } +td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +.highlight .hll { background-color: #ffffcc } +.highlight { background: #f8f8f8; } +.highlight .c { color: #3D7B7B; font-style: italic } /* Comment */ +.highlight .err { border: 1px solid #FF0000 } /* Error */ +.highlight .k { color: #008000; font-weight: bold } /* Keyword */ +.highlight .o { color: #666666 } /* Operator */ +.highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */ +.highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #9C6500 } /* Comment.Preproc */ +.highlight .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */ +.highlight .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */ +.highlight .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */ +.highlight .gd { color: #A00000 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */ +.highlight .gr { color: #E40000 } /* Generic.Error */ +.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.highlight .gi { color: #008400 } /* Generic.Inserted */ +.highlight .go { color: #717171 } /* Generic.Output */ +.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */ +.highlight .gs { font-weight: bold } /* Generic.Strong */ +.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.highlight .gt { color: #0044DD } /* Generic.Traceback */ +.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */ +.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */ +.highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */ +.highlight .kp { color: #008000 } /* Keyword.Pseudo */ +.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */ +.highlight .kt { color: #B00040 } /* Keyword.Type */ +.highlight .m { color: #666666 } /* Literal.Number */ +.highlight .s { color: #BA2121 } /* Literal.String */ +.highlight .na { color: #687822 } /* Name.Attribute */ +.highlight .nb { color: #008000 } /* Name.Builtin */ +.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */ +.highlight .no { color: #880000 } /* Name.Constant */ +.highlight .nd { color: #AA22FF } /* Name.Decorator */ +.highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */ +.highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */ +.highlight .nf { color: #0000FF } /* Name.Function */ +.highlight .nl { color: #767600 } /* Name.Label */ +.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */ +.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */ +.highlight .nv { color: #19177C } /* Name.Variable */ +.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */ +.highlight .w { color: #bbbbbb } /* Text.Whitespace */ +.highlight .mb { color: #666666 } /* Literal.Number.Bin */ +.highlight .mf { color: #666666 } /* Literal.Number.Float */ +.highlight .mh { color: #666666 } /* Literal.Number.Hex */ +.highlight .mi { color: #666666 } /* Literal.Number.Integer */ +.highlight .mo { color: #666666 } /* Literal.Number.Oct */ +.highlight .sa { color: #BA2121 } /* Literal.String.Affix */ +.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */ +.highlight .sc { color: #BA2121 } /* Literal.String.Char */ +.highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */ +.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #BA2121 } /* Literal.String.Double */ +.highlight .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */ +.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */ +.highlight .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */ +.highlight .sx { color: #008000 } /* Literal.String.Other */ +.highlight .sr { color: #A45A77 } /* Literal.String.Regex */ +.highlight .s1 { color: #BA2121 } /* Literal.String.Single */ +.highlight .ss { color: #19177C } /* Literal.String.Symbol */ +.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */ +.highlight .fm { color: #0000FF } /* Name.Function.Magic */ +.highlight .vc { color: #19177C } /* Name.Variable.Class */ +.highlight .vg { color: #19177C } /* Name.Variable.Global */ +.highlight .vi { color: #19177C } /* Name.Variable.Instance */ +.highlight .vm { color: #19177C } /* Name.Variable.Magic */ +.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/_static/searchtools.js b/_static/searchtools.js new file mode 100644 index 00000000..2c774d17 --- /dev/null +++ b/_static/searchtools.js @@ -0,0 +1,632 @@ +/* + * Sphinx JavaScript utilities for the full-text search. + */ +"use strict"; + +/** + * Simple result scoring code. + */ +if (typeof Scorer === "undefined") { + var Scorer = { + // Implement the following function to further tweak the score for each result + // The function takes a result array [docname, title, anchor, descr, score, filename] + // and returns the new score. + /* + score: result => { + const [docname, title, anchor, descr, score, filename, kind] = result + return score + }, + */ + + // query matches the full name of an object + objNameMatch: 11, + // or matches in the last dotted part of the object name + objPartialMatch: 6, + // Additive scores depending on the priority of the object + objPrio: { + 0: 15, // used to be importantResults + 1: 5, // used to be objectResults + 2: -5, // used to be unimportantResults + }, + // Used when the priority is not in the mapping. + objPrioDefault: 0, + + // query found in title + title: 15, + partialTitle: 7, + // query found in terms + term: 5, + partialTerm: 2, + }; +} + +// Global search result kind enum, used by themes to style search results. +class SearchResultKind { + static get index() { return "index"; } + static get object() { return "object"; } + static get text() { return "text"; } + static get title() { return "title"; } +} + +const _removeChildren = (element) => { + while (element && element.lastChild) element.removeChild(element.lastChild); +}; + +/** + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping + */ +const _escapeRegExp = (string) => + string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string + +const _displayItem = (item, searchTerms, highlightTerms) => { + const docBuilder = DOCUMENTATION_OPTIONS.BUILDER; + const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX; + const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX; + const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY; + const contentRoot = document.documentElement.dataset.content_root; + + const [docName, title, anchor, descr, score, _filename, kind] = item; + + let listItem = document.createElement("li"); + // Add a class representing the item's type: + // can be used by a theme's CSS selector for styling + // See SearchResultKind for the class names. + listItem.classList.add(`kind-${kind}`); + let requestUrl; + let linkUrl; + if (docBuilder === "dirhtml") { + // dirhtml builder + let dirname = docName + "/"; + if (dirname.match(/\/index\/$/)) + dirname = dirname.substring(0, dirname.length - 6); + else if (dirname === "index/") dirname = ""; + requestUrl = contentRoot + dirname; + linkUrl = requestUrl; + } else { + // normal html builders + requestUrl = contentRoot + docName + docFileSuffix; + linkUrl = docName + docLinkSuffix; + } + let linkEl = listItem.appendChild(document.createElement("a")); + linkEl.href = linkUrl + anchor; + linkEl.dataset.score = score; + linkEl.innerHTML = title; + if (descr) { + listItem.appendChild(document.createElement("span")).innerHTML = + " (" + descr + ")"; + // highlight search terms in the description + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + } + else if (showSearchSummary) + fetch(requestUrl) + .then((responseData) => responseData.text()) + .then((data) => { + if (data) + listItem.appendChild( + Search.makeSearchSummary(data, searchTerms, anchor) + ); + // highlight search terms in the summary + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + }); + Search.output.appendChild(listItem); +}; +const _finishSearch = (resultCount) => { + Search.stopPulse(); + Search.title.innerText = _("Search Results"); + if (!resultCount) + Search.status.innerText = Documentation.gettext( + "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories." + ); + else + Search.status.innerText = Documentation.ngettext( + "Search finished, found one page matching the search query.", + "Search finished, found ${resultCount} pages matching the search query.", + resultCount, + ).replace('${resultCount}', resultCount); +}; +const _displayNextItem = ( + results, + resultCount, + searchTerms, + highlightTerms, +) => { + // results left, load the summary and display it + // this is intended to be dynamic (don't sub resultsCount) + if (results.length) { + _displayItem(results.pop(), searchTerms, highlightTerms); + setTimeout( + () => _displayNextItem(results, resultCount, searchTerms, highlightTerms), + 5 + ); + } + // search finished, update title and status message + else _finishSearch(resultCount); +}; +// Helper function used by query() to order search results. +// Each input is an array of [docname, title, anchor, descr, score, filename, kind]. +// Order the results by score (in opposite order of appearance, since the +// `_displayNextItem` function uses pop() to retrieve items) and then alphabetically. +const _orderResultsByScoreThenName = (a, b) => { + const leftScore = a[4]; + const rightScore = b[4]; + if (leftScore === rightScore) { + // same score: sort alphabetically + const leftTitle = a[1].toLowerCase(); + const rightTitle = b[1].toLowerCase(); + if (leftTitle === rightTitle) return 0; + return leftTitle > rightTitle ? -1 : 1; // inverted is intentional + } + return leftScore > rightScore ? 1 : -1; +}; + +/** + * Default splitQuery function. Can be overridden in ``sphinx.search`` with a + * custom function per language. + * + * The regular expression works by splitting the string on consecutive characters + * that are not Unicode letters, numbers, underscores, or emoji characters. + * This is the same as ``\W+`` in Python, preserving the surrogate pair area. + */ +if (typeof splitQuery === "undefined") { + var splitQuery = (query) => query + .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu) + .filter(term => term) // remove remaining empty strings +} + +/** + * Search Module + */ +const Search = { + _index: null, + _queued_query: null, + _pulse_status: -1, + + htmlToText: (htmlString, anchor) => { + const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html'); + for (const removalQuery of [".headerlink", "script", "style"]) { + htmlElement.querySelectorAll(removalQuery).forEach((el) => { el.remove() }); + } + if (anchor) { + const anchorContent = htmlElement.querySelector(`[role="main"] ${anchor}`); + if (anchorContent) return anchorContent.textContent; + + console.warn( + `Anchored content block not found. Sphinx search tries to obtain it via DOM query '[role=main] ${anchor}'. Check your theme or template.` + ); + } + + // if anchor not specified or not found, fall back to main content + const docContent = htmlElement.querySelector('[role="main"]'); + if (docContent) return docContent.textContent; + + console.warn( + "Content block not found. Sphinx search tries to obtain it via DOM query '[role=main]'. Check your theme or template." + ); + return ""; + }, + + init: () => { + const query = new URLSearchParams(window.location.search).get("q"); + document + .querySelectorAll('input[name="q"]') + .forEach((el) => (el.value = query)); + if (query) Search.performSearch(query); + }, + + loadIndex: (url) => + (document.body.appendChild(document.createElement("script")).src = url), + + setIndex: (index) => { + Search._index = index; + if (Search._queued_query !== null) { + const query = Search._queued_query; + Search._queued_query = null; + Search.query(query); + } + }, + + hasIndex: () => Search._index !== null, + + deferQuery: (query) => (Search._queued_query = query), + + stopPulse: () => (Search._pulse_status = -1), + + startPulse: () => { + if (Search._pulse_status >= 0) return; + + const pulse = () => { + Search._pulse_status = (Search._pulse_status + 1) % 4; + Search.dots.innerText = ".".repeat(Search._pulse_status); + if (Search._pulse_status >= 0) window.setTimeout(pulse, 500); + }; + pulse(); + }, + + /** + * perform a search for something (or wait until index is loaded) + */ + performSearch: (query) => { + // create the required interface elements + const searchText = document.createElement("h2"); + searchText.textContent = _("Searching"); + const searchSummary = document.createElement("p"); + searchSummary.classList.add("search-summary"); + searchSummary.innerText = ""; + const searchList = document.createElement("ul"); + searchList.setAttribute("role", "list"); + searchList.classList.add("search"); + + const out = document.getElementById("search-results"); + Search.title = out.appendChild(searchText); + Search.dots = Search.title.appendChild(document.createElement("span")); + Search.status = out.appendChild(searchSummary); + Search.output = out.appendChild(searchList); + + const searchProgress = document.getElementById("search-progress"); + // Some themes don't use the search progress node + if (searchProgress) { + searchProgress.innerText = _("Preparing search..."); + } + Search.startPulse(); + + // index already loaded, the browser was quick! + if (Search.hasIndex()) Search.query(query); + else Search.deferQuery(query); + }, + + _parseQuery: (query) => { + // stem the search terms and add them to the correct list + const stemmer = new Stemmer(); + const searchTerms = new Set(); + const excludedTerms = new Set(); + const highlightTerms = new Set(); + const objectTerms = new Set(splitQuery(query.toLowerCase().trim())); + splitQuery(query.trim()).forEach((queryTerm) => { + const queryTermLower = queryTerm.toLowerCase(); + + // maybe skip this "word" + // stopwords array is from language_data.js + if ( + stopwords.indexOf(queryTermLower) !== -1 || + queryTerm.match(/^\d+$/) + ) + return; + + // stem the word + let word = stemmer.stemWord(queryTermLower); + // select the correct list + if (word[0] === "-") excludedTerms.add(word.substr(1)); + else { + searchTerms.add(word); + highlightTerms.add(queryTermLower); + } + }); + + if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js + localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" ")) + } + + // console.debug("SEARCH: searching for:"); + // console.info("required: ", [...searchTerms]); + // console.info("excluded: ", [...excludedTerms]); + + return [query, searchTerms, excludedTerms, highlightTerms, objectTerms]; + }, + + /** + * execute search (requires search index to be loaded) + */ + _performSearch: (query, searchTerms, excludedTerms, highlightTerms, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + const allTitles = Search._index.alltitles; + const indexEntries = Search._index.indexentries; + + // Collect multiple result groups to be sorted separately and then ordered. + // Each is an array of [docname, title, anchor, descr, score, filename, kind]. + const normalResults = []; + const nonMainIndexResults = []; + + _removeChildren(document.getElementById("search-progress")); + + const queryLower = query.toLowerCase().trim(); + for (const [title, foundTitles] of Object.entries(allTitles)) { + if (title.toLowerCase().trim().includes(queryLower) && (queryLower.length >= title.length/2)) { + for (const [file, id] of foundTitles) { + const score = Math.round(Scorer.title * queryLower.length / title.length); + const boost = titles[file] === title ? 1 : 0; // add a boost for document titles + normalResults.push([ + docNames[file], + titles[file] !== title ? `${titles[file]} > ${title}` : title, + id !== null ? "#" + id : "", + null, + score + boost, + filenames[file], + SearchResultKind.title, + ]); + } + } + } + + // search for explicit entries in index directives + for (const [entry, foundEntries] of Object.entries(indexEntries)) { + if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) { + for (const [file, id, isMain] of foundEntries) { + const score = Math.round(100 * queryLower.length / entry.length); + const result = [ + docNames[file], + titles[file], + id ? "#" + id : "", + null, + score, + filenames[file], + SearchResultKind.index, + ]; + if (isMain) { + normalResults.push(result); + } else { + nonMainIndexResults.push(result); + } + } + } + } + + // lookup as object + objectTerms.forEach((term) => + normalResults.push(...Search.performObjectSearch(term, objectTerms)) + ); + + // lookup as search terms in fulltext + normalResults.push(...Search.performTermsSearch(searchTerms, excludedTerms)); + + // let the scorer override scores with a custom scoring function + if (Scorer.score) { + normalResults.forEach((item) => (item[4] = Scorer.score(item))); + nonMainIndexResults.forEach((item) => (item[4] = Scorer.score(item))); + } + + // Sort each group of results by score and then alphabetically by name. + normalResults.sort(_orderResultsByScoreThenName); + nonMainIndexResults.sort(_orderResultsByScoreThenName); + + // Combine the result groups in (reverse) order. + // Non-main index entries are typically arbitrary cross-references, + // so display them after other results. + let results = [...nonMainIndexResults, ...normalResults]; + + // remove duplicate search results + // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept + let seen = new Set(); + results = results.reverse().reduce((acc, result) => { + let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(','); + if (!seen.has(resultStr)) { + acc.push(result); + seen.add(resultStr); + } + return acc; + }, []); + + return results.reverse(); + }, + + query: (query) => { + const [searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms] = Search._parseQuery(query); + const results = Search._performSearch(searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms); + + // for debugging + //Search.lastresults = results.slice(); // a copy + // console.info("search results:", Search.lastresults); + + // print the results + _displayNextItem(results, results.length, searchTerms, highlightTerms); + }, + + /** + * search for object names + */ + performObjectSearch: (object, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const objects = Search._index.objects; + const objNames = Search._index.objnames; + const titles = Search._index.titles; + + const results = []; + + const objectSearchCallback = (prefix, match) => { + const name = match[4] + const fullname = (prefix ? prefix + "." : "") + name; + const fullnameLower = fullname.toLowerCase(); + if (fullnameLower.indexOf(object) < 0) return; + + let score = 0; + const parts = fullnameLower.split("."); + + // check for different match types: exact matches of full name or + // "last name" (i.e. last dotted part) + if (fullnameLower === object || parts.slice(-1)[0] === object) + score += Scorer.objNameMatch; + else if (parts.slice(-1)[0].indexOf(object) > -1) + score += Scorer.objPartialMatch; // matches in last name + + const objName = objNames[match[1]][2]; + const title = titles[match[0]]; + + // If more than one term searched for, we require other words to be + // found in the name/title/description + const otherTerms = new Set(objectTerms); + otherTerms.delete(object); + if (otherTerms.size > 0) { + const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase(); + if ( + [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0) + ) + return; + } + + let anchor = match[3]; + if (anchor === "") anchor = fullname; + else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname; + + const descr = objName + _(", in ") + title; + + // add custom score for some objects according to scorer + if (Scorer.objPrio.hasOwnProperty(match[2])) + score += Scorer.objPrio[match[2]]; + else score += Scorer.objPrioDefault; + + results.push([ + docNames[match[0]], + fullname, + "#" + anchor, + descr, + score, + filenames[match[0]], + SearchResultKind.object, + ]); + }; + Object.keys(objects).forEach((prefix) => + objects[prefix].forEach((array) => + objectSearchCallback(prefix, array) + ) + ); + return results; + }, + + /** + * search for full-text terms in the index + */ + performTermsSearch: (searchTerms, excludedTerms) => { + // prepare search + const terms = Search._index.terms; + const titleTerms = Search._index.titleterms; + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + + const scoreMap = new Map(); + const fileMap = new Map(); + + // perform the search on the required terms + searchTerms.forEach((word) => { + const files = []; + const arr = [ + { files: terms[word], score: Scorer.term }, + { files: titleTerms[word], score: Scorer.title }, + ]; + // add support for partial matches + if (word.length > 2) { + const escapedWord = _escapeRegExp(word); + if (!terms.hasOwnProperty(word)) { + Object.keys(terms).forEach((term) => { + if (term.match(escapedWord)) + arr.push({ files: terms[term], score: Scorer.partialTerm }); + }); + } + if (!titleTerms.hasOwnProperty(word)) { + Object.keys(titleTerms).forEach((term) => { + if (term.match(escapedWord)) + arr.push({ files: titleTerms[term], score: Scorer.partialTitle }); + }); + } + } + + // no match but word was a required one + if (arr.every((record) => record.files === undefined)) return; + + // found search word in contents + arr.forEach((record) => { + if (record.files === undefined) return; + + let recordFiles = record.files; + if (recordFiles.length === undefined) recordFiles = [recordFiles]; + files.push(...recordFiles); + + // set score for the word in each file + recordFiles.forEach((file) => { + if (!scoreMap.has(file)) scoreMap.set(file, {}); + scoreMap.get(file)[word] = record.score; + }); + }); + + // create the mapping + files.forEach((file) => { + if (!fileMap.has(file)) fileMap.set(file, [word]); + else if (fileMap.get(file).indexOf(word) === -1) fileMap.get(file).push(word); + }); + }); + + // now check if the files don't contain excluded terms + const results = []; + for (const [file, wordList] of fileMap) { + // check if all requirements are matched + + // as search terms with length < 3 are discarded + const filteredTermCount = [...searchTerms].filter( + (term) => term.length > 2 + ).length; + if ( + wordList.length !== searchTerms.size && + wordList.length !== filteredTermCount + ) + continue; + + // ensure that none of the excluded terms is in the search result + if ( + [...excludedTerms].some( + (term) => + terms[term] === file || + titleTerms[term] === file || + (terms[term] || []).includes(file) || + (titleTerms[term] || []).includes(file) + ) + ) + break; + + // select one (max) score for the file. + const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w])); + // add result to the result list + results.push([ + docNames[file], + titles[file], + "", + null, + score, + filenames[file], + SearchResultKind.text, + ]); + } + return results; + }, + + /** + * helper function to return a node containing the + * search summary for a given text. keywords is a list + * of stemmed words. + */ + makeSearchSummary: (htmlText, keywords, anchor) => { + const text = Search.htmlToText(htmlText, anchor); + if (text === "") return null; + + const textLower = text.toLowerCase(); + const actualStartPosition = [...keywords] + .map((k) => textLower.indexOf(k.toLowerCase())) + .filter((i) => i > -1) + .slice(-1)[0]; + const startWithContext = Math.max(actualStartPosition - 120, 0); + + const top = startWithContext === 0 ? "" : "..."; + const tail = startWithContext + 240 < text.length ? "..." : ""; + + let summary = document.createElement("p"); + summary.classList.add("context"); + summary.textContent = top + text.substr(startWithContext, 240).trim() + tail; + + return summary; + }, +}; + +_ready(Search.init); diff --git a/_static/sphinx_highlight.js b/_static/sphinx_highlight.js new file mode 100644 index 00000000..8a96c69a --- /dev/null +++ b/_static/sphinx_highlight.js @@ -0,0 +1,154 @@ +/* Highlighting utilities for Sphinx HTML documentation. */ +"use strict"; + +const SPHINX_HIGHLIGHT_ENABLED = true + +/** + * highlight a given string on a node by wrapping it in + * span elements with the given class name. + */ +const _highlight = (node, addItems, text, className) => { + if (node.nodeType === Node.TEXT_NODE) { + const val = node.nodeValue; + const parent = node.parentNode; + const pos = val.toLowerCase().indexOf(text); + if ( + pos >= 0 && + !parent.classList.contains(className) && + !parent.classList.contains("nohighlight") + ) { + let span; + + const closestNode = parent.closest("body, svg, foreignObject"); + const isInSVG = closestNode && closestNode.matches("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.classList.add(className); + } + + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + const rest = document.createTextNode(val.substr(pos + text.length)); + parent.insertBefore( + span, + parent.insertBefore( + rest, + node.nextSibling + ) + ); + node.nodeValue = val.substr(0, pos); + /* There may be more occurrences of search term in this node. So call this + * function recursively on the remaining fragment. + */ + _highlight(rest, addItems, text, className); + + if (isInSVG) { + const rect = document.createElementNS( + "http://www.w3.org/2000/svg", + "rect" + ); + const bbox = parent.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute("class", className); + addItems.push({ parent: parent, target: rect }); + } + } + } else if (node.matches && !node.matches("button, select, textarea")) { + node.childNodes.forEach((el) => _highlight(el, addItems, text, className)); + } +}; +const _highlightText = (thisNode, text, className) => { + let addItems = []; + _highlight(thisNode, addItems, text, className); + addItems.forEach((obj) => + obj.parent.insertAdjacentElement("beforebegin", obj.target) + ); +}; + +/** + * Small JavaScript module for the documentation. + */ +const SphinxHighlight = { + + /** + * highlight the search words provided in localstorage in the text + */ + highlightSearchWords: () => { + if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight + + // get and clear terms from localstorage + const url = new URL(window.location); + const highlight = + localStorage.getItem("sphinx_highlight_terms") + || url.searchParams.get("highlight") + || ""; + localStorage.removeItem("sphinx_highlight_terms") + url.searchParams.delete("highlight"); + window.history.replaceState({}, "", url); + + // get individual terms from highlight string + const terms = highlight.toLowerCase().split(/\s+/).filter(x => x); + if (terms.length === 0) return; // nothing to do + + // There should never be more than one element matching "div.body" + const divBody = document.querySelectorAll("div.body"); + const body = divBody.length ? divBody[0] : document.querySelector("body"); + window.setTimeout(() => { + terms.forEach((term) => _highlightText(body, term, "highlighted")); + }, 10); + + const searchBox = document.getElementById("searchbox"); + if (searchBox === null) return; + searchBox.appendChild( + document + .createRange() + .createContextualFragment( + '

' + + '' + + _("Hide Search Matches") + + "

" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/api_introduction.html b/api_introduction.html new file mode 100644 index 00000000..64bc266e --- /dev/null +++ b/api_introduction.html @@ -0,0 +1,129 @@ + + + + + + + + + API Introduction — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

API Introduction

+

There are a few key classes for communication with the Rest API of HomematicIP.

+
+
Home: is the most important object as it has the “overview” of the installation
+
Group: a group of devices for a specific need. E.g. Heating group, security group, …
+
MetaGroup: a collection of groups. In the HomematicIP App this is called a “Room”
+
Device: a hardware device e.g. shutter contact, heating thermostat, alarm siren, …
+
FunctionChannel: a channel of a device. For example DoorLockChannel for DoorLockDrive or DimmerChannel. A device has multiple channels - depending on its functions.
+
+
+
For example:
+
The device HmIP-DLD is represented by the class DoorLockDrive (or AsyncDoorLockDrive). The device has multiple channels.
+
The base channel holds informations about the device and has the index 0.
+
The device has also a channel called DoorLockChannel which contains the functions “set_lock_state” and “async_set_lock_state”. These are functions to set the lock state of that device.
+
+

If you have dimmer with multiple I/Os, there are multiple channels. For each I/O a unique channel.

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/genindex.html b/genindex.html new file mode 100644 index 00000000..7f8309ae --- /dev/null +++ b/genindex.html @@ -0,0 +1,4009 @@ + + + + + + + + Index — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Index
    • +
  • +
    • +
+
+
+
+
+ + +

Index

+ +
+ A + | B + | C + | D + | E + | F + | G + | H + | I + | K + | L + | M + | N + | O + | P + | R + | S + | T + | U + | V + | W + | Y + +
+

A

+ + + +
+ +

B

+ + + +
+ +

C

+ + + +
+ +

D

+ + + +
+ +

E

+ + + +
+ +

F

+ + + +
+ +

G

+ + + +
+ +

H

+ + + +
+ +

I

+ + + +
+ +

K

+ + + +
+ +

L

+ + + +
+ +

M

+ + + +
+ +

N

+ + + +
+ +

O

+ + + +
+ +

P

+ + + +
+ +

R

+ + + +
+ +

S

+ + + +
+ +

T

+ + + +
+ +

U

+ + + +
+ +

V

+ + + +
+ +

W

+ + + +
+ +

Y

+ + +
+ + + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/gettingstarted.html b/gettingstarted.html new file mode 100644 index 00000000..86384aef --- /dev/null +++ b/gettingstarted.html @@ -0,0 +1,188 @@ + + + + + + + + + Getting Started — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Getting Started

+
+

Installation

+

Just run pip3 install -U homematicip in the command line to get the package. +This will install (and update) the library and all required packages

+
+
+

Getting the AUTH-TOKEN

+

Before you can start using the library you will need an auth-token. Otherwise the HMIP Cloud will not trust you.

+

You will need:

+
    +

  • Access to an active Access Point (it must glow blue)

    • +

  • the SGTIN of the Access Point

    • +

  • [optional] the PIN

    • +
+

Now you have to run hmip_generate_auth_token from terminal and follow it’s instructions. +It will generate a config.ini in your current working directory. The scripts which are using this library are looking +for this file to load the auth-token and SGTIN of the Access Point. You can either place it in the working directory when you are +running the scripts or depending on your OS in different “global” folders:

+
    +

  • General

    +
      +

    • current working directory

      • +
    +
    • +

  • Windows

    +
      +

    • %APPDATA%\homematicip-rest-api

      • +

    • %PROGRAMDATA%\homematicip-rest-api

      • +
    +
    • +

  • Linux

    +
      +

    • ~/.homematicip-rest-api/

      • +

    • /etc/homematicip-rest-api/

      • +
    +
    • +

  • MAC OS

    +
      +

    • ~/Library/Preferences/homematicip-rest-api/

      • +

    • /Library/Application Support/homematicip-rest-api/

      • +
    +
    • +
+
+
+

Using the CLI

+

You can send commands to homematicIP using the hmip_cli script. To get an overview, use -h or –help param. To address devices, use the argument -d in combination with the 24-digit ID (301400000000000000000000) from –list-devices.

+
+

Get Information about devices and groups

+

Commands are bound to the channel type. To get a list of all allowed actions for a device you can write hmip_cli -d {deviceid} –print-allowed-commands or hmip_cli -d {deviceid} -ac.

+

To get infos for a device and its channels use the –print-infos argument in combination with -d for a device or -g for a group.

+
+
+

Examples

+

A few examples:

+
    +

  • hmip_cli –help to get help

    • +

  • hmip_cli –list-devices to get a list of your devices.

    • +

  • hmip_cli -d <id-from-device-list> –toggle-garage-door to toogle the garage door with HmIP-WGC.

    • +

  • hmip_cli –list-events to listen to events and changes in your homematicIP system

    • +

  • hmip_cli -d <id> –set-lock-state LOCKED –pin 1234 to lock a door with HmIP-DLD

    • +

  • hmip_cli –dump-configuration –anonymize to dump the current config and anonymize it.

    • +
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/homematicip.aio.html b/homematicip.aio.html new file mode 100644 index 00000000..f0eb12c8 --- /dev/null +++ b/homematicip.aio.html @@ -0,0 +1,2053 @@ + + + + + + + + + homematicip.aio package — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

homematicip.aio package

+
+

Submodules

+
+
+

homematicip.aio.auth module

+
+
+class homematicip.aio.auth.AsyncAuth(loop, websession=None)[source]
+

Bases: Auth

+

this class represents the ‘Async Auth’ of the homematic ip

+
+
+async confirmAuthToken(authToken)[source]
+
+ +
+
+async connectionRequest(devicename='homematicip-async')[source]
+
+ +
+
+async init(access_point_id, lookup=True, lookup_url=None)[source]
+
+ +
+
+async isRequestAcknowledged()[source]
+
+ +
+
+async requestAuthToken()[source]
+
+ +
+ +
+
+class homematicip.aio.auth.AsyncAuthConnection(loop, session=None)[source]
+

Bases: AsyncConnection

+
+ +
+
+

homematicip.aio.class_maps module

+
+
+

homematicip.aio.connection module

+
+
+class homematicip.aio.connection.AsyncConnection(loop, session=None)[source]
+

Bases: BaseConnection

+

Handles async http and websocket traffic.

+
+
+async api_call(path, body=None, full_url=False)[source]
+

Make the actual call to the HMIP server.

+

Throws HmipWrongHttpStatusError or HmipConnectionError if connection has failed or +response is not correct.

+
+ +
+
+async close_websocket_connection(source_is_reading_loop=False)[source]
+
+ +
+
+connect_timeout = 20
+
+ +
+
+full_url(partial_url)[source]
+
+ +
+
+async init(accesspoint_id, lookup=True, lookup_url='https://lookup.homematic.com:48335/getHost', **kwargs)[source]
+
+ +
+
+ping_loop = 60
+
+ +
+
+ping_timeout = 3
+
+ +
+
+async ws_connect(*, on_message, on_error)[source]
+
+ +
+
+property ws_connected
+

Websocket is connected.

+
+ +
+ +
+
+

homematicip.aio.device module

+
+
+class homematicip.aio.device.AsyncAccelerationSensor(connection)[source]
+

Bases: AccelerationSensor, AsyncDevice

+

HMIP-SAM

+
+
+async set_acceleration_sensor_event_filter_period(period: float, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_mode(mode: AccelerationSensorMode, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_neutral_position(neutralPosition: AccelerationSensorNeutralPosition, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_trigger_angle(angle: int, channelIndex=1)[source]
+
+ +
+
+async set_notification_sound_type(soundType: NotificationSoundType, isHighToLow: bool, channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncAlarmSirenIndoor(connection)[source]
+

Bases: AlarmSirenIndoor, AsyncSabotageDevice

+

HMIP-ASIR (Alarm Siren)

+
+ +
+
+class homematicip.aio.device.AsyncAlarmSirenOutdoor(connection)[source]
+

Bases: AlarmSirenOutdoor, AsyncAlarmSirenIndoor

+

HMIP-ASIR-O (Alarm Siren Outdoor)

+
+ +
+
+class homematicip.aio.device.AsyncBaseDevice(connection)[source]
+

Bases: BaseDevice

+

Async implementation of a generic homematic ip device (hmip and external)

+
+ +
+
+class homematicip.aio.device.AsyncBlind(connection)[source]
+

Bases: Blind, AsyncShutter

+

Base class for async blind devices

+
+
+async set_slats_level(slatsLevel=0.0, shutterLevel=None, channelIndex=1)[source]
+

sets the slats and shutter level

+
+
Parameters:
+
    +

  • slatsLevel (float) – the new level of the slats. 0.0 = open, 1.0 = closed,

    • +

  • shutterLevel (float) – the new level of the shutter. 0.0 = open, 1.0 = closed, None = use the current value

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.aio.device.AsyncBlindModule(connection)[source]
+

Bases: BlindModule, AsyncDevice

+

HMIP-HDM1 (Hunter Douglas & erfal window blinds)

+
+
+async set_primary_shading_level(primaryShadingLevel: float)[source]
+
+ +
+
+async set_secondary_shading_level(primaryShadingLevel: float, secondaryShadingLevel: float)[source]
+
+ +
+
+async stop()[source]
+

stops the current operation +:returns: the result of the _restCall

+
+ +
+ +
+
+class homematicip.aio.device.AsyncBrandBlind(connection)[source]
+

Bases: BrandBlind, AsyncFullFlushBlind

+

HMIP-BBL (Blind Actuator for brand switches)

+
+ +
+
+class homematicip.aio.device.AsyncBrandDimmer(connection)[source]
+

Bases: AsyncDimmer

+

HMIP-BDT Brand Dimmer

+
+ +
+
+class homematicip.aio.device.AsyncBrandPushButton(connection)[source]
+

Bases: BrandPushButton, AsyncPushButton

+

HMIP-BRC2 (Remote Control for brand switches – 2x channels)

+
+ +
+
+class homematicip.aio.device.AsyncBrandSwitch2(connection)[source]
+

Bases: BrandSwitch2, AsyncSwitch

+

ELV-SH-BS2 (ELV Smart Home ARR-Bausatz Schaltaktor für Markenschalter – 2-fach powered by Homematic IP)

+
+ +
+
+class homematicip.aio.device.AsyncBrandSwitchMeasuring(connection)[source]
+

Bases: BrandSwitchMeasuring, AsyncSwitchMeasuring

+

HMIP-BSM (Brand Switch and Meter)

+
+ +
+
+class homematicip.aio.device.AsyncBrandSwitchNotificationLight(connection)[source]
+

Bases: BrandSwitchNotificationLight, AsyncSwitch

+

HMIP-BSL (Switch Actuator for brand switches – with signal lamp)

+
+
+async set_rgb_dim_level(channelIndex: int, rgb: RGBColorState, dimLevel: float)[source]
+

sets the color and dimlevel of the lamp

+
+
Parameters:
+
    +

  • channelIndex (int) – the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex

    • +

  • rgb (RGBColorState) – the color of the lamp

    • +

  • dimLevel (float) – the dimLevel of the lamp. 0.0 = off, 1.0 = MAX

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+async set_rgb_dim_level_with_time(channelIndex: int, rgb: RGBColorState, dimLevel: float, onTime: float, rampTime: float)[source]
+

sets the color and dimlevel of the lamp

+
+
Parameters:
+
    +

  • channelIndex (int) – the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex

    • +

  • rgb (RGBColorState) – the color of the lamp

    • +

  • dimLevel (float) – the dimLevel of the lamp. 0.0 = off, 1.0 = MAX

    • +

  • onTime (float)

    • +

  • rampTime (float)

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.aio.device.AsyncCarbonDioxideSensor(connection)[source]
+

Bases: CarbonDioxideSensor, AsyncSwitch

+

HmIP-SCTH230

+
+ +
+
+class homematicip.aio.device.AsyncContactInterface(connection)[source]
+

Bases: ContactInterface, AsyncSabotageDevice

+

HMIP-SCI (Contact Interface Sensor)

+
+ +
+
+class homematicip.aio.device.AsyncDaliGateway(connection)[source]
+

Bases: DaliGateway, AsyncDevice

+
+ +
+
+class homematicip.aio.device.AsyncDevice(connection)[source]
+

Bases: Device

+

Async implementation of a genereric homematic ip device

+
+
+async authorizeUpdate()[source]
+
+ +
+
+async delete()[source]
+
+ +
+
+async is_update_applicable()[source]
+
+ +
+
+async set_label(label)[source]
+
+ +
+
+async set_router_module_enabled(enabled=True)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncDimmer(connection)[source]
+

Bases: Dimmer, AsyncDevice

+

Base dimmer device class

+
+
+async set_dim_level(dimLevel=0.0, channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncDinRailBlind4(connection)[source]
+

Bases: DinRailBlind4, AsyncBlind

+

HmIP-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)

+
+ +
+
+class homematicip.aio.device.AsyncDinRailDimmer3(connection)[source]
+

Bases: DinRailDimmer3, AsyncDimmer

+

HmIP-DRDI3 (Din Rail Dimmer 3 Inbound)

+
+ +
+
+class homematicip.aio.device.AsyncDinRailSwitch(connection)[source]
+

Bases: DinRailSwitch, AsyncFullFlushInputSwitch

+

HMIP-DRSI1 (Switch Actuator for DIN rail mount – 1x channel)

+
+ +
+
+class homematicip.aio.device.AsyncDinRailSwitch4(connection)[source]
+

Bases: DinRailSwitch4, AsyncSwitch

+

HMIP-DRSI4 (Homematic IP Switch Actuator for DIN rail mount – 4x channels)

+
+ +
+
+class homematicip.aio.device.AsyncDoorBellButton(connection)[source]
+

Bases: DoorBellButton, AsyncDevice

+
+ +
+
+class homematicip.aio.device.AsyncDoorBellContactInterface(connection)[source]
+

Bases: DoorBellContactInterface, AsyncDevice

+
+ +
+
+class homematicip.aio.device.AsyncDoorLockDrive(connection)[source]
+

Bases: DoorLockDrive, AsyncDevice

+

HmIP-DLD (DoorLockDrive)

+
+
+async set_lock_state(doorLockState: LockState, pin='', channelIndex=1)[source]
+

sets the door lock state

+
+
Parameters:
+
    +

  • doorLockState (float) – the state of the door. See LockState from base/enums.py

    • +

  • pin (string) – Pin, if specified.

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.aio.device.AsyncDoorLockSensor(connection)[source]
+

Bases: DoorLockSensor, AsyncDevice

+

HmIP-DLS

+
+ +
+
+class homematicip.aio.device.AsyncDoorModule(connection)[source]
+

Bases: DoorModule, AsyncDevice

+

Generic Door Module class

+
+
+async send_door_command(doorCommand=DoorCommand.STOP)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncEnergySensorsInterface(connection)[source]
+

Bases: EnergySensorsInterface, AsyncDevice

+
+ +
+
+class homematicip.aio.device.AsyncExternalDevice(connection)[source]
+

Bases: ExternalDevice

+

Async implementation of external device (hue)

+
+ +
+
+class homematicip.aio.device.AsyncFloorTerminalBlock10(connection)[source]
+

Bases: FloorTerminalBlock10, AsyncFloorTerminalBlock6

+

HMIP-FAL24-C10 (Floor Heating Actuator – 10x channels, 24V)

+
+ +
+
+class homematicip.aio.device.AsyncFloorTerminalBlock12(connection)[source]
+

Bases: FloorTerminalBlock12, AsyncDevice

+

HMIP-FALMOT-C12 (Floor Heating Actuator – 12x channels, motorised)

+
+
+async set_minimum_floor_heating_valve_position(minimumFloorHeatingValvePosition: float)[source]
+

sets the minimum floot heating valve position

+
+
Parameters:
+

minimumFloorHeatingValvePosition (float) – the minimum valve position. must be between 0.0 and 1.0 AsyncFloorTerminalBlock12

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.aio.device.AsyncFloorTerminalBlock6(connection)[source]
+

Bases: FloorTerminalBlock6, AsyncDevice

+

HMIP-FAL230-C6 (Floor Heating Actuator - 6 channels, 230 V)

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushBlind(connection)[source]
+

Bases: FullFlushBlind, AsyncBlind

+

HMIP-FBL (Blind Actuator - flush-mount)

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushContactInterface(connection)[source]
+

Bases: FullFlushContactInterface, AsyncDevice

+

HMIP-FCI1 (Contact Interface flush-mount – 1 channel)

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushContactInterface6(connection)[source]
+

Bases: FullFlushContactInterface6, AsyncDevice

+

HMIP-FCI6 (Contact Interface flush-mount – 6 channels)

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushDimmer(connection)[source]
+

Bases: AsyncDimmer

+

HMIP-FDT Dimming Actuator flush-mount

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushInputSwitch(connection)[source]
+

Bases: FullFlushInputSwitch, AsyncSwitch

+

HMIP-FSI16 (Switch Actuator with Push-button Input 230V, 16A)

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushShutter(connection)[source]
+

Bases: FullFlushShutter, AsyncShutter

+

HMIP-FROLL (Shutter Actuator - flush-mount) / HMIP-BROLL (Shutter Actuator - Brand-mount)

+
+ +
+
+class homematicip.aio.device.AsyncFullFlushSwitchMeasuring(connection)[source]
+

Bases: FullFlushSwitchMeasuring, AsyncSwitchMeasuring

+

HMIP-FSM (Full flush Switch and Meter)

+
+ +
+
+class homematicip.aio.device.AsyncGarageDoorModuleTormatic(connection)[source]
+

Bases: GarageDoorModuleTormatic, AsyncDoorModule

+

HMIP-MOD-TM (Garage Door Module Tormatic)

+
+ +
+
+class homematicip.aio.device.AsyncHeatingSwitch2(connection)[source]
+

Bases: HeatingSwitch2, AsyncSwitch

+

HMIP-WHS2 (Switch Actuator for heating systems – 2x channels)

+
+ +
+
+class homematicip.aio.device.AsyncHeatingThermostat(connection)[source]
+

Bases: HeatingThermostat, AsyncOperationLockableDevice

+

HMIP-eTRV (Radiator Thermostat)

+
+ +
+
+class homematicip.aio.device.AsyncHeatingThermostatCompact(connection)[source]
+

Bases: HeatingThermostatCompact, AsyncSabotageDevice

+

HMIP-eTRV-C (Heating-thermostat compact without display)

+
+ +
+
+class homematicip.aio.device.AsyncHeatingThermostatEvo(connection)[source]
+

Bases: HeatingThermostatEvo, AsyncOperationLockableDevice

+

HMIP-eTRV-E (Heating-thermostat new evo version)

+
+ +
+
+class homematicip.aio.device.AsyncHoermannDrivesModule(connection)[source]
+

Bases: HoermannDrivesModule, AsyncDoorModule

+

HMIP-MOD-HO (Garage Door Module for Hörmann)

+
+ +
+
+class homematicip.aio.device.AsyncHomeControlAccessPoint(connection)[source]
+

Bases: HomeControlAccessPoint, AsyncDevice

+

HMIP-HAP

+
+ +
+
+class homematicip.aio.device.AsyncHomeControlUnit(connection)[source]
+

Bases: HomeControlAccessPoint, AsyncDevice

+

HMIP-HCU

+
+ +
+
+class homematicip.aio.device.AsyncKeyRemoteControl4(connection)[source]
+

Bases: KeyRemoteControl4, AsyncPushButton

+

HMIP-KRC4 (Key Ring Remote Control - 4 buttons)

+
+ +
+
+class homematicip.aio.device.AsyncKeyRemoteControlAlarm(connection)[source]
+

Bases: KeyRemoteControlAlarm, AsyncDevice

+

HMIP-KRCA (Key Ring Remote Control - alarm)

+
+ +
+
+class homematicip.aio.device.AsyncLightSensor(connection)[source]
+

Bases: LightSensor, AsyncDevice

+

Async implementation of HMIP-SLO (Light Sensor outdoor)

+
+ +
+
+class homematicip.aio.device.AsyncMotionDetectorIndoor(connection)[source]
+

Bases: MotionDetectorIndoor, AsyncSabotageDevice

+

HMIP-SMI (Motion Detector with Brightness Sensor - indoor)

+
+ +
+
+class homematicip.aio.device.AsyncMotionDetectorOutdoor(connection)[source]
+

Bases: MotionDetectorOutdoor, AsyncDevice

+

HMIP-SMO-A (Motion Detector with Brightness Sensor - outdoor)

+
+ +
+
+class homematicip.aio.device.AsyncMotionDetectorPushButton(connection)[source]
+

Bases: MotionDetectorPushButton, AsyncDevice

+

HMIP-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2-button)

+
+ +
+
+class homematicip.aio.device.AsyncMultiIOBox(connection)[source]
+

Bases: MultiIOBox, AsyncSwitch

+

HMIP-MIOB (Multi IO Box for floor heating & cooling)

+
+ +
+
+class homematicip.aio.device.AsyncOpenCollector8Module(connection)[source]
+

Bases: OpenCollector8Module, AsyncSwitch

+

Async implementation of HMIP-MOD-OC8 ( Open Collector Module )

+
+ +
+
+class homematicip.aio.device.AsyncOperationLockableDevice(connection)[source]
+

Bases: OperationLockableDevice, AsyncDevice

+
+
+async set_operation_lock(operationLock=True)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncPassageDetector(connection)[source]
+

Bases: PassageDetector, AsyncSabotageDevice

+

HMIP-SPDR (Passage Detector)

+
+ +
+
+class homematicip.aio.device.AsyncPlugableSwitch(connection)[source]
+

Bases: PlugableSwitch, AsyncSwitch

+

Async implementation of HMIP-PS (Pluggable Switch)

+
+ +
+
+class homematicip.aio.device.AsyncPlugableSwitchMeasuring(connection)[source]
+

Bases: PlugableSwitchMeasuring, AsyncSwitchMeasuring

+

HMIP-PSM (Pluggable Switch and Meter)

+
+ +
+
+class homematicip.aio.device.AsyncPluggableDimmer(connection)[source]
+

Bases: AsyncDimmer

+

HMIP-PDT Pluggable Dimmer

+
+ +
+
+class homematicip.aio.device.AsyncPluggableMainsFailureSurveillance(connection)[source]
+

Bases: PluggableMainsFailureSurveillance, AsyncDevice

+

[HMIP-PMFS] (Plugable Power Supply Monitoring)

+
+ +
+
+class homematicip.aio.device.AsyncPresenceDetectorIndoor(connection)[source]
+

Bases: PresenceDetectorIndoor, AsyncSabotageDevice

+

HMIP-SPI (Presence Sensor - indoor)

+
+ +
+
+class homematicip.aio.device.AsyncPrintedCircuitBoardSwitch2(connection)[source]
+

Bases: PrintedCircuitBoardSwitch2, AsyncSwitch

+

Async implementation of HMIP-PCBS2 (Switch Circuit Board - 2x channels)

+
+ +
+
+class homematicip.aio.device.AsyncPrintedCircuitBoardSwitchBattery(connection)[source]
+

Bases: PrintedCircuitBoardSwitchBattery, AsyncSwitch

+

HMIP-PCBS-BAT (Printed Circuit Board Switch Battery)

+
+ +
+
+class homematicip.aio.device.AsyncPushButton(connection)[source]
+

Bases: PushButton, AsyncDevice

+

HMIP-WRC2 (Wall-mount Remote Control - 2-button)

+
+ +
+
+class homematicip.aio.device.AsyncPushButton6(connection)[source]
+

Bases: PushButton6, AsyncPushButton

+

HMIP-WRC6 (Wall-mount Remote Control - 6-button)

+
+ +
+
+class homematicip.aio.device.AsyncPushButtonFlat(connection)[source]
+

Bases: PushButtonFlat, AsyncPushButton

+

HMIP-WRCC2 (Wall-mount Remote Control – flat)

+
+ +
+
+class homematicip.aio.device.AsyncRainSensor(connection)[source]
+

Bases: RainSensor, AsyncDevice

+

HMIP-SRD (Rain Sensor)

+
+ +
+
+class homematicip.aio.device.AsyncRemoteControl8(connection)[source]
+

Bases: RemoteControl8, AsyncPushButton

+

HMIP-RC8 (Remote Control - 8 buttons)

+
+ +
+
+class homematicip.aio.device.AsyncRemoteControl8Module(connection)[source]
+

Bases: RemoteControl8Module, AsyncRemoteControl8

+

HMIP-MOD-RC8 (Open Collector Module Sender - 8x)

+
+ +
+
+class homematicip.aio.device.AsyncRgbwDimmer(connection)[source]
+

Bases: RgbwDimmer, AsyncDevice

+

HmIP-RGBW device.

+
+ +
+
+class homematicip.aio.device.AsyncRoomControlDevice(connection)[source]
+

Bases: RoomControlDevice, AsyncWallMountedThermostatPro

+

ALPHA-IP-RBG (Alpha IP Wall Thermostat Display)

+
+ +
+
+class homematicip.aio.device.AsyncRoomControlDeviceAnalog(connection)[source]
+

Bases: AsyncDevice

+

ALPHA-IP-RBGa (ALpha IP Wall Thermostat Display analog)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.aio.device.AsyncRotaryHandleSensor(connection)[source]
+

Bases: RotaryHandleSensor, AsyncSabotageDevice

+

HMIP-SRH

+
+ +
+
+class homematicip.aio.device.AsyncSabotageDevice(connection)[source]
+

Bases: SabotageDevice, AsyncDevice

+

Async implementation sabotage signaling devices

+
+ +
+
+class homematicip.aio.device.AsyncShutter(connection)[source]
+

Bases: Shutter, AsyncDevice

+

Base class for async shutter devices

+
+
+async set_shutter_level(level=0.0, channelIndex=1)[source]
+

sets the shutter level

+
+
Parameters:
+
    +

  • level (float) – the new level of the shutter. 0.0 = open, 1.0 = closed

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+async set_shutter_stop(channelIndex=1)[source]
+

stops the current shutter operation

+
+
Parameters:
+

channelIndex (int) – the channel to control

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.aio.device.AsyncShutterContact(connection)[source]
+

Bases: ShutterContact, AsyncSabotageDevice

+

HMIP-SWDO (Door / Window Contact - optical) / +HMIP-SWDO-I (Door / Window Contact Invisible - optical)

+
+ +
+
+class homematicip.aio.device.AsyncShutterContactMagnetic(connection)[source]
+

Bases: ShutterContactMagnetic, AsyncDevice

+

HMIP-SWDM / HMIP-SWDM-B2 (Door / Window Contact - magnetic

+
+ +
+
+class homematicip.aio.device.AsyncShutterContactOpticalPlus(connection)[source]
+

Bases: ShutterContactOpticalPlus, AsyncShutterContact

+

HmIP-SWDO-PL ( Window / Door Contact – optical, plus )

+
+ +
+
+class homematicip.aio.device.AsyncSmokeDetector(connection)[source]
+

Bases: SmokeDetector, AsyncDevice

+

HMIP-SWSD (Smoke Alarm with Q label)

+
+ +
+
+class homematicip.aio.device.AsyncSwitch(connection)[source]
+

Bases: Switch, AsyncDevice

+

Generic async switch

+
+
+async set_switch_state(on=True, channelIndex=1)[source]
+
+ +
+
+async turn_off(channelIndex=1)[source]
+
+ +
+
+async turn_on(channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncSwitchMeasuring(connection)[source]
+

Bases: SwitchMeasuring, AsyncSwitch

+

Generic async switch measuring

+
+
+async reset_energy_counter()[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncTemperatureDifferenceSensor2(connection)[source]
+

Bases: TemperatureDifferenceSensor2, AsyncDevice

+

HmIP-STE2-PCB (Temperature Difference Sensors - 2x sensors)

+
+ +
+
+class homematicip.aio.device.AsyncTemperatureHumiditySensorDisplay(connection)[source]
+

Bases: TemperatureHumiditySensorDisplay, AsyncDevice

+

HMIP-STHD (Temperature and Humidity Sensor with display - indoor)

+
+
+async set_display(display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncTemperatureHumiditySensorOutdoor(connection)[source]
+

Bases: TemperatureHumiditySensorOutdoor, AsyncDevice

+

HMIP-STHO (Temperature and Humidity Sensor outdoor)

+
+ +
+
+class homematicip.aio.device.AsyncTemperatureHumiditySensorWithoutDisplay(connection)[source]
+

Bases: TemperatureHumiditySensorWithoutDisplay, AsyncDevice

+

HMIP-STH (Temperature and Humidity Sensor without display - indoor)

+
+ +
+
+class homematicip.aio.device.AsyncTiltVibrationSensor(connection)[source]
+

Bases: TiltVibrationSensor, AsyncDevice

+

HMIP-STV (Inclination and vibration Sensor)

+
+
+async set_acceleration_sensor_event_filter_period(period: float, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_mode(mode: AccelerationSensorMode, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity, channelIndex=1)[source]
+
+ +
+
+async set_acceleration_sensor_trigger_angle(angle: int, channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncWallMountedGarageDoorController(connection)[source]
+

Bases: WallMountedGarageDoorController, AsyncDevice

+

HmIP-WGC (Garage Door Controller)

+
+
+async send_start_impulse()[source]
+

Toggle Wall mounted Garage Door Controller.

+
+ +
+ +
+
+class homematicip.aio.device.AsyncWallMountedThermostatBasicHumidity(connection)[source]
+

Bases: AsyncWallMountedThermostatPro

+

HMIP-WTH-B (Wall Thermostat – basic)

+
+ +
+
+class homematicip.aio.device.AsyncWallMountedThermostatPro(connection)[source]
+

Bases: WallMountedThermostatPro, AsyncTemperatureHumiditySensorDisplay, AsyncOperationLockableDevice

+

HMIP-WTH, HMIP-WTH-2 (Wall Thermostat with Humidity Sensor) +/ HMIP-BWTH (Brand Wall Thermostat with Humidity Sensor)

+
+ +
+
+class homematicip.aio.device.AsyncWaterSensor(connection)[source]
+

Bases: WaterSensor, AsyncDevice

+

HMIP-SWD

+
+
+async set_acoustic_alarm_signal(acousticAlarmSignal: AcousticAlarmSignal)[source]
+
+ +
+
+async set_acoustic_alarm_timing(acousticAlarmTiming: AcousticAlarmTiming)[source]
+
+ +
+
+async set_acoustic_water_alarm_trigger(acousticWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+async set_inapp_water_alarm_trigger(inAppWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+async set_siren_water_alarm_trigger(sirenWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncWeatherSensor(connection)[source]
+

Bases: WeatherSensor, AsyncDevice

+

HMIP-SWO-B

+
+ +
+
+class homematicip.aio.device.AsyncWeatherSensorPlus(connection)[source]
+

Bases: WeatherSensorPlus, AsyncDevice

+

HMIP-SWO-PL

+
+ +
+
+class homematicip.aio.device.AsyncWeatherSensorPro(connection)[source]
+

Bases: WeatherSensorPro, AsyncDevice

+

HMIP-SWO-PR

+
+ +
+
+class homematicip.aio.device.AsyncWiredDimmer3(connection)[source]
+

Bases: WiredDimmer3, AsyncDimmer

+

HMIPW-DRD3 (Homematic IP Wired Dimming Actuator – 3x channels)

+
+ +
+
+class homematicip.aio.device.AsyncWiredDinRailAccessPoint(connection)[source]
+

Bases: WiredDinRailAccessPoint, AsyncDevice

+

HmIPW-DRAP

+
+ +
+
+class homematicip.aio.device.AsyncWiredDinRailBlind4(connection)[source]
+

Bases: WiredDinRailBlind4, AsyncBlind

+

HmIPW-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)

+
+ +
+
+class homematicip.aio.device.AsyncWiredFloorTerminalBlock12(connection)[source]
+

Bases: AsyncFloorTerminalBlock12

+

HmIPW-FALMOT-C12

+
+ +
+
+class homematicip.aio.device.AsyncWiredInput32(connection)[source]
+

Bases: WiredInput32, AsyncFullFlushContactInterface

+

HMIPW-DRI32 (Homematic IP Wired Inbound module – 32x channels)

+
+ +
+
+class homematicip.aio.device.AsyncWiredInputSwitch6(connection)[source]
+

Bases: WiredInputSwitch6, AsyncSwitch

+

HmIPW-FIO6

+
+ +
+
+class homematicip.aio.device.AsyncWiredMotionDetectorPushButton(connection)[source]
+

Bases: WiredMotionDetectorPushButton, AsyncDevice

+

HMIPW-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2-button)

+
+ +
+
+class homematicip.aio.device.AsyncWiredPushButton(connection)[source]
+

Bases: WiredPushButton, AsyncDevice

+

HmIPW-WRC6 and HmIPW-WRC2

+
+
+async set_dim_level(channelIndex, dimLevel)[source]
+

sets the signal type for the leds +:param channelIndex: Channel which is affected +:type channelIndex: int +:param dimLevel: usally 1.01. Use set_dim_level instead +:type dimLevel: float

+
+
Returns:
+

Result of the _restCall

+
+
+
+ +
+
+async set_optical_signal(channelIndex, opticalSignalBehaviour: OpticalSignalBehaviour, rgb: RGBColorState, dimLevel=1.01)[source]
+

sets the signal type for the leds

+
+
Parameters:
+
    +

  • channelIndex (int) – Channel which is affected

    • +

  • opticalSignalBehaviour (OpticalSignalBehaviour) – LED signal behaviour

    • +

  • rgb (RGBColorState) – Color

    • +

  • dimLevel (float) – usally 1.01. Use set_dim_level instead

    • +
+
+
Returns:
+

Result of the _restCall

+
+
+
+ +
+
+async set_switch_state(on=True, channelIndex=1)[source]
+
+ +
+
+async turn_off(channelIndex=1)[source]
+
+ +
+
+async turn_on(channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.aio.device.AsyncWiredSwitch4(connection)[source]
+

Bases: WiredSwitch4, AsyncSwitch

+

HMIPW-DRS4 (Homematic IP Wired Switch Actuator – 4x channels)

+
+ +
+
+class homematicip.aio.device.AsyncWiredSwitch8(connection)[source]
+

Bases: WiredSwitch8, AsyncSwitch

+

HMIPW-DRS8 (Homematic IP Wired Switch Actuator – 8x channels)

+
+ +
+
+

homematicip.aio.group module

+
+
+class homematicip.aio.group.AsyncAccessAuthorizationProfileGroup(connection)[source]
+

Bases: AccessAuthorizationProfileGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncAccessControlGroup(connection)[source]
+

Bases: AccessControlGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncAlarmSwitchingGroup(connection)[source]
+

Bases: AlarmSwitchingGroup, AsyncGroup

+
+
+async set_on_time(onTimeSeconds)[source]
+
+ +
+
+async set_signal_acoustic(signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING)[source]
+
+ +
+
+async set_signal_optical(signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING)[source]
+
+ +
+
+async test_signal_acoustic(signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING)[source]
+
+ +
+
+async test_signal_optical(signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncEnergyGroup(connection)[source]
+

Bases: AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncEnvironmentGroup(connection)[source]
+

Bases: EnvironmentGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncExtendedGarageDoorGroup(connection)[source]
+

Bases: ExtendedLinkedGarageDoorGroup, AsyncGroup

+

Class which represents Extended Garage Door Group.

+
+ +
+
+class homematicip.aio.group.AsyncExtendedLinkedShutterGroup(connection)[source]
+

Bases: ExtendedLinkedShutterGroup, AsyncGroup

+
+
+async set_shutter_level(level)[source]
+
+ +
+
+async set_shutter_stop()[source]
+
+ +
+
+async set_slats_level(slatsLevel=0.0, shutterLevel=None)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncExtendedLinkedSwitchingGroup(connection)[source]
+

Bases: ExtendedLinkedSwitchingGroup, AsyncSwitchGroupBase

+
+
+async set_on_time(onTimeSeconds)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncGroup(connection)[source]
+

Bases: Group

+
+
+async delete()[source]
+
+ +
+
+async set_label(label)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncHeatingChangeoverGroup(connection)[source]
+

Bases: HeatingChangeoverGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingCoolingDemandBoilerGroup(connection)[source]
+

Bases: HeatingCoolingDemandBoilerGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingCoolingDemandGroup(connection)[source]
+

Bases: HeatingCoolingDemandGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingCoolingDemandPumpGroup(connection)[source]
+

Bases: HeatingCoolingDemandPumpGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingDehumidifierGroup(connection)[source]
+

Bases: HeatingDehumidifierGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingExternalClockGroup(connection)[source]
+

Bases: HeatingExternalClockGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingFailureAlertRuleGroup(connection)[source]
+

Bases: HeatingFailureAlertRuleGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingGroup(connection)[source]
+

Bases: HeatingGroup, AsyncGroup

+
+
+async set_active_profile(index)[source]
+
+ +
+
+async set_boost(enable=True)[source]
+
+ +
+
+async set_boost_duration(duration: int)[source]
+
+ +
+
+async set_control_mode(mode=ClimateControlMode.AUTOMATIC)[source]
+
+ +
+
+async set_point_temperature(temperature)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncHeatingHumidyLimiterGroup(connection)[source]
+

Bases: HeatingHumidyLimiterGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHeatingTemperatureLimiterGroup(connection)[source]
+

Bases: HeatingTemperatureLimiterGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncHotWaterGroup(connection)[source]
+

Bases: HotWaterGroup, AsyncGroup

+
+
+async set_profile_mode(profileMode: ProfileMode)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncHumidityWarningRuleGroup(connection)[source]
+

Bases: HumidityWarningRuleGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncInboxGroup(connection)[source]
+

Bases: InboxGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncIndoorClimateGroup(connection)[source]
+

Bases: IndoorClimateGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncLinkedSwitchingGroup(connection)[source]
+

Bases: LinkedSwitchingGroup, AsyncGroup

+
+
+async set_light_group_switches(devices)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncLockOutProtectionRule(connection)[source]
+

Bases: LockOutProtectionRule, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncMetaGroup(connection)[source]
+

Bases: MetaGroup, AsyncGroup

+

a meta group is a “Room” inside the homematic configuration

+
+ +
+
+class homematicip.aio.group.AsyncOverHeatProtectionRule(connection)[source]
+

Bases: OverHeatProtectionRule, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncSecurityGroup(connection)[source]
+

Bases: SecurityGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncSecurityZoneGroup(connection)[source]
+

Bases: SecurityZoneGroup, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncShutterProfile(connection)[source]
+

Bases: ShutterProfile, AsyncGroup

+
+
+async set_profile_mode(profileMode: ProfileMode)[source]
+
+ +
+
+async set_shutter_level(level)[source]
+
+ +
+
+async set_shutter_stop()[source]
+
+ +
+
+async set_slats_level(slatsLevel, shutterlevel)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncShutterWindProtectionRule(connection)[source]
+

Bases: ShutterWindProtectionRule, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncSmokeAlarmDetectionRule(connection)[source]
+

Bases: SmokeAlarmDetectionRule, AsyncGroup

+
+ +
+
+class homematicip.aio.group.AsyncSwitchGroupBase(connection)[source]
+

Bases: SwitchGroupBase, AsyncGroup

+
+
+async set_switch_state(on=True)[source]
+
+ +
+
+async turn_off()[source]
+
+ +
+
+async turn_on()[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncSwitchingGroup(connection)[source]
+

Bases: SwitchingGroup, AsyncSwitchGroupBase

+
+
+async set_shutter_level(level)[source]
+
+ +
+
+async set_shutter_stop()[source]
+
+ +
+
+async set_slats_level(slatsLevel, shutterlevel)[source]
+
+ +
+ +
+
+class homematicip.aio.group.AsyncSwitchingProfileGroup(connection)[source]
+

Bases: SwitchingProfileGroup, AsyncGroup

+
+
+async create(label)[source]
+
+ +
+
+async set_group_channels()[source]
+
+ +
+
+async set_profile_mode(devices, automatic=True)[source]
+
+ +
+ +
+
+

homematicip.aio.home module

+
+
+class homematicip.aio.home.AsyncHome(loop, websession=None)[source]
+

Bases: Home

+

this class represents the ‘Async Home’ of the homematic ip

+
+
+async activate_absence_permanent()[source]
+

activates the absence forever

+
+ +
+
+async activate_absence_with_duration(duration)[source]
+

activates the absence mode for a given time

+
+
Parameters:
+

duration (int) – the absence duration in minutes

+
+
+
+ +
+
+async activate_absence_with_period(endtime)[source]
+

activates the absence mode until the given time

+
+
Parameters:
+

endtime (datetime) – the time when the absence should automatically be disabled

+
+
+
+ +
+
+async activate_vacation(endtime, temperature)[source]
+

activates the vatation mode until the given time

+
+
Parameters:
+
    +

  • endtime (datetime) – the time when the vatation mode should automatically be disabled

    • +

  • temperature (float) – the settemperature during the vacation mode

    • +
+
+
+
+ +
+
+async deactivate_absence()[source]
+

deactivates the absence mode immediately

+
+ +
+
+async deactivate_vacation()[source]
+

deactivates the vacation mode immediately

+
+ +
+
+async delete_group(group)[source]
+

deletes the given group from the cloud

+
+
Parameters:
+

group (Group) – the group to delete

+
+
+
+ +
+
+async disable_events()[source]
+
+ +
+
+async download_configuration()[source]
+

downloads the current configuration from the cloud

+
+
Returns

the downloaded configuration or an errorCode

+
+
+
+ +
+
+async enable_events() → Task[source]
+

Connects to the websocket. Returns a listening task.

+
+ +
+
+async get_OAuth_OTK()[source]
+
+ +
+
+async get_current_state(clearConfig: bool = False)[source]
+

downloads the current configuration and parses it into self

+
+
Parameters:
+
    +

  • clearConfig (bool) – if set to true, this function will remove all old objects

    • +

  • self.devices (from)

    • +

  • self.client

    • +

  • them (... to have a fresh config instead of reparsing)

    • +
+
+
+
+ +
+
+async get_security_journal()[source]
+
+ +
+
+async init(access_point_id, lookup=True)[source]
+
+ +
+
+async set_cooling(cooling)[source]
+
+ +
+
+async set_intrusion_alert_through_smoke_detectors(activate=True)[source]
+

activate or deactivate if smoke detectors should “ring” during an alarm

+
+
Parameters:
+

activate (bool) – True will let the smoke detectors “ring” during an alarm

+
+
+
+ +
+
+async set_location(city, latitude, longitude)[source]
+
+ +
+
+async set_pin(newPin, oldPin=None)[source]
+

sets a new pin for the home

+
+
Parameters:
+
    +

  • newPin (str) – the new pin

    • +

  • oldPin (str) – optional, if there is currently a pin active it must be given here. +Otherwise it will not be possible to set the new pin

    • +
+
+
Returns:
+

the result of the call

+
+
+
+ +
+
+async set_powermeter_unit_price(price)[source]
+
+ +
+
+async set_security_zones_activation(internal=True, external=True)[source]
+

this function will set the alarm system to armed or disable it

+
+
Parameters:
+
    +

  • internal (bool) – activates/deactivates the internal zone

    • +

  • external (bool) – activates/deactivates the external zone

    • +
+
+
+

Examples

+

arming while being at home

+
>>> home.set_security_zones_activation(False,True)
+
+
+

arming without being at home

+
>>> home.set_security_zones_activation(True,True)
+
+
+

disarming the alarm system

+
>>> home.set_security_zones_activation(False,False)
+
+
+
+ +
+
+async set_timezone(timezone)[source]
+

sets the timezone for the AP. e.g. “Europe/Berlin” +:param timezone: the new timezone +:type timezone: str

+
+ +
+
+async set_zone_activation_delay(delay)[source]
+
+ +
+
+async set_zones_device_assignment(internal_devices, external_devices)[source]
+

sets the devices for the security zones +:param internal_devices: the devices which should be used for the internal zone +:type internal_devices: List[Device] +:param external_devices: the devices which should be used for the external(hull) zone +:type external_devices: List[Device]

+
+
Returns:
+

the result of _restCall

+
+
+
+ +
+ +
+
+

homematicip.aio.rule module

+
+
+class homematicip.aio.rule.AsyncRule(connection)[source]
+

Bases: Rule

+

Async implementation of a homematic ip rule

+
+
+async set_label(label)[source]
+

sets the label of the rule

+
+ +
+ +
+
+class homematicip.aio.rule.AsyncSimpleRule(connection)[source]
+

Bases: SimpleRule, AsyncRule

+

Async implementation of a homematic ip simple rule

+
+
+async disable()[source]
+

disables the rule

+
+ +
+
+async enable()[source]
+

enables the rule

+
+ +
+
+async get_simple_rule()[source]
+
+ +
+
+async set_rule_enabled_state(enabled)[source]
+

enables/disables this rule

+
+ +
+ +
+
+

homematicip.aio.securityEvent module

+
+
+class homematicip.aio.securityEvent.AsyncAccessPointConnectedEvent(connection)[source]
+

Bases: AccessPointConnectedEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncAccessPointDisconnectedEvent(connection)[source]
+

Bases: AccessPointDisconnectedEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncActivationChangedEvent(connection)[source]
+

Bases: ActivationChangedEvent, AsyncSecurityZoneEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncExternalTriggeredEvent(connection)[source]
+

Bases: ExternalTriggeredEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncMainsFailureEvent(connection)[source]
+

Bases: MainsFailureEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncMoistureDetectionEvent(connection)[source]
+

Bases: MoistureDetectionEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncOfflineAlarmEvent(connection)[source]
+

Bases: OfflineAlarmEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncOfflineWaterDetectionEvent(connection)[source]
+

Bases: OfflineWaterDetectionEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncSabotageEvent(connection)[source]
+

Bases: SabotageEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncSecurityEvent(connection)[source]
+

Bases: SecurityEvent

+

this class represents a security event

+
+ +
+
+class homematicip.aio.securityEvent.AsyncSecurityZoneEvent(connection)[source]
+

Bases: SecurityZoneEvent, AsyncSecurityEvent

+

This class will be used by other events which are just adding “securityZoneValues”

+
+ +
+
+class homematicip.aio.securityEvent.AsyncSensorEvent(connection)[source]
+

Bases: SensorEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncSilenceChangedEvent(connection)[source]
+

Bases: SilenceChangedEvent, AsyncSecurityZoneEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncSmokeAlarmEvent(connection)[source]
+

Bases: SmokeAlarmEvent, AsyncSecurityEvent

+
+ +
+
+class homematicip.aio.securityEvent.AsyncWaterDetectionEvent(connection)[source]
+

Bases: WaterDetectionEvent, AsyncSecurityEvent

+
+ +
+
+

Module contents

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/homematicip.base.html b/homematicip.base.html new file mode 100644 index 00000000..257f21ee --- /dev/null +++ b/homematicip.base.html @@ -0,0 +1,5170 @@ + + + + + + + + + homematicip.base package — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

homematicip.base package

+
+

Submodules

+
+
+

homematicip.base.HomeMaticIPObject module

+
+
+

homematicip.base.base_connection module

+
+
+class homematicip.base.base_connection.BaseConnection[source]
+

Bases: object

+

Base connection class.

+

Threaded and Async connection class must inherit from this.

+
+
+property accesspoint_id
+
+ +
+
+property auth_token
+
+ +
+
+property clientCharacteristics
+
+ +
+
+property clientauth_token
+
+ +
+
+init(accesspoint_id, lookup=True, **kwargs)[source]
+
+ +
+
+set_auth_token(auth_token)[source]
+
+ +
+
+set_token_and_characteristics(accesspoint_id)[source]
+
+ +
+
+property urlREST
+
+ +
+
+property urlWebSocket
+
+ +
+ +
+
+exception homematicip.base.base_connection.HmipConnectionError[source]
+

Bases: Exception

+
+ +
+
+exception homematicip.base.base_connection.HmipServerCloseError[source]
+

Bases: HmipConnectionError

+
+ +
+
+exception homematicip.base.base_connection.HmipThrottlingError[source]
+

Bases: HmipConnectionError

+
+ +
+
+exception homematicip.base.base_connection.HmipWrongHttpStatusError(status_code=None)[source]
+

Bases: HmipConnectionError

+
+ +
+
+

homematicip.base.constants module

+
+
+

homematicip.base.enums module

+
+
+class homematicip.base.enums.AbsenceType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+NOT_ABSENT = 'NOT_ABSENT'
+
+ +
+
+PARTY = 'PARTY'
+
+ +
+
+PERIOD = 'PERIOD'
+
+ +
+
+PERMANENT = 'PERMANENT'
+
+ +
+
+VACATION = 'VACATION'
+
+ +
+ +
+
+class homematicip.base.enums.AccelerationSensorMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ANY_MOTION = 'ANY_MOTION'
+
+ +
+
+FLAT_DECT = 'FLAT_DECT'
+
+ +
+ +
+
+class homematicip.base.enums.AccelerationSensorNeutralPosition(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+HORIZONTAL = 'HORIZONTAL'
+
+ +
+
+VERTICAL = 'VERTICAL'
+
+ +
+ +
+
+class homematicip.base.enums.AccelerationSensorSensitivity(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+SENSOR_RANGE_16G = 'SENSOR_RANGE_16G'
+
+ +
+
+SENSOR_RANGE_2G = 'SENSOR_RANGE_2G'
+
+ +
+
+SENSOR_RANGE_2G_2PLUS_SENSE = 'SENSOR_RANGE_2G_2PLUS_SENSE'
+
+ +
+
+SENSOR_RANGE_2G_PLUS_SENS = 'SENSOR_RANGE_2G_PLUS_SENS'
+
+ +
+
+SENSOR_RANGE_4G = 'SENSOR_RANGE_4G'
+
+ +
+
+SENSOR_RANGE_8G = 'SENSOR_RANGE_8G'
+
+ +
+ +
+
+class homematicip.base.enums.AcousticAlarmSignal(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+DELAYED_EXTERNALLY_ARMED = 'DELAYED_EXTERNALLY_ARMED'
+
+ +
+
+DELAYED_INTERNALLY_ARMED = 'DELAYED_INTERNALLY_ARMED'
+
+ +
+
+DISABLE_ACOUSTIC_SIGNAL = 'DISABLE_ACOUSTIC_SIGNAL'
+
+ +
+
+DISARMED = 'DISARMED'
+
+ +
+
+ERROR = 'ERROR'
+
+ +
+
+EVENT = 'EVENT'
+
+ +
+
+EXTERNALLY_ARMED = 'EXTERNALLY_ARMED'
+
+ +
+
+FREQUENCY_ALTERNATING_LOW_HIGH = 'FREQUENCY_ALTERNATING_LOW_HIGH'
+
+ +
+
+FREQUENCY_ALTERNATING_LOW_MID_HIGH = 'FREQUENCY_ALTERNATING_LOW_MID_HIGH'
+
+ +
+
+FREQUENCY_FALLING = 'FREQUENCY_FALLING'
+
+ +
+
+FREQUENCY_HIGHON_LONGOFF = 'FREQUENCY_HIGHON_LONGOFF'
+
+ +
+
+FREQUENCY_HIGHON_OFF = 'FREQUENCY_HIGHON_OFF'
+
+ +
+
+FREQUENCY_LOWON_LONGOFF_HIGHON_LONGOFF = 'FREQUENCY_LOWON_LONGOFF_HIGHON_LONGOFF'
+
+ +
+
+FREQUENCY_LOWON_OFF_HIGHON_OFF = 'FREQUENCY_LOWON_OFF_HIGHON_OFF'
+
+ +
+
+FREQUENCY_RISING = 'FREQUENCY_RISING'
+
+ +
+
+FREQUENCY_RISING_AND_FALLING = 'FREQUENCY_RISING_AND_FALLING'
+
+ +
+
+INTERNALLY_ARMED = 'INTERNALLY_ARMED'
+
+ +
+
+LOW_BATTERY = 'LOW_BATTERY'
+
+ +
+ +
+
+class homematicip.base.enums.AcousticAlarmTiming(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ONCE_PER_MINUTE = 'ONCE_PER_MINUTE'
+
+ +
+
+PERMANENT = 'PERMANENT'
+
+ +
+
+SIX_MINUTES = 'SIX_MINUTES'
+
+ +
+
+THREE_MINUTES = 'THREE_MINUTES'
+
+ +
+ +
+
+class homematicip.base.enums.AlarmContactType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+PASSIVE_GLASS_BREAKAGE_DETECTOR = 'PASSIVE_GLASS_BREAKAGE_DETECTOR'
+
+ +
+
+WINDOW_DOOR_CONTACT = 'WINDOW_DOOR_CONTACT'
+
+ +
+ +
+
+class homematicip.base.enums.AlarmSignalType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+FULL_ALARM = 'FULL_ALARM'
+
+ +
+
+NO_ALARM = 'NO_ALARM'
+
+ +
+
+SILENT_ALARM = 'SILENT_ALARM'
+
+ +
+ +
+
+class homematicip.base.enums.ApExchangeState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+DONE = 'DONE'
+
+ +
+
+IN_PROGRESS = 'IN_PROGRESS'
+
+ +
+
+NONE = 'NONE'
+
+ +
+
+REJECTED = 'REJECTED'
+
+ +
+
+REQUESTED = 'REQUESTED'
+
+ +
+ +
+
+class homematicip.base.enums.AutoNameEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: str, Enum

+

auto() will generate the name of the attribute as value

+
+
+classmethod from_str(text: str, default=None)[source]
+

this function will create the enum object based on its string value

+
+
Parameters:
+
    +

  • text (str) – the string value of the enum

    • +

  • default (AutoNameEnum) – a default value if text could not be used

    • +
+
+
Returns:
+

the enum object or None if the text is None or the default value

+
+
+
+ +
+ +
+
+class homematicip.base.enums.AutomationRuleType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+SIMPLE = 'SIMPLE'
+
+ +
+ +
+
+class homematicip.base.enums.BinaryBehaviorType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+NORMALLY_CLOSE = 'NORMALLY_CLOSE'
+
+ +
+
+NORMALLY_OPEN = 'NORMALLY_OPEN'
+
+ +
+ +
+
+class homematicip.base.enums.ChannelEventTypes(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+DOOR_BELL_SENSOR_EVENT = 'DOOR_BELL_SENSOR_EVENT'
+
+ +
+ +
+
+class homematicip.base.enums.CliActions(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+RESET_ENERGY_COUNTER = 'RESET_ENERGY_COUNTER'
+
+ +
+
+SEND_DOOR_COMMAND = 'SEND_DOOR_COMMAND'
+
+ +
+
+SET_DIM_LEVEL = 'SET_DIM_LEVEL'
+
+ +
+
+SET_LOCK_STATE = 'SET_LOCK_STATE'
+
+ +
+
+SET_SHUTTER_LEVEL = 'SET_SHUTTER_LEVEL'
+
+ +
+
+SET_SHUTTER_STOP = 'SET_SHUTTER_STOP'
+
+ +
+
+SET_SLATS_LEVEL = 'SET_SLATS_LEVEL'
+
+ +
+
+SET_SWITCH_STATE = 'SET_SWITCH_STATE'
+
+ +
+
+TOGGLE_GARAGE_DOOR = 'TOGGLE_GARAGE_DOOR'
+
+ +
+ +
+
+class homematicip.base.enums.ClientType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+APP = 'APP'
+
+ +
+
+C2C = 'C2C'
+
+ +
+ +
+
+class homematicip.base.enums.ClimateControlDisplay(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACTUAL = 'ACTUAL'
+
+ +
+
+ACTUAL_HUMIDITY = 'ACTUAL_HUMIDITY'
+
+ +
+
+SETPOINT = 'SETPOINT'
+
+ +
+ +
+
+class homematicip.base.enums.ClimateControlMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+AUTOMATIC = 'AUTOMATIC'
+
+ +
+
+ECO = 'ECO'
+
+ +
+
+MANUAL = 'MANUAL'
+
+ +
+ +
+
+class homematicip.base.enums.ConnectionType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+EXTERNAL = 'EXTERNAL'
+
+ +
+
+HMIP_LAN = 'HMIP_LAN'
+
+ +
+
+HMIP_RF = 'HMIP_RF'
+
+ +
+
+HMIP_WIRED = 'HMIP_WIRED'
+
+ +
+
+HMIP_WLAN = 'HMIP_WLAN'
+
+ +
+ +
+
+class homematicip.base.enums.ContactType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+NORMALLY_CLOSE = 'NORMALLY_CLOSE'
+
+ +
+
+NORMALLY_OPEN = 'NORMALLY_OPEN'
+
+ +
+ +
+
+class homematicip.base.enums.DeviceArchetype(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+EXTERNAL = 'EXTERNAL'
+
+ +
+
+HMIP = 'HMIP'
+
+ +
+ +
+
+class homematicip.base.enums.DeviceType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACCELERATION_SENSOR = 'ACCELERATION_SENSOR'
+
+ +
+
+ACCESS_POINT = 'ACCESS_POINT'
+
+ +
+
+ALARM_SIREN_INDOOR = 'ALARM_SIREN_INDOOR'
+
+ +
+
+ALARM_SIREN_OUTDOOR = 'ALARM_SIREN_OUTDOOR'
+
+ +
+
+BASE_DEVICE = 'BASE_DEVICE'
+
+ +
+
+BLIND_MODULE = 'BLIND_MODULE'
+
+ +
+
+BRAND_BLIND = 'BRAND_BLIND'
+
+ +
+
+BRAND_DIMMER = 'BRAND_DIMMER'
+
+ +
+
+BRAND_PUSH_BUTTON = 'BRAND_PUSH_BUTTON'
+
+ +
+
+BRAND_SHUTTER = 'BRAND_SHUTTER'
+
+ +
+
+BRAND_SWITCH_2 = 'BRAND_SWITCH_2'
+
+ +
+
+BRAND_SWITCH_MEASURING = 'BRAND_SWITCH_MEASURING'
+
+ +
+
+BRAND_SWITCH_NOTIFICATION_LIGHT = 'BRAND_SWITCH_NOTIFICATION_LIGHT'
+
+ +
+
+BRAND_WALL_MOUNTED_THERMOSTAT = 'BRAND_WALL_MOUNTED_THERMOSTAT'
+
+ +
+
+CARBON_DIOXIDE_SENSOR = 'CARBON_DIOXIDE_SENSOR'
+
+ +
+
+DALI_GATEWAY = 'DALI_GATEWAY'
+
+ +
+
+DEVICE = 'DEVICE'
+
+ +
+
+DIN_RAIL_BLIND_4 = 'DIN_RAIL_BLIND_4'
+
+ +
+
+DIN_RAIL_DIMMER_3 = 'DIN_RAIL_DIMMER_3'
+
+ +
+
+DIN_RAIL_SWITCH = 'DIN_RAIL_SWITCH'
+
+ +
+
+DIN_RAIL_SWITCH_4 = 'DIN_RAIL_SWITCH_4'
+
+ +
+
+DOOR_BELL_BUTTON = 'DOOR_BELL_BUTTON'
+
+ +
+
+DOOR_BELL_CONTACT_INTERFACE = 'DOOR_BELL_CONTACT_INTERFACE'
+
+ +
+
+DOOR_LOCK_DRIVE = 'DOOR_LOCK_DRIVE'
+
+ +
+
+DOOR_LOCK_SENSOR = 'DOOR_LOCK_SENSOR'
+
+ +
+
+ENERGY_SENSORS_INTERFACE = 'ENERGY_SENSORS_INTERFACE'
+
+ +
+
+EXTERNAL = 'EXTERNAL'
+
+ +
+
+FLOOR_TERMINAL_BLOCK_10 = 'FLOOR_TERMINAL_BLOCK_10'
+
+ +
+
+FLOOR_TERMINAL_BLOCK_12 = 'FLOOR_TERMINAL_BLOCK_12'
+
+ +
+
+FLOOR_TERMINAL_BLOCK_6 = 'FLOOR_TERMINAL_BLOCK_6'
+
+ +
+
+FULL_FLUSH_BLIND = 'FULL_FLUSH_BLIND'
+
+ +
+
+FULL_FLUSH_CONTACT_INTERFACE = 'FULL_FLUSH_CONTACT_INTERFACE'
+
+ +
+
+FULL_FLUSH_CONTACT_INTERFACE_6 = 'FULL_FLUSH_CONTACT_INTERFACE_6'
+
+ +
+
+FULL_FLUSH_DIMMER = 'FULL_FLUSH_DIMMER'
+
+ +
+
+FULL_FLUSH_INPUT_SWITCH = 'FULL_FLUSH_INPUT_SWITCH'
+
+ +
+
+FULL_FLUSH_SHUTTER = 'FULL_FLUSH_SHUTTER'
+
+ +
+
+FULL_FLUSH_SWITCH_MEASURING = 'FULL_FLUSH_SWITCH_MEASURING'
+
+ +
+
+HEATING_SWITCH_2 = 'HEATING_SWITCH_2'
+
+ +
+
+HEATING_THERMOSTAT = 'HEATING_THERMOSTAT'
+
+ +
+
+HEATING_THERMOSTAT_COMPACT = 'HEATING_THERMOSTAT_COMPACT'
+
+ +
+
+HEATING_THERMOSTAT_COMPACT_PLUS = 'HEATING_THERMOSTAT_COMPACT_PLUS'
+
+ +
+
+HEATING_THERMOSTAT_EVO = 'HEATING_THERMOSTAT_EVO'
+
+ +
+
+HOERMANN_DRIVES_MODULE = 'HOERMANN_DRIVES_MODULE'
+
+ +
+
+HOME_CONTROL_ACCESS_POINT = 'HOME_CONTROL_ACCESS_POINT'
+
+ +
+
+KEY_REMOTE_CONTROL_4 = 'KEY_REMOTE_CONTROL_4'
+
+ +
+
+KEY_REMOTE_CONTROL_ALARM = 'KEY_REMOTE_CONTROL_ALARM'
+
+ +
+
+LIGHT_SENSOR = 'LIGHT_SENSOR'
+
+ +
+
+MOTION_DETECTOR_INDOOR = 'MOTION_DETECTOR_INDOOR'
+
+ +
+
+MOTION_DETECTOR_OUTDOOR = 'MOTION_DETECTOR_OUTDOOR'
+
+ +
+
+MOTION_DETECTOR_PUSH_BUTTON = 'MOTION_DETECTOR_PUSH_BUTTON'
+
+ +
+
+MULTI_IO_BOX = 'MULTI_IO_BOX'
+
+ +
+
+OPEN_COLLECTOR_8_MODULE = 'OPEN_COLLECTOR_8_MODULE'
+
+ +
+
+PASSAGE_DETECTOR = 'PASSAGE_DETECTOR'
+
+ +
+
+PLUGABLE_SWITCH = 'PLUGABLE_SWITCH'
+
+ +
+
+PLUGABLE_SWITCH_MEASURING = 'PLUGABLE_SWITCH_MEASURING'
+
+ +
+
+PLUGGABLE_DIMMER = 'PLUGGABLE_DIMMER'
+
+ +
+
+PLUGGABLE_MAINS_FAILURE_SURVEILLANCE = 'PLUGGABLE_MAINS_FAILURE_SURVEILLANCE'
+
+ +
+
+PRESENCE_DETECTOR_INDOOR = 'PRESENCE_DETECTOR_INDOOR'
+
+ +
+
+PRINTED_CIRCUIT_BOARD_SWITCH_2 = 'PRINTED_CIRCUIT_BOARD_SWITCH_2'
+
+ +
+
+PRINTED_CIRCUIT_BOARD_SWITCH_BATTERY = 'PRINTED_CIRCUIT_BOARD_SWITCH_BATTERY'
+
+ +
+
+PUSH_BUTTON = 'PUSH_BUTTON'
+
+ +
+
+PUSH_BUTTON_6 = 'PUSH_BUTTON_6'
+
+ +
+
+PUSH_BUTTON_FLAT = 'PUSH_BUTTON_FLAT'
+
+ +
+
+RAIN_SENSOR = 'RAIN_SENSOR'
+
+ +
+
+REMOTE_CONTROL_8 = 'REMOTE_CONTROL_8'
+
+ +
+
+REMOTE_CONTROL_8_MODULE = 'REMOTE_CONTROL_8_MODULE'
+
+ +
+
+RGBW_DIMMER = 'RGBW_DIMMER'
+
+ +
+
+ROOM_CONTROL_DEVICE = 'ROOM_CONTROL_DEVICE'
+
+ +
+
+ROOM_CONTROL_DEVICE_ANALOG = 'ROOM_CONTROL_DEVICE_ANALOG'
+
+ +
+
+ROTARY_HANDLE_SENSOR = 'ROTARY_HANDLE_SENSOR'
+
+ +
+
+SHUTTER_CONTACT = 'SHUTTER_CONTACT'
+
+ +
+
+SHUTTER_CONTACT_INTERFACE = 'SHUTTER_CONTACT_INTERFACE'
+
+ +
+
+SHUTTER_CONTACT_INVISIBLE = 'SHUTTER_CONTACT_INVISIBLE'
+
+ +
+
+SHUTTER_CONTACT_MAGNETIC = 'SHUTTER_CONTACT_MAGNETIC'
+
+ +
+
+SHUTTER_CONTACT_OPTICAL_PLUS = 'SHUTTER_CONTACT_OPTICAL_PLUS'
+
+ +
+
+SMOKE_DETECTOR = 'SMOKE_DETECTOR'
+
+ +
+
+TEMPERATURE_HUMIDITY_SENSOR = 'TEMPERATURE_HUMIDITY_SENSOR'
+
+ +
+
+TEMPERATURE_HUMIDITY_SENSOR_DISPLAY = 'TEMPERATURE_HUMIDITY_SENSOR_DISPLAY'
+
+ +
+
+TEMPERATURE_HUMIDITY_SENSOR_OUTDOOR = 'TEMPERATURE_HUMIDITY_SENSOR_OUTDOOR'
+
+ +
+
+TEMPERATURE_SENSOR_2_EXTERNAL_DELTA = 'TEMPERATURE_SENSOR_2_EXTERNAL_DELTA'
+
+ +
+
+TILT_VIBRATION_SENSOR = 'TILT_VIBRATION_SENSOR'
+
+ +
+
+TORMATIC_MODULE = 'TORMATIC_MODULE'
+
+ +
+
+WALL_MOUNTED_GARAGE_DOOR_CONTROLLER = 'WALL_MOUNTED_GARAGE_DOOR_CONTROLLER'
+
+ +
+
+WALL_MOUNTED_THERMOSTAT_BASIC_HUMIDITY = 'WALL_MOUNTED_THERMOSTAT_BASIC_HUMIDITY'
+
+ +
+
+WALL_MOUNTED_THERMOSTAT_PRO = 'WALL_MOUNTED_THERMOSTAT_PRO'
+
+ +
+
+WALL_MOUNTED_UNIVERSAL_ACTUATOR = 'WALL_MOUNTED_UNIVERSAL_ACTUATOR'
+
+ +
+
+WATER_SENSOR = 'WATER_SENSOR'
+
+ +
+
+WEATHER_SENSOR = 'WEATHER_SENSOR'
+
+ +
+
+WEATHER_SENSOR_PLUS = 'WEATHER_SENSOR_PLUS'
+
+ +
+
+WEATHER_SENSOR_PRO = 'WEATHER_SENSOR_PRO'
+
+ +
+
+WIRED_BLIND_4 = 'WIRED_BLIND_4'
+
+ +
+
+WIRED_DIMMER_3 = 'WIRED_DIMMER_3'
+
+ +
+
+WIRED_DIN_RAIL_ACCESS_POINT = 'WIRED_DIN_RAIL_ACCESS_POINT'
+
+ +
+
+WIRED_FLOOR_TERMINAL_BLOCK_12 = 'WIRED_FLOOR_TERMINAL_BLOCK_12'
+
+ +
+
+WIRED_INPUT_32 = 'WIRED_INPUT_32'
+
+ +
+
+WIRED_INPUT_SWITCH_6 = 'WIRED_INPUT_SWITCH_6'
+
+ +
+
+WIRED_MOTION_DETECTOR_PUSH_BUTTON = 'WIRED_MOTION_DETECTOR_PUSH_BUTTON'
+
+ +
+
+WIRED_PRESENCE_DETECTOR_INDOOR = 'WIRED_PRESENCE_DETECTOR_INDOOR'
+
+ +
+
+WIRED_PUSH_BUTTON_2 = 'WIRED_PUSH_BUTTON_2'
+
+ +
+
+WIRED_PUSH_BUTTON_6 = 'WIRED_PUSH_BUTTON_6'
+
+ +
+
+WIRED_SWITCH_4 = 'WIRED_SWITCH_4'
+
+ +
+
+WIRED_SWITCH_8 = 'WIRED_SWITCH_8'
+
+ +
+
+WIRED_WALL_MOUNTED_THERMOSTAT = 'WIRED_WALL_MOUNTED_THERMOSTAT'
+
+ +
+ +
+
+class homematicip.base.enums.DeviceUpdateState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+BACKGROUND_UPDATE_NOT_SUPPORTED = 'BACKGROUND_UPDATE_NOT_SUPPORTED'
+
+ +
+
+TRANSFERING_UPDATE = 'TRANSFERING_UPDATE'
+
+ +
+
+UPDATE_AUTHORIZED = 'UPDATE_AUTHORIZED'
+
+ +
+
+UPDATE_AVAILABLE = 'UPDATE_AVAILABLE'
+
+ +
+
+UP_TO_DATE = 'UP_TO_DATE'
+
+ +
+ +
+
+class homematicip.base.enums.DeviceUpdateStrategy(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+AUTOMATICALLY_IF_POSSIBLE = 'AUTOMATICALLY_IF_POSSIBLE'
+
+ +
+
+MANUALLY = 'MANUALLY'
+
+ +
+ +
+
+class homematicip.base.enums.DoorCommand(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CLOSE = 'CLOSE'
+
+ +
+
+OPEN = 'OPEN'
+
+ +
+
+PARTIAL_OPEN = 'PARTIAL_OPEN'
+
+ +
+
+STOP = 'STOP'
+
+ +
+ +
+
+class homematicip.base.enums.DoorState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CLOSED = 'CLOSED'
+
+ +
+
+OPEN = 'OPEN'
+
+ +
+
+POSITION_UNKNOWN = 'POSITION_UNKNOWN'
+
+ +
+
+VENTILATION_POSITION = 'VENTILATION_POSITION'
+
+ +
+ +
+
+class homematicip.base.enums.DriveSpeed(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CREEP_SPEED = 'CREEP_SPEED'
+
+ +
+
+NOMINAL_SPEED = 'NOMINAL_SPEED'
+
+ +
+
+OPTIONAL_SPEED = 'OPTIONAL_SPEED'
+
+ +
+
+SLOW_SPEED = 'SLOW_SPEED'
+
+ +
+ +
+
+class homematicip.base.enums.EcoDuration(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+FOUR = 'FOUR'
+
+ +
+
+ONE = 'ONE'
+
+ +
+
+PERMANENT = 'PERMANENT'
+
+ +
+
+SIX = 'SIX'
+
+ +
+
+TWO = 'TWO'
+
+ +
+ +
+
+class homematicip.base.enums.EventType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CLIENT_ADDED = 'CLIENT_ADDED'
+
+ +
+
+CLIENT_CHANGED = 'CLIENT_CHANGED'
+
+ +
+
+CLIENT_REMOVED = 'CLIENT_REMOVED'
+
+ +
+
+DEVICE_ADDED = 'DEVICE_ADDED'
+
+ +
+
+DEVICE_CHANGED = 'DEVICE_CHANGED'
+
+ +
+
+DEVICE_CHANNEL_EVENT = 'DEVICE_CHANNEL_EVENT'
+
+ +
+
+DEVICE_REMOVED = 'DEVICE_REMOVED'
+
+ +
+
+GROUP_ADDED = 'GROUP_ADDED'
+
+ +
+
+GROUP_CHANGED = 'GROUP_CHANGED'
+
+ +
+
+GROUP_REMOVED = 'GROUP_REMOVED'
+
+ +
+
+HOME_CHANGED = 'HOME_CHANGED'
+
+ +
+
+SECURITY_JOURNAL_CHANGED = 'SECURITY_JOURNAL_CHANGED'
+
+ +
+ +
+
+class homematicip.base.enums.FunctionalChannelType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACCELERATION_SENSOR_CHANNEL = 'ACCELERATION_SENSOR_CHANNEL'
+
+ +
+
+ACCESS_AUTHORIZATION_CHANNEL = 'ACCESS_AUTHORIZATION_CHANNEL'
+
+ +
+
+ACCESS_CONTROLLER_CHANNEL = 'ACCESS_CONTROLLER_CHANNEL'
+
+ +
+
+ACCESS_CONTROLLER_WIRED_CHANNEL = 'ACCESS_CONTROLLER_WIRED_CHANNEL'
+
+ +
+
+ALARM_SIREN_CHANNEL = 'ALARM_SIREN_CHANNEL'
+
+ +
+
+ANALOG_OUTPUT_CHANNEL = 'ANALOG_OUTPUT_CHANNEL'
+
+ +
+
+ANALOG_ROOM_CONTROL_CHANNEL = 'ANALOG_ROOM_CONTROL_CHANNEL'
+
+ +
+
+BLIND_CHANNEL = 'BLIND_CHANNEL'
+
+ +
+
+CARBON_DIOXIDE_SENSOR_CHANNEL = 'CARBON_DIOXIDE_SENSOR_CHANNEL'
+
+ +
+
+CHANGE_OVER_CHANNEL = 'CHANGE_OVER_CHANNEL'
+
+ +
+
+CLIMATE_SENSOR_CHANNEL = 'CLIMATE_SENSOR_CHANNEL'
+
+ +
+
+CONTACT_INTERFACE_CHANNEL = 'CONTACT_INTERFACE_CHANNEL'
+
+ +
+
+DEHUMIDIFIER_DEMAND_CHANNEL = 'DEHUMIDIFIER_DEMAND_CHANNEL'
+
+ +
+
+DEVICE_BASE = 'DEVICE_BASE'
+
+ +
+
+DEVICE_BASE_FLOOR_HEATING = 'DEVICE_BASE_FLOOR_HEATING'
+
+ +
+
+DEVICE_GLOBAL_PUMP_CONTROL = 'DEVICE_GLOBAL_PUMP_CONTROL'
+
+ +
+
+DEVICE_INCORRECT_POSITIONED = 'DEVICE_INCORRECT_POSITIONED'
+
+ +
+
+DEVICE_OPERATIONLOCK = 'DEVICE_OPERATIONLOCK'
+
+ +
+
+DEVICE_OPERATIONLOCK_WITH_SABOTAGE = 'DEVICE_OPERATIONLOCK_WITH_SABOTAGE'
+
+ +
+
+DEVICE_PERMANENT_FULL_RX = 'DEVICE_PERMANENT_FULL_RX'
+
+ +
+
+DEVICE_RECHARGEABLE_WITH_SABOTAGE = 'DEVICE_RECHARGEABLE_WITH_SABOTAGE'
+
+ +
+
+DEVICE_SABOTAGE = 'DEVICE_SABOTAGE'
+
+ +
+
+DIMMER_CHANNEL = 'DIMMER_CHANNEL'
+
+ +
+
+DOOR_CHANNEL = 'DOOR_CHANNEL'
+
+ +
+
+DOOR_LOCK_CHANNEL = 'DOOR_LOCK_CHANNEL'
+
+ +
+
+DOOR_LOCK_SENSOR_CHANNEL = 'DOOR_LOCK_SENSOR_CHANNEL'
+
+ +
+
+ENERGY_SENSORS_INTERFACE_CHANNEL = 'ENERGY_SENSORS_INTERFACE_CHANNEL'
+
+ +
+
+EXTERNAL_BASE_CHANNEL = 'EXTERNAL_BASE_CHANNEL'
+
+ +
+
+EXTERNAL_UNIVERSAL_LIGHT_CHANNEL = 'EXTERNAL_UNIVERSAL_LIGHT_CHANNEL'
+
+ +
+
+FLOOR_TERMINAL_BLOCK_CHANNEL = 'FLOOR_TERMINAL_BLOCK_CHANNEL'
+
+ +
+
+FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL = 'FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL'
+
+ +
+
+FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL = 'FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL'
+
+ +
+
+FUNCTIONAL_CHANNEL = 'FUNCTIONAL_CHANNEL'
+
+ +
+
+GENERIC_INPUT_CHANNEL = 'GENERIC_INPUT_CHANNEL'
+
+ +
+
+HEATING_THERMOSTAT_CHANNEL = 'HEATING_THERMOSTAT_CHANNEL'
+
+ +
+
+HEAT_DEMAND_CHANNEL = 'HEAT_DEMAND_CHANNEL'
+
+ +
+
+IMPULSE_OUTPUT_CHANNEL = 'IMPULSE_OUTPUT_CHANNEL'
+
+ +
+
+INTERNAL_SWITCH_CHANNEL = 'INTERNAL_SWITCH_CHANNEL'
+
+ +
+
+LIGHT_SENSOR_CHANNEL = 'LIGHT_SENSOR_CHANNEL'
+
+ +
+
+MAINS_FAILURE_CHANNEL = 'MAINS_FAILURE_CHANNEL'
+
+ +
+
+MOTION_DETECTION_CHANNEL = 'MOTION_DETECTION_CHANNEL'
+
+ +
+
+MULTI_MODE_INPUT_BLIND_CHANNEL = 'MULTI_MODE_INPUT_BLIND_CHANNEL'
+
+ +
+
+MULTI_MODE_INPUT_CHANNEL = 'MULTI_MODE_INPUT_CHANNEL'
+
+ +
+
+MULTI_MODE_INPUT_DIMMER_CHANNEL = 'MULTI_MODE_INPUT_DIMMER_CHANNEL'
+
+ +
+
+MULTI_MODE_INPUT_SWITCH_CHANNEL = 'MULTI_MODE_INPUT_SWITCH_CHANNEL'
+
+ +
+
+NOTIFICATION_LIGHT_CHANNEL = 'NOTIFICATION_LIGHT_CHANNEL'
+
+ +
+
+OPTICAL_SIGNAL_CHANNEL = 'OPTICAL_SIGNAL_CHANNEL'
+
+ +
+
+OPTICAL_SIGNAL_GROUP_CHANNEL = 'OPTICAL_SIGNAL_GROUP_CHANNEL'
+
+ +
+
+PASSAGE_DETECTOR_CHANNEL = 'PASSAGE_DETECTOR_CHANNEL'
+
+ +
+
+PRESENCE_DETECTION_CHANNEL = 'PRESENCE_DETECTION_CHANNEL'
+
+ +
+
+RAIN_DETECTION_CHANNEL = 'RAIN_DETECTION_CHANNEL'
+
+ +
+
+ROTARY_HANDLE_CHANNEL = 'ROTARY_HANDLE_CHANNEL'
+
+ +
+
+SHADING_CHANNEL = 'SHADING_CHANNEL'
+
+ +
+
+SHUTTER_CHANNEL = 'SHUTTER_CHANNEL'
+
+ +
+
+SHUTTER_CONTACT_CHANNEL = 'SHUTTER_CONTACT_CHANNEL'
+
+ +
+
+SINGLE_KEY_CHANNEL = 'SINGLE_KEY_CHANNEL'
+
+ +
+
+SMOKE_DETECTOR_CHANNEL = 'SMOKE_DETECTOR_CHANNEL'
+
+ +
+
+SWITCH_CHANNEL = 'SWITCH_CHANNEL'
+
+ +
+
+SWITCH_MEASURING_CHANNEL = 'SWITCH_MEASURING_CHANNEL'
+
+ +
+
+TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL = 'TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL'
+
+ +
+
+TILT_VIBRATION_SENSOR_CHANNEL = 'TILT_VIBRATION_SENSOR_CHANNEL'
+
+ +
+
+UNIVERSAL_ACTUATOR_CHANNEL = 'UNIVERSAL_ACTUATOR_CHANNEL'
+
+ +
+
+UNIVERSAL_LIGHT_CHANNEL = 'UNIVERSAL_LIGHT_CHANNEL'
+
+ +
+
+UNIVERSAL_LIGHT_GROUP_CHANNEL = 'UNIVERSAL_LIGHT_GROUP_CHANNEL'
+
+ +
+
+WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL = 'WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL'
+
+ +
+
+WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL = 'WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL'
+
+ +
+
+WATER_SENSOR_CHANNEL = 'WATER_SENSOR_CHANNEL'
+
+ +
+
+WEATHER_SENSOR_CHANNEL = 'WEATHER_SENSOR_CHANNEL'
+
+ +
+
+WEATHER_SENSOR_PLUS_CHANNEL = 'WEATHER_SENSOR_PLUS_CHANNEL'
+
+ +
+
+WEATHER_SENSOR_PRO_CHANNEL = 'WEATHER_SENSOR_PRO_CHANNEL'
+
+ +
+ +
+
+class homematicip.base.enums.FunctionalHomeType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACCESS_CONTROL = 'ACCESS_CONTROL'
+
+ +
+
+ENERGY = 'ENERGY'
+
+ +
+
+INDOOR_CLIMATE = 'INDOOR_CLIMATE'
+
+ +
+
+LIGHT_AND_SHADOW = 'LIGHT_AND_SHADOW'
+
+ +
+
+SECURITY_AND_ALARM = 'SECURITY_AND_ALARM'
+
+ +
+
+WEATHER_AND_ENVIRONMENT = 'WEATHER_AND_ENVIRONMENT'
+
+ +
+ +
+
+class homematicip.base.enums.GroupType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACCESS_AUTHORIZATION_PROFILE = 'ACCESS_AUTHORIZATION_PROFILE'
+
+ +
+
+ACCESS_CONTROL = 'ACCESS_CONTROL'
+
+ +
+
+ALARM_SWITCHING = 'ALARM_SWITCHING'
+
+ +
+
+ENERGY = 'ENERGY'
+
+ +
+
+ENVIRONMENT = 'ENVIRONMENT'
+
+ +
+
+EXTENDED_LINKED_GARAGE_DOOR = 'EXTENDED_LINKED_GARAGE_DOOR'
+
+ +
+
+EXTENDED_LINKED_SHUTTER = 'EXTENDED_LINKED_SHUTTER'
+
+ +
+
+EXTENDED_LINKED_SWITCHING = 'EXTENDED_LINKED_SWITCHING'
+
+ +
+
+GROUP = 'GROUP'
+
+ +
+
+HEATING = 'HEATING'
+
+ +
+
+HEATING_CHANGEOVER = 'HEATING_CHANGEOVER'
+
+ +
+
+HEATING_COOLING_DEMAND = 'HEATING_COOLING_DEMAND'
+
+ +
+
+HEATING_COOLING_DEMAND_BOILER = 'HEATING_COOLING_DEMAND_BOILER'
+
+ +
+
+HEATING_COOLING_DEMAND_PUMP = 'HEATING_COOLING_DEMAND_PUMP'
+
+ +
+
+HEATING_DEHUMIDIFIER = 'HEATING_DEHUMIDIFIER'
+
+ +
+
+HEATING_EXTERNAL_CLOCK = 'HEATING_EXTERNAL_CLOCK'
+
+ +
+
+HEATING_FAILURE_ALERT_RULE_GROUP = 'HEATING_FAILURE_ALERT_RULE_GROUP'
+
+ +
+
+HEATING_HUMIDITY_LIMITER = 'HEATING_HUMIDITY_LIMITER'
+
+ +
+
+HEATING_TEMPERATURE_LIMITER = 'HEATING_TEMPERATURE_LIMITER'
+
+ +
+
+HOT_WATER = 'HOT_WATER'
+
+ +
+
+HUMIDITY_WARNING_RULE_GROUP = 'HUMIDITY_WARNING_RULE_GROUP'
+
+ +
+
+INBOX = 'INBOX'
+
+ +
+
+INDOOR_CLIMATE = 'INDOOR_CLIMATE'
+
+ +
+
+LINKED_SWITCHING = 'LINKED_SWITCHING'
+
+ +
+
+LOCK_OUT_PROTECTION_RULE = 'LOCK_OUT_PROTECTION_RULE'
+
+ +
+
+OVER_HEAT_PROTECTION_RULE = 'OVER_HEAT_PROTECTION_RULE'
+
+ +
+
+SECURITY = 'SECURITY'
+
+ +
+
+SECURITY_BACKUP_ALARM_SWITCHING = 'SECURITY_BACKUP_ALARM_SWITCHING'
+
+ +
+
+SECURITY_ZONE = 'SECURITY_ZONE'
+
+ +
+
+SHUTTER_PROFILE = 'SHUTTER_PROFILE'
+
+ +
+
+SHUTTER_WIND_PROTECTION_RULE = 'SHUTTER_WIND_PROTECTION_RULE'
+
+ +
+
+SMOKE_ALARM_DETECTION_RULE = 'SMOKE_ALARM_DETECTION_RULE'
+
+ +
+
+SWITCHING = 'SWITCHING'
+
+ +
+
+SWITCHING_PROFILE = 'SWITCHING_PROFILE'
+
+ +
+ +
+
+class homematicip.base.enums.GroupVisibility(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+INVISIBLE_CONTROL = 'INVISIBLE_CONTROL'
+
+ +
+
+INVISIBLE_GROUP_AND_CONTROL = 'INVISIBLE_GROUP_AND_CONTROL'
+
+ +
+
+VISIBLE = 'VISIBLE'
+
+ +
+ +
+
+class homematicip.base.enums.HeatingFailureValidationType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+HEATING_FAILURE_ALARM = 'HEATING_FAILURE_ALARM'
+
+ +
+
+HEATING_FAILURE_WARNING = 'HEATING_FAILURE_WARNING'
+
+ +
+
+NO_HEATING_FAILURE = 'NO_HEATING_FAILURE'
+
+ +
+ +
+
+class homematicip.base.enums.HeatingLoadType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+LOAD_BALANCING = 'LOAD_BALANCING'
+
+ +
+
+LOAD_COLLECTION = 'LOAD_COLLECTION'
+
+ +
+ +
+
+class homematicip.base.enums.HeatingValveType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+NORMALLY_CLOSE = 'NORMALLY_CLOSE'
+
+ +
+
+NORMALLY_OPEN = 'NORMALLY_OPEN'
+
+ +
+ +
+
+class homematicip.base.enums.HomeUpdateState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+PERFORMING_UPDATE = 'PERFORMING_UPDATE'
+
+ +
+
+PERFORM_UPDATE_SENT = 'PERFORM_UPDATE_SENT'
+
+ +
+
+UPDATE_AVAILABLE = 'UPDATE_AVAILABLE'
+
+ +
+
+UP_TO_DATE = 'UP_TO_DATE'
+
+ +
+ +
+
+class homematicip.base.enums.HumidityValidationType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+GREATER_LOWER_LESSER_UPPER_THRESHOLD = 'GREATER_LOWER_LESSER_UPPER_THRESHOLD'
+
+ +
+
+GREATER_UPPER_THRESHOLD = 'GREATER_UPPER_THRESHOLD'
+
+ +
+
+LESSER_LOWER_THRESHOLD = 'LESSER_LOWER_THRESHOLD'
+
+ +
+ +
+
+class homematicip.base.enums.LiveUpdateState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+LIVE_UPDATE_NOT_SUPPORTED = 'LIVE_UPDATE_NOT_SUPPORTED'
+
+ +
+
+UPDATE_AVAILABLE = 'UPDATE_AVAILABLE'
+
+ +
+
+UPDATE_INCOMPLETE = 'UPDATE_INCOMPLETE'
+
+ +
+
+UP_TO_DATE = 'UP_TO_DATE'
+
+ +
+ +
+
+class homematicip.base.enums.LockState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+LOCKED = 'LOCKED'
+
+ +
+
+NONE = 'NONE'
+
+ +
+
+OPEN = 'OPEN'
+
+ +
+
+UNLOCKED = 'UNLOCKED'
+
+ +
+ +
+
+class homematicip.base.enums.MotionDetectionSendInterval(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+SECONDS_120 = 'SECONDS_120'
+
+ +
+
+SECONDS_240 = 'SECONDS_240'
+
+ +
+
+SECONDS_30 = 'SECONDS_30'
+
+ +
+
+SECONDS_480 = 'SECONDS_480'
+
+ +
+
+SECONDS_60 = 'SECONDS_60'
+
+ +
+ +
+
+class homematicip.base.enums.MotorState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CLOSING = 'CLOSING'
+
+ +
+
+OPENING = 'OPENING'
+
+ +
+
+STOPPED = 'STOPPED'
+
+ +
+ +
+
+class homematicip.base.enums.MultiModeInputMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+BINARY_BEHAVIOR = 'BINARY_BEHAVIOR'
+
+ +
+
+KEY_BEHAVIOR = 'KEY_BEHAVIOR'
+
+ +
+
+SWITCH_BEHAVIOR = 'SWITCH_BEHAVIOR'
+
+ +
+ +
+
+class homematicip.base.enums.NotificationSoundType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+SOUND_LONG = 'SOUND_LONG'
+
+ +
+
+SOUND_NO_SOUND = 'SOUND_NO_SOUND'
+
+ +
+
+SOUND_SHORT = 'SOUND_SHORT'
+
+ +
+
+SOUND_SHORT_SHORT = 'SOUND_SHORT_SHORT'
+
+ +
+ +
+
+class homematicip.base.enums.OpticalAlarmSignal(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+BLINKING_ALTERNATELY_REPEATING = 'BLINKING_ALTERNATELY_REPEATING'
+
+ +
+
+BLINKING_BOTH_REPEATING = 'BLINKING_BOTH_REPEATING'
+
+ +
+
+CONFIRMATION_SIGNAL_0 = 'CONFIRMATION_SIGNAL_0'
+
+ +
+
+CONFIRMATION_SIGNAL_1 = 'CONFIRMATION_SIGNAL_1'
+
+ +
+
+CONFIRMATION_SIGNAL_2 = 'CONFIRMATION_SIGNAL_2'
+
+ +
+
+DISABLE_OPTICAL_SIGNAL = 'DISABLE_OPTICAL_SIGNAL'
+
+ +
+
+DOUBLE_FLASHING_REPEATING = 'DOUBLE_FLASHING_REPEATING'
+
+ +
+
+FLASHING_BOTH_REPEATING = 'FLASHING_BOTH_REPEATING'
+
+ +
+ +
+
+class homematicip.base.enums.OpticalSignalBehaviour(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+BILLOW_MIDDLE = 'BILLOW_MIDDLE'
+
+ +
+
+BLINKING_MIDDLE = 'BLINKING_MIDDLE'
+
+ +
+
+FLASH_MIDDLE = 'FLASH_MIDDLE'
+
+ +
+
+OFF = 'OFF'
+
+ +
+
+ON = 'ON'
+
+ +
+ +
+
+class homematicip.base.enums.PassageDirection(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+LEFT = 'LEFT'
+
+ +
+
+RIGHT = 'RIGHT'
+
+ +
+ +
+
+class homematicip.base.enums.ProfileMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+AUTOMATIC = 'AUTOMATIC'
+
+ +
+
+MANUAL = 'MANUAL'
+
+ +
+ +
+
+class homematicip.base.enums.RGBColorState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+BLACK = 'BLACK'
+
+ +
+
+BLUE = 'BLUE'
+
+ +
+
+GREEN = 'GREEN'
+
+ +
+
+PURPLE = 'PURPLE'
+
+ +
+
+RED = 'RED'
+
+ +
+
+TURQUOISE = 'TURQUOISE'
+
+ +
+
+WHITE = 'WHITE'
+
+ +
+
+YELLOW = 'YELLOW'
+
+ +
+ +
+
+class homematicip.base.enums.SecurityEventType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACCESS_POINT_CONNECTED = 'ACCESS_POINT_CONNECTED'
+
+ +
+
+ACCESS_POINT_DISCONNECTED = 'ACCESS_POINT_DISCONNECTED'
+
+ +
+
+ACTIVATION_CHANGED = 'ACTIVATION_CHANGED'
+
+ +
+
+EXTERNAL_TRIGGERED = 'EXTERNAL_TRIGGERED'
+
+ +
+
+MAINS_FAILURE_EVENT = 'MAINS_FAILURE_EVENT'
+
+ +
+
+MOISTURE_DETECTION_EVENT = 'MOISTURE_DETECTION_EVENT'
+
+ +
+
+OFFLINE_ALARM = 'OFFLINE_ALARM'
+
+ +
+
+OFFLINE_WATER_DETECTION_EVENT = 'OFFLINE_WATER_DETECTION_EVENT'
+
+ +
+
+SABOTAGE = 'SABOTAGE'
+
+ +
+
+SENSOR_EVENT = 'SENSOR_EVENT'
+
+ +
+
+SILENCE_CHANGED = 'SILENCE_CHANGED'
+
+ +
+
+SMOKE_ALARM = 'SMOKE_ALARM'
+
+ +
+
+WATER_DETECTION_EVENT = 'WATER_DETECTION_EVENT'
+
+ +
+ +
+
+class homematicip.base.enums.SecurityZoneActivationMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ACTIVATION_IF_ALL_IN_VALID_STATE = 'ACTIVATION_IF_ALL_IN_VALID_STATE'
+
+ +
+
+ACTIVATION_WITH_DEVICE_IGNORELIST = 'ACTIVATION_WITH_DEVICE_IGNORELIST'
+
+ +
+ +
+
+class homematicip.base.enums.ShadingPackagePosition(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+BOTTOM = 'BOTTOM'
+
+ +
+
+CENTER = 'CENTER'
+
+ +
+
+LEFT = 'LEFT'
+
+ +
+
+NOT_USED = 'NOT_USED'
+
+ +
+
+RIGHT = 'RIGHT'
+
+ +
+
+SPLIT = 'SPLIT'
+
+ +
+
+TDBU = 'TDBU'
+
+ +
+
+TOP = 'TOP'
+
+ +
+ +
+
+class homematicip.base.enums.ShadingStateType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+MIXED = 'MIXED'
+
+ +
+
+NOT_EXISTENT = 'NOT_EXISTENT'
+
+ +
+
+NOT_POSSIBLE = 'NOT_POSSIBLE'
+
+ +
+
+NOT_USED = 'NOT_USED'
+
+ +
+
+POSITION_USED = 'POSITION_USED'
+
+ +
+
+TILT_USED = 'TILT_USED'
+
+ +
+ +
+
+class homematicip.base.enums.SmokeDetectorAlarmType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+IDLE_OFF = 'IDLE_OFF'
+
+ +
+
+INTRUSION_ALARM = 'INTRUSION_ALARM'
+
+ +
+
+PRIMARY_ALARM = 'PRIMARY_ALARM'
+
+ +
+
+SECONDARY_ALARM = 'SECONDARY_ALARM'
+
+ +
+ +
+
+class homematicip.base.enums.ValveState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+ADAPTION_DONE = 'ADAPTION_DONE'
+
+ +
+
+ADAPTION_IN_PROGRESS = 'ADAPTION_IN_PROGRESS'
+
+ +
+
+ADJUSTMENT_TOO_BIG = 'ADJUSTMENT_TOO_BIG'
+
+ +
+
+ADJUSTMENT_TOO_SMALL = 'ADJUSTMENT_TOO_SMALL'
+
+ +
+
+ERROR_POSITION = 'ERROR_POSITION'
+
+ +
+
+RUN_TO_START = 'RUN_TO_START'
+
+ +
+
+STATE_NOT_AVAILABLE = 'STATE_NOT_AVAILABLE'
+
+ +
+
+TOO_TIGHT = 'TOO_TIGHT'
+
+ +
+
+WAIT_FOR_ADAPTION = 'WAIT_FOR_ADAPTION'
+
+ +
+ +
+
+class homematicip.base.enums.WaterAlarmTrigger(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+MOISTURE_DETECTION = 'MOISTURE_DETECTION'
+
+ +
+
+NO_ALARM = 'NO_ALARM'
+
+ +
+
+WATER_DETECTION = 'WATER_DETECTION'
+
+ +
+
+WATER_MOISTURE_DETECTION = 'WATER_MOISTURE_DETECTION'
+
+ +
+ +
+
+class homematicip.base.enums.WeatherCondition(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CLEAR = 'CLEAR'
+
+ +
+
+CLOUDY = 'CLOUDY'
+
+ +
+
+CLOUDY_WITH_RAIN = 'CLOUDY_WITH_RAIN'
+
+ +
+
+CLOUDY_WITH_SNOW_RAIN = 'CLOUDY_WITH_SNOW_RAIN'
+
+ +
+
+FOGGY = 'FOGGY'
+
+ +
+
+HEAVILY_CLOUDY = 'HEAVILY_CLOUDY'
+
+ +
+
+HEAVILY_CLOUDY_WITH_RAIN = 'HEAVILY_CLOUDY_WITH_RAIN'
+
+ +
+
+HEAVILY_CLOUDY_WITH_RAIN_AND_THUNDER = 'HEAVILY_CLOUDY_WITH_RAIN_AND_THUNDER'
+
+ +
+
+HEAVILY_CLOUDY_WITH_SNOW = 'HEAVILY_CLOUDY_WITH_SNOW'
+
+ +
+
+HEAVILY_CLOUDY_WITH_SNOW_RAIN = 'HEAVILY_CLOUDY_WITH_SNOW_RAIN'
+
+ +
+
+HEAVILY_CLOUDY_WITH_STRONG_RAIN = 'HEAVILY_CLOUDY_WITH_STRONG_RAIN'
+
+ +
+
+HEAVILY_CLOUDY_WITH_THUNDER = 'HEAVILY_CLOUDY_WITH_THUNDER'
+
+ +
+
+LIGHT_CLOUDY = 'LIGHT_CLOUDY'
+
+ +
+
+STRONG_WIND = 'STRONG_WIND'
+
+ +
+
+UNKNOWN = 'UNKNOWN'
+
+ +
+ +
+
+class homematicip.base.enums.WeatherDayTime(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+DAY = 'DAY'
+
+ +
+
+NIGHT = 'NIGHT'
+
+ +
+
+TWILIGHT = 'TWILIGHT'
+
+ +
+ +
+
+class homematicip.base.enums.WindValueType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+AVERAGE_VALUE = 'AVERAGE_VALUE'
+
+ +
+
+CURRENT_VALUE = 'CURRENT_VALUE'
+
+ +
+
+MAX_VALUE = 'MAX_VALUE'
+
+ +
+
+MIN_VALUE = 'MIN_VALUE'
+
+ +
+ +
+
+class homematicip.base.enums.WindowState(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: AutoNameEnum

+
+
+CLOSED = 'CLOSED'
+
+ +
+
+OPEN = 'OPEN'
+
+ +
+
+TILTED = 'TILTED'
+
+ +
+ +
+
+

homematicip.base.functionalChannels module

+
+
+class homematicip.base.functionalChannels.AccelerationSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the ACCELERATION_SENSOR_CHANNEL channel

+
+
+accelerationSensorEventFilterPeriod
+

float:

+
+ +
+
+accelerationSensorMode
+

AccelerationSensorMode:

+
+ +
+
+accelerationSensorNeutralPosition
+

AccelerationSensorNeutralPosition:

+
+ +
+
+accelerationSensorSensitivity
+

AccelerationSensorSensitivity:

+
+ +
+
+accelerationSensorTriggerAngle
+

int:

+
+ +
+
+accelerationSensorTriggered
+

bool:

+
+ +
+
+async async_set_acceleration_sensor_event_filter_period(period: float)[source]
+
+ +
+
+async async_set_acceleration_sensor_mode(mode)[source]
+
+ +
+
+async async_set_acceleration_sensor_neutral_position(neutralPosition: AccelerationSensorNeutralPosition)[source]
+
+ +
+
+async async_set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity)[source]
+
+ +
+
+async async_set_acceleration_sensor_trigger_angle(angle: int)[source]
+
+ +
+
+async async_set_notification_sound_type(soundType: NotificationSoundType, isHighToLow: bool)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+notificationSoundTypeHighToLow
+

NotificationSoundType:

+
+ +
+
+notificationSoundTypeLowToHigh
+

NotificationSoundType:

+
+ +
+
+set_acceleration_sensor_event_filter_period(period: float)[source]
+
+ +
+
+set_acceleration_sensor_mode(mode: AccelerationSensorMode)[source]
+
+ +
+
+set_acceleration_sensor_neutral_position(neutralPosition: AccelerationSensorNeutralPosition)[source]
+
+ +
+
+set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity)[source]
+
+ +
+
+set_acceleration_sensor_trigger_angle(angle: int)[source]
+
+ +
+
+set_notification_sound_type(soundType: NotificationSoundType, isHighToLow: bool)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.AccessAuthorizationChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this represents ACCESS_AUTHORIZATION_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.AccessControllerChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the ACCESS_CONTROLLER_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.AccessControllerWiredChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the ACCESS_CONTROLLER_WIRED_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.AlarmSirenChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the ALARM_SIREN_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.AnalogOutputChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the ANALOG_OUTPUT_CHANNEL channel

+
+
+analogOutputLevel
+

the analog output level (Volt?)

+
+
Type:
+

float

+
+
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.AnalogRoomControlChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the ANALOG_ROOM_CONTROL_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.BlindChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the BLIND_CHANNEL channel

+
+
+async async_set_shutter_level(level=0.0)[source]
+
+ +
+
+async async_set_shutter_stop()[source]
+
+ +
+
+async async_set_slats_level(slatsLevel=0.0, shutterLevel=None)[source]
+
+ +
+
+async async_stop()[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_shutter_level(level=0.0)[source]
+

sets the shutter level

+
+
Parameters:
+
    +

  • level (float) – the new level of the shutter. 0.0 = open, 1.0 = closed

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+set_shutter_stop()[source]
+

stops the current operation +:returns: the result of the _restCall

+
+ +
+
+set_slats_level(slatsLevel=0.0, shutterLevel=None)[source]
+

sets the slats and shutter level

+
+
Parameters:
+
    +

  • slatsLevel (float) – the new level of the slats. 0.0 = open, 1.0 = closed,

    • +

  • shutterLevel (float) – the new level of the shutter. 0.0 = open, 1.0 = closed, None = use the current value

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+stop()[source]
+

stops the current shutter operation

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.CarbonDioxideSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

Representation of the CarbonDioxideSensorChannel Channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.ChangeOverChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the CHANGE_OVER_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.ClimateSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the CLIMATE_SENSOR_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.ContactInterfaceChannel(device, connection)[source]
+

Bases: ShutterContactChannel

+

this is the representative of the CONTACT_INTERFACE_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DehumidifierDemandChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the DEHUMIDIFIER_DEMAND_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.DeviceBaseChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the DEVICE_BASE channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceBaseFloorHeatingChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the DEVICE_BASE_FLOOR_HEATING channel

+
+
+async async_set_minimum_floor_heating_valve_position(minimumFloorHeatingValvePosition: float)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_minimum_floor_heating_valve_position(minimumFloorHeatingValvePosition: float)[source]
+

sets the minimum floot heating valve position

+
+
Parameters:
+

minimumFloorHeatingValvePosition (float) – the minimum valve position. must be between 0.0 and 1.0

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceGlobalPumpControlChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the DEVICE_GLOBAL_PUMP_CONTROL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceIncorrectPositionedChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the DEVICE_INCORRECT_POSITIONED channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceOperationLockChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the DEVICE_OPERATIONLOCK channel

+
+
+async async_set_operation_lock(operationLock=True)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_operation_lock(operationLock=True)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceOperationLockChannelWithSabotage(device, connection)[source]
+

Bases: DeviceOperationLockChannel

+

this is the representation of the DeviceOperationLockChannelWithSabotage channel

+
+ +
+
+class homematicip.base.functionalChannels.DevicePermanentFullRxChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the DEVICE_PERMANENT_FULL_RX channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceRechargeableWithSabotage(device, connection)[source]
+

Bases: DeviceSabotageChannel

+

this is the representative of the DEVICE_RECHARGEABLE_WITH_SABOTAGE channel

+
+
+badBatteryHealth
+

is the battery in a bad condition

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DeviceSabotageChannel(device, connection)[source]
+

Bases: DeviceBaseChannel

+

this is the representative of the DEVICE_SABOTAGE channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DimmerChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the DIMMER_CHANNEL channel

+
+
+async async_set_dim_level(dimLevel=0.0)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_dim_level(dimLevel=0.0)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DoorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the DoorChannel channel

+
+
+async async_send_door_command(doorCommand=DoorCommand.STOP)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+send_door_command(doorCommand=DoorCommand.STOP)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DoorLockChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

This respresents of the DoorLockChannel

+
+
+async async_set_lock_state(doorLockState: LockState, pin='')[source]
+

sets the door lock state

+
+
Parameters:
+
    +

  • doorLockState (float) – the state of the door. See LockState from base/enums.py

    • +

  • pin (string) – Pin, if specified.

    • +

  • channelIndex (int) – the channel to control. Normally the channel from DOOR_LOCK_CHANNEL is used.

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_lock_state(doorLockState: LockState, pin='')[source]
+

sets the door lock state

+
+
Parameters:
+
    +

  • doorLockState (float) – the state of the door. See LockState from base/enums.py

    • +

  • pin (string) – Pin, if specified.

    • +

  • channelIndex (int) – the channel to control. Normally the channel from DOOR_LOCK_CHANNEL is used.

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.DoorLockSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

This respresents of the DoorLockSensorChannel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.EnergySensorInterfaceChannel(device, connection)[source]
+

Bases: FunctionalChannel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.ExternalBaseChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this represents the EXTERNAL_BASE_CHANNEL function-channel for external devices

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.ExternalUniversalLightChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this represents the EXTERNAL_UNIVERSAL_LIGHT_CHANNEL function-channel for external devices

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.FloorTeminalBlockChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the FLOOR_TERMINAL_BLOCK_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.FloorTerminalBlockLocalPumpChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.FloorTerminalBlockMechanicChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the class FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL(FunctionalChannel) channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+valveState
+

the current valve state

+
+
Type:
+

ValveState

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.FunctionalChannel(device, connection)[source]
+

Bases: HomeMaticIPObject

+

this is the base class for the functional channels

+
+
+add_on_channel_event_handler(handler)[source]
+

Adds an event handler to the update method. Fires when a device +is updated.

+
+ +
+
+fire_channel_event(*args, **kwargs)[source]
+

Trigger the methods tied to _on_channel_event

+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.GenericInputChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the GENERIC_INPUT_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.HeatDemandChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the HEAT_DEMAND_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.HeatingThermostatChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the HEATING_THERMOSTAT_CHANNEL channel

+
+
+automaticValveAdaptionNeeded
+

must the adaption re-run?

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+setPointTemperature
+

the current temperature which should be reached in the room

+
+
Type:
+

float

+
+
+
+ +
+
+temperatureOffset
+

the offset temperature for the thermostat (+/- 3.5)

+
+
Type:
+

float

+
+
+
+ +
+
+valveActualTemperature
+

the current measured temperature at the valve

+
+
Type:
+

float

+
+
+
+ +
+
+valvePosition
+

the current position of the valve 0.0 = closed, 1.0 max opened

+
+
Type:
+

float

+
+
+
+ +
+
+valveState
+

the current state of the valve

+
+
Type:
+

ValveState

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.ImpulseOutputChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representation of the IMPULSE_OUTPUT_CHANNEL

+
+
+async async_send_start_impulse()[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+send_start_impulse()[source]
+

Toggle Wall mounted Garage Door Controller.

+
+ +
+ +
+
+class homematicip.base.functionalChannels.InternalSwitchChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the INTERNAL_SWITCH_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.LightSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the LIGHT_SENSOR_CHANNEL channel

+
+
+averageIllumination
+

the average illumination value

+
+
Type:
+

float

+
+
+
+ +
+
+currentIllumination
+

the current illumination value

+
+
Type:
+

float

+
+
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+highestIllumination
+

the highest illumination value

+
+
Type:
+

float

+
+
+
+ +
+
+lowestIllumination
+

the lowest illumination value

+
+
Type:
+

float

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.MainsFailureChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the MAINS_FAILURE_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.MotionDetectionChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the MOTION_DETECTION_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.MultiModeInputBlindChannel(device, connection)[source]
+

Bases: BlindChannel

+

this is the representative of the MULTI_MODE_INPUT_BLIND_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.MultiModeInputChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the MULTI_MODE_INPUT_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.MultiModeInputDimmerChannel(device, connection)[source]
+

Bases: DimmerChannel

+

this is the representative of the MULTI_MODE_INPUT_DIMMER_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.MultiModeInputSwitchChannel(device, connection)[source]
+

Bases: SwitchChannel

+

this is the representative of the MULTI_MODE_INPUT_SWITCH_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.NotificationLightChannel(device, connection)[source]
+

Bases: DimmerChannel, SwitchChannel

+

this is the representative of the NOTIFICATION_LIGHT_CHANNEL channel

+
+
+async async_set_optical_signal(opticalSignalBehaviour: OpticalSignalBehaviour, rgb: RGBColorState, dimLevel=1.01)[source]
+
+ +
+
+async async_set_rgb_dim_level(rgb: RGBColorState, dimLevel: float)[source]
+
+ +
+
+async async_set_rgb_dim_level_with_time(rgb: RGBColorState, dimLevel: float, onTime: float, rampTime: float)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+on
+

is the light turned on?

+
+
Type:
+

boolean

+
+
+
+ +
+
+set_optical_signal(opticalSignalBehaviour: OpticalSignalBehaviour, rgb: RGBColorState, dimLevel=1.01)[source]
+

sets the signal type for the leds

+
+
Parameters:
+
+
+
Returns:
+

Result of the _restCall

+
+
+
+ +
+
+set_rgb_dim_level(rgb: RGBColorState, dimLevel: float)[source]
+

sets the color and dimlevel of the lamp

+
+
Parameters:
+
    +

  • channelIndex (int) – the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex

    • +

  • rgb (RGBColorState) – the color of the lamp

    • +

  • dimLevel (float) – the dimLevel of the lamp. 0.0 = off, 1.0 = MAX

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+set_rgb_dim_level_with_time(rgb: RGBColorState, dimLevel: float, onTime: float, rampTime: float)[source]
+

sets the color and dimlevel of the lamp

+
+
Parameters:
+
    +

  • channelIndex (int) – the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex

    • +

  • rgb (RGBColorState) – the color of the lamp

    • +

  • dimLevel (float) – the dimLevel of the lamp. 0.0 = off, 1.0 = MAX

    • +

  • onTime (float)

    • +

  • rampTime (float)

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+simpleRGBColorState
+

the color of the light

+
+
Type:
+

RGBColorState

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.OpticalSignalChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this class represents the OPTICAL_SIGNAL_CHANNEL

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.OpticalSignalGroupChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this class represents the OPTICAL_SIGNAL_GROUP_CHANNEL

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.PassageDetectorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the PASSAGE_DETECTOR_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.PresenceDetectionChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the PRESENCE_DETECTION_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.RainDetectionChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the TILT_VIBRATION_SENSOR_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+rainSensorSensitivity
+

float:

+
+ +
+
+raining
+

bool:

+
+ +
+ +
+
+class homematicip.base.functionalChannels.RotaryHandleChannel(device, connection)[source]
+

Bases: ShutterContactChannel

+

this is the representative of the ROTARY_HANDLE_CHANNEL channel

+
+ +
+
+class homematicip.base.functionalChannels.ShadingChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the SHADING_CHANNEL channel

+
+
+async async_set_primary_shading_level(primaryShadingLevel: float)[source]
+
+ +
+
+async async_set_secondary_shading_level(primaryShadingLevel: float, secondaryShadingLevel: float)[source]
+
+ +
+
+async async_set_shutter_stop()[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_primary_shading_level(primaryShadingLevel: float)[source]
+
+ +
+
+set_secondary_shading_level(primaryShadingLevel: float, secondaryShadingLevel: float)[source]
+
+ +
+
+set_shutter_stop()[source]
+

stops the current operation +:returns: the result of the _restCall

+
+ +
+ +
+
+class homematicip.base.functionalChannels.ShutterChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the SHUTTER_CHANNEL channel

+
+
+async async_set_shutter_level(level=0.0)[source]
+
+ +
+
+async async_set_shutter_stop()[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_shutter_level(level=0.0)[source]
+

sets the shutter level

+
+
Parameters:
+

level (float) – the new level of the shutter. 0.0 = open, 1.0 = closed

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+set_shutter_stop()[source]
+

stops the current shutter operation

+
+
Parameters:
+

channelIndex (int) – the channel to control

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.ShutterContactChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the SHUTTER_CONTACT_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.SingleKeyChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the SINGLE_KEY_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.SmokeDetectorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the SMOKE_DETECTOR_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.SwitchChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the SWITCH_CHANNEL channel

+
+
+async async_set_switch_state(on=True)[source]
+
+ +
+
+async async_turn_off()[source]
+
+ +
+
+async async_turn_on()[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_switch_state(on=True)[source]
+
+ +
+
+turn_off()[source]
+
+ +
+
+turn_on()[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.SwitchMeasuringChannel(device, connection)[source]
+

Bases: SwitchChannel

+

this is the representative of the SWITCH_MEASURING_CHANNEL channel

+
+
+async async_reset_energy_counter()[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+reset_energy_counter()[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+temperatureExternalDelta
+

float:

+
+ +
+
+temperatureExternalOne
+

float:

+
+ +
+
+temperatureExternalTwo
+

float:

+
+ +
+ +
+
+class homematicip.base.functionalChannels.TiltVibrationSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the TILT_VIBRATION_SENSOR_CHANNEL channel

+
+
+accelerationSensorEventFilterPeriod
+

float:

+
+ +
+
+accelerationSensorMode
+

AccelerationSensorMode:

+
+ +
+
+accelerationSensorSensitivity
+

AccelerationSensorSensitivity:

+
+ +
+
+accelerationSensorTriggerAngle
+

int:

+
+ +
+
+accelerationSensorTriggered
+

bool:

+
+ +
+
+async async_set_acceleration_sensor_event_filter_period(period: float)[source]
+
+ +
+
+async async_set_acceleration_sensor_mode(mode: AccelerationSensorMode)[source]
+
+ +
+
+async async_set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity)[source]
+
+ +
+
+async async_set_acceleration_sensor_trigger_angle(angle: int)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_acceleration_sensor_event_filter_period(period: float)[source]
+
+ +
+
+set_acceleration_sensor_mode(mode: AccelerationSensorMode)[source]
+
+ +
+
+set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity)[source]
+
+ +
+
+set_acceleration_sensor_trigger_angle(angle: int)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.UniversalActuatorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the UniversalActuatorChannel UNIVERSAL_ACTUATOR_CHANNEL

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.UniversalLightChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

Represents Universal Light Channel.

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.UniversalLightChannelGroup(device, connection)[source]
+

Bases: UniversalLightChannel

+

Universal-Light-Channel-Group.

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.WallMountedThermostatProChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL channel

+
+
+async async_set_display(display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_display(display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.WallMountedThermostatWithoutDisplayChannel(device, connection)[source]
+

Bases: ClimateSensorChannel

+

this is the representative of the WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.WaterSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the WATER_SENSOR_CHANNEL channel

+
+
+async async_set_acoustic_alarm_signal(acousticAlarmSignal: AcousticAlarmSignal)[source]
+
+ +
+
+async async_set_acoustic_alarm_timing(acousticAlarmTiming: AcousticAlarmTiming)[source]
+
+ +
+
+async async_set_acoustic_water_alarm_trigger(acousticWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+async async_set_inapp_water_alarm_trigger(inAppWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+async async_set_siren_water_alarm_trigger(sirenWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+
+set_acoustic_alarm_signal(acousticAlarmSignal: AcousticAlarmSignal)[source]
+
+ +
+
+set_acoustic_alarm_timing(acousticAlarmTiming: AcousticAlarmTiming)[source]
+
+ +
+
+set_acoustic_water_alarm_trigger(acousticWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+set_inapp_water_alarm_trigger(inAppWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+set_siren_water_alarm_trigger(sirenWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+ +
+
+class homematicip.base.functionalChannels.WeatherSensorChannel(device, connection)[source]
+

Bases: FunctionalChannel

+

this is the representative of the WEATHER_SENSOR_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.WeatherSensorPlusChannel(device, connection)[source]
+

Bases: WeatherSensorChannel

+

this is the representative of the WEATHER_SENSOR_PLUS_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+class homematicip.base.functionalChannels.WeatherSensorProChannel(device, connection)[source]
+

Bases: WeatherSensorPlusChannel

+

this is the representative of the WEATHER_SENSOR_PRO_CHANNEL channel

+
+
+from_json(js, groups: Iterable[Group])[source]
+

this function will load the functional channel object +from a json object and the given groups

+
+
Parameters:
+
    +

  • js (dict) – the json object

    • +

  • groups (Iterable[Group]) – the groups for referencing

    • +
+
+
+
+ +
+ +
+
+

homematicip.base.helpers module

+
+
+homematicip.base.helpers.anonymizeConfig(config, pattern, format, flags=re.IGNORECASE)[source]
+
+ +
+
+homematicip.base.helpers.bytes2str(b)[source]
+
+ +
+
+homematicip.base.helpers.detect_encoding(b)[source]
+
+ +
+
+homematicip.base.helpers.get_functional_channel(channel_type, js)[source]
+
+ +
+
+homematicip.base.helpers.get_functional_channels(channel_type, js)[source]
+
+ +
+
+homematicip.base.helpers.handle_config(json_state: str, anonymize: bool) → str[source]
+
+ +
+
+

Module contents

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/homematicip.html b/homematicip.html new file mode 100644 index 00000000..1cbda884 --- /dev/null +++ b/homematicip.html @@ -0,0 +1,6022 @@ + + + + + + + + + homematicip package — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

homematicip package

+
+

Subpackages

+
+ +
+
+
+

Submodules

+
+
+

homematicip.EventHook module

+
+
+class homematicip.EventHook.EventHook[source]
+

Bases: object

+
+
+fire(*args, **keywargs)[source]
+
+ +
+ +
+
+

homematicip.HomeMaticIPObject module

+
+
+

homematicip.access_point_update_state module

+
+
+class homematicip.access_point_update_state.AccessPointUpdateState(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+

homematicip.auth module

+
+
+class homematicip.auth.Auth(home: Home)[source]
+

Bases: object

+
+
+confirmAuthToken(authToken)[source]
+
+ +
+
+connectionRequest(access_point, devicename='homematicip-python') → Response[source]
+
+ +
+
+isRequestAcknowledged()[source]
+
+ +
+
+requestAuthToken()[source]
+
+ +
+ +
+
+

homematicip.class_maps module

+
+
+

homematicip.client module

+
+
+class homematicip.client.Client(connection)[source]
+

Bases: HomeMaticIPObject

+

A client is an app which has access to the access point. +e.g. smartphone, 3th party apps, google home, conrad connect

+
+
+c2cServiceIdentifier
+

the c2c service name

+
+
Type:
+

str

+
+
+
+ +
+
+clientType
+

the type of this client

+
+
Type:
+

ClientType

+
+
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+homeId
+

the home where the client belongs to

+
+
Type:
+

str

+
+
+
+ +
+
+id
+

the unique id of the client

+
+
Type:
+

str

+
+
+
+ +
+
+label
+

a human understandable name of the client

+
+
Type:
+

str

+
+
+
+ +
+ +
+
+

homematicip.connection module

+
+
+class homematicip.connection.Connection[source]
+

Bases: BaseConnection

+
+
+init(accesspoint_id, lookup=True, lookup_url='https://lookup.homematic.com:48335/getHost', **kwargs)[source]
+
+ +
+ +
+
+

homematicip.device module

+
+
+class homematicip.device.AccelerationSensor(connection)[source]
+

Bases: Device

+

HMIP-SAM (Contact Interface flush-mount – 1 channel)

+
+
+accelerationSensorEventFilterPeriod
+

float:

+
+ +
+
+accelerationSensorMode
+

AccelerationSensorMode:

+
+ +
+
+accelerationSensorNeutralPosition
+

AccelerationSensorNeutralPosition:

+
+ +
+
+accelerationSensorSensitivity
+

AccelerationSensorSensitivity:

+
+ +
+
+accelerationSensorTriggerAngle
+

int:

+
+ +
+
+accelerationSensorTriggered
+

bool:

+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+notificationSoundTypeHighToLow
+

NotificationSoundType:

+
+ +
+
+notificationSoundTypeLowToHigh
+

NotificationSoundType:

+
+ +
+
+set_acceleration_sensor_event_filter_period(period: float, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_mode(mode: AccelerationSensorMode, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_neutral_position(neutralPosition: AccelerationSensorNeutralPosition, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_trigger_angle(angle: int, channelIndex=1)[source]
+
+ +
+
+set_notification_sound_type(soundType: NotificationSoundType, isHighToLow: bool, channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.device.AlarmSirenIndoor(connection)[source]
+

Bases: SabotageDevice

+

HMIP-ASIR (Alarm Siren)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.AlarmSirenOutdoor(connection)[source]
+

Bases: AlarmSirenIndoor

+

HMIP-ASIR-O (Alarm Siren Outdoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.BaseDevice(connection)[source]
+

Bases: HomeMaticIPObject

+

Base device class. This is the foundation for homematicip and external (hue) devices

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+load_functionalChannels(groups: Iterable[Group], channels: Iterable[FunctionalChannel])[source]
+

this function will load the functionalChannels into the device

+
+ +
+ +
+
+class homematicip.device.Blind(connection)[source]
+

Bases: Shutter

+

Base class for blind devices

+
+
+set_slats_level(slatsLevel=0.0, shutterLevel=None, channelIndex=1)[source]
+

sets the slats and shutter level

+
+
Parameters:
+
    +

  • slatsLevel (float) – the new level of the slats. 0.0 = open, 1.0 = closed,

    • +

  • shutterLevel (float) – the new level of the shutter. 0.0 = open, 1.0 = closed, None = use the current value

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.device.BlindModule(connection)[source]
+

Bases: Device

+

HMIP-HDM1 (Hunter Douglas & erfal window blinds)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_primary_shading_level(primaryShadingLevel: float)[source]
+
+ +
+
+set_secondary_shading_level(primaryShadingLevel: float, secondaryShadingLevel: float)[source]
+
+ +
+
+stop()[source]
+

stops the current operation +:returns: the result of the _restCall

+
+ +
+ +
+
+class homematicip.device.BrandBlind(connection)[source]
+

Bases: FullFlushBlind

+

HMIP-BBL (Blind Actuator for brand switches)

+
+ +
+
+class homematicip.device.BrandDimmer(connection)[source]
+

Bases: Dimmer

+

HMIP-BDT Brand Dimmer

+
+ +
+
+class homematicip.device.BrandPushButton(connection)[source]
+

Bases: PushButton

+

HMIP-BRC2 (Remote Control for brand switches – 2x channels)

+
+ +
+
+class homematicip.device.BrandSwitch2(connection)[source]
+

Bases: Switch

+

ELV-SH-BS2 (ELV Smart Home ARR-Bausatz Schaltaktor für Markenschalter – 2-fach powered by Homematic IP)

+
+ +
+
+class homematicip.device.BrandSwitchMeasuring(connection)[source]
+

Bases: SwitchMeasuring

+

HMIP-BSM (Brand Switch and Meter)

+
+ +
+
+class homematicip.device.BrandSwitchNotificationLight(connection)[source]
+

Bases: Switch

+

HMIP-BSL (Switch Actuator for brand switches – with signal lamp)

+
+
+bottomLightChannelIndex
+

the channel number for the bottom light

+
+
Type:
+

int

+
+
+
+ +
+
+set_rgb_dim_level(channelIndex: int, rgb: RGBColorState, dimLevel: float)[source]
+

sets the color and dimlevel of the lamp

+
+
Parameters:
+
    +

  • channelIndex (int) – the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex

    • +

  • rgb (RGBColorState) – the color of the lamp

    • +

  • dimLevel (float) – the dimLevel of the lamp. 0.0 = off, 1.0 = MAX

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+set_rgb_dim_level_with_time(channelIndex: int, rgb: RGBColorState, dimLevel: float, onTime: float, rampTime: float)[source]
+

sets the color and dimlevel of the lamp

+
+
Parameters:
+
    +

  • channelIndex (int) – the channelIndex of the lamp. Use self.topLightChannelIndex or self.bottomLightChannelIndex

    • +

  • rgb (RGBColorState) – the color of the lamp

    • +

  • dimLevel (float) – the dimLevel of the lamp. 0.0 = off, 1.0 = MAX

    • +

  • onTime (float)

    • +

  • rampTime (float)

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+topLightChannelIndex
+

the channel number for the top light

+
+
Type:
+

int

+
+
+
+ +
+ +
+
+class homematicip.device.CarbonDioxideSensor(connection)[source]
+

Bases: Switch

+

HmIP-SCTH230

+
+ +
+
+class homematicip.device.ContactInterface(connection)[source]
+

Bases: SabotageDevice

+

HMIP-SCI (Contact Interface Sensor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.DaliGateway(connection)[source]
+

Bases: Device

+

HmIP-DRG-DALI Dali Gateway device.

+
+ +
+
+class homematicip.device.Device(connection)[source]
+

Bases: BaseDevice

+

this class represents a generic homematic ip device

+
+
+authorizeUpdate()[source]
+
+ +
+
+delete()[source]
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+is_update_applicable()[source]
+
+ +
+
+set_label(label)[source]
+
+ +
+
+set_router_module_enabled(enabled=True)[source]
+
+ +
+ +
+
+class homematicip.device.Dimmer(connection)[source]
+

Bases: Device

+

Base dimmer device class

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_dim_level(dimLevel=0.0, channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.device.DinRailBlind4(connection)[source]
+

Bases: Blind

+

HmIP-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)

+
+ +
+
+class homematicip.device.DinRailDimmer3(connection)[source]
+

Bases: Dimmer

+

HMIP-DRDI3 (Dimming Actuator Inbound 230V – 3x channels, 200W per channel) electrical DIN rail

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.DinRailSwitch(connection)[source]
+

Bases: FullFlushInputSwitch

+

HMIP-DRSI1 (Switch Actuator for DIN rail mount – 1x channel)

+
+ +
+
+class homematicip.device.DinRailSwitch4(connection)[source]
+

Bases: Switch

+

HMIP-DRSI4 (Homematic IP Switch Actuator for DIN rail mount – 4x channels)

+
+ +
+
+class homematicip.device.DoorBellButton(connection)[source]
+

Bases: PushButton

+

HmIP-DBB

+
+ +
+
+class homematicip.device.DoorBellContactInterface(connection)[source]
+

Bases: Device

+

HMIP-DSD-PCB (Door Bell Contact Interface)

+
+ +
+
+class homematicip.device.DoorLockDrive(connection)[source]
+

Bases: OperationLockableDevice

+

HmIP-DLD

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_lock_state(doorLockState: LockState, pin='', channelIndex=1)[source]
+

sets the door lock state

+
+
Parameters:
+
    +

  • doorLockState (float) – the state of the door. See LockState from base/enums.py

    • +

  • pin (string) – Pin, if specified.

    • +

  • channelIndex (int) – the channel to control. Normally the channel from DOOR_LOCK_CHANNEL is used.

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.device.DoorLockSensor(connection)[source]
+

Bases: Device

+

HmIP-DLS

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.DoorModule(connection)[source]
+

Bases: Device

+

Generic class for a door module

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+send_door_command(doorCommand=DoorCommand.STOP)[source]
+
+ +
+ +
+
+class homematicip.device.EnergySensorsInterface(connection)[source]
+

Bases: Device

+

HmIP-ESI

+
+ +
+
+class homematicip.device.ExternalDevice(connection)[source]
+

Bases: BaseDevice

+

Represents devices with archtetype EXTERNAL

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.FloorTerminalBlock10(connection)[source]
+

Bases: FloorTerminalBlock6

+

HMIP-FAL24-C10 (Floor Heating Actuator – 10x channels, 24V)

+
+ +
+
+class homematicip.device.FloorTerminalBlock12(connection)[source]
+

Bases: Device

+

HMIP-FALMOT-C12 (Floor Heating Actuator – 12x channels, motorised)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_minimum_floor_heating_valve_position(minimumFloorHeatingValvePosition: float)[source]
+

sets the minimum floot heating valve position

+
+
Parameters:
+

minimumFloorHeatingValvePosition (float) – the minimum valve position. must be between 0.0 and 1.0

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.device.FloorTerminalBlock6(connection)[source]
+

Bases: Device

+

HMIP-FAL230-C6 (Floor Heating Actuator - 6 channels, 230 V)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.FullFlushBlind(connection)[source]
+

Bases: FullFlushShutter, Blind

+

HMIP-FBL (Blind Actuator - flush-mount)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.FullFlushContactInterface(connection)[source]
+

Bases: Device

+

HMIP-FCI1 (Contact Interface flush-mount – 1 channel)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.FullFlushContactInterface6(connection)[source]
+

Bases: Device

+

HMIP-FCI6 (Contact Interface flush-mount – 6 channels)

+
+ +
+
+class homematicip.device.FullFlushDimmer(connection)[source]
+

Bases: Dimmer

+

HMIP-FDT Dimming Actuator flush-mount

+
+ +
+
+class homematicip.device.FullFlushInputSwitch(connection)[source]
+

Bases: Switch

+

HMIP-FSI16 (Switch Actuator with Push-button Input 230V, 16A)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.FullFlushShutter(connection)[source]
+

Bases: Shutter

+

HMIP-FROLL (Shutter Actuator - flush-mount) / HMIP-BROLL (Shutter Actuator - Brand-mount)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.FullFlushSwitchMeasuring(connection)[source]
+

Bases: SwitchMeasuring

+

HMIP-FSM, HMIP-FSM16 (Full flush Switch and Meter)

+
+ +
+
+class homematicip.device.GarageDoorModuleTormatic(connection)[source]
+

Bases: DoorModule

+

HMIP-MOD-TM (Garage Door Module Tormatic)

+
+ +
+
+class homematicip.device.HeatingSwitch2(connection)[source]
+

Bases: Switch

+

HMIP-WHS2 (Switch Actuator for heating systems – 2x channels)

+
+ +
+
+class homematicip.device.HeatingThermostat(connection)[source]
+

Bases: OperationLockableDevice

+

HMIP-eTRV (Radiator Thermostat)

+
+
+automaticValveAdaptionNeeded
+

must the adaption re-run?

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+setPointTemperature
+

the current temperature which should be reached in the room

+
+
Type:
+

float

+
+
+
+ +
+
+temperatureOffset
+

the offset temperature for the thermostat (+/- 3.5)

+
+
Type:
+

float

+
+
+
+ +
+
+valveActualTemperature
+

the current measured temperature at the valve

+
+
Type:
+

float

+
+
+
+ +
+
+valvePosition
+

the current position of the valve 0.0 = closed, 1.0 max opened

+
+
Type:
+

float

+
+
+
+ +
+
+valveState
+

the current state of the valve

+
+
Type:
+

ValveState

+
+
+
+ +
+ +
+
+class homematicip.device.HeatingThermostatCompact(connection)[source]
+

Bases: SabotageDevice

+

HMIP-eTRV-C (Heating-thermostat compact without display)

+
+
+automaticValveAdaptionNeeded
+

must the adaption re-run?

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+setPointTemperature
+

the current temperature which should be reached in the room

+
+
Type:
+

float

+
+
+
+ +
+
+temperatureOffset
+

the offset temperature for the thermostat (+/- 3.5)

+
+
Type:
+

float

+
+
+
+ +
+
+valveActualTemperature
+

the current measured temperature at the valve

+
+
Type:
+

float

+
+
+
+ +
+
+valvePosition
+

the current position of the valve 0.0 = closed, 1.0 max opened

+
+
Type:
+

float

+
+
+
+ +
+
+valveState
+

the current state of the valve

+
+
Type:
+

ValveState

+
+
+
+ +
+ +
+
+class homematicip.device.HeatingThermostatEvo(connection)[source]
+

Bases: OperationLockableDevice

+

HMIP-eTRV-E (Heating-thermostat new evo version)

+
+
+automaticValveAdaptionNeeded
+

must the adaption re-run?

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+setPointTemperature
+

the current temperature which should be reached in the room

+
+
Type:
+

float

+
+
+
+ +
+
+temperatureOffset
+

the offset temperature for the thermostat (+/- 3.5)

+
+
Type:
+

float

+
+
+
+ +
+
+valveActualTemperature
+

the current measured temperature at the valve

+
+
Type:
+

float

+
+
+
+ +
+
+valvePosition
+

the current position of the valve 0.0 = closed, 1.0 max opened

+
+
Type:
+

float

+
+
+
+ +
+
+valveState
+

the current state of the valve

+
+
Type:
+

ValveState

+
+
+
+ +
+ +
+
+class homematicip.device.HoermannDrivesModule(connection)[source]
+

Bases: DoorModule

+

HMIP-MOD-HO (Garage Door Module for Hörmann)

+
+ +
+
+class homematicip.device.HomeControlAccessPoint(connection)[source]
+

Bases: Device

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.HomeControlUnit(connection)[source]
+

Bases: Device

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.KeyRemoteControl4(connection)[source]
+

Bases: PushButton

+

HMIP-KRC4 (Key Ring Remote Control - 4 buttons)

+
+ +
+
+class homematicip.device.KeyRemoteControlAlarm(connection)[source]
+

Bases: Device

+

HMIP-KRCA (Key Ring Remote Control - alarm)

+
+ +
+
+class homematicip.device.LightSensor(connection)[source]
+

Bases: Device

+

HMIP-SLO (Light Sensor outdoor)

+
+
+averageIllumination
+

the average illumination value

+
+
Type:
+

float

+
+
+
+ +
+
+currentIllumination
+

the current illumination value

+
+
Type:
+

float

+
+
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+highestIllumination
+

the highest illumination value

+
+
Type:
+

float

+
+
+
+ +
+
+lowestIllumination
+

the lowest illumination value

+
+
Type:
+

float

+
+
+
+ +
+ +
+
+class homematicip.device.MotionDetectorIndoor(connection)[source]
+

Bases: SabotageDevice

+

HMIP-SMI (Motion Detector with Brightness Sensor - indoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.MotionDetectorOutdoor(connection)[source]
+

Bases: Device

+

HMIP-SMO-A (Motion Detector with Brightness Sensor - outdoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.MotionDetectorPushButton(connection)[source]
+

Bases: MotionDetectorOutdoor

+

HMIP-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2-button)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.MultiIOBox(connection)[source]
+

Bases: Switch

+

HMIP-MIOB (Multi IO Box for floor heating & cooling)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.OpenCollector8Module(connection)[source]
+

Bases: Switch

+

HMIP-MOD-OC8 ( Open Collector Module )

+
+ +
+
+class homematicip.device.OperationLockableDevice(connection)[source]
+

Bases: Device

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_operation_lock(operationLock=True)[source]
+
+ +
+ +
+
+class homematicip.device.PassageDetector(connection)[source]
+

Bases: SabotageDevice

+

HMIP-SPDR (Passage Detector)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.PlugableSwitch(connection)[source]
+

Bases: Switch

+

HMIP-PS (Pluggable Switch), HMIP-PCBS (Switch Circuit Board - 1 channel)

+
+ +
+
+class homematicip.device.PlugableSwitchMeasuring(connection)[source]
+

Bases: SwitchMeasuring

+

HMIP-PSM (Pluggable Switch and Meter)

+
+ +
+
+class homematicip.device.PluggableDimmer(connection)[source]
+

Bases: Dimmer

+

HMIP-PDT Pluggable Dimmer

+
+ +
+
+class homematicip.device.PluggableMainsFailureSurveillance(connection)[source]
+

Bases: Device

+

HMIP-PMFS (Plugable Power Supply Monitoring)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.PresenceDetectorIndoor(connection)[source]
+

Bases: SabotageDevice

+

HMIP-SPI (Presence Sensor - indoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.PrintedCircuitBoardSwitch2(connection)[source]
+

Bases: Switch

+

HMIP-PCBS2 (Switch Circuit Board - 2x channels)

+
+ +
+
+class homematicip.device.PrintedCircuitBoardSwitchBattery(connection)[source]
+

Bases: Switch

+

HMIP-PCBS-BAT (Printed Circuit Board Switch Battery)

+
+ +
+
+class homematicip.device.PushButton(connection)[source]
+

Bases: Device

+

HMIP-WRC2 (Wall-mount Remote Control - 2-button)

+
+ +
+
+class homematicip.device.PushButton6(connection)[source]
+

Bases: PushButton

+

HMIP-WRC6 (Wall-mount Remote Control - 6-button)

+
+ +
+
+class homematicip.device.PushButtonFlat(connection)[source]
+

Bases: PushButton

+

HmIP-WRCC2 (Wall-mount Remote Control – flat)

+
+ +
+
+class homematicip.device.RainSensor(connection)[source]
+

Bases: Device

+

HMIP-SRD (Rain Sensor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+rainSensorSensitivity
+

float:

+
+ +
+
+raining
+

bool:

+
+ +
+ +
+
+class homematicip.device.RemoteControl8(connection)[source]
+

Bases: PushButton

+

HMIP-RC8 (Remote Control - 8 buttons)

+
+ +
+
+class homematicip.device.RemoteControl8Module(connection)[source]
+

Bases: RemoteControl8

+

HMIP-MOD-RC8 (Open Collector Module Sender - 8x)

+
+ +
+
+class homematicip.device.RgbwDimmer(connection)[source]
+

Bases: Device

+

HmIP-RGBW

+
+
+fastColorChangeSupported: bool = False
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.RoomControlDevice(connection)[source]
+

Bases: WallMountedThermostatPro

+

ALPHA-IP-RBG (Alpha IP Wall Thermostat Display)

+
+ +
+
+class homematicip.device.RoomControlDeviceAnalog(connection)[source]
+

Bases: Device

+

ALPHA-IP-RBGa (ALpha IP Wall Thermostat Display analog)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.RotaryHandleSensor(connection)[source]
+

Bases: SabotageDevice

+

HMIP-SRH

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.SabotageDevice(connection)[source]
+

Bases: Device

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.Shutter(connection)[source]
+

Bases: Device

+

Base class for shutter devices

+
+
+set_shutter_level(level=0.0, channelIndex=1)[source]
+

sets the shutter level

+
+
Parameters:
+
    +

  • level (float) – the new level of the shutter. 0.0 = open, 1.0 = closed

    • +

  • channelIndex (int) – the channel to control

    • +
+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+
+set_shutter_stop(channelIndex=1)[source]
+

stops the current shutter operation

+
+
Parameters:
+

channelIndex (int) – the channel to control

+
+
Returns:
+

the result of the _restCall

+
+
+
+ +
+ +
+
+class homematicip.device.ShutterContact(connection)[source]
+

Bases: SabotageDevice

+

HMIP-SWDO (Door / Window Contact - optical) / HMIP-SWDO-I (Door / Window Contact Invisible - optical)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.ShutterContactMagnetic(connection)[source]
+

Bases: Device

+

HMIP-SWDM / HMIP-SWDM-B2 (Door / Window Contact - magnetic )

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.ShutterContactOpticalPlus(connection)[source]
+

Bases: ShutterContact

+

HmIP-SWDO-PL ( Window / Door Contact – optical, plus )

+
+ +
+
+class homematicip.device.SmokeDetector(connection)[source]
+

Bases: Device

+

HMIP-SWSD (Smoke Alarm with Q label)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.Switch(connection)[source]
+

Bases: Device

+

Generic Switch class

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_switch_state(on=True, channelIndex=1)[source]
+
+ +
+
+turn_off(channelIndex=1)[source]
+
+ +
+
+turn_on(channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.device.SwitchMeasuring(connection)[source]
+

Bases: Switch

+

Generic class for Switch and Meter

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+reset_energy_counter()[source]
+
+ +
+ +
+
+class homematicip.device.TemperatureDifferenceSensor2(connection)[source]
+

Bases: Device

+

HmIP-STE2-PCB (Temperature Difference Sensors - 2x sensors)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+temperatureExternalDelta
+

float:

+
+ +
+
+temperatureExternalOne
+

float:

+
+ +
+
+temperatureExternalTwo
+

float:

+
+ +
+ +
+
+class homematicip.device.TemperatureHumiditySensorDisplay(connection)[source]
+

Bases: Device

+

HMIP-STHD (Temperature and Humidity Sensor with display - indoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_display(display: ClimateControlDisplay = ClimateControlDisplay.ACTUAL)[source]
+
+ +
+ +
+
+class homematicip.device.TemperatureHumiditySensorOutdoor(connection)[source]
+

Bases: Device

+

HMIP-STHO (Temperature and Humidity Sensor outdoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.TemperatureHumiditySensorWithoutDisplay(connection)[source]
+

Bases: Device

+

HMIP-STH (Temperature and Humidity Sensor without display - indoor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.TiltVibrationSensor(connection)[source]
+

Bases: Device

+

HMIP-STV (Inclination and vibration Sensor)

+
+
+accelerationSensorEventFilterPeriod
+

float:

+
+ +
+
+accelerationSensorMode
+

AccelerationSensorMode:

+
+ +
+
+accelerationSensorSensitivity
+

AccelerationSensorSensitivity:

+
+ +
+
+accelerationSensorTriggerAngle
+

int:

+
+ +
+
+accelerationSensorTriggered
+

bool:

+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_acceleration_sensor_event_filter_period(period: float, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_mode(mode: AccelerationSensorMode, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_sensitivity(sensitivity: AccelerationSensorSensitivity, channelIndex=1)[source]
+
+ +
+
+set_acceleration_sensor_trigger_angle(angle: int, channelIndex=1)[source]
+
+ +
+ +
+
+class homematicip.device.WallMountedGarageDoorController(connection)[source]
+

Bases: Device

+

HmIP-WGC Wall mounted Garage Door Controller

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+send_start_impulse(channelIndex=2)[source]
+

Toggle Wall mounted Garage Door Controller.

+
+ +
+ +
+
+class homematicip.device.WallMountedThermostatBasicHumidity(connection)[source]
+

Bases: WallMountedThermostatPro

+

HMIP-WTH-B (Wall Thermostat – basic)

+
+ +
+
+class homematicip.device.WallMountedThermostatPro(connection)[source]
+

Bases: TemperatureHumiditySensorDisplay, OperationLockableDevice

+

HMIP-WTH, HMIP-WTH-2 (Wall Thermostat with Humidity Sensor) / HMIP-BWTH (Brand Wall Thermostat with Humidity Sensor)

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.WaterSensor(connection)[source]
+

Bases: Device

+

HMIP-SWD ( Water Sensor )

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_acoustic_alarm_signal(acousticAlarmSignal: AcousticAlarmSignal)[source]
+
+ +
+
+set_acoustic_alarm_timing(acousticAlarmTiming: AcousticAlarmTiming)[source]
+
+ +
+
+set_acoustic_water_alarm_trigger(acousticWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+set_inapp_water_alarm_trigger(inAppWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+
+set_siren_water_alarm_trigger(sirenWaterAlarmTrigger: WaterAlarmTrigger)[source]
+
+ +
+ +
+
+class homematicip.device.WeatherSensor(connection)[source]
+

Bases: Device

+

HMIP-SWO-B

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.WeatherSensorPlus(connection)[source]
+

Bases: Device

+

HMIP-SWO-PL

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.WeatherSensorPro(connection)[source]
+

Bases: Device

+

HMIP-SWO-PR

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.WiredDimmer3(connection)[source]
+

Bases: Dimmer

+

HMIPW-DRD3 (Homematic IP Wired Dimming Actuator – 3x channels)

+
+ +
+
+class homematicip.device.WiredDinRailAccessPoint(connection)[source]
+

Bases: Device

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.device.WiredDinRailBlind4(connection)[source]
+

Bases: Blind

+

HmIPW-DRBL4

+
+ +
+
+class homematicip.device.WiredFloorTerminalBlock12(connection)[source]
+

Bases: FloorTerminalBlock12

+

Implementation of HmIPW-FALMOT-C12

+
+ +
+
+class homematicip.device.WiredInput32(connection)[source]
+

Bases: FullFlushContactInterface

+

HMIPW-DRI32 (Homematic IP Wired Inbound module – 32x channels)

+
+ +
+
+class homematicip.device.WiredInputSwitch6(connection)[source]
+

Bases: Switch

+

HmIPW-FIO6

+
+ +
+
+class homematicip.device.WiredMotionDetectorPushButton(connection)[source]
+

Bases: MotionDetectorOutdoor

+

HmIPW-SMI55

+
+ +
+
+class homematicip.device.WiredPushButton(connection)[source]
+

Bases: PushButton

+

HmIPW-WRC6 and HmIPW-WRC2

+
+
+set_dim_level(channelIndex, dimLevel)[source]
+

sets the signal type for the leds +:param channelIndex: Channel which is affected +:type channelIndex: int +:param dimLevel: usally 1.01. Use set_dim_level instead +:type dimLevel: float

+
+
Returns:
+

Result of the _restCall

+
+
+
+ +
+
+set_optical_signal(channelIndex, opticalSignalBehaviour: OpticalSignalBehaviour, rgb: RGBColorState, dimLevel=1.01)[source]
+

sets the signal type for the leds

+
+
Parameters:
+
    +

  • channelIndex (int) – Channel which is affected

    • +

  • opticalSignalBehaviour (OpticalSignalBehaviour) – LED signal behaviour

    • +

  • rgb (RGBColorState) – Color

    • +

  • dimLevel (float) – usally 1.01. Use set_dim_level instead

    • +
+
+
Returns:
+

Result of the _restCall

+
+
+
+ +
+
+set_switch_state(on, channelIndex)[source]
+
+ +
+
+turn_off(channelIndex)[source]
+
+ +
+
+turn_on(channelIndex)[source]
+
+ +
+ +
+
+class homematicip.device.WiredSwitch4(connection)[source]
+

Bases: Switch

+

HMIPW-DRS4 (Homematic IP Wired Switch Actuator – 4x channels)

+
+ +
+
+class homematicip.device.WiredSwitch8(connection)[source]
+

Bases: Switch

+

HMIPW-DRS8 (Homematic IP Wired Switch Actuator – 8x channels)

+
+ +
+
+

homematicip.functionalHomes module

+
+
+class homematicip.functionalHomes.AccessControlHome(connection)[source]
+

Bases: FunctionalHome

+
+
+from_json(js, groups: List[Group])[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.functionalHomes.EnergyHome(connection)[source]
+

Bases: FunctionalHome

+
+ +
+
+class homematicip.functionalHomes.FunctionalHome(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+assignGroups(gids, groups: List[Group])[source]
+
+ +
+
+from_json(js, groups: List[Group])[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.functionalHomes.IndoorClimateHome(connection)[source]
+

Bases: FunctionalHome

+
+
+from_json(js, groups: List[Group])[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.functionalHomes.LightAndShadowHome(connection)[source]
+

Bases: FunctionalHome

+
+
+from_json(js, groups: List[Group])[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.functionalHomes.SecurityAndAlarmHome(connection)[source]
+

Bases: FunctionalHome

+
+
+from_json(js, groups: List[Group])[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.functionalHomes.WeatherAndEnvironmentHome(connection)[source]
+

Bases: FunctionalHome

+
+ +
+
+

homematicip.group module

+
+
+class homematicip.group.AccessAuthorizationProfileGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.AccessControlGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.AlarmSwitchingGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_on_time(onTimeSeconds)[source]
+
+ +
+
+set_signal_acoustic(signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING)[source]
+
+ +
+
+set_signal_optical(signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING)[source]
+
+ +
+
+test_signal_acoustic(signalAcoustic=AcousticAlarmSignal.FREQUENCY_FALLING)[source]
+
+ +
+
+test_signal_optical(signalOptical=OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING)[source]
+
+ +
+ +
+
+class homematicip.group.EnergyGroup(connection)[source]
+

Bases: Group

+
+ +
+
+class homematicip.group.EnvironmentGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.ExtendedLinkedGarageDoorGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.ExtendedLinkedShutterGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_shutter_level(level)[source]
+
+ +
+
+set_shutter_stop()[source]
+
+ +
+
+set_slats_level(slatsLevel=0.0, shutterLevel=None)[source]
+
+ +
+ +
+
+class homematicip.group.ExtendedLinkedSwitchingGroup(connection)[source]
+

Bases: SwitchGroupBase

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_on_time(onTimeSeconds)[source]
+
+ +
+ +
+
+class homematicip.group.Group(connection)[source]
+

Bases: HomeMaticIPObject

+

this class represents a group

+
+
+delete()[source]
+
+ +
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_label(label)[source]
+
+ +
+ +
+
+class homematicip.group.HeatingChangeoverGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingCoolingDemandBoilerGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingCoolingDemandGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingCoolingDemandPumpGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingCoolingPeriod(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingCoolingProfile(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+get_details()[source]
+
+ +
+
+update_profile()[source]
+
+ +
+ +
+
+class homematicip.group.HeatingCoolingProfileDay(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingDehumidifierGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingExternalClockGroup(connection)[source]
+

Bases: Group

+
+ +
+
+class homematicip.group.HeatingFailureAlertRuleGroup(connection)[source]
+

Bases: Group

+
+
+checkInterval
+

how often the system will check for an error

+
+
Type:
+

int

+
+
+
+ +
+
+enabled
+

is this rule active

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+heatingFailureValidationResult
+

the heating failure value

+
+
Type:
+

HeatingFailureValidationType

+
+
+
+ +
+
+lastExecutionTimestamp
+

last time of execution

+
+
Type:
+

datetime

+
+
+
+ +
+
+validationTimeout
+

time in ms for the validation period. default 24Hours

+
+
Type:
+

int

+
+
+
+ +
+ +
+
+class homematicip.group.HeatingGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_active_profile(index)[source]
+
+ +
+
+set_boost(enable=True)[source]
+
+ +
+
+set_boost_duration(duration: int)[source]
+
+ +
+
+set_control_mode(mode=ClimateControlMode.AUTOMATIC)[source]
+
+ +
+
+set_point_temperature(temperature)[source]
+
+ +
+ +
+
+class homematicip.group.HeatingHumidyLimiterGroup(connection)[source]
+

Bases: Group

+
+ +
+
+class homematicip.group.HeatingTemperatureLimiterGroup(connection)[source]
+

Bases: Group

+
+ +
+
+class homematicip.group.HotWaterGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_profile_mode(profileMode: ProfileMode)[source]
+
+ +
+ +
+
+class homematicip.group.HumidityWarningRuleGroup(connection)[source]
+

Bases: Group

+
+
+enabled
+

is this rule active

+
+
Type:
+

bool

+
+
+
+ +
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+humidityLowerThreshold
+

the lower humidity threshold

+
+
Type:
+

int

+
+
+
+ +
+
+humidityUpperThreshold
+

the upper humidity threshold

+
+
Type:
+

int

+
+
+
+ +
+
+humidityValidationResult
+

the current humidity result

+
+
Type:
+

HumidityValidationType

+
+
+
+ +
+
+lastExecutionTimestamp
+

last time of execution

+
+
Type:
+

datetime

+
+
+
+ +
+
+lastStatusUpdate
+

last time the humidity got updated

+
+
Type:
+

datetime

+
+
+
+ +
+
+outdoorClimateSensor
+

the climate sensor which get used as an outside reference. None if OpenWeatherMap will be used

+
+
Type:
+

Device

+
+
+
+ +
+
+triggered
+

is it currently triggered?

+
+
Type:
+

bool

+
+
+
+ +
+
+ventilationRecommended
+

should the windows be opened?

+
+
Type:
+

bool

+
+
+
+ +
+ +
+
+class homematicip.group.InboxGroup(connection)[source]
+

Bases: Group

+
+ +
+
+class homematicip.group.IndoorClimateGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.LinkedSwitchingGroup(connection)[source]
+

Bases: Group

+
+
+set_light_group_switches(devices)[source]
+
+ +
+ +
+
+class homematicip.group.LockOutProtectionRule(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.MetaGroup(connection)[source]
+

Bases: Group

+

a meta group is a “Room” inside the homematic configuration

+
+
+from_json(js, devices, groups)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.OverHeatProtectionRule(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.SecurityGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.SecurityZoneGroup(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.ShutterProfile(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_profile_mode(profileMode: ProfileMode)[source]
+
+ +
+
+set_shutter_level(level)[source]
+
+ +
+
+set_shutter_stop()[source]
+
+ +
+
+set_slats_level(slatsLevel, shutterlevel=None)[source]
+
+ +
+ +
+
+class homematicip.group.ShutterWindProtectionRule(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.SmokeAlarmDetectionRule(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.group.SwitchGroupBase(connection)[source]
+

Bases: Group

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_switch_state(on=True)[source]
+
+ +
+
+turn_off()[source]
+
+ +
+
+turn_on()[source]
+
+ +
+ +
+
+class homematicip.group.SwitchingGroup(connection)[source]
+

Bases: SwitchGroupBase

+
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_shutter_level(level)[source]
+
+ +
+
+set_shutter_stop()[source]
+
+ +
+
+set_slats_level(slatsLevel, shutterlevel=None)[source]
+
+ +
+ +
+
+class homematicip.group.SwitchingProfileGroup(connection)[source]
+

Bases: Group

+
+
+create(label)[source]
+
+ +
+
+from_json(js, devices)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_group_channels()[source]
+
+ +
+
+set_profile_mode(devices, automatic=True)[source]
+
+ +
+ +
+
+class homematicip.group.TimeProfile(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+get_details()[source]
+
+ +
+ +
+
+class homematicip.group.TimeProfilePeriod(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+

homematicip.home module

+
+
+class homematicip.home.Home(connection=None)[source]
+

Bases: HomeMaticIPObject

+

this class represents the ‘Home’ of the homematic ip

+
+
+accessPointUpdateStates
+

a map of all access points and their updateStates

+
+
Type:
+

Map

+
+
+
+ +
+
+activate_absence_permanent()[source]
+

activates the absence forever

+
+ +
+
+activate_absence_with_duration(duration: int)[source]
+

activates the absence mode for a given time

+
+
Parameters:
+

duration (int) – the absence duration in minutes

+
+
+
+ +
+
+activate_absence_with_period(endtime: datetime)[source]
+

activates the absence mode until the given time

+
+
Parameters:
+

endtime (datetime) – the time when the absence should automatically be disabled

+
+
+
+ +
+
+activate_vacation(endtime: datetime, temperature: float)[source]
+

activates the vatation mode until the given time

+
+
Parameters:
+
    +

  • endtime (datetime) – the time when the vatation mode should automatically be disabled

    • +

  • temperature (float) – the settemperature during the vacation mode

    • +
+
+
+
+ +
+
+channels
+

a collection of all channels in the home

+
+
Type:
+

List[FunctionalChannel]

+
+
+
+ +
+
+clients
+

a collection of all clients in home

+
+
Type:
+

List[Client]

+
+
+
+ +
+
+currentAPVersion
+

the current version of the access point

+
+
Type:
+

str

+
+
+
+ +
+
+deactivate_absence()[source]
+

deactivates the absence mode immediately

+
+ +
+
+deactivate_vacation()[source]
+

deactivates the vacation mode immediately

+
+ +
+
+delete_group(group: Group)[source]
+

deletes the given group from the cloud

+
+
Parameters:
+

group (Group) – the group to delete

+
+
+
+ +
+
+devices
+

a collection of all devices in home

+
+
Type:
+

List[Device]

+
+
+
+ +
+
+disable_events()[source]
+
+ +
+
+download_configuration() → str[source]
+

downloads the current configuration from the cloud

+
+
Returns

the downloaded configuration or an errorCode

+
+
+
+ +
+
+enable_events(enable_trace=False, ping_interval=20)[source]
+
+ +
+
+fire_channel_event(*args, **kwargs)[source]
+

Trigger the method tied to _on_channel_event

+
+ +
+
+fire_create_event(*args, **kwargs)[source]
+

Trigger the method tied to _on_create

+
+ +
+
+from_json(js_home)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+functionalHomes
+

a collection of all functionalHomes in the home

+
+ +
+
+get_OAuth_OTK()[source]
+
+ +
+
+get_current_state(clearConfig: bool = False)[source]
+

downloads the current configuration and parses it into self

+
+
Parameters:
+
    +

  • clearConfig (bool) – if set to true, this function will remove all old objects

    • +

  • self.devices (from)

    • +

  • self.client

    • +

  • them (... to have a fresh config instead of reparsing)

    • +
+
+
+
+ +
+
+get_functionalHome(functionalHomeType: type) → FunctionalHome[source]
+

gets the specified functionalHome

+
+
Parameters:
+

functionalHome (type) – the type of the functionalHome which should be returned

+
+
Returns:
+

the FunctionalHome or None if it couldn’t be found

+
+
+
+ +
+
+get_security_journal()[source]
+
+ +
+
+get_security_zones_activation() -> (<class 'bool'>, <class 'bool'>)[source]
+

returns the value of the security zones if they are armed or not

+
+
Returns
+
internal

True if the internal zone is armed

+
+
external

True if the external zone is armed

+
+
+
+
+
+ +
+
+groups
+

a collection of all groups in the home

+
+
Type:
+

List[Group]

+
+
+
+ +
+
+id
+

the SGTIN of the access point

+
+
Type:
+

str

+
+
+
+ +
+
+init(access_point_id, lookup=True)[source]
+
+ +
+
+location
+

the location of the AP

+
+
Type:
+

Location

+
+
+
+ +
+
+on_channel_event(handler)[source]
+

Adds an event handler to the channel event method. Fires when a channel event +is received.

+
+ +
+
+on_create(handler)[source]
+

Adds an event handler to the create method. Fires when a device +is created.

+
+ +
+
+pinAssigned
+

determines if a pin is set on this access point

+
+
Type:
+

bool

+
+
+
+ +
+
+remove_callback(handler)[source]
+

Remove event handler.

+
+ +
+
+remove_channel_event_handler(handler)[source]
+

Remove event handler.

+
+ +
+
+rules
+

a collection of all rules in the home

+
+
Type:
+

List[Rule]

+
+
+
+ +
+
+search_channel(deviceID, channelIndex) → FunctionalChannel[source]
+

searches a channel by given deviceID and channelIndex

+
+ +
+
+search_client_by_id(clientID) → Client[source]
+

searches a client by given id

+
+
Parameters:
+

clientID (str) – the client to search for

+
+
+
+
Returns

the client object or None if it couldn’t find a client

+
+
+
+ +
+
+search_device_by_id(deviceID) → Device[source]
+

searches a device by given id

+
+
Parameters:
+

deviceID (str) – the device to search for

+
+
+
+
Returns

the Device object or None if it couldn’t find a device

+
+
+
+ +
+
+search_group_by_id(groupID) → Group[source]
+

searches a group by given id

+
+
Parameters:
+

groupID (str) – groupID the group to search for

+
+
+
+
Returns

the group object or None if it couldn’t find a group

+
+
+
+ +
+
+search_rule_by_id(ruleID) → Rule[source]
+

searches a rule by given id

+
+
Parameters:
+

ruleID (str) – the rule to search for

+
+
+
+
Returns

the rule object or None if it couldn’t find a rule

+
+
+
+ +
+
+set_auth_token(auth_token)[source]
+
+ +
+
+set_cooling(cooling)[source]
+
+ +
+
+set_intrusion_alert_through_smoke_detectors(activate: bool = True)[source]
+

activate or deactivate if smoke detectors should “ring” during an alarm

+
+
Parameters:
+

activate (bool) – True will let the smoke detectors “ring” during an alarm

+
+
+
+ +
+
+set_location(city, latitude, longitude)[source]
+
+ +
+
+set_pin(newPin: str, oldPin: str = None) → dict[source]
+

sets a new pin for the home

+
+
Parameters:
+
    +

  • newPin (str) – the new pin

    • +

  • oldPin (str) – optional, if there is currently a pin active it must be given here. +Otherwise it will not be possible to set the new pin

    • +
+
+
Returns:
+

the result of the call

+
+
+
+ +
+
+set_powermeter_unit_price(price)[source]
+
+ +
+
+set_security_zones_activation(internal=True, external=True)[source]
+

this function will set the alarm system to armed or disable it

+
+
Parameters:
+
    +

  • internal (bool) – activates/deactivates the internal zone

    • +

  • external (bool) – activates/deactivates the external zone

    • +
+
+
+

Examples

+

arming while being at home

+
>>> home.set_security_zones_activation(False,True)
+
+
+

arming without being at home

+
>>> home.set_security_zones_activation(True,True)
+
+
+

disarming the alarm system

+
>>> home.set_security_zones_activation(False,False)
+
+
+
+ +
+
+set_silent_alarm(internal=True, external=True)[source]
+

this function will set the silent alarm for interal or external

+
+
Parameters:
+
    +

  • internal (bool) – activates/deactivates the silent alarm for internal zone

    • +

  • external (bool) – activates/deactivates the silent alarm for the external zone

    • +
+
+
+
+ +
+
+set_timezone(timezone: str)[source]
+

sets the timezone for the AP. e.g. “Europe/Berlin” +:param timezone: the new timezone +:type timezone: str

+
+ +
+
+set_zone_activation_delay(delay)[source]
+
+ +
+
+set_zones_device_assignment(internal_devices, external_devices) → dict[source]
+

sets the devices for the security zones +:param internal_devices: the devices which should be used for the internal zone +:type internal_devices: List[Device] +:param external_devices: the devices which should be used for the external(hull) zone +:type external_devices: List[Device]

+
+
Returns:
+

the result of _restCall

+
+
+
+ +
+
+start_inclusion(deviceId)[source]
+

start inclusion mode for specific device +:param deviceId: sgtin of device

+
+ +
+
+update_home(json_state, clearConfig: bool = False)[source]
+

parse a given json configuration into self. +This will update the whole home including devices, clients and groups.

+
+
Parameters:
+
    +

  • clearConfig (bool) – if set to true, this function will remove all old objects

    • +

  • self.devices (from)

    • +

  • self.client

    • +

  • them (... to have a fresh config instead of reparsing)

    • +
+
+
+
+ +
+
+update_home_only(js_home, clearConfig: bool = False)[source]
+

parse a given home json configuration into self. +This will update only the home without updating devices, clients and groups.

+
+
Parameters:
+
    +

  • clearConfig (bool) – if set to true, this function will remove all old objects

    • +

  • self.devices (from)

    • +

  • self.client

    • +

  • them (... to have a fresh config instead of reparsing)

    • +
+
+
+
+ +
+
+weather
+

the current weather

+
+
Type:
+

Weather

+
+
+
+ +
+
+websocket_reconnect_on_error
+

switch to enable/disable automatic reconnection of the websocket (default=True)

+
+
Type:
+

bool

+
+
+
+ +
+ +
+
+

homematicip.location module

+
+
+class homematicip.location.Location(connection)[source]
+

Bases: HomeMaticIPObject

+

This class represents the possible location

+
+
+city
+

the name of the city

+
+
Type:
+

str

+
+
+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+latitude
+

the latitude of the location

+
+
Type:
+

float

+
+
+
+ +
+
+longitude
+

the longitue of the location

+
+
Type:
+

float

+
+
+
+ +
+ +
+
+

homematicip.oauth_otk module

+
+
+class homematicip.oauth_otk.OAuthOTK(connection)[source]
+

Bases: HomeMaticIPObject

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+

homematicip.rule module

+
+
+class homematicip.rule.Rule(connection)[source]
+

Bases: HomeMaticIPObject

+

this class represents the automation rule

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+set_label(label)[source]
+

sets the label of the rule

+
+ +
+ +
+
+class homematicip.rule.SimpleRule(connection)[source]
+

Bases: Rule

+

This class represents a “Simple” automation rule

+
+
+disable()[source]
+

disables the rule

+
+ +
+
+enable()[source]
+

enables the rule

+
+ +
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+get_simple_rule()[source]
+
+ +
+
+set_rule_enabled_state(enabled)[source]
+

enables/disables this rule

+
+ +
+ +
+
+

homematicip.securityEvent module

+
+
+class homematicip.securityEvent.AccessPointConnectedEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.AccessPointDisconnectedEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.ActivationChangedEvent(connection)[source]
+

Bases: SecurityZoneEvent

+
+ +
+
+class homematicip.securityEvent.ExternalTriggeredEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.MainsFailureEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.MoistureDetectionEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.OfflineAlarmEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.OfflineWaterDetectionEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.SabotageEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.SecurityEvent(connection)[source]
+

Bases: HomeMaticIPObject

+

this class represents a security event

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.securityEvent.SecurityZoneEvent(connection)[source]
+

Bases: SecurityEvent

+

This class will be used by other events which are just adding “securityZoneValues”

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+ +
+
+class homematicip.securityEvent.SensorEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.SilenceChangedEvent(connection)[source]
+

Bases: SecurityZoneEvent

+
+ +
+
+class homematicip.securityEvent.SmokeAlarmEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+class homematicip.securityEvent.WaterDetectionEvent(connection)[source]
+

Bases: SecurityEvent

+
+ +
+
+

homematicip.weather module

+
+
+class homematicip.weather.Weather(connection)[source]
+

Bases: HomeMaticIPObject

+

this class represents the weather of the home location

+
+
+from_json(js)[source]
+

this method will parse the homematicip object from a json object

+
+
Parameters:
+

js – the json object to parse

+
+
+
+ +
+
+humidity
+

the current humidity

+
+
Type:
+

float

+
+
+
+ +
+
+maxTemperature
+

the maximum temperature of the day

+
+
Type:
+

float

+
+
+
+ +
+
+minTemperature
+

the minimum temperature of the day

+
+
Type:
+

float

+
+
+
+ +
+
+temperature
+

the current temperature

+
+
Type:
+

float

+
+
+
+ +
+
+vaporAmount
+

the current vapor

+
+
Type:
+

float

+
+
+
+ +
+
+weatherCondition
+

the current weather

+
+
Type:
+

WeatherCondition

+
+
+
+ +
+
+weatherDayTime
+

the current datime

+
+
Type:
+

datetime

+
+
+
+ +
+
+windDirection
+

the current wind direction in 360° where 0° is north

+
+
Type:
+

int

+
+
+
+ +
+
+windSpeed
+

the current windspeed

+
+
Type:
+

float

+
+
+
+ +
+ +
+
+

Module contents

+
+
+class homematicip.HmipConfig(auth_token, access_point, log_level, log_file, raw_config)
+

Bases: tuple

+
+
+access_point
+

Alias for field number 1

+
+ +
+
+auth_token
+

Alias for field number 0

+
+ +
+
+log_file
+

Alias for field number 3

+
+ +
+
+log_level
+

Alias for field number 2

+
+ +
+
+raw_config
+

Alias for field number 4

+
+ +
+ +
+
+homematicip.find_and_load_config_file() → HmipConfig[source]
+
+ +
+
+homematicip.get_config_file_locations() → [][source]
+
+ +
+
+homematicip.load_config_file(config_file: str) → HmipConfig[source]
+

Loads the config ini file. +:raises a FileNotFoundError when the config file does not exist.

+
+ +
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 00000000..ea90d72a --- /dev/null +++ b/index.html @@ -0,0 +1,379 @@ + + + + + + + + + Welcome to Homematic IP Rest API’s documentation! — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Welcome to Homematic IP Rest API’s documentation!

+

This documentation is for a Python 3 wrapper for the homematicIP REST API (Access Point Based) +Since there is no official documentation about this API everything was +done via reverse engineering. Use at your own risk.

+
+

Getting started

+ +
+
+

API Documentation

+ +
+
+
+

Indices and tables

+ +
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/modules.html b/modules.html new file mode 100644 index 00000000..14a73ffa --- /dev/null +++ b/modules.html @@ -0,0 +1,932 @@ + + + + + + + + + homematicip — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

homematicip

+
+ +
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/objects.inv b/objects.inv new file mode 100644 index 00000000..46709b95 Binary files /dev/null and b/objects.inv differ diff --git a/py-modindex.html b/py-modindex.html new file mode 100644 index 00000000..32dae94f --- /dev/null +++ b/py-modindex.html @@ -0,0 +1,280 @@ + + + + + + + + Python Module Index — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Python Module Index
    • +
  • +
    • +
+
+
+
+
+ + +

Python Module Index

+ +
+ h +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 
+ h
+ homematicip +
    + homematicip.access_point_update_state +
    + homematicip.aio +
    + homematicip.aio.auth +
    + homematicip.aio.class_maps +
    + homematicip.aio.connection +
    + homematicip.aio.device +
    + homematicip.aio.group +
    + homematicip.aio.home +
    + homematicip.aio.rule +
    + homematicip.aio.securityEvent +
    + homematicip.auth +
    + homematicip.base +
    + homematicip.base.base_connection +
    + homematicip.base.constants +
    + homematicip.base.enums +
    + homematicip.base.functionalChannels +
    + homematicip.base.helpers +
    + homematicip.class_maps +
    + homematicip.client +
    + homematicip.connection +
    + homematicip.device +
    + homematicip.EventHook +
    + homematicip.functionalHomes +
    + homematicip.group +
    + homematicip.home +
    + homematicip.HomeMaticIPObject +
    + homematicip.location +
    + homematicip.oauth_otk +
    + homematicip.rule +
    + homematicip.securityEvent +
    + homematicip.weather +
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/search.html b/search.html new file mode 100644 index 00000000..657e54c1 --- /dev/null +++ b/search.html @@ -0,0 +1,125 @@ + + + + + + + + Search — HomematicIP-Rest-API 0.0.post1.dev1 documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Search
    • +
  • +
    • +
+
+
+
+
+ + + + +
+ +
+ +
+
+ +
+
+
+
+ + + + + + + + + \ No newline at end of file diff --git a/searchindex.js b/searchindex.js new file mode 100644 index 00000000..116e9335 --- /dev/null +++ b/searchindex.js @@ -0,0 +1 @@ +Search.setIndex({"alltitles": {"API Documentation": [[5, null]], "API Introduction": [[0, null]], "Examples": [[1, "examples"]], "Get Information about devices and groups": [[1, "get-information-about-devices-and-groups"]], "Getting Started": [[1, null]], "Getting started": [[5, null]], "Getting the AUTH-TOKEN": [[1, "getting-the-auth-token"]], "Indices and tables": [[5, "indices-and-tables"]], "Installation": [[1, "installation"]], "Module contents": [[2, "module-homematicip"], [3, "module-homematicip.aio"], [4, "module-homematicip.base"]], "Submodules": [[2, "submodules"], [3, "submodules"], [4, "submodules"]], "Subpackages": [[2, "subpackages"]], "Using the CLI": [[1, "using-the-cli"]], "Welcome to Homematic IP Rest API\u2019s documentation!": [[5, null]], "homematicip": [[6, null]], "homematicip package": [[2, null]], "homematicip.EventHook module": [[2, "module-homematicip.EventHook"]], "homematicip.HomeMaticIPObject module": [[2, "module-homematicip.HomeMaticIPObject"]], "homematicip.access_point_update_state module": [[2, "module-homematicip.access_point_update_state"]], "homematicip.aio package": [[3, null]], "homematicip.aio.auth module": [[3, "module-homematicip.aio.auth"]], "homematicip.aio.class_maps module": [[3, "module-homematicip.aio.class_maps"]], "homematicip.aio.connection module": [[3, "module-homematicip.aio.connection"]], "homematicip.aio.device module": [[3, "module-homematicip.aio.device"]], "homematicip.aio.group module": [[3, "module-homematicip.aio.group"]], "homematicip.aio.home module": [[3, "module-homematicip.aio.home"]], "homematicip.aio.rule module": [[3, "module-homematicip.aio.rule"]], "homematicip.aio.securityEvent module": [[3, "module-homematicip.aio.securityEvent"]], "homematicip.auth module": [[2, "module-homematicip.auth"]], "homematicip.base package": [[4, null]], "homematicip.base.HomeMaticIPObject module": [[4, "homematicip-base-homematicipobject-module"]], "homematicip.base.base_connection module": [[4, "module-homematicip.base.base_connection"]], "homematicip.base.constants module": [[4, "module-homematicip.base.constants"]], "homematicip.base.enums module": [[4, "module-homematicip.base.enums"]], "homematicip.base.functionalChannels module": [[4, "module-homematicip.base.functionalChannels"]], "homematicip.base.helpers module": [[4, "module-homematicip.base.helpers"]], "homematicip.class_maps module": [[2, "module-homematicip.class_maps"]], "homematicip.client module": [[2, "module-homematicip.client"]], "homematicip.connection module": [[2, "module-homematicip.connection"]], "homematicip.device module": [[2, "module-homematicip.device"]], "homematicip.functionalHomes module": [[2, "module-homematicip.functionalHomes"]], "homematicip.group module": [[2, "module-homematicip.group"]], "homematicip.home module": [[2, "module-homematicip.home"]], "homematicip.location module": [[2, "module-homematicip.location"]], "homematicip.oauth_otk module": [[2, "module-homematicip.oauth_otk"]], "homematicip.rule module": [[2, "module-homematicip.rule"]], "homematicip.securityEvent module": [[2, "module-homematicip.securityEvent"]], "homematicip.weather module": [[2, "module-homematicip.weather"]]}, "docnames": ["api_introduction", "gettingstarted", "homematicip", "homematicip.aio", "homematicip.base", "index", "modules"], "envversion": {"sphinx": 64, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.viewcode": 1}, "filenames": ["api_introduction.rst", "gettingstarted.rst", "homematicip.rst", "homematicip.aio.rst", "homematicip.base.rst", "index.rst", "modules.rst"], "indexentries": {"absencetype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AbsenceType", false]], "acceleration_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ACCELERATION_SENSOR", false]], "acceleration_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ACCELERATION_SENSOR_CHANNEL", false]], "accelerationsensor (class in homematicip.device)": [[2, "homematicip.device.AccelerationSensor", false]], "accelerationsensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel", false]], "accelerationsensoreventfilterperiod (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.accelerationSensorEventFilterPeriod", false]], "accelerationsensoreventfilterperiod (homematicip.base.functionalchannels.tiltvibrationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.accelerationSensorEventFilterPeriod", false]], "accelerationsensoreventfilterperiod (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.accelerationSensorEventFilterPeriod", false]], "accelerationsensoreventfilterperiod (homematicip.device.tiltvibrationsensor attribute)": [[2, "homematicip.device.TiltVibrationSensor.accelerationSensorEventFilterPeriod", false]], "accelerationsensormode (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AccelerationSensorMode", false]], "accelerationsensormode (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.accelerationSensorMode", false]], "accelerationsensormode (homematicip.base.functionalchannels.tiltvibrationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.accelerationSensorMode", false]], "accelerationsensormode (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.accelerationSensorMode", false]], "accelerationsensormode (homematicip.device.tiltvibrationsensor attribute)": [[2, "homematicip.device.TiltVibrationSensor.accelerationSensorMode", false]], "accelerationsensorneutralposition (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AccelerationSensorNeutralPosition", false]], "accelerationsensorneutralposition (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.accelerationSensorNeutralPosition", false]], "accelerationsensorneutralposition (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.accelerationSensorNeutralPosition", false]], "accelerationsensorsensitivity (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity", false]], "accelerationsensorsensitivity (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.accelerationSensorSensitivity", false]], "accelerationsensorsensitivity (homematicip.base.functionalchannels.tiltvibrationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.accelerationSensorSensitivity", false]], "accelerationsensorsensitivity (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.accelerationSensorSensitivity", false]], "accelerationsensorsensitivity (homematicip.device.tiltvibrationsensor attribute)": [[2, "homematicip.device.TiltVibrationSensor.accelerationSensorSensitivity", false]], "accelerationsensortriggerangle (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.accelerationSensorTriggerAngle", false]], "accelerationsensortriggerangle (homematicip.base.functionalchannels.tiltvibrationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.accelerationSensorTriggerAngle", false]], "accelerationsensortriggerangle (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.accelerationSensorTriggerAngle", false]], "accelerationsensortriggerangle (homematicip.device.tiltvibrationsensor attribute)": [[2, "homematicip.device.TiltVibrationSensor.accelerationSensorTriggerAngle", false]], "accelerationsensortriggered (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.accelerationSensorTriggered", false]], "accelerationsensortriggered (homematicip.base.functionalchannels.tiltvibrationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.accelerationSensorTriggered", false]], "accelerationsensortriggered (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.accelerationSensorTriggered", false]], "accelerationsensortriggered (homematicip.device.tiltvibrationsensor attribute)": [[2, "homematicip.device.TiltVibrationSensor.accelerationSensorTriggered", false]], "access_authorization_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ACCESS_AUTHORIZATION_CHANNEL", false]], "access_authorization_profile (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.ACCESS_AUTHORIZATION_PROFILE", false]], "access_control (homematicip.base.enums.functionalhometype attribute)": [[4, "homematicip.base.enums.FunctionalHomeType.ACCESS_CONTROL", false]], "access_control (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.ACCESS_CONTROL", false]], "access_controller_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ACCESS_CONTROLLER_CHANNEL", false]], "access_controller_wired_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ACCESS_CONTROLLER_WIRED_CHANNEL", false]], "access_point (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ACCESS_POINT", false]], "access_point (homematicip.hmipconfig attribute)": [[2, "homematicip.HmipConfig.access_point", false]], "access_point_connected (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.ACCESS_POINT_CONNECTED", false]], "access_point_disconnected (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.ACCESS_POINT_DISCONNECTED", false]], "accessauthorizationchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AccessAuthorizationChannel", false]], "accessauthorizationprofilegroup (class in homematicip.group)": [[2, "homematicip.group.AccessAuthorizationProfileGroup", false]], "accesscontrolgroup (class in homematicip.group)": [[2, "homematicip.group.AccessControlGroup", false]], "accesscontrolhome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.AccessControlHome", false]], "accesscontrollerchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AccessControllerChannel", false]], "accesscontrollerwiredchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AccessControllerWiredChannel", false]], "accesspoint_id (homematicip.base.base_connection.baseconnection property)": [[4, "homematicip.base.base_connection.BaseConnection.accesspoint_id", false]], "accesspointconnectedevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.AccessPointConnectedEvent", false]], "accesspointdisconnectedevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.AccessPointDisconnectedEvent", false]], "accesspointupdatestate (class in homematicip.access_point_update_state)": [[2, "homematicip.access_point_update_state.AccessPointUpdateState", false]], "accesspointupdatestates (homematicip.home.home attribute)": [[2, "homematicip.home.Home.accessPointUpdateStates", false]], "acousticalarmsignal (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AcousticAlarmSignal", false]], "acousticalarmtiming (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AcousticAlarmTiming", false]], "activate_absence_permanent() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.activate_absence_permanent", false]], "activate_absence_permanent() (homematicip.home.home method)": [[2, "homematicip.home.Home.activate_absence_permanent", false]], "activate_absence_with_duration() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.activate_absence_with_duration", false]], "activate_absence_with_duration() (homematicip.home.home method)": [[2, "homematicip.home.Home.activate_absence_with_duration", false]], "activate_absence_with_period() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.activate_absence_with_period", false]], "activate_absence_with_period() (homematicip.home.home method)": [[2, "homematicip.home.Home.activate_absence_with_period", false]], "activate_vacation() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.activate_vacation", false]], "activate_vacation() (homematicip.home.home method)": [[2, "homematicip.home.Home.activate_vacation", false]], "activation_changed (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.ACTIVATION_CHANGED", false]], "activation_if_all_in_valid_state (homematicip.base.enums.securityzoneactivationmode attribute)": [[4, "homematicip.base.enums.SecurityZoneActivationMode.ACTIVATION_IF_ALL_IN_VALID_STATE", false]], "activation_with_device_ignorelist (homematicip.base.enums.securityzoneactivationmode attribute)": [[4, "homematicip.base.enums.SecurityZoneActivationMode.ACTIVATION_WITH_DEVICE_IGNORELIST", false]], "activationchangedevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.ActivationChangedEvent", false]], "actual (homematicip.base.enums.climatecontroldisplay attribute)": [[4, "homematicip.base.enums.ClimateControlDisplay.ACTUAL", false]], "actual_humidity (homematicip.base.enums.climatecontroldisplay attribute)": [[4, "homematicip.base.enums.ClimateControlDisplay.ACTUAL_HUMIDITY", false]], "adaption_done (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.ADAPTION_DONE", false]], "adaption_in_progress (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.ADAPTION_IN_PROGRESS", false]], "add_on_channel_event_handler() (homematicip.base.functionalchannels.functionalchannel method)": [[4, "homematicip.base.functionalChannels.FunctionalChannel.add_on_channel_event_handler", false]], "adjustment_too_big (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.ADJUSTMENT_TOO_BIG", false]], "adjustment_too_small (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.ADJUSTMENT_TOO_SMALL", false]], "alarm_siren_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ALARM_SIREN_CHANNEL", false]], "alarm_siren_indoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ALARM_SIREN_INDOOR", false]], "alarm_siren_outdoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ALARM_SIREN_OUTDOOR", false]], "alarm_switching (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.ALARM_SWITCHING", false]], "alarmcontacttype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AlarmContactType", false]], "alarmsignaltype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AlarmSignalType", false]], "alarmsirenchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AlarmSirenChannel", false]], "alarmsirenindoor (class in homematicip.device)": [[2, "homematicip.device.AlarmSirenIndoor", false]], "alarmsirenoutdoor (class in homematicip.device)": [[2, "homematicip.device.AlarmSirenOutdoor", false]], "alarmswitchinggroup (class in homematicip.group)": [[2, "homematicip.group.AlarmSwitchingGroup", false]], "analog_output_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ANALOG_OUTPUT_CHANNEL", false]], "analog_room_control_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ANALOG_ROOM_CONTROL_CHANNEL", false]], "analogoutputchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AnalogOutputChannel", false]], "analogoutputlevel (homematicip.base.functionalchannels.analogoutputchannel attribute)": [[4, "homematicip.base.functionalChannels.AnalogOutputChannel.analogOutputLevel", false]], "analogroomcontrolchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.AnalogRoomControlChannel", false]], "anonymizeconfig() (in module homematicip.base.helpers)": [[4, "homematicip.base.helpers.anonymizeConfig", false]], "any_motion (homematicip.base.enums.accelerationsensormode attribute)": [[4, "homematicip.base.enums.AccelerationSensorMode.ANY_MOTION", false]], "apexchangestate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ApExchangeState", false]], "api_call() (homematicip.aio.connection.asyncconnection method)": [[3, "homematicip.aio.connection.AsyncConnection.api_call", false]], "app (homematicip.base.enums.clienttype attribute)": [[4, "homematicip.base.enums.ClientType.APP", false]], "assigngroups() (homematicip.functionalhomes.functionalhome method)": [[2, "homematicip.functionalHomes.FunctionalHome.assignGroups", false]], "async_reset_energy_counter() (homematicip.base.functionalchannels.switchmeasuringchannel method)": [[4, "homematicip.base.functionalChannels.SwitchMeasuringChannel.async_reset_energy_counter", false]], "async_send_door_command() (homematicip.base.functionalchannels.doorchannel method)": [[4, "homematicip.base.functionalChannels.DoorChannel.async_send_door_command", false]], "async_send_start_impulse() (homematicip.base.functionalchannels.impulseoutputchannel method)": [[4, "homematicip.base.functionalChannels.ImpulseOutputChannel.async_send_start_impulse", false]], "async_set_acceleration_sensor_event_filter_period() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.async_set_acceleration_sensor_event_filter_period", false]], "async_set_acceleration_sensor_event_filter_period() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.async_set_acceleration_sensor_event_filter_period", false]], "async_set_acceleration_sensor_mode() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.async_set_acceleration_sensor_mode", false]], "async_set_acceleration_sensor_mode() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.async_set_acceleration_sensor_mode", false]], "async_set_acceleration_sensor_neutral_position() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.async_set_acceleration_sensor_neutral_position", false]], "async_set_acceleration_sensor_sensitivity() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.async_set_acceleration_sensor_sensitivity", false]], "async_set_acceleration_sensor_sensitivity() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.async_set_acceleration_sensor_sensitivity", false]], "async_set_acceleration_sensor_trigger_angle() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.async_set_acceleration_sensor_trigger_angle", false]], "async_set_acceleration_sensor_trigger_angle() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.async_set_acceleration_sensor_trigger_angle", false]], "async_set_acoustic_alarm_signal() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.async_set_acoustic_alarm_signal", false]], "async_set_acoustic_alarm_timing() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.async_set_acoustic_alarm_timing", false]], "async_set_acoustic_water_alarm_trigger() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.async_set_acoustic_water_alarm_trigger", false]], "async_set_dim_level() (homematicip.base.functionalchannels.dimmerchannel method)": [[4, "homematicip.base.functionalChannels.DimmerChannel.async_set_dim_level", false]], "async_set_display() (homematicip.base.functionalchannels.wallmountedthermostatprochannel method)": [[4, "homematicip.base.functionalChannels.WallMountedThermostatProChannel.async_set_display", false]], "async_set_inapp_water_alarm_trigger() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.async_set_inapp_water_alarm_trigger", false]], "async_set_lock_state() (homematicip.base.functionalchannels.doorlockchannel method)": [[4, "homematicip.base.functionalChannels.DoorLockChannel.async_set_lock_state", false]], "async_set_minimum_floor_heating_valve_position() (homematicip.base.functionalchannels.devicebasefloorheatingchannel method)": [[4, "homematicip.base.functionalChannels.DeviceBaseFloorHeatingChannel.async_set_minimum_floor_heating_valve_position", false]], "async_set_notification_sound_type() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.async_set_notification_sound_type", false]], "async_set_operation_lock() (homematicip.base.functionalchannels.deviceoperationlockchannel method)": [[4, "homematicip.base.functionalChannels.DeviceOperationLockChannel.async_set_operation_lock", false]], "async_set_optical_signal() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.async_set_optical_signal", false]], "async_set_primary_shading_level() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.async_set_primary_shading_level", false]], "async_set_rgb_dim_level() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.async_set_rgb_dim_level", false]], "async_set_rgb_dim_level_with_time() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.async_set_rgb_dim_level_with_time", false]], "async_set_secondary_shading_level() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.async_set_secondary_shading_level", false]], "async_set_shutter_level() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.async_set_shutter_level", false]], "async_set_shutter_level() (homematicip.base.functionalchannels.shutterchannel method)": [[4, "homematicip.base.functionalChannels.ShutterChannel.async_set_shutter_level", false]], "async_set_shutter_stop() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.async_set_shutter_stop", false]], "async_set_shutter_stop() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.async_set_shutter_stop", false]], "async_set_shutter_stop() (homematicip.base.functionalchannels.shutterchannel method)": [[4, "homematicip.base.functionalChannels.ShutterChannel.async_set_shutter_stop", false]], "async_set_siren_water_alarm_trigger() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.async_set_siren_water_alarm_trigger", false]], "async_set_slats_level() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.async_set_slats_level", false]], "async_set_switch_state() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.async_set_switch_state", false]], "async_stop() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.async_stop", false]], "async_turn_off() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.async_turn_off", false]], "async_turn_on() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.async_turn_on", false]], "asyncaccelerationsensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncAccelerationSensor", false]], "asyncaccessauthorizationprofilegroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncAccessAuthorizationProfileGroup", false]], "asyncaccesscontrolgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncAccessControlGroup", false]], "asyncaccesspointconnectedevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncAccessPointConnectedEvent", false]], "asyncaccesspointdisconnectedevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncAccessPointDisconnectedEvent", false]], "asyncactivationchangedevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncActivationChangedEvent", false]], "asyncalarmsirenindoor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncAlarmSirenIndoor", false]], "asyncalarmsirenoutdoor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncAlarmSirenOutdoor", false]], "asyncalarmswitchinggroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncAlarmSwitchingGroup", false]], "asyncauth (class in homematicip.aio.auth)": [[3, "homematicip.aio.auth.AsyncAuth", false]], "asyncauthconnection (class in homematicip.aio.auth)": [[3, "homematicip.aio.auth.AsyncAuthConnection", false]], "asyncbasedevice (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBaseDevice", false]], "asyncblind (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBlind", false]], "asyncblindmodule (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBlindModule", false]], "asyncbrandblind (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBrandBlind", false]], "asyncbranddimmer (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBrandDimmer", false]], "asyncbrandpushbutton (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBrandPushButton", false]], "asyncbrandswitch2 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBrandSwitch2", false]], "asyncbrandswitchmeasuring (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBrandSwitchMeasuring", false]], "asyncbrandswitchnotificationlight (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncBrandSwitchNotificationLight", false]], "asynccarbondioxidesensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncCarbonDioxideSensor", false]], "asyncconnection (class in homematicip.aio.connection)": [[3, "homematicip.aio.connection.AsyncConnection", false]], "asynccontactinterface (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncContactInterface", false]], "asyncdaligateway (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDaliGateway", false]], "asyncdevice (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDevice", false]], "asyncdimmer (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDimmer", false]], "asyncdinrailblind4 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDinRailBlind4", false]], "asyncdinraildimmer3 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDinRailDimmer3", false]], "asyncdinrailswitch (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDinRailSwitch", false]], "asyncdinrailswitch4 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDinRailSwitch4", false]], "asyncdoorbellbutton (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDoorBellButton", false]], "asyncdoorbellcontactinterface (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDoorBellContactInterface", false]], "asyncdoorlockdrive (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDoorLockDrive", false]], "asyncdoorlocksensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDoorLockSensor", false]], "asyncdoormodule (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncDoorModule", false]], "asyncenergygroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncEnergyGroup", false]], "asyncenergysensorsinterface (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncEnergySensorsInterface", false]], "asyncenvironmentgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncEnvironmentGroup", false]], "asyncextendedgaragedoorgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncExtendedGarageDoorGroup", false]], "asyncextendedlinkedshuttergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncExtendedLinkedShutterGroup", false]], "asyncextendedlinkedswitchinggroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncExtendedLinkedSwitchingGroup", false]], "asyncexternaldevice (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncExternalDevice", false]], "asyncexternaltriggeredevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncExternalTriggeredEvent", false]], "asyncfloorterminalblock10 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFloorTerminalBlock10", false]], "asyncfloorterminalblock12 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFloorTerminalBlock12", false]], "asyncfloorterminalblock6 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFloorTerminalBlock6", false]], "asyncfullflushblind (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushBlind", false]], "asyncfullflushcontactinterface (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushContactInterface", false]], "asyncfullflushcontactinterface6 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushContactInterface6", false]], "asyncfullflushdimmer (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushDimmer", false]], "asyncfullflushinputswitch (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushInputSwitch", false]], "asyncfullflushshutter (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushShutter", false]], "asyncfullflushswitchmeasuring (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncFullFlushSwitchMeasuring", false]], "asyncgaragedoormoduletormatic (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncGarageDoorModuleTormatic", false]], "asyncgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncGroup", false]], "asyncheatingchangeovergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingChangeoverGroup", false]], "asyncheatingcoolingdemandboilergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingCoolingDemandBoilerGroup", false]], "asyncheatingcoolingdemandgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingCoolingDemandGroup", false]], "asyncheatingcoolingdemandpumpgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingCoolingDemandPumpGroup", false]], "asyncheatingdehumidifiergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingDehumidifierGroup", false]], "asyncheatingexternalclockgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingExternalClockGroup", false]], "asyncheatingfailurealertrulegroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingFailureAlertRuleGroup", false]], "asyncheatinggroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingGroup", false]], "asyncheatinghumidylimitergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingHumidyLimiterGroup", false]], "asyncheatingswitch2 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHeatingSwitch2", false]], "asyncheatingtemperaturelimitergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHeatingTemperatureLimiterGroup", false]], "asyncheatingthermostat (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHeatingThermostat", false]], "asyncheatingthermostatcompact (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHeatingThermostatCompact", false]], "asyncheatingthermostatevo (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHeatingThermostatEvo", false]], "asynchoermanndrivesmodule (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHoermannDrivesModule", false]], "asynchome (class in homematicip.aio.home)": [[3, "homematicip.aio.home.AsyncHome", false]], "asynchomecontrolaccesspoint (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHomeControlAccessPoint", false]], "asynchomecontrolunit (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncHomeControlUnit", false]], "asynchotwatergroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHotWaterGroup", false]], "asynchumiditywarningrulegroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncHumidityWarningRuleGroup", false]], "asyncinboxgroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncInboxGroup", false]], "asyncindoorclimategroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncIndoorClimateGroup", false]], "asynckeyremotecontrol4 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncKeyRemoteControl4", false]], "asynckeyremotecontrolalarm (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncKeyRemoteControlAlarm", false]], "asynclightsensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncLightSensor", false]], "asynclinkedswitchinggroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncLinkedSwitchingGroup", false]], "asynclockoutprotectionrule (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncLockOutProtectionRule", false]], "asyncmainsfailureevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncMainsFailureEvent", false]], "asyncmetagroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncMetaGroup", false]], "asyncmoisturedetectionevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncMoistureDetectionEvent", false]], "asyncmotiondetectorindoor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncMotionDetectorIndoor", false]], "asyncmotiondetectoroutdoor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncMotionDetectorOutdoor", false]], "asyncmotiondetectorpushbutton (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncMotionDetectorPushButton", false]], "asyncmultiiobox (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncMultiIOBox", false]], "asyncofflinealarmevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncOfflineAlarmEvent", false]], "asyncofflinewaterdetectionevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncOfflineWaterDetectionEvent", false]], "asyncopencollector8module (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncOpenCollector8Module", false]], "asyncoperationlockabledevice (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncOperationLockableDevice", false]], "asyncoverheatprotectionrule (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncOverHeatProtectionRule", false]], "asyncpassagedetector (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPassageDetector", false]], "asyncplugableswitch (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPlugableSwitch", false]], "asyncplugableswitchmeasuring (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPlugableSwitchMeasuring", false]], "asyncpluggabledimmer (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPluggableDimmer", false]], "asyncpluggablemainsfailuresurveillance (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPluggableMainsFailureSurveillance", false]], "asyncpresencedetectorindoor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPresenceDetectorIndoor", false]], "asyncprintedcircuitboardswitch2 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPrintedCircuitBoardSwitch2", false]], "asyncprintedcircuitboardswitchbattery (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPrintedCircuitBoardSwitchBattery", false]], "asyncpushbutton (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPushButton", false]], "asyncpushbutton6 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPushButton6", false]], "asyncpushbuttonflat (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncPushButtonFlat", false]], "asyncrainsensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRainSensor", false]], "asyncremotecontrol8 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRemoteControl8", false]], "asyncremotecontrol8module (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRemoteControl8Module", false]], "asyncrgbwdimmer (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRgbwDimmer", false]], "asyncroomcontroldevice (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRoomControlDevice", false]], "asyncroomcontroldeviceanalog (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRoomControlDeviceAnalog", false]], "asyncrotaryhandlesensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncRotaryHandleSensor", false]], "asyncrule (class in homematicip.aio.rule)": [[3, "homematicip.aio.rule.AsyncRule", false]], "asyncsabotagedevice (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncSabotageDevice", false]], "asyncsabotageevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncSabotageEvent", false]], "asyncsecurityevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncSecurityEvent", false]], "asyncsecuritygroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncSecurityGroup", false]], "asyncsecurityzoneevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncSecurityZoneEvent", false]], "asyncsecurityzonegroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncSecurityZoneGroup", false]], "asyncsensorevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncSensorEvent", false]], "asyncshutter (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncShutter", false]], "asyncshuttercontact (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncShutterContact", false]], "asyncshuttercontactmagnetic (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncShutterContactMagnetic", false]], "asyncshuttercontactopticalplus (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncShutterContactOpticalPlus", false]], "asyncshutterprofile (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncShutterProfile", false]], "asyncshutterwindprotectionrule (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncShutterWindProtectionRule", false]], "asyncsilencechangedevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncSilenceChangedEvent", false]], "asyncsimplerule (class in homematicip.aio.rule)": [[3, "homematicip.aio.rule.AsyncSimpleRule", false]], "asyncsmokealarmdetectionrule (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncSmokeAlarmDetectionRule", false]], "asyncsmokealarmevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncSmokeAlarmEvent", false]], "asyncsmokedetector (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncSmokeDetector", false]], "asyncswitch (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncSwitch", false]], "asyncswitchgroupbase (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncSwitchGroupBase", false]], "asyncswitchinggroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncSwitchingGroup", false]], "asyncswitchingprofilegroup (class in homematicip.aio.group)": [[3, "homematicip.aio.group.AsyncSwitchingProfileGroup", false]], "asyncswitchmeasuring (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncSwitchMeasuring", false]], "asynctemperaturedifferencesensor2 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncTemperatureDifferenceSensor2", false]], "asynctemperaturehumiditysensordisplay (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncTemperatureHumiditySensorDisplay", false]], "asynctemperaturehumiditysensoroutdoor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncTemperatureHumiditySensorOutdoor", false]], "asynctemperaturehumiditysensorwithoutdisplay (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncTemperatureHumiditySensorWithoutDisplay", false]], "asynctiltvibrationsensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncTiltVibrationSensor", false]], "asyncwallmountedgaragedoorcontroller (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWallMountedGarageDoorController", false]], "asyncwallmountedthermostatbasichumidity (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWallMountedThermostatBasicHumidity", false]], "asyncwallmountedthermostatpro (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWallMountedThermostatPro", false]], "asyncwaterdetectionevent (class in homematicip.aio.securityevent)": [[3, "homematicip.aio.securityEvent.AsyncWaterDetectionEvent", false]], "asyncwatersensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWaterSensor", false]], "asyncweathersensor (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWeatherSensor", false]], "asyncweathersensorplus (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWeatherSensorPlus", false]], "asyncweathersensorpro (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWeatherSensorPro", false]], "asyncwireddimmer3 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredDimmer3", false]], "asyncwireddinrailaccesspoint (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredDinRailAccessPoint", false]], "asyncwireddinrailblind4 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredDinRailBlind4", false]], "asyncwiredfloorterminalblock12 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredFloorTerminalBlock12", false]], "asyncwiredinput32 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredInput32", false]], "asyncwiredinputswitch6 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredInputSwitch6", false]], "asyncwiredmotiondetectorpushbutton (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredMotionDetectorPushButton", false]], "asyncwiredpushbutton (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredPushButton", false]], "asyncwiredswitch4 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredSwitch4", false]], "asyncwiredswitch8 (class in homematicip.aio.device)": [[3, "homematicip.aio.device.AsyncWiredSwitch8", false]], "auth (class in homematicip.auth)": [[2, "homematicip.auth.Auth", false]], "auth_token (homematicip.base.base_connection.baseconnection property)": [[4, "homematicip.base.base_connection.BaseConnection.auth_token", false]], "auth_token (homematicip.hmipconfig attribute)": [[2, "homematicip.HmipConfig.auth_token", false]], "authorizeupdate() (homematicip.aio.device.asyncdevice method)": [[3, "homematicip.aio.device.AsyncDevice.authorizeUpdate", false]], "authorizeupdate() (homematicip.device.device method)": [[2, "homematicip.device.Device.authorizeUpdate", false]], "automatic (homematicip.base.enums.climatecontrolmode attribute)": [[4, "homematicip.base.enums.ClimateControlMode.AUTOMATIC", false]], "automatic (homematicip.base.enums.profilemode attribute)": [[4, "homematicip.base.enums.ProfileMode.AUTOMATIC", false]], "automatically_if_possible (homematicip.base.enums.deviceupdatestrategy attribute)": [[4, "homematicip.base.enums.DeviceUpdateStrategy.AUTOMATICALLY_IF_POSSIBLE", false]], "automaticvalveadaptionneeded (homematicip.base.functionalchannels.heatingthermostatchannel attribute)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.automaticValveAdaptionNeeded", false]], "automaticvalveadaptionneeded (homematicip.device.heatingthermostat attribute)": [[2, "homematicip.device.HeatingThermostat.automaticValveAdaptionNeeded", false]], "automaticvalveadaptionneeded (homematicip.device.heatingthermostatcompact attribute)": [[2, "homematicip.device.HeatingThermostatCompact.automaticValveAdaptionNeeded", false]], "automaticvalveadaptionneeded (homematicip.device.heatingthermostatevo attribute)": [[2, "homematicip.device.HeatingThermostatEvo.automaticValveAdaptionNeeded", false]], "automationruletype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AutomationRuleType", false]], "autonameenum (class in homematicip.base.enums)": [[4, "homematicip.base.enums.AutoNameEnum", false]], "average_value (homematicip.base.enums.windvaluetype attribute)": [[4, "homematicip.base.enums.WindValueType.AVERAGE_VALUE", false]], "averageillumination (homematicip.base.functionalchannels.lightsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.LightSensorChannel.averageIllumination", false]], "averageillumination (homematicip.device.lightsensor attribute)": [[2, "homematicip.device.LightSensor.averageIllumination", false]], "background_update_not_supported (homematicip.base.enums.deviceupdatestate attribute)": [[4, "homematicip.base.enums.DeviceUpdateState.BACKGROUND_UPDATE_NOT_SUPPORTED", false]], "badbatteryhealth (homematicip.base.functionalchannels.devicerechargeablewithsabotage attribute)": [[4, "homematicip.base.functionalChannels.DeviceRechargeableWithSabotage.badBatteryHealth", false]], "base_device (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BASE_DEVICE", false]], "baseconnection (class in homematicip.base.base_connection)": [[4, "homematicip.base.base_connection.BaseConnection", false]], "basedevice (class in homematicip.device)": [[2, "homematicip.device.BaseDevice", false]], "billow_middle (homematicip.base.enums.opticalsignalbehaviour attribute)": [[4, "homematicip.base.enums.OpticalSignalBehaviour.BILLOW_MIDDLE", false]], "binary_behavior (homematicip.base.enums.multimodeinputmode attribute)": [[4, "homematicip.base.enums.MultiModeInputMode.BINARY_BEHAVIOR", false]], "binarybehaviortype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.BinaryBehaviorType", false]], "black (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.BLACK", false]], "blind (class in homematicip.device)": [[2, "homematicip.device.Blind", false]], "blind_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.BLIND_CHANNEL", false]], "blind_module (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BLIND_MODULE", false]], "blindchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.BlindChannel", false]], "blindmodule (class in homematicip.device)": [[2, "homematicip.device.BlindModule", false]], "blinking_alternately_repeating (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.BLINKING_ALTERNATELY_REPEATING", false]], "blinking_both_repeating (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.BLINKING_BOTH_REPEATING", false]], "blinking_middle (homematicip.base.enums.opticalsignalbehaviour attribute)": [[4, "homematicip.base.enums.OpticalSignalBehaviour.BLINKING_MIDDLE", false]], "blue (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.BLUE", false]], "bottom (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.BOTTOM", false]], "bottomlightchannelindex (homematicip.device.brandswitchnotificationlight attribute)": [[2, "homematicip.device.BrandSwitchNotificationLight.bottomLightChannelIndex", false]], "brand_blind (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_BLIND", false]], "brand_dimmer (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_DIMMER", false]], "brand_push_button (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_PUSH_BUTTON", false]], "brand_shutter (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_SHUTTER", false]], "brand_switch_2 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_SWITCH_2", false]], "brand_switch_measuring (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_SWITCH_MEASURING", false]], "brand_switch_notification_light (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_SWITCH_NOTIFICATION_LIGHT", false]], "brand_wall_mounted_thermostat (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.BRAND_WALL_MOUNTED_THERMOSTAT", false]], "brandblind (class in homematicip.device)": [[2, "homematicip.device.BrandBlind", false]], "branddimmer (class in homematicip.device)": [[2, "homematicip.device.BrandDimmer", false]], "brandpushbutton (class in homematicip.device)": [[2, "homematicip.device.BrandPushButton", false]], "brandswitch2 (class in homematicip.device)": [[2, "homematicip.device.BrandSwitch2", false]], "brandswitchmeasuring (class in homematicip.device)": [[2, "homematicip.device.BrandSwitchMeasuring", false]], "brandswitchnotificationlight (class in homematicip.device)": [[2, "homematicip.device.BrandSwitchNotificationLight", false]], "bytes2str() (in module homematicip.base.helpers)": [[4, "homematicip.base.helpers.bytes2str", false]], "c2c (homematicip.base.enums.clienttype attribute)": [[4, "homematicip.base.enums.ClientType.C2C", false]], "c2cserviceidentifier (homematicip.client.client attribute)": [[2, "homematicip.client.Client.c2cServiceIdentifier", false]], "carbon_dioxide_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.CARBON_DIOXIDE_SENSOR", false]], "carbon_dioxide_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.CARBON_DIOXIDE_SENSOR_CHANNEL", false]], "carbondioxidesensor (class in homematicip.device)": [[2, "homematicip.device.CarbonDioxideSensor", false]], "carbondioxidesensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.CarbonDioxideSensorChannel", false]], "center (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.CENTER", false]], "change_over_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.CHANGE_OVER_CHANNEL", false]], "changeoverchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ChangeOverChannel", false]], "channeleventtypes (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ChannelEventTypes", false]], "channels (homematicip.home.home attribute)": [[2, "homematicip.home.Home.channels", false]], "checkinterval (homematicip.group.heatingfailurealertrulegroup attribute)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup.checkInterval", false]], "city (homematicip.location.location attribute)": [[2, "homematicip.location.Location.city", false]], "clear (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.CLEAR", false]], "cliactions (class in homematicip.base.enums)": [[4, "homematicip.base.enums.CliActions", false]], "client (class in homematicip.client)": [[2, "homematicip.client.Client", false]], "client_added (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.CLIENT_ADDED", false]], "client_changed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.CLIENT_CHANGED", false]], "client_removed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.CLIENT_REMOVED", false]], "clientauth_token (homematicip.base.base_connection.baseconnection property)": [[4, "homematicip.base.base_connection.BaseConnection.clientauth_token", false]], "clientcharacteristics (homematicip.base.base_connection.baseconnection property)": [[4, "homematicip.base.base_connection.BaseConnection.clientCharacteristics", false]], "clients (homematicip.home.home attribute)": [[2, "homematicip.home.Home.clients", false]], "clienttype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ClientType", false]], "clienttype (homematicip.client.client attribute)": [[2, "homematicip.client.Client.clientType", false]], "climate_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.CLIMATE_SENSOR_CHANNEL", false]], "climatecontroldisplay (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ClimateControlDisplay", false]], "climatecontrolmode (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ClimateControlMode", false]], "climatesensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ClimateSensorChannel", false]], "close (homematicip.base.enums.doorcommand attribute)": [[4, "homematicip.base.enums.DoorCommand.CLOSE", false]], "close_websocket_connection() (homematicip.aio.connection.asyncconnection method)": [[3, "homematicip.aio.connection.AsyncConnection.close_websocket_connection", false]], "closed (homematicip.base.enums.doorstate attribute)": [[4, "homematicip.base.enums.DoorState.CLOSED", false]], "closed (homematicip.base.enums.windowstate attribute)": [[4, "homematicip.base.enums.WindowState.CLOSED", false]], "closing (homematicip.base.enums.motorstate attribute)": [[4, "homematicip.base.enums.MotorState.CLOSING", false]], "cloudy (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.CLOUDY", false]], "cloudy_with_rain (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.CLOUDY_WITH_RAIN", false]], "cloudy_with_snow_rain (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.CLOUDY_WITH_SNOW_RAIN", false]], "confirmation_signal_0 (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.CONFIRMATION_SIGNAL_0", false]], "confirmation_signal_1 (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.CONFIRMATION_SIGNAL_1", false]], "confirmation_signal_2 (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.CONFIRMATION_SIGNAL_2", false]], "confirmauthtoken() (homematicip.aio.auth.asyncauth method)": [[3, "homematicip.aio.auth.AsyncAuth.confirmAuthToken", false]], "confirmauthtoken() (homematicip.auth.auth method)": [[2, "homematicip.auth.Auth.confirmAuthToken", false]], "connect_timeout (homematicip.aio.connection.asyncconnection attribute)": [[3, "homematicip.aio.connection.AsyncConnection.connect_timeout", false]], "connection (class in homematicip.connection)": [[2, "homematicip.connection.Connection", false]], "connectionrequest() (homematicip.aio.auth.asyncauth method)": [[3, "homematicip.aio.auth.AsyncAuth.connectionRequest", false]], "connectionrequest() (homematicip.auth.auth method)": [[2, "homematicip.auth.Auth.connectionRequest", false]], "connectiontype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ConnectionType", false]], "contact_interface_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.CONTACT_INTERFACE_CHANNEL", false]], "contactinterface (class in homematicip.device)": [[2, "homematicip.device.ContactInterface", false]], "contactinterfacechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ContactInterfaceChannel", false]], "contacttype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ContactType", false]], "create() (homematicip.aio.group.asyncswitchingprofilegroup method)": [[3, "homematicip.aio.group.AsyncSwitchingProfileGroup.create", false]], "create() (homematicip.group.switchingprofilegroup method)": [[2, "homematicip.group.SwitchingProfileGroup.create", false]], "creep_speed (homematicip.base.enums.drivespeed attribute)": [[4, "homematicip.base.enums.DriveSpeed.CREEP_SPEED", false]], "current_value (homematicip.base.enums.windvaluetype attribute)": [[4, "homematicip.base.enums.WindValueType.CURRENT_VALUE", false]], "currentapversion (homematicip.home.home attribute)": [[2, "homematicip.home.Home.currentAPVersion", false]], "currentillumination (homematicip.base.functionalchannels.lightsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.LightSensorChannel.currentIllumination", false]], "currentillumination (homematicip.device.lightsensor attribute)": [[2, "homematicip.device.LightSensor.currentIllumination", false]], "dali_gateway (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DALI_GATEWAY", false]], "daligateway (class in homematicip.device)": [[2, "homematicip.device.DaliGateway", false]], "day (homematicip.base.enums.weatherdaytime attribute)": [[4, "homematicip.base.enums.WeatherDayTime.DAY", false]], "deactivate_absence() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.deactivate_absence", false]], "deactivate_absence() (homematicip.home.home method)": [[2, "homematicip.home.Home.deactivate_absence", false]], "deactivate_vacation() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.deactivate_vacation", false]], "deactivate_vacation() (homematicip.home.home method)": [[2, "homematicip.home.Home.deactivate_vacation", false]], "dehumidifier_demand_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEHUMIDIFIER_DEMAND_CHANNEL", false]], "dehumidifierdemandchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DehumidifierDemandChannel", false]], "delayed_externally_armed (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.DELAYED_EXTERNALLY_ARMED", false]], "delayed_internally_armed (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.DELAYED_INTERNALLY_ARMED", false]], "delete() (homematicip.aio.device.asyncdevice method)": [[3, "homematicip.aio.device.AsyncDevice.delete", false]], "delete() (homematicip.aio.group.asyncgroup method)": [[3, "homematicip.aio.group.AsyncGroup.delete", false]], "delete() (homematicip.device.device method)": [[2, "homematicip.device.Device.delete", false]], "delete() (homematicip.group.group method)": [[2, "homematicip.group.Group.delete", false]], "delete_group() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.delete_group", false]], "delete_group() (homematicip.home.home method)": [[2, "homematicip.home.Home.delete_group", false]], "detect_encoding() (in module homematicip.base.helpers)": [[4, "homematicip.base.helpers.detect_encoding", false]], "device (class in homematicip.device)": [[2, "homematicip.device.Device", false]], "device (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DEVICE", false]], "device_added (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.DEVICE_ADDED", false]], "device_base (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_BASE", false]], "device_base_floor_heating (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_BASE_FLOOR_HEATING", false]], "device_changed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.DEVICE_CHANGED", false]], "device_channel_event (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.DEVICE_CHANNEL_EVENT", false]], "device_global_pump_control (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_GLOBAL_PUMP_CONTROL", false]], "device_incorrect_positioned (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_INCORRECT_POSITIONED", false]], "device_operationlock (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_OPERATIONLOCK", false]], "device_operationlock_with_sabotage (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_OPERATIONLOCK_WITH_SABOTAGE", false]], "device_permanent_full_rx (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_PERMANENT_FULL_RX", false]], "device_rechargeable_with_sabotage (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_RECHARGEABLE_WITH_SABOTAGE", false]], "device_removed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.DEVICE_REMOVED", false]], "device_sabotage (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DEVICE_SABOTAGE", false]], "devicearchetype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DeviceArchetype", false]], "devicebasechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceBaseChannel", false]], "devicebasefloorheatingchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceBaseFloorHeatingChannel", false]], "deviceglobalpumpcontrolchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceGlobalPumpControlChannel", false]], "deviceincorrectpositionedchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceIncorrectPositionedChannel", false]], "deviceoperationlockchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceOperationLockChannel", false]], "deviceoperationlockchannelwithsabotage (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceOperationLockChannelWithSabotage", false]], "devicepermanentfullrxchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DevicePermanentFullRxChannel", false]], "devicerechargeablewithsabotage (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceRechargeableWithSabotage", false]], "devices (homematicip.home.home attribute)": [[2, "homematicip.home.Home.devices", false]], "devicesabotagechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DeviceSabotageChannel", false]], "devicetype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DeviceType", false]], "deviceupdatestate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DeviceUpdateState", false]], "deviceupdatestrategy (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DeviceUpdateStrategy", false]], "dimmer (class in homematicip.device)": [[2, "homematicip.device.Dimmer", false]], "dimmer_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DIMMER_CHANNEL", false]], "dimmerchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DimmerChannel", false]], "din_rail_blind_4 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DIN_RAIL_BLIND_4", false]], "din_rail_dimmer_3 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DIN_RAIL_DIMMER_3", false]], "din_rail_switch (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DIN_RAIL_SWITCH", false]], "din_rail_switch_4 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DIN_RAIL_SWITCH_4", false]], "dinrailblind4 (class in homematicip.device)": [[2, "homematicip.device.DinRailBlind4", false]], "dinraildimmer3 (class in homematicip.device)": [[2, "homematicip.device.DinRailDimmer3", false]], "dinrailswitch (class in homematicip.device)": [[2, "homematicip.device.DinRailSwitch", false]], "dinrailswitch4 (class in homematicip.device)": [[2, "homematicip.device.DinRailSwitch4", false]], "disable() (homematicip.aio.rule.asyncsimplerule method)": [[3, "homematicip.aio.rule.AsyncSimpleRule.disable", false]], "disable() (homematicip.rule.simplerule method)": [[2, "homematicip.rule.SimpleRule.disable", false]], "disable_acoustic_signal (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.DISABLE_ACOUSTIC_SIGNAL", false]], "disable_events() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.disable_events", false]], "disable_events() (homematicip.home.home method)": [[2, "homematicip.home.Home.disable_events", false]], "disable_optical_signal (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.DISABLE_OPTICAL_SIGNAL", false]], "disarmed (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.DISARMED", false]], "done (homematicip.base.enums.apexchangestate attribute)": [[4, "homematicip.base.enums.ApExchangeState.DONE", false]], "door_bell_button (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DOOR_BELL_BUTTON", false]], "door_bell_contact_interface (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DOOR_BELL_CONTACT_INTERFACE", false]], "door_bell_sensor_event (homematicip.base.enums.channeleventtypes attribute)": [[4, "homematicip.base.enums.ChannelEventTypes.DOOR_BELL_SENSOR_EVENT", false]], "door_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DOOR_CHANNEL", false]], "door_lock_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DOOR_LOCK_CHANNEL", false]], "door_lock_drive (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DOOR_LOCK_DRIVE", false]], "door_lock_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.DOOR_LOCK_SENSOR", false]], "door_lock_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.DOOR_LOCK_SENSOR_CHANNEL", false]], "doorbellbutton (class in homematicip.device)": [[2, "homematicip.device.DoorBellButton", false]], "doorbellcontactinterface (class in homematicip.device)": [[2, "homematicip.device.DoorBellContactInterface", false]], "doorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DoorChannel", false]], "doorcommand (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DoorCommand", false]], "doorlockchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DoorLockChannel", false]], "doorlockdrive (class in homematicip.device)": [[2, "homematicip.device.DoorLockDrive", false]], "doorlocksensor (class in homematicip.device)": [[2, "homematicip.device.DoorLockSensor", false]], "doorlocksensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.DoorLockSensorChannel", false]], "doormodule (class in homematicip.device)": [[2, "homematicip.device.DoorModule", false]], "doorstate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DoorState", false]], "double_flashing_repeating (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.DOUBLE_FLASHING_REPEATING", false]], "download_configuration() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.download_configuration", false]], "download_configuration() (homematicip.home.home method)": [[2, "homematicip.home.Home.download_configuration", false]], "drivespeed (class in homematicip.base.enums)": [[4, "homematicip.base.enums.DriveSpeed", false]], "eco (homematicip.base.enums.climatecontrolmode attribute)": [[4, "homematicip.base.enums.ClimateControlMode.ECO", false]], "ecoduration (class in homematicip.base.enums)": [[4, "homematicip.base.enums.EcoDuration", false]], "enable() (homematicip.aio.rule.asyncsimplerule method)": [[3, "homematicip.aio.rule.AsyncSimpleRule.enable", false]], "enable() (homematicip.rule.simplerule method)": [[2, "homematicip.rule.SimpleRule.enable", false]], "enable_events() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.enable_events", false]], "enable_events() (homematicip.home.home method)": [[2, "homematicip.home.Home.enable_events", false]], "enabled (homematicip.group.heatingfailurealertrulegroup attribute)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup.enabled", false]], "enabled (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.enabled", false]], "energy (homematicip.base.enums.functionalhometype attribute)": [[4, "homematicip.base.enums.FunctionalHomeType.ENERGY", false]], "energy (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.ENERGY", false]], "energy_sensors_interface (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ENERGY_SENSORS_INTERFACE", false]], "energy_sensors_interface_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ENERGY_SENSORS_INTERFACE_CHANNEL", false]], "energygroup (class in homematicip.group)": [[2, "homematicip.group.EnergyGroup", false]], "energyhome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.EnergyHome", false]], "energysensorinterfacechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.EnergySensorInterfaceChannel", false]], "energysensorsinterface (class in homematicip.device)": [[2, "homematicip.device.EnergySensorsInterface", false]], "environment (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.ENVIRONMENT", false]], "environmentgroup (class in homematicip.group)": [[2, "homematicip.group.EnvironmentGroup", false]], "error (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.ERROR", false]], "error_position (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.ERROR_POSITION", false]], "event (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.EVENT", false]], "eventhook (class in homematicip.eventhook)": [[2, "homematicip.EventHook.EventHook", false]], "eventtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.EventType", false]], "extended_linked_garage_door (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.EXTENDED_LINKED_GARAGE_DOOR", false]], "extended_linked_shutter (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.EXTENDED_LINKED_SHUTTER", false]], "extended_linked_switching (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.EXTENDED_LINKED_SWITCHING", false]], "extendedlinkedgaragedoorgroup (class in homematicip.group)": [[2, "homematicip.group.ExtendedLinkedGarageDoorGroup", false]], "extendedlinkedshuttergroup (class in homematicip.group)": [[2, "homematicip.group.ExtendedLinkedShutterGroup", false]], "extendedlinkedswitchinggroup (class in homematicip.group)": [[2, "homematicip.group.ExtendedLinkedSwitchingGroup", false]], "external (homematicip.base.enums.connectiontype attribute)": [[4, "homematicip.base.enums.ConnectionType.EXTERNAL", false]], "external (homematicip.base.enums.devicearchetype attribute)": [[4, "homematicip.base.enums.DeviceArchetype.EXTERNAL", false]], "external (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.EXTERNAL", false]], "external_base_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.EXTERNAL_BASE_CHANNEL", false]], "external_triggered (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.EXTERNAL_TRIGGERED", false]], "external_universal_light_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.EXTERNAL_UNIVERSAL_LIGHT_CHANNEL", false]], "externalbasechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ExternalBaseChannel", false]], "externaldevice (class in homematicip.device)": [[2, "homematicip.device.ExternalDevice", false]], "externally_armed (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.EXTERNALLY_ARMED", false]], "externaltriggeredevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.ExternalTriggeredEvent", false]], "externaluniversallightchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ExternalUniversalLightChannel", false]], "fastcolorchangesupported (homematicip.device.rgbwdimmer attribute)": [[2, "homematicip.device.RgbwDimmer.fastColorChangeSupported", false]], "find_and_load_config_file() (in module homematicip)": [[2, "homematicip.find_and_load_config_file", false]], "fire() (homematicip.eventhook.eventhook method)": [[2, "homematicip.EventHook.EventHook.fire", false]], "fire_channel_event() (homematicip.base.functionalchannels.functionalchannel method)": [[4, "homematicip.base.functionalChannels.FunctionalChannel.fire_channel_event", false]], "fire_channel_event() (homematicip.home.home method)": [[2, "homematicip.home.Home.fire_channel_event", false]], "fire_create_event() (homematicip.home.home method)": [[2, "homematicip.home.Home.fire_create_event", false]], "flash_middle (homematicip.base.enums.opticalsignalbehaviour attribute)": [[4, "homematicip.base.enums.OpticalSignalBehaviour.FLASH_MIDDLE", false]], "flashing_both_repeating (homematicip.base.enums.opticalalarmsignal attribute)": [[4, "homematicip.base.enums.OpticalAlarmSignal.FLASHING_BOTH_REPEATING", false]], "flat_dect (homematicip.base.enums.accelerationsensormode attribute)": [[4, "homematicip.base.enums.AccelerationSensorMode.FLAT_DECT", false]], "floor_terminal_block_10 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FLOOR_TERMINAL_BLOCK_10", false]], "floor_terminal_block_12 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FLOOR_TERMINAL_BLOCK_12", false]], "floor_terminal_block_6 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FLOOR_TERMINAL_BLOCK_6", false]], "floor_terminal_block_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.FLOOR_TERMINAL_BLOCK_CHANNEL", false]], "floor_terminal_block_local_pump_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL", false]], "floor_terminal_block_mechanic_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL", false]], "floorteminalblockchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.FloorTeminalBlockChannel", false]], "floorterminalblock10 (class in homematicip.device)": [[2, "homematicip.device.FloorTerminalBlock10", false]], "floorterminalblock12 (class in homematicip.device)": [[2, "homematicip.device.FloorTerminalBlock12", false]], "floorterminalblock6 (class in homematicip.device)": [[2, "homematicip.device.FloorTerminalBlock6", false]], "floorterminalblocklocalpumpchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.FloorTerminalBlockLocalPumpChannel", false]], "floorterminalblockmechanicchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.FloorTerminalBlockMechanicChannel", false]], "foggy (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.FOGGY", false]], "four (homematicip.base.enums.ecoduration attribute)": [[4, "homematicip.base.enums.EcoDuration.FOUR", false]], "frequency_alternating_low_high (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_ALTERNATING_LOW_HIGH", false]], "frequency_alternating_low_mid_high (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_ALTERNATING_LOW_MID_HIGH", false]], "frequency_falling (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_FALLING", false]], "frequency_highon_longoff (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_HIGHON_LONGOFF", false]], "frequency_highon_off (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_HIGHON_OFF", false]], "frequency_lowon_longoff_highon_longoff (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_LOWON_LONGOFF_HIGHON_LONGOFF", false]], "frequency_lowon_off_highon_off (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_LOWON_OFF_HIGHON_OFF", false]], "frequency_rising (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_RISING", false]], "frequency_rising_and_falling (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.FREQUENCY_RISING_AND_FALLING", false]], "from_json() (homematicip.access_point_update_state.accesspointupdatestate method)": [[2, "homematicip.access_point_update_state.AccessPointUpdateState.from_json", false]], "from_json() (homematicip.aio.device.asyncroomcontroldeviceanalog method)": [[3, "homematicip.aio.device.AsyncRoomControlDeviceAnalog.from_json", false]], "from_json() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.accessauthorizationchannel method)": [[4, "homematicip.base.functionalChannels.AccessAuthorizationChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.accesscontrollerchannel method)": [[4, "homematicip.base.functionalChannels.AccessControllerChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.accesscontrollerwiredchannel method)": [[4, "homematicip.base.functionalChannels.AccessControllerWiredChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.analogoutputchannel method)": [[4, "homematicip.base.functionalChannels.AnalogOutputChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.analogroomcontrolchannel method)": [[4, "homematicip.base.functionalChannels.AnalogRoomControlChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.carbondioxidesensorchannel method)": [[4, "homematicip.base.functionalChannels.CarbonDioxideSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.climatesensorchannel method)": [[4, "homematicip.base.functionalChannels.ClimateSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.contactinterfacechannel method)": [[4, "homematicip.base.functionalChannels.ContactInterfaceChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.devicebasechannel method)": [[4, "homematicip.base.functionalChannels.DeviceBaseChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.devicebasefloorheatingchannel method)": [[4, "homematicip.base.functionalChannels.DeviceBaseFloorHeatingChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.deviceglobalpumpcontrolchannel method)": [[4, "homematicip.base.functionalChannels.DeviceGlobalPumpControlChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.deviceincorrectpositionedchannel method)": [[4, "homematicip.base.functionalChannels.DeviceIncorrectPositionedChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.deviceoperationlockchannel method)": [[4, "homematicip.base.functionalChannels.DeviceOperationLockChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.devicepermanentfullrxchannel method)": [[4, "homematicip.base.functionalChannels.DevicePermanentFullRxChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.devicerechargeablewithsabotage method)": [[4, "homematicip.base.functionalChannels.DeviceRechargeableWithSabotage.from_json", false]], "from_json() (homematicip.base.functionalchannels.devicesabotagechannel method)": [[4, "homematicip.base.functionalChannels.DeviceSabotageChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.dimmerchannel method)": [[4, "homematicip.base.functionalChannels.DimmerChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.doorchannel method)": [[4, "homematicip.base.functionalChannels.DoorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.doorlockchannel method)": [[4, "homematicip.base.functionalChannels.DoorLockChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.doorlocksensorchannel method)": [[4, "homematicip.base.functionalChannels.DoorLockSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.energysensorinterfacechannel method)": [[4, "homematicip.base.functionalChannels.EnergySensorInterfaceChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.externalbasechannel method)": [[4, "homematicip.base.functionalChannels.ExternalBaseChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.externaluniversallightchannel method)": [[4, "homematicip.base.functionalChannels.ExternalUniversalLightChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.floorterminalblocklocalpumpchannel method)": [[4, "homematicip.base.functionalChannels.FloorTerminalBlockLocalPumpChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.floorterminalblockmechanicchannel method)": [[4, "homematicip.base.functionalChannels.FloorTerminalBlockMechanicChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.functionalchannel method)": [[4, "homematicip.base.functionalChannels.FunctionalChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.heatingthermostatchannel method)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.impulseoutputchannel method)": [[4, "homematicip.base.functionalChannels.ImpulseOutputChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.internalswitchchannel method)": [[4, "homematicip.base.functionalChannels.InternalSwitchChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.lightsensorchannel method)": [[4, "homematicip.base.functionalChannels.LightSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.mainsfailurechannel method)": [[4, "homematicip.base.functionalChannels.MainsFailureChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.motiondetectionchannel method)": [[4, "homematicip.base.functionalChannels.MotionDetectionChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.multimodeinputblindchannel method)": [[4, "homematicip.base.functionalChannels.MultiModeInputBlindChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.multimodeinputchannel method)": [[4, "homematicip.base.functionalChannels.MultiModeInputChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.multimodeinputdimmerchannel method)": [[4, "homematicip.base.functionalChannels.MultiModeInputDimmerChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.multimodeinputswitchchannel method)": [[4, "homematicip.base.functionalChannels.MultiModeInputSwitchChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.opticalsignalchannel method)": [[4, "homematicip.base.functionalChannels.OpticalSignalChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.opticalsignalgroupchannel method)": [[4, "homematicip.base.functionalChannels.OpticalSignalGroupChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.passagedetectorchannel method)": [[4, "homematicip.base.functionalChannels.PassageDetectorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.presencedetectionchannel method)": [[4, "homematicip.base.functionalChannels.PresenceDetectionChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.raindetectionchannel method)": [[4, "homematicip.base.functionalChannels.RainDetectionChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.shutterchannel method)": [[4, "homematicip.base.functionalChannels.ShutterChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.shuttercontactchannel method)": [[4, "homematicip.base.functionalChannels.ShutterContactChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.singlekeychannel method)": [[4, "homematicip.base.functionalChannels.SingleKeyChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.smokedetectorchannel method)": [[4, "homematicip.base.functionalChannels.SmokeDetectorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.switchmeasuringchannel method)": [[4, "homematicip.base.functionalChannels.SwitchMeasuringChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.temperaturedifferencesensor2channel method)": [[4, "homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel.from_json", false]], "from_json() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.universalactuatorchannel method)": [[4, "homematicip.base.functionalChannels.UniversalActuatorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.universallightchannel method)": [[4, "homematicip.base.functionalChannels.UniversalLightChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.universallightchannelgroup method)": [[4, "homematicip.base.functionalChannels.UniversalLightChannelGroup.from_json", false]], "from_json() (homematicip.base.functionalchannels.wallmountedthermostatprochannel method)": [[4, "homematicip.base.functionalChannels.WallMountedThermostatProChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.wallmountedthermostatwithoutdisplaychannel method)": [[4, "homematicip.base.functionalChannels.WallMountedThermostatWithoutDisplayChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.weathersensorchannel method)": [[4, "homematicip.base.functionalChannels.WeatherSensorChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.weathersensorpluschannel method)": [[4, "homematicip.base.functionalChannels.WeatherSensorPlusChannel.from_json", false]], "from_json() (homematicip.base.functionalchannels.weathersensorprochannel method)": [[4, "homematicip.base.functionalChannels.WeatherSensorProChannel.from_json", false]], "from_json() (homematicip.client.client method)": [[2, "homematicip.client.Client.from_json", false]], "from_json() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.from_json", false]], "from_json() (homematicip.device.alarmsirenindoor method)": [[2, "homematicip.device.AlarmSirenIndoor.from_json", false]], "from_json() (homematicip.device.alarmsirenoutdoor method)": [[2, "homematicip.device.AlarmSirenOutdoor.from_json", false]], "from_json() (homematicip.device.basedevice method)": [[2, "homematicip.device.BaseDevice.from_json", false]], "from_json() (homematicip.device.blindmodule method)": [[2, "homematicip.device.BlindModule.from_json", false]], "from_json() (homematicip.device.contactinterface method)": [[2, "homematicip.device.ContactInterface.from_json", false]], "from_json() (homematicip.device.device method)": [[2, "homematicip.device.Device.from_json", false]], "from_json() (homematicip.device.dimmer method)": [[2, "homematicip.device.Dimmer.from_json", false]], "from_json() (homematicip.device.dinraildimmer3 method)": [[2, "homematicip.device.DinRailDimmer3.from_json", false]], "from_json() (homematicip.device.doorlockdrive method)": [[2, "homematicip.device.DoorLockDrive.from_json", false]], "from_json() (homematicip.device.doorlocksensor method)": [[2, "homematicip.device.DoorLockSensor.from_json", false]], "from_json() (homematicip.device.doormodule method)": [[2, "homematicip.device.DoorModule.from_json", false]], "from_json() (homematicip.device.externaldevice method)": [[2, "homematicip.device.ExternalDevice.from_json", false]], "from_json() (homematicip.device.floorterminalblock12 method)": [[2, "homematicip.device.FloorTerminalBlock12.from_json", false]], "from_json() (homematicip.device.floorterminalblock6 method)": [[2, "homematicip.device.FloorTerminalBlock6.from_json", false]], "from_json() (homematicip.device.fullflushblind method)": [[2, "homematicip.device.FullFlushBlind.from_json", false]], "from_json() (homematicip.device.fullflushcontactinterface method)": [[2, "homematicip.device.FullFlushContactInterface.from_json", false]], "from_json() (homematicip.device.fullflushinputswitch method)": [[2, "homematicip.device.FullFlushInputSwitch.from_json", false]], "from_json() (homematicip.device.fullflushshutter method)": [[2, "homematicip.device.FullFlushShutter.from_json", false]], "from_json() (homematicip.device.heatingthermostat method)": [[2, "homematicip.device.HeatingThermostat.from_json", false]], "from_json() (homematicip.device.heatingthermostatcompact method)": [[2, "homematicip.device.HeatingThermostatCompact.from_json", false]], "from_json() (homematicip.device.heatingthermostatevo method)": [[2, "homematicip.device.HeatingThermostatEvo.from_json", false]], "from_json() (homematicip.device.homecontrolaccesspoint method)": [[2, "homematicip.device.HomeControlAccessPoint.from_json", false]], "from_json() (homematicip.device.homecontrolunit method)": [[2, "homematicip.device.HomeControlUnit.from_json", false]], "from_json() (homematicip.device.lightsensor method)": [[2, "homematicip.device.LightSensor.from_json", false]], "from_json() (homematicip.device.motiondetectorindoor method)": [[2, "homematicip.device.MotionDetectorIndoor.from_json", false]], "from_json() (homematicip.device.motiondetectoroutdoor method)": [[2, "homematicip.device.MotionDetectorOutdoor.from_json", false]], "from_json() (homematicip.device.motiondetectorpushbutton method)": [[2, "homematicip.device.MotionDetectorPushButton.from_json", false]], "from_json() (homematicip.device.multiiobox method)": [[2, "homematicip.device.MultiIOBox.from_json", false]], "from_json() (homematicip.device.operationlockabledevice method)": [[2, "homematicip.device.OperationLockableDevice.from_json", false]], "from_json() (homematicip.device.passagedetector method)": [[2, "homematicip.device.PassageDetector.from_json", false]], "from_json() (homematicip.device.pluggablemainsfailuresurveillance method)": [[2, "homematicip.device.PluggableMainsFailureSurveillance.from_json", false]], "from_json() (homematicip.device.presencedetectorindoor method)": [[2, "homematicip.device.PresenceDetectorIndoor.from_json", false]], "from_json() (homematicip.device.rainsensor method)": [[2, "homematicip.device.RainSensor.from_json", false]], "from_json() (homematicip.device.rgbwdimmer method)": [[2, "homematicip.device.RgbwDimmer.from_json", false]], "from_json() (homematicip.device.roomcontroldeviceanalog method)": [[2, "homematicip.device.RoomControlDeviceAnalog.from_json", false]], "from_json() (homematicip.device.rotaryhandlesensor method)": [[2, "homematicip.device.RotaryHandleSensor.from_json", false]], "from_json() (homematicip.device.sabotagedevice method)": [[2, "homematicip.device.SabotageDevice.from_json", false]], "from_json() (homematicip.device.shuttercontact method)": [[2, "homematicip.device.ShutterContact.from_json", false]], "from_json() (homematicip.device.shuttercontactmagnetic method)": [[2, "homematicip.device.ShutterContactMagnetic.from_json", false]], "from_json() (homematicip.device.smokedetector method)": [[2, "homematicip.device.SmokeDetector.from_json", false]], "from_json() (homematicip.device.switch method)": [[2, "homematicip.device.Switch.from_json", false]], "from_json() (homematicip.device.switchmeasuring method)": [[2, "homematicip.device.SwitchMeasuring.from_json", false]], "from_json() (homematicip.device.temperaturedifferencesensor2 method)": [[2, "homematicip.device.TemperatureDifferenceSensor2.from_json", false]], "from_json() (homematicip.device.temperaturehumiditysensordisplay method)": [[2, "homematicip.device.TemperatureHumiditySensorDisplay.from_json", false]], "from_json() (homematicip.device.temperaturehumiditysensoroutdoor method)": [[2, "homematicip.device.TemperatureHumiditySensorOutdoor.from_json", false]], "from_json() (homematicip.device.temperaturehumiditysensorwithoutdisplay method)": [[2, "homematicip.device.TemperatureHumiditySensorWithoutDisplay.from_json", false]], "from_json() (homematicip.device.tiltvibrationsensor method)": [[2, "homematicip.device.TiltVibrationSensor.from_json", false]], "from_json() (homematicip.device.wallmountedgaragedoorcontroller method)": [[2, "homematicip.device.WallMountedGarageDoorController.from_json", false]], "from_json() (homematicip.device.wallmountedthermostatpro method)": [[2, "homematicip.device.WallMountedThermostatPro.from_json", false]], "from_json() (homematicip.device.watersensor method)": [[2, "homematicip.device.WaterSensor.from_json", false]], "from_json() (homematicip.device.weathersensor method)": [[2, "homematicip.device.WeatherSensor.from_json", false]], "from_json() (homematicip.device.weathersensorplus method)": [[2, "homematicip.device.WeatherSensorPlus.from_json", false]], "from_json() (homematicip.device.weathersensorpro method)": [[2, "homematicip.device.WeatherSensorPro.from_json", false]], "from_json() (homematicip.device.wireddinrailaccesspoint method)": [[2, "homematicip.device.WiredDinRailAccessPoint.from_json", false]], "from_json() (homematicip.functionalhomes.accesscontrolhome method)": [[2, "homematicip.functionalHomes.AccessControlHome.from_json", false]], "from_json() (homematicip.functionalhomes.functionalhome method)": [[2, "homematicip.functionalHomes.FunctionalHome.from_json", false]], "from_json() (homematicip.functionalhomes.indoorclimatehome method)": [[2, "homematicip.functionalHomes.IndoorClimateHome.from_json", false]], "from_json() (homematicip.functionalhomes.lightandshadowhome method)": [[2, "homematicip.functionalHomes.LightAndShadowHome.from_json", false]], "from_json() (homematicip.functionalhomes.securityandalarmhome method)": [[2, "homematicip.functionalHomes.SecurityAndAlarmHome.from_json", false]], "from_json() (homematicip.group.accessauthorizationprofilegroup method)": [[2, "homematicip.group.AccessAuthorizationProfileGroup.from_json", false]], "from_json() (homematicip.group.accesscontrolgroup method)": [[2, "homematicip.group.AccessControlGroup.from_json", false]], "from_json() (homematicip.group.alarmswitchinggroup method)": [[2, "homematicip.group.AlarmSwitchingGroup.from_json", false]], "from_json() (homematicip.group.environmentgroup method)": [[2, "homematicip.group.EnvironmentGroup.from_json", false]], "from_json() (homematicip.group.extendedlinkedgaragedoorgroup method)": [[2, "homematicip.group.ExtendedLinkedGarageDoorGroup.from_json", false]], "from_json() (homematicip.group.extendedlinkedshuttergroup method)": [[2, "homematicip.group.ExtendedLinkedShutterGroup.from_json", false]], "from_json() (homematicip.group.extendedlinkedswitchinggroup method)": [[2, "homematicip.group.ExtendedLinkedSwitchingGroup.from_json", false]], "from_json() (homematicip.group.group method)": [[2, "homematicip.group.Group.from_json", false]], "from_json() (homematicip.group.heatingchangeovergroup method)": [[2, "homematicip.group.HeatingChangeoverGroup.from_json", false]], "from_json() (homematicip.group.heatingcoolingdemandboilergroup method)": [[2, "homematicip.group.HeatingCoolingDemandBoilerGroup.from_json", false]], "from_json() (homematicip.group.heatingcoolingdemandgroup method)": [[2, "homematicip.group.HeatingCoolingDemandGroup.from_json", false]], "from_json() (homematicip.group.heatingcoolingdemandpumpgroup method)": [[2, "homematicip.group.HeatingCoolingDemandPumpGroup.from_json", false]], "from_json() (homematicip.group.heatingcoolingperiod method)": [[2, "homematicip.group.HeatingCoolingPeriod.from_json", false]], "from_json() (homematicip.group.heatingcoolingprofile method)": [[2, "homematicip.group.HeatingCoolingProfile.from_json", false]], "from_json() (homematicip.group.heatingcoolingprofileday method)": [[2, "homematicip.group.HeatingCoolingProfileDay.from_json", false]], "from_json() (homematicip.group.heatingdehumidifiergroup method)": [[2, "homematicip.group.HeatingDehumidifierGroup.from_json", false]], "from_json() (homematicip.group.heatingfailurealertrulegroup method)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup.from_json", false]], "from_json() (homematicip.group.heatinggroup method)": [[2, "homematicip.group.HeatingGroup.from_json", false]], "from_json() (homematicip.group.hotwatergroup method)": [[2, "homematicip.group.HotWaterGroup.from_json", false]], "from_json() (homematicip.group.humiditywarningrulegroup method)": [[2, "homematicip.group.HumidityWarningRuleGroup.from_json", false]], "from_json() (homematicip.group.indoorclimategroup method)": [[2, "homematicip.group.IndoorClimateGroup.from_json", false]], "from_json() (homematicip.group.lockoutprotectionrule method)": [[2, "homematicip.group.LockOutProtectionRule.from_json", false]], "from_json() (homematicip.group.metagroup method)": [[2, "homematicip.group.MetaGroup.from_json", false]], "from_json() (homematicip.group.overheatprotectionrule method)": [[2, "homematicip.group.OverHeatProtectionRule.from_json", false]], "from_json() (homematicip.group.securitygroup method)": [[2, "homematicip.group.SecurityGroup.from_json", false]], "from_json() (homematicip.group.securityzonegroup method)": [[2, "homematicip.group.SecurityZoneGroup.from_json", false]], "from_json() (homematicip.group.shutterprofile method)": [[2, "homematicip.group.ShutterProfile.from_json", false]], "from_json() (homematicip.group.shutterwindprotectionrule method)": [[2, "homematicip.group.ShutterWindProtectionRule.from_json", false]], "from_json() (homematicip.group.smokealarmdetectionrule method)": [[2, "homematicip.group.SmokeAlarmDetectionRule.from_json", false]], "from_json() (homematicip.group.switchgroupbase method)": [[2, "homematicip.group.SwitchGroupBase.from_json", false]], "from_json() (homematicip.group.switchinggroup method)": [[2, "homematicip.group.SwitchingGroup.from_json", false]], "from_json() (homematicip.group.switchingprofilegroup method)": [[2, "homematicip.group.SwitchingProfileGroup.from_json", false]], "from_json() (homematicip.group.timeprofileperiod method)": [[2, "homematicip.group.TimeProfilePeriod.from_json", false]], "from_json() (homematicip.home.home method)": [[2, "homematicip.home.Home.from_json", false]], "from_json() (homematicip.location.location method)": [[2, "homematicip.location.Location.from_json", false]], "from_json() (homematicip.oauth_otk.oauthotk method)": [[2, "homematicip.oauth_otk.OAuthOTK.from_json", false]], "from_json() (homematicip.rule.rule method)": [[2, "homematicip.rule.Rule.from_json", false]], "from_json() (homematicip.rule.simplerule method)": [[2, "homematicip.rule.SimpleRule.from_json", false]], "from_json() (homematicip.securityevent.securityevent method)": [[2, "homematicip.securityEvent.SecurityEvent.from_json", false]], "from_json() (homematicip.securityevent.securityzoneevent method)": [[2, "homematicip.securityEvent.SecurityZoneEvent.from_json", false]], "from_json() (homematicip.weather.weather method)": [[2, "homematicip.weather.Weather.from_json", false]], "from_str() (homematicip.base.enums.autonameenum class method)": [[4, "homematicip.base.enums.AutoNameEnum.from_str", false]], "full_alarm (homematicip.base.enums.alarmsignaltype attribute)": [[4, "homematicip.base.enums.AlarmSignalType.FULL_ALARM", false]], "full_flush_blind (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_BLIND", false]], "full_flush_contact_interface (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_CONTACT_INTERFACE", false]], "full_flush_contact_interface_6 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_CONTACT_INTERFACE_6", false]], "full_flush_dimmer (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_DIMMER", false]], "full_flush_input_switch (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_INPUT_SWITCH", false]], "full_flush_shutter (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_SHUTTER", false]], "full_flush_switch_measuring (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.FULL_FLUSH_SWITCH_MEASURING", false]], "full_url() (homematicip.aio.connection.asyncconnection method)": [[3, "homematicip.aio.connection.AsyncConnection.full_url", false]], "fullflushblind (class in homematicip.device)": [[2, "homematicip.device.FullFlushBlind", false]], "fullflushcontactinterface (class in homematicip.device)": [[2, "homematicip.device.FullFlushContactInterface", false]], "fullflushcontactinterface6 (class in homematicip.device)": [[2, "homematicip.device.FullFlushContactInterface6", false]], "fullflushdimmer (class in homematicip.device)": [[2, "homematicip.device.FullFlushDimmer", false]], "fullflushinputswitch (class in homematicip.device)": [[2, "homematicip.device.FullFlushInputSwitch", false]], "fullflushshutter (class in homematicip.device)": [[2, "homematicip.device.FullFlushShutter", false]], "fullflushswitchmeasuring (class in homematicip.device)": [[2, "homematicip.device.FullFlushSwitchMeasuring", false]], "functional_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.FUNCTIONAL_CHANNEL", false]], "functionalchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.FunctionalChannel", false]], "functionalchanneltype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.FunctionalChannelType", false]], "functionalhome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.FunctionalHome", false]], "functionalhomes (homematicip.home.home attribute)": [[2, "homematicip.home.Home.functionalHomes", false]], "functionalhometype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.FunctionalHomeType", false]], "garagedoormoduletormatic (class in homematicip.device)": [[2, "homematicip.device.GarageDoorModuleTormatic", false]], "generic_input_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.GENERIC_INPUT_CHANNEL", false]], "genericinputchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.GenericInputChannel", false]], "get_config_file_locations() (in module homematicip)": [[2, "homematicip.get_config_file_locations", false]], "get_current_state() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.get_current_state", false]], "get_current_state() (homematicip.home.home method)": [[2, "homematicip.home.Home.get_current_state", false]], "get_details() (homematicip.group.heatingcoolingprofile method)": [[2, "homematicip.group.HeatingCoolingProfile.get_details", false]], "get_details() (homematicip.group.timeprofile method)": [[2, "homematicip.group.TimeProfile.get_details", false]], "get_functional_channel() (in module homematicip.base.helpers)": [[4, "homematicip.base.helpers.get_functional_channel", false]], "get_functional_channels() (in module homematicip.base.helpers)": [[4, "homematicip.base.helpers.get_functional_channels", false]], "get_functionalhome() (homematicip.home.home method)": [[2, "homematicip.home.Home.get_functionalHome", false]], "get_oauth_otk() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.get_OAuth_OTK", false]], "get_oauth_otk() (homematicip.home.home method)": [[2, "homematicip.home.Home.get_OAuth_OTK", false]], "get_security_journal() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.get_security_journal", false]], "get_security_journal() (homematicip.home.home method)": [[2, "homematicip.home.Home.get_security_journal", false]], "get_security_zones_activation() (homematicip.home.home method)": [[2, "homematicip.home.Home.get_security_zones_activation", false]], "get_simple_rule() (homematicip.aio.rule.asyncsimplerule method)": [[3, "homematicip.aio.rule.AsyncSimpleRule.get_simple_rule", false]], "get_simple_rule() (homematicip.rule.simplerule method)": [[2, "homematicip.rule.SimpleRule.get_simple_rule", false]], "greater_lower_lesser_upper_threshold (homematicip.base.enums.humidityvalidationtype attribute)": [[4, "homematicip.base.enums.HumidityValidationType.GREATER_LOWER_LESSER_UPPER_THRESHOLD", false]], "greater_upper_threshold (homematicip.base.enums.humidityvalidationtype attribute)": [[4, "homematicip.base.enums.HumidityValidationType.GREATER_UPPER_THRESHOLD", false]], "green (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.GREEN", false]], "group (class in homematicip.group)": [[2, "homematicip.group.Group", false]], "group (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.GROUP", false]], "group_added (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.GROUP_ADDED", false]], "group_changed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.GROUP_CHANGED", false]], "group_removed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.GROUP_REMOVED", false]], "groups (homematicip.home.home attribute)": [[2, "homematicip.home.Home.groups", false]], "grouptype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.GroupType", false]], "groupvisibility (class in homematicip.base.enums)": [[4, "homematicip.base.enums.GroupVisibility", false]], "handle_config() (in module homematicip.base.helpers)": [[4, "homematicip.base.helpers.handle_config", false]], "heat_demand_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.HEAT_DEMAND_CHANNEL", false]], "heatdemandchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.HeatDemandChannel", false]], "heating (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING", false]], "heating_changeover (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_CHANGEOVER", false]], "heating_cooling_demand (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_COOLING_DEMAND", false]], "heating_cooling_demand_boiler (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_COOLING_DEMAND_BOILER", false]], "heating_cooling_demand_pump (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_COOLING_DEMAND_PUMP", false]], "heating_dehumidifier (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_DEHUMIDIFIER", false]], "heating_external_clock (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_EXTERNAL_CLOCK", false]], "heating_failure_alarm (homematicip.base.enums.heatingfailurevalidationtype attribute)": [[4, "homematicip.base.enums.HeatingFailureValidationType.HEATING_FAILURE_ALARM", false]], "heating_failure_alert_rule_group (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_FAILURE_ALERT_RULE_GROUP", false]], "heating_failure_warning (homematicip.base.enums.heatingfailurevalidationtype attribute)": [[4, "homematicip.base.enums.HeatingFailureValidationType.HEATING_FAILURE_WARNING", false]], "heating_humidity_limiter (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_HUMIDITY_LIMITER", false]], "heating_switch_2 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HEATING_SWITCH_2", false]], "heating_temperature_limiter (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HEATING_TEMPERATURE_LIMITER", false]], "heating_thermostat (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HEATING_THERMOSTAT", false]], "heating_thermostat_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.HEATING_THERMOSTAT_CHANNEL", false]], "heating_thermostat_compact (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HEATING_THERMOSTAT_COMPACT", false]], "heating_thermostat_compact_plus (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HEATING_THERMOSTAT_COMPACT_PLUS", false]], "heating_thermostat_evo (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HEATING_THERMOSTAT_EVO", false]], "heatingchangeovergroup (class in homematicip.group)": [[2, "homematicip.group.HeatingChangeoverGroup", false]], "heatingcoolingdemandboilergroup (class in homematicip.group)": [[2, "homematicip.group.HeatingCoolingDemandBoilerGroup", false]], "heatingcoolingdemandgroup (class in homematicip.group)": [[2, "homematicip.group.HeatingCoolingDemandGroup", false]], "heatingcoolingdemandpumpgroup (class in homematicip.group)": [[2, "homematicip.group.HeatingCoolingDemandPumpGroup", false]], "heatingcoolingperiod (class in homematicip.group)": [[2, "homematicip.group.HeatingCoolingPeriod", false]], "heatingcoolingprofile (class in homematicip.group)": [[2, "homematicip.group.HeatingCoolingProfile", false]], "heatingcoolingprofileday (class in homematicip.group)": [[2, "homematicip.group.HeatingCoolingProfileDay", false]], "heatingdehumidifiergroup (class in homematicip.group)": [[2, "homematicip.group.HeatingDehumidifierGroup", false]], "heatingexternalclockgroup (class in homematicip.group)": [[2, "homematicip.group.HeatingExternalClockGroup", false]], "heatingfailurealertrulegroup (class in homematicip.group)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup", false]], "heatingfailurevalidationresult (homematicip.group.heatingfailurealertrulegroup attribute)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup.heatingFailureValidationResult", false]], "heatingfailurevalidationtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.HeatingFailureValidationType", false]], "heatinggroup (class in homematicip.group)": [[2, "homematicip.group.HeatingGroup", false]], "heatinghumidylimitergroup (class in homematicip.group)": [[2, "homematicip.group.HeatingHumidyLimiterGroup", false]], "heatingloadtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.HeatingLoadType", false]], "heatingswitch2 (class in homematicip.device)": [[2, "homematicip.device.HeatingSwitch2", false]], "heatingtemperaturelimitergroup (class in homematicip.group)": [[2, "homematicip.group.HeatingTemperatureLimiterGroup", false]], "heatingthermostat (class in homematicip.device)": [[2, "homematicip.device.HeatingThermostat", false]], "heatingthermostatchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel", false]], "heatingthermostatcompact (class in homematicip.device)": [[2, "homematicip.device.HeatingThermostatCompact", false]], "heatingthermostatevo (class in homematicip.device)": [[2, "homematicip.device.HeatingThermostatEvo", false]], "heatingvalvetype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.HeatingValveType", false]], "heavily_cloudy (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY", false]], "heavily_cloudy_with_rain (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY_WITH_RAIN", false]], "heavily_cloudy_with_rain_and_thunder (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY_WITH_RAIN_AND_THUNDER", false]], "heavily_cloudy_with_snow (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY_WITH_SNOW", false]], "heavily_cloudy_with_snow_rain (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY_WITH_SNOW_RAIN", false]], "heavily_cloudy_with_strong_rain (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY_WITH_STRONG_RAIN", false]], "heavily_cloudy_with_thunder (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.HEAVILY_CLOUDY_WITH_THUNDER", false]], "highestillumination (homematicip.base.functionalchannels.lightsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.LightSensorChannel.highestIllumination", false]], "highestillumination (homematicip.device.lightsensor attribute)": [[2, "homematicip.device.LightSensor.highestIllumination", false]], "hmip (homematicip.base.enums.devicearchetype attribute)": [[4, "homematicip.base.enums.DeviceArchetype.HMIP", false]], "hmip_lan (homematicip.base.enums.connectiontype attribute)": [[4, "homematicip.base.enums.ConnectionType.HMIP_LAN", false]], "hmip_rf (homematicip.base.enums.connectiontype attribute)": [[4, "homematicip.base.enums.ConnectionType.HMIP_RF", false]], "hmip_wired (homematicip.base.enums.connectiontype attribute)": [[4, "homematicip.base.enums.ConnectionType.HMIP_WIRED", false]], "hmip_wlan (homematicip.base.enums.connectiontype attribute)": [[4, "homematicip.base.enums.ConnectionType.HMIP_WLAN", false]], "hmipconfig (class in homematicip)": [[2, "homematicip.HmipConfig", false]], "hmipconnectionerror": [[4, "homematicip.base.base_connection.HmipConnectionError", false]], "hmipservercloseerror": [[4, "homematicip.base.base_connection.HmipServerCloseError", false]], "hmipthrottlingerror": [[4, "homematicip.base.base_connection.HmipThrottlingError", false]], "hmipwronghttpstatuserror": [[4, "homematicip.base.base_connection.HmipWrongHttpStatusError", false]], "hoermann_drives_module (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HOERMANN_DRIVES_MODULE", false]], "hoermanndrivesmodule (class in homematicip.device)": [[2, "homematicip.device.HoermannDrivesModule", false]], "home (class in homematicip.home)": [[2, "homematicip.home.Home", false]], "home_changed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.HOME_CHANGED", false]], "home_control_access_point (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.HOME_CONTROL_ACCESS_POINT", false]], "homecontrolaccesspoint (class in homematicip.device)": [[2, "homematicip.device.HomeControlAccessPoint", false]], "homecontrolunit (class in homematicip.device)": [[2, "homematicip.device.HomeControlUnit", false]], "homeid (homematicip.client.client attribute)": [[2, "homematicip.client.Client.homeId", false]], "homematicip": [[2, "module-homematicip", false]], "homematicip.access_point_update_state": [[2, "module-homematicip.access_point_update_state", false]], "homematicip.aio": [[3, "module-homematicip.aio", false]], "homematicip.aio.auth": [[3, "module-homematicip.aio.auth", false]], "homematicip.aio.class_maps": [[3, "module-homematicip.aio.class_maps", false]], "homematicip.aio.connection": [[3, "module-homematicip.aio.connection", false]], "homematicip.aio.device": [[3, "module-homematicip.aio.device", false]], "homematicip.aio.group": [[3, "module-homematicip.aio.group", false]], "homematicip.aio.home": [[3, "module-homematicip.aio.home", false]], "homematicip.aio.rule": [[3, "module-homematicip.aio.rule", false]], "homematicip.aio.securityevent": [[3, "module-homematicip.aio.securityEvent", false]], "homematicip.auth": [[2, "module-homematicip.auth", false]], "homematicip.base": [[4, "module-homematicip.base", false]], "homematicip.base.base_connection": [[4, "module-homematicip.base.base_connection", false]], "homematicip.base.constants": [[4, "module-homematicip.base.constants", false]], "homematicip.base.enums": [[4, "module-homematicip.base.enums", false]], "homematicip.base.functionalchannels": [[4, "module-homematicip.base.functionalChannels", false]], "homematicip.base.helpers": [[4, "module-homematicip.base.helpers", false]], "homematicip.class_maps": [[2, "module-homematicip.class_maps", false]], "homematicip.client": [[2, "module-homematicip.client", false]], "homematicip.connection": [[2, "module-homematicip.connection", false]], "homematicip.device": [[2, "module-homematicip.device", false]], "homematicip.eventhook": [[2, "module-homematicip.EventHook", false]], "homematicip.functionalhomes": [[2, "module-homematicip.functionalHomes", false]], "homematicip.group": [[2, "module-homematicip.group", false]], "homematicip.home": [[2, "module-homematicip.home", false]], "homematicip.homematicipobject": [[2, "module-homematicip.HomeMaticIPObject", false]], "homematicip.location": [[2, "module-homematicip.location", false]], "homematicip.oauth_otk": [[2, "module-homematicip.oauth_otk", false]], "homematicip.rule": [[2, "module-homematicip.rule", false]], "homematicip.securityevent": [[2, "module-homematicip.securityEvent", false]], "homematicip.weather": [[2, "module-homematicip.weather", false]], "homeupdatestate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.HomeUpdateState", false]], "horizontal (homematicip.base.enums.accelerationsensorneutralposition attribute)": [[4, "homematicip.base.enums.AccelerationSensorNeutralPosition.HORIZONTAL", false]], "hot_water (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HOT_WATER", false]], "hotwatergroup (class in homematicip.group)": [[2, "homematicip.group.HotWaterGroup", false]], "humidity (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.humidity", false]], "humidity_warning_rule_group (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.HUMIDITY_WARNING_RULE_GROUP", false]], "humiditylowerthreshold (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.humidityLowerThreshold", false]], "humidityupperthreshold (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.humidityUpperThreshold", false]], "humidityvalidationresult (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.humidityValidationResult", false]], "humidityvalidationtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.HumidityValidationType", false]], "humiditywarningrulegroup (class in homematicip.group)": [[2, "homematicip.group.HumidityWarningRuleGroup", false]], "id (homematicip.client.client attribute)": [[2, "homematicip.client.Client.id", false]], "id (homematicip.home.home attribute)": [[2, "homematicip.home.Home.id", false]], "idle_off (homematicip.base.enums.smokedetectoralarmtype attribute)": [[4, "homematicip.base.enums.SmokeDetectorAlarmType.IDLE_OFF", false]], "impulse_output_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.IMPULSE_OUTPUT_CHANNEL", false]], "impulseoutputchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ImpulseOutputChannel", false]], "in_progress (homematicip.base.enums.apexchangestate attribute)": [[4, "homematicip.base.enums.ApExchangeState.IN_PROGRESS", false]], "inbox (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.INBOX", false]], "inboxgroup (class in homematicip.group)": [[2, "homematicip.group.InboxGroup", false]], "indoor_climate (homematicip.base.enums.functionalhometype attribute)": [[4, "homematicip.base.enums.FunctionalHomeType.INDOOR_CLIMATE", false]], "indoor_climate (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.INDOOR_CLIMATE", false]], "indoorclimategroup (class in homematicip.group)": [[2, "homematicip.group.IndoorClimateGroup", false]], "indoorclimatehome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.IndoorClimateHome", false]], "init() (homematicip.aio.auth.asyncauth method)": [[3, "homematicip.aio.auth.AsyncAuth.init", false]], "init() (homematicip.aio.connection.asyncconnection method)": [[3, "homematicip.aio.connection.AsyncConnection.init", false]], "init() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.init", false]], "init() (homematicip.base.base_connection.baseconnection method)": [[4, "homematicip.base.base_connection.BaseConnection.init", false]], "init() (homematicip.connection.connection method)": [[2, "homematicip.connection.Connection.init", false]], "init() (homematicip.home.home method)": [[2, "homematicip.home.Home.init", false]], "internal_switch_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.INTERNAL_SWITCH_CHANNEL", false]], "internally_armed (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.INTERNALLY_ARMED", false]], "internalswitchchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.InternalSwitchChannel", false]], "intrusion_alarm (homematicip.base.enums.smokedetectoralarmtype attribute)": [[4, "homematicip.base.enums.SmokeDetectorAlarmType.INTRUSION_ALARM", false]], "invisible_control (homematicip.base.enums.groupvisibility attribute)": [[4, "homematicip.base.enums.GroupVisibility.INVISIBLE_CONTROL", false]], "invisible_group_and_control (homematicip.base.enums.groupvisibility attribute)": [[4, "homematicip.base.enums.GroupVisibility.INVISIBLE_GROUP_AND_CONTROL", false]], "is_update_applicable() (homematicip.aio.device.asyncdevice method)": [[3, "homematicip.aio.device.AsyncDevice.is_update_applicable", false]], "is_update_applicable() (homematicip.device.device method)": [[2, "homematicip.device.Device.is_update_applicable", false]], "isrequestacknowledged() (homematicip.aio.auth.asyncauth method)": [[3, "homematicip.aio.auth.AsyncAuth.isRequestAcknowledged", false]], "isrequestacknowledged() (homematicip.auth.auth method)": [[2, "homematicip.auth.Auth.isRequestAcknowledged", false]], "key_behavior (homematicip.base.enums.multimodeinputmode attribute)": [[4, "homematicip.base.enums.MultiModeInputMode.KEY_BEHAVIOR", false]], "key_remote_control_4 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.KEY_REMOTE_CONTROL_4", false]], "key_remote_control_alarm (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.KEY_REMOTE_CONTROL_ALARM", false]], "keyremotecontrol4 (class in homematicip.device)": [[2, "homematicip.device.KeyRemoteControl4", false]], "keyremotecontrolalarm (class in homematicip.device)": [[2, "homematicip.device.KeyRemoteControlAlarm", false]], "label (homematicip.client.client attribute)": [[2, "homematicip.client.Client.label", false]], "lastexecutiontimestamp (homematicip.group.heatingfailurealertrulegroup attribute)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup.lastExecutionTimestamp", false]], "lastexecutiontimestamp (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.lastExecutionTimestamp", false]], "laststatusupdate (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.lastStatusUpdate", false]], "latitude (homematicip.location.location attribute)": [[2, "homematicip.location.Location.latitude", false]], "left (homematicip.base.enums.passagedirection attribute)": [[4, "homematicip.base.enums.PassageDirection.LEFT", false]], "left (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.LEFT", false]], "lesser_lower_threshold (homematicip.base.enums.humidityvalidationtype attribute)": [[4, "homematicip.base.enums.HumidityValidationType.LESSER_LOWER_THRESHOLD", false]], "light_and_shadow (homematicip.base.enums.functionalhometype attribute)": [[4, "homematicip.base.enums.FunctionalHomeType.LIGHT_AND_SHADOW", false]], "light_cloudy (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.LIGHT_CLOUDY", false]], "light_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.LIGHT_SENSOR", false]], "light_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.LIGHT_SENSOR_CHANNEL", false]], "lightandshadowhome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.LightAndShadowHome", false]], "lightsensor (class in homematicip.device)": [[2, "homematicip.device.LightSensor", false]], "lightsensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.LightSensorChannel", false]], "linked_switching (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.LINKED_SWITCHING", false]], "linkedswitchinggroup (class in homematicip.group)": [[2, "homematicip.group.LinkedSwitchingGroup", false]], "live_update_not_supported (homematicip.base.enums.liveupdatestate attribute)": [[4, "homematicip.base.enums.LiveUpdateState.LIVE_UPDATE_NOT_SUPPORTED", false]], "liveupdatestate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.LiveUpdateState", false]], "load_balancing (homematicip.base.enums.heatingloadtype attribute)": [[4, "homematicip.base.enums.HeatingLoadType.LOAD_BALANCING", false]], "load_collection (homematicip.base.enums.heatingloadtype attribute)": [[4, "homematicip.base.enums.HeatingLoadType.LOAD_COLLECTION", false]], "load_config_file() (in module homematicip)": [[2, "homematicip.load_config_file", false]], "load_functionalchannels() (homematicip.device.basedevice method)": [[2, "homematicip.device.BaseDevice.load_functionalChannels", false]], "location (class in homematicip.location)": [[2, "homematicip.location.Location", false]], "location (homematicip.home.home attribute)": [[2, "homematicip.home.Home.location", false]], "lock_out_protection_rule (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.LOCK_OUT_PROTECTION_RULE", false]], "locked (homematicip.base.enums.lockstate attribute)": [[4, "homematicip.base.enums.LockState.LOCKED", false]], "lockoutprotectionrule (class in homematicip.group)": [[2, "homematicip.group.LockOutProtectionRule", false]], "lockstate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.LockState", false]], "log_file (homematicip.hmipconfig attribute)": [[2, "homematicip.HmipConfig.log_file", false]], "log_level (homematicip.hmipconfig attribute)": [[2, "homematicip.HmipConfig.log_level", false]], "longitude (homematicip.location.location attribute)": [[2, "homematicip.location.Location.longitude", false]], "low_battery (homematicip.base.enums.acousticalarmsignal attribute)": [[4, "homematicip.base.enums.AcousticAlarmSignal.LOW_BATTERY", false]], "lowestillumination (homematicip.base.functionalchannels.lightsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.LightSensorChannel.lowestIllumination", false]], "lowestillumination (homematicip.device.lightsensor attribute)": [[2, "homematicip.device.LightSensor.lowestIllumination", false]], "mains_failure_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.MAINS_FAILURE_CHANNEL", false]], "mains_failure_event (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.MAINS_FAILURE_EVENT", false]], "mainsfailurechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.MainsFailureChannel", false]], "mainsfailureevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.MainsFailureEvent", false]], "manual (homematicip.base.enums.climatecontrolmode attribute)": [[4, "homematicip.base.enums.ClimateControlMode.MANUAL", false]], "manual (homematicip.base.enums.profilemode attribute)": [[4, "homematicip.base.enums.ProfileMode.MANUAL", false]], "manually (homematicip.base.enums.deviceupdatestrategy attribute)": [[4, "homematicip.base.enums.DeviceUpdateStrategy.MANUALLY", false]], "max_value (homematicip.base.enums.windvaluetype attribute)": [[4, "homematicip.base.enums.WindValueType.MAX_VALUE", false]], "maxtemperature (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.maxTemperature", false]], "metagroup (class in homematicip.group)": [[2, "homematicip.group.MetaGroup", false]], "min_value (homematicip.base.enums.windvaluetype attribute)": [[4, "homematicip.base.enums.WindValueType.MIN_VALUE", false]], "mintemperature (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.minTemperature", false]], "mixed (homematicip.base.enums.shadingstatetype attribute)": [[4, "homematicip.base.enums.ShadingStateType.MIXED", false]], "module": [[2, "module-homematicip", false], [2, "module-homematicip.EventHook", false], [2, "module-homematicip.HomeMaticIPObject", false], [2, "module-homematicip.access_point_update_state", false], [2, "module-homematicip.auth", false], [2, "module-homematicip.class_maps", false], [2, "module-homematicip.client", false], [2, "module-homematicip.connection", false], [2, "module-homematicip.device", false], [2, "module-homematicip.functionalHomes", false], [2, "module-homematicip.group", false], [2, "module-homematicip.home", false], [2, "module-homematicip.location", false], [2, "module-homematicip.oauth_otk", false], [2, "module-homematicip.rule", false], [2, "module-homematicip.securityEvent", false], [2, "module-homematicip.weather", false], [3, "module-homematicip.aio", false], [3, "module-homematicip.aio.auth", false], [3, "module-homematicip.aio.class_maps", false], [3, "module-homematicip.aio.connection", false], [3, "module-homematicip.aio.device", false], [3, "module-homematicip.aio.group", false], [3, "module-homematicip.aio.home", false], [3, "module-homematicip.aio.rule", false], [3, "module-homematicip.aio.securityEvent", false], [4, "module-homematicip.base", false], [4, "module-homematicip.base.base_connection", false], [4, "module-homematicip.base.constants", false], [4, "module-homematicip.base.enums", false], [4, "module-homematicip.base.functionalChannels", false], [4, "module-homematicip.base.helpers", false]], "moisture_detection (homematicip.base.enums.wateralarmtrigger attribute)": [[4, "homematicip.base.enums.WaterAlarmTrigger.MOISTURE_DETECTION", false]], "moisture_detection_event (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.MOISTURE_DETECTION_EVENT", false]], "moisturedetectionevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.MoistureDetectionEvent", false]], "motion_detection_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.MOTION_DETECTION_CHANNEL", false]], "motion_detector_indoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.MOTION_DETECTOR_INDOOR", false]], "motion_detector_outdoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.MOTION_DETECTOR_OUTDOOR", false]], "motion_detector_push_button (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.MOTION_DETECTOR_PUSH_BUTTON", false]], "motiondetectionchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.MotionDetectionChannel", false]], "motiondetectionsendinterval (class in homematicip.base.enums)": [[4, "homematicip.base.enums.MotionDetectionSendInterval", false]], "motiondetectorindoor (class in homematicip.device)": [[2, "homematicip.device.MotionDetectorIndoor", false]], "motiondetectoroutdoor (class in homematicip.device)": [[2, "homematicip.device.MotionDetectorOutdoor", false]], "motiondetectorpushbutton (class in homematicip.device)": [[2, "homematicip.device.MotionDetectorPushButton", false]], "motorstate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.MotorState", false]], "multi_io_box (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.MULTI_IO_BOX", false]], "multi_mode_input_blind_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.MULTI_MODE_INPUT_BLIND_CHANNEL", false]], "multi_mode_input_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.MULTI_MODE_INPUT_CHANNEL", false]], "multi_mode_input_dimmer_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.MULTI_MODE_INPUT_DIMMER_CHANNEL", false]], "multi_mode_input_switch_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.MULTI_MODE_INPUT_SWITCH_CHANNEL", false]], "multiiobox (class in homematicip.device)": [[2, "homematicip.device.MultiIOBox", false]], "multimodeinputblindchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.MultiModeInputBlindChannel", false]], "multimodeinputchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.MultiModeInputChannel", false]], "multimodeinputdimmerchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.MultiModeInputDimmerChannel", false]], "multimodeinputmode (class in homematicip.base.enums)": [[4, "homematicip.base.enums.MultiModeInputMode", false]], "multimodeinputswitchchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.MultiModeInputSwitchChannel", false]], "night (homematicip.base.enums.weatherdaytime attribute)": [[4, "homematicip.base.enums.WeatherDayTime.NIGHT", false]], "no_alarm (homematicip.base.enums.alarmsignaltype attribute)": [[4, "homematicip.base.enums.AlarmSignalType.NO_ALARM", false]], "no_alarm (homematicip.base.enums.wateralarmtrigger attribute)": [[4, "homematicip.base.enums.WaterAlarmTrigger.NO_ALARM", false]], "no_heating_failure (homematicip.base.enums.heatingfailurevalidationtype attribute)": [[4, "homematicip.base.enums.HeatingFailureValidationType.NO_HEATING_FAILURE", false]], "nominal_speed (homematicip.base.enums.drivespeed attribute)": [[4, "homematicip.base.enums.DriveSpeed.NOMINAL_SPEED", false]], "none (homematicip.base.enums.apexchangestate attribute)": [[4, "homematicip.base.enums.ApExchangeState.NONE", false]], "none (homematicip.base.enums.lockstate attribute)": [[4, "homematicip.base.enums.LockState.NONE", false]], "normally_close (homematicip.base.enums.binarybehaviortype attribute)": [[4, "homematicip.base.enums.BinaryBehaviorType.NORMALLY_CLOSE", false]], "normally_close (homematicip.base.enums.contacttype attribute)": [[4, "homematicip.base.enums.ContactType.NORMALLY_CLOSE", false]], "normally_close (homematicip.base.enums.heatingvalvetype attribute)": [[4, "homematicip.base.enums.HeatingValveType.NORMALLY_CLOSE", false]], "normally_open (homematicip.base.enums.binarybehaviortype attribute)": [[4, "homematicip.base.enums.BinaryBehaviorType.NORMALLY_OPEN", false]], "normally_open (homematicip.base.enums.contacttype attribute)": [[4, "homematicip.base.enums.ContactType.NORMALLY_OPEN", false]], "normally_open (homematicip.base.enums.heatingvalvetype attribute)": [[4, "homematicip.base.enums.HeatingValveType.NORMALLY_OPEN", false]], "not_absent (homematicip.base.enums.absencetype attribute)": [[4, "homematicip.base.enums.AbsenceType.NOT_ABSENT", false]], "not_existent (homematicip.base.enums.shadingstatetype attribute)": [[4, "homematicip.base.enums.ShadingStateType.NOT_EXISTENT", false]], "not_possible (homematicip.base.enums.shadingstatetype attribute)": [[4, "homematicip.base.enums.ShadingStateType.NOT_POSSIBLE", false]], "not_used (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.NOT_USED", false]], "not_used (homematicip.base.enums.shadingstatetype attribute)": [[4, "homematicip.base.enums.ShadingStateType.NOT_USED", false]], "notification_light_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.NOTIFICATION_LIGHT_CHANNEL", false]], "notificationlightchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel", false]], "notificationsoundtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.NotificationSoundType", false]], "notificationsoundtypehightolow (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.notificationSoundTypeHighToLow", false]], "notificationsoundtypehightolow (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.notificationSoundTypeHighToLow", false]], "notificationsoundtypelowtohigh (homematicip.base.functionalchannels.accelerationsensorchannel attribute)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.notificationSoundTypeLowToHigh", false]], "notificationsoundtypelowtohigh (homematicip.device.accelerationsensor attribute)": [[2, "homematicip.device.AccelerationSensor.notificationSoundTypeLowToHigh", false]], "oauthotk (class in homematicip.oauth_otk)": [[2, "homematicip.oauth_otk.OAuthOTK", false]], "off (homematicip.base.enums.opticalsignalbehaviour attribute)": [[4, "homematicip.base.enums.OpticalSignalBehaviour.OFF", false]], "offline_alarm (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.OFFLINE_ALARM", false]], "offline_water_detection_event (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.OFFLINE_WATER_DETECTION_EVENT", false]], "offlinealarmevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.OfflineAlarmEvent", false]], "offlinewaterdetectionevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.OfflineWaterDetectionEvent", false]], "on (homematicip.base.enums.opticalsignalbehaviour attribute)": [[4, "homematicip.base.enums.OpticalSignalBehaviour.ON", false]], "on (homematicip.base.functionalchannels.notificationlightchannel attribute)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.on", false]], "on_channel_event() (homematicip.home.home method)": [[2, "homematicip.home.Home.on_channel_event", false]], "on_create() (homematicip.home.home method)": [[2, "homematicip.home.Home.on_create", false]], "once_per_minute (homematicip.base.enums.acousticalarmtiming attribute)": [[4, "homematicip.base.enums.AcousticAlarmTiming.ONCE_PER_MINUTE", false]], "one (homematicip.base.enums.ecoduration attribute)": [[4, "homematicip.base.enums.EcoDuration.ONE", false]], "open (homematicip.base.enums.doorcommand attribute)": [[4, "homematicip.base.enums.DoorCommand.OPEN", false]], "open (homematicip.base.enums.doorstate attribute)": [[4, "homematicip.base.enums.DoorState.OPEN", false]], "open (homematicip.base.enums.lockstate attribute)": [[4, "homematicip.base.enums.LockState.OPEN", false]], "open (homematicip.base.enums.windowstate attribute)": [[4, "homematicip.base.enums.WindowState.OPEN", false]], "open_collector_8_module (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.OPEN_COLLECTOR_8_MODULE", false]], "opencollector8module (class in homematicip.device)": [[2, "homematicip.device.OpenCollector8Module", false]], "opening (homematicip.base.enums.motorstate attribute)": [[4, "homematicip.base.enums.MotorState.OPENING", false]], "operationlockabledevice (class in homematicip.device)": [[2, "homematicip.device.OperationLockableDevice", false]], "optical_signal_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.OPTICAL_SIGNAL_CHANNEL", false]], "optical_signal_group_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.OPTICAL_SIGNAL_GROUP_CHANNEL", false]], "opticalalarmsignal (class in homematicip.base.enums)": [[4, "homematicip.base.enums.OpticalAlarmSignal", false]], "opticalsignalbehaviour (class in homematicip.base.enums)": [[4, "homematicip.base.enums.OpticalSignalBehaviour", false]], "opticalsignalchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.OpticalSignalChannel", false]], "opticalsignalgroupchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.OpticalSignalGroupChannel", false]], "optional_speed (homematicip.base.enums.drivespeed attribute)": [[4, "homematicip.base.enums.DriveSpeed.OPTIONAL_SPEED", false]], "outdoorclimatesensor (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.outdoorClimateSensor", false]], "over_heat_protection_rule (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.OVER_HEAT_PROTECTION_RULE", false]], "overheatprotectionrule (class in homematicip.group)": [[2, "homematicip.group.OverHeatProtectionRule", false]], "partial_open (homematicip.base.enums.doorcommand attribute)": [[4, "homematicip.base.enums.DoorCommand.PARTIAL_OPEN", false]], "party (homematicip.base.enums.absencetype attribute)": [[4, "homematicip.base.enums.AbsenceType.PARTY", false]], "passage_detector (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PASSAGE_DETECTOR", false]], "passage_detector_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.PASSAGE_DETECTOR_CHANNEL", false]], "passagedetector (class in homematicip.device)": [[2, "homematicip.device.PassageDetector", false]], "passagedetectorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.PassageDetectorChannel", false]], "passagedirection (class in homematicip.base.enums)": [[4, "homematicip.base.enums.PassageDirection", false]], "passive_glass_breakage_detector (homematicip.base.enums.alarmcontacttype attribute)": [[4, "homematicip.base.enums.AlarmContactType.PASSIVE_GLASS_BREAKAGE_DETECTOR", false]], "perform_update_sent (homematicip.base.enums.homeupdatestate attribute)": [[4, "homematicip.base.enums.HomeUpdateState.PERFORM_UPDATE_SENT", false]], "performing_update (homematicip.base.enums.homeupdatestate attribute)": [[4, "homematicip.base.enums.HomeUpdateState.PERFORMING_UPDATE", false]], "period (homematicip.base.enums.absencetype attribute)": [[4, "homematicip.base.enums.AbsenceType.PERIOD", false]], "permanent (homematicip.base.enums.absencetype attribute)": [[4, "homematicip.base.enums.AbsenceType.PERMANENT", false]], "permanent (homematicip.base.enums.acousticalarmtiming attribute)": [[4, "homematicip.base.enums.AcousticAlarmTiming.PERMANENT", false]], "permanent (homematicip.base.enums.ecoduration attribute)": [[4, "homematicip.base.enums.EcoDuration.PERMANENT", false]], "pinassigned (homematicip.home.home attribute)": [[2, "homematicip.home.Home.pinAssigned", false]], "ping_loop (homematicip.aio.connection.asyncconnection attribute)": [[3, "homematicip.aio.connection.AsyncConnection.ping_loop", false]], "ping_timeout (homematicip.aio.connection.asyncconnection attribute)": [[3, "homematicip.aio.connection.AsyncConnection.ping_timeout", false]], "plugable_switch (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PLUGABLE_SWITCH", false]], "plugable_switch_measuring (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PLUGABLE_SWITCH_MEASURING", false]], "plugableswitch (class in homematicip.device)": [[2, "homematicip.device.PlugableSwitch", false]], "plugableswitchmeasuring (class in homematicip.device)": [[2, "homematicip.device.PlugableSwitchMeasuring", false]], "pluggable_dimmer (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PLUGGABLE_DIMMER", false]], "pluggable_mains_failure_surveillance (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PLUGGABLE_MAINS_FAILURE_SURVEILLANCE", false]], "pluggabledimmer (class in homematicip.device)": [[2, "homematicip.device.PluggableDimmer", false]], "pluggablemainsfailuresurveillance (class in homematicip.device)": [[2, "homematicip.device.PluggableMainsFailureSurveillance", false]], "position_unknown (homematicip.base.enums.doorstate attribute)": [[4, "homematicip.base.enums.DoorState.POSITION_UNKNOWN", false]], "position_used (homematicip.base.enums.shadingstatetype attribute)": [[4, "homematicip.base.enums.ShadingStateType.POSITION_USED", false]], "presence_detection_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.PRESENCE_DETECTION_CHANNEL", false]], "presence_detector_indoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PRESENCE_DETECTOR_INDOOR", false]], "presencedetectionchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.PresenceDetectionChannel", false]], "presencedetectorindoor (class in homematicip.device)": [[2, "homematicip.device.PresenceDetectorIndoor", false]], "primary_alarm (homematicip.base.enums.smokedetectoralarmtype attribute)": [[4, "homematicip.base.enums.SmokeDetectorAlarmType.PRIMARY_ALARM", false]], "printed_circuit_board_switch_2 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PRINTED_CIRCUIT_BOARD_SWITCH_2", false]], "printed_circuit_board_switch_battery (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PRINTED_CIRCUIT_BOARD_SWITCH_BATTERY", false]], "printedcircuitboardswitch2 (class in homematicip.device)": [[2, "homematicip.device.PrintedCircuitBoardSwitch2", false]], "printedcircuitboardswitchbattery (class in homematicip.device)": [[2, "homematicip.device.PrintedCircuitBoardSwitchBattery", false]], "profilemode (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ProfileMode", false]], "purple (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.PURPLE", false]], "push_button (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PUSH_BUTTON", false]], "push_button_6 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PUSH_BUTTON_6", false]], "push_button_flat (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.PUSH_BUTTON_FLAT", false]], "pushbutton (class in homematicip.device)": [[2, "homematicip.device.PushButton", false]], "pushbutton6 (class in homematicip.device)": [[2, "homematicip.device.PushButton6", false]], "pushbuttonflat (class in homematicip.device)": [[2, "homematicip.device.PushButtonFlat", false]], "rain_detection_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.RAIN_DETECTION_CHANNEL", false]], "rain_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.RAIN_SENSOR", false]], "raindetectionchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.RainDetectionChannel", false]], "raining (homematicip.base.functionalchannels.raindetectionchannel attribute)": [[4, "homematicip.base.functionalChannels.RainDetectionChannel.raining", false]], "raining (homematicip.device.rainsensor attribute)": [[2, "homematicip.device.RainSensor.raining", false]], "rainsensor (class in homematicip.device)": [[2, "homematicip.device.RainSensor", false]], "rainsensorsensitivity (homematicip.base.functionalchannels.raindetectionchannel attribute)": [[4, "homematicip.base.functionalChannels.RainDetectionChannel.rainSensorSensitivity", false]], "rainsensorsensitivity (homematicip.device.rainsensor attribute)": [[2, "homematicip.device.RainSensor.rainSensorSensitivity", false]], "raw_config (homematicip.hmipconfig attribute)": [[2, "homematicip.HmipConfig.raw_config", false]], "red (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.RED", false]], "rejected (homematicip.base.enums.apexchangestate attribute)": [[4, "homematicip.base.enums.ApExchangeState.REJECTED", false]], "remote_control_8 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.REMOTE_CONTROL_8", false]], "remote_control_8_module (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.REMOTE_CONTROL_8_MODULE", false]], "remotecontrol8 (class in homematicip.device)": [[2, "homematicip.device.RemoteControl8", false]], "remotecontrol8module (class in homematicip.device)": [[2, "homematicip.device.RemoteControl8Module", false]], "remove_callback() (homematicip.home.home method)": [[2, "homematicip.home.Home.remove_callback", false]], "remove_channel_event_handler() (homematicip.home.home method)": [[2, "homematicip.home.Home.remove_channel_event_handler", false]], "requestauthtoken() (homematicip.aio.auth.asyncauth method)": [[3, "homematicip.aio.auth.AsyncAuth.requestAuthToken", false]], "requestauthtoken() (homematicip.auth.auth method)": [[2, "homematicip.auth.Auth.requestAuthToken", false]], "requested (homematicip.base.enums.apexchangestate attribute)": [[4, "homematicip.base.enums.ApExchangeState.REQUESTED", false]], "reset_energy_counter (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.RESET_ENERGY_COUNTER", false]], "reset_energy_counter() (homematicip.aio.device.asyncswitchmeasuring method)": [[3, "homematicip.aio.device.AsyncSwitchMeasuring.reset_energy_counter", false]], "reset_energy_counter() (homematicip.base.functionalchannels.switchmeasuringchannel method)": [[4, "homematicip.base.functionalChannels.SwitchMeasuringChannel.reset_energy_counter", false]], "reset_energy_counter() (homematicip.device.switchmeasuring method)": [[2, "homematicip.device.SwitchMeasuring.reset_energy_counter", false]], "rgbcolorstate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.RGBColorState", false]], "rgbw_dimmer (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.RGBW_DIMMER", false]], "rgbwdimmer (class in homematicip.device)": [[2, "homematicip.device.RgbwDimmer", false]], "right (homematicip.base.enums.passagedirection attribute)": [[4, "homematicip.base.enums.PassageDirection.RIGHT", false]], "right (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.RIGHT", false]], "room_control_device (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ROOM_CONTROL_DEVICE", false]], "room_control_device_analog (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ROOM_CONTROL_DEVICE_ANALOG", false]], "roomcontroldevice (class in homematicip.device)": [[2, "homematicip.device.RoomControlDevice", false]], "roomcontroldeviceanalog (class in homematicip.device)": [[2, "homematicip.device.RoomControlDeviceAnalog", false]], "rotary_handle_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.ROTARY_HANDLE_CHANNEL", false]], "rotary_handle_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.ROTARY_HANDLE_SENSOR", false]], "rotaryhandlechannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.RotaryHandleChannel", false]], "rotaryhandlesensor (class in homematicip.device)": [[2, "homematicip.device.RotaryHandleSensor", false]], "rule (class in homematicip.rule)": [[2, "homematicip.rule.Rule", false]], "rules (homematicip.home.home attribute)": [[2, "homematicip.home.Home.rules", false]], "run_to_start (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.RUN_TO_START", false]], "sabotage (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.SABOTAGE", false]], "sabotagedevice (class in homematicip.device)": [[2, "homematicip.device.SabotageDevice", false]], "sabotageevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.SabotageEvent", false]], "search_channel() (homematicip.home.home method)": [[2, "homematicip.home.Home.search_channel", false]], "search_client_by_id() (homematicip.home.home method)": [[2, "homematicip.home.Home.search_client_by_id", false]], "search_device_by_id() (homematicip.home.home method)": [[2, "homematicip.home.Home.search_device_by_id", false]], "search_group_by_id() (homematicip.home.home method)": [[2, "homematicip.home.Home.search_group_by_id", false]], "search_rule_by_id() (homematicip.home.home method)": [[2, "homematicip.home.Home.search_rule_by_id", false]], "secondary_alarm (homematicip.base.enums.smokedetectoralarmtype attribute)": [[4, "homematicip.base.enums.SmokeDetectorAlarmType.SECONDARY_ALARM", false]], "seconds_120 (homematicip.base.enums.motiondetectionsendinterval attribute)": [[4, "homematicip.base.enums.MotionDetectionSendInterval.SECONDS_120", false]], "seconds_240 (homematicip.base.enums.motiondetectionsendinterval attribute)": [[4, "homematicip.base.enums.MotionDetectionSendInterval.SECONDS_240", false]], "seconds_30 (homematicip.base.enums.motiondetectionsendinterval attribute)": [[4, "homematicip.base.enums.MotionDetectionSendInterval.SECONDS_30", false]], "seconds_480 (homematicip.base.enums.motiondetectionsendinterval attribute)": [[4, "homematicip.base.enums.MotionDetectionSendInterval.SECONDS_480", false]], "seconds_60 (homematicip.base.enums.motiondetectionsendinterval attribute)": [[4, "homematicip.base.enums.MotionDetectionSendInterval.SECONDS_60", false]], "security (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SECURITY", false]], "security_and_alarm (homematicip.base.enums.functionalhometype attribute)": [[4, "homematicip.base.enums.FunctionalHomeType.SECURITY_AND_ALARM", false]], "security_backup_alarm_switching (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SECURITY_BACKUP_ALARM_SWITCHING", false]], "security_journal_changed (homematicip.base.enums.eventtype attribute)": [[4, "homematicip.base.enums.EventType.SECURITY_JOURNAL_CHANGED", false]], "security_zone (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SECURITY_ZONE", false]], "securityandalarmhome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.SecurityAndAlarmHome", false]], "securityevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.SecurityEvent", false]], "securityeventtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.SecurityEventType", false]], "securitygroup (class in homematicip.group)": [[2, "homematicip.group.SecurityGroup", false]], "securityzoneactivationmode (class in homematicip.base.enums)": [[4, "homematicip.base.enums.SecurityZoneActivationMode", false]], "securityzoneevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.SecurityZoneEvent", false]], "securityzonegroup (class in homematicip.group)": [[2, "homematicip.group.SecurityZoneGroup", false]], "send_door_command (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SEND_DOOR_COMMAND", false]], "send_door_command() (homematicip.aio.device.asyncdoormodule method)": [[3, "homematicip.aio.device.AsyncDoorModule.send_door_command", false]], "send_door_command() (homematicip.base.functionalchannels.doorchannel method)": [[4, "homematicip.base.functionalChannels.DoorChannel.send_door_command", false]], "send_door_command() (homematicip.device.doormodule method)": [[2, "homematicip.device.DoorModule.send_door_command", false]], "send_start_impulse() (homematicip.aio.device.asyncwallmountedgaragedoorcontroller method)": [[3, "homematicip.aio.device.AsyncWallMountedGarageDoorController.send_start_impulse", false]], "send_start_impulse() (homematicip.base.functionalchannels.impulseoutputchannel method)": [[4, "homematicip.base.functionalChannels.ImpulseOutputChannel.send_start_impulse", false]], "send_start_impulse() (homematicip.device.wallmountedgaragedoorcontroller method)": [[2, "homematicip.device.WallMountedGarageDoorController.send_start_impulse", false]], "sensor_event (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.SENSOR_EVENT", false]], "sensor_range_16g (homematicip.base.enums.accelerationsensorsensitivity attribute)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity.SENSOR_RANGE_16G", false]], "sensor_range_2g (homematicip.base.enums.accelerationsensorsensitivity attribute)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity.SENSOR_RANGE_2G", false]], "sensor_range_2g_2plus_sense (homematicip.base.enums.accelerationsensorsensitivity attribute)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity.SENSOR_RANGE_2G_2PLUS_SENSE", false]], "sensor_range_2g_plus_sens (homematicip.base.enums.accelerationsensorsensitivity attribute)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity.SENSOR_RANGE_2G_PLUS_SENS", false]], "sensor_range_4g (homematicip.base.enums.accelerationsensorsensitivity attribute)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity.SENSOR_RANGE_4G", false]], "sensor_range_8g (homematicip.base.enums.accelerationsensorsensitivity attribute)": [[4, "homematicip.base.enums.AccelerationSensorSensitivity.SENSOR_RANGE_8G", false]], "sensorevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.SensorEvent", false]], "set_acceleration_sensor_event_filter_period() (homematicip.aio.device.asyncaccelerationsensor method)": [[3, "homematicip.aio.device.AsyncAccelerationSensor.set_acceleration_sensor_event_filter_period", false]], "set_acceleration_sensor_event_filter_period() (homematicip.aio.device.asynctiltvibrationsensor method)": [[3, "homematicip.aio.device.AsyncTiltVibrationSensor.set_acceleration_sensor_event_filter_period", false]], "set_acceleration_sensor_event_filter_period() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.set_acceleration_sensor_event_filter_period", false]], "set_acceleration_sensor_event_filter_period() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.set_acceleration_sensor_event_filter_period", false]], "set_acceleration_sensor_event_filter_period() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.set_acceleration_sensor_event_filter_period", false]], "set_acceleration_sensor_event_filter_period() (homematicip.device.tiltvibrationsensor method)": [[2, "homematicip.device.TiltVibrationSensor.set_acceleration_sensor_event_filter_period", false]], "set_acceleration_sensor_mode() (homematicip.aio.device.asyncaccelerationsensor method)": [[3, "homematicip.aio.device.AsyncAccelerationSensor.set_acceleration_sensor_mode", false]], "set_acceleration_sensor_mode() (homematicip.aio.device.asynctiltvibrationsensor method)": [[3, "homematicip.aio.device.AsyncTiltVibrationSensor.set_acceleration_sensor_mode", false]], "set_acceleration_sensor_mode() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.set_acceleration_sensor_mode", false]], "set_acceleration_sensor_mode() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.set_acceleration_sensor_mode", false]], "set_acceleration_sensor_mode() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.set_acceleration_sensor_mode", false]], "set_acceleration_sensor_mode() (homematicip.device.tiltvibrationsensor method)": [[2, "homematicip.device.TiltVibrationSensor.set_acceleration_sensor_mode", false]], "set_acceleration_sensor_neutral_position() (homematicip.aio.device.asyncaccelerationsensor method)": [[3, "homematicip.aio.device.AsyncAccelerationSensor.set_acceleration_sensor_neutral_position", false]], "set_acceleration_sensor_neutral_position() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.set_acceleration_sensor_neutral_position", false]], "set_acceleration_sensor_neutral_position() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.set_acceleration_sensor_neutral_position", false]], "set_acceleration_sensor_sensitivity() (homematicip.aio.device.asyncaccelerationsensor method)": [[3, "homematicip.aio.device.AsyncAccelerationSensor.set_acceleration_sensor_sensitivity", false]], "set_acceleration_sensor_sensitivity() (homematicip.aio.device.asynctiltvibrationsensor method)": [[3, "homematicip.aio.device.AsyncTiltVibrationSensor.set_acceleration_sensor_sensitivity", false]], "set_acceleration_sensor_sensitivity() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.set_acceleration_sensor_sensitivity", false]], "set_acceleration_sensor_sensitivity() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.set_acceleration_sensor_sensitivity", false]], "set_acceleration_sensor_sensitivity() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.set_acceleration_sensor_sensitivity", false]], "set_acceleration_sensor_sensitivity() (homematicip.device.tiltvibrationsensor method)": [[2, "homematicip.device.TiltVibrationSensor.set_acceleration_sensor_sensitivity", false]], "set_acceleration_sensor_trigger_angle() (homematicip.aio.device.asyncaccelerationsensor method)": [[3, "homematicip.aio.device.AsyncAccelerationSensor.set_acceleration_sensor_trigger_angle", false]], "set_acceleration_sensor_trigger_angle() (homematicip.aio.device.asynctiltvibrationsensor method)": [[3, "homematicip.aio.device.AsyncTiltVibrationSensor.set_acceleration_sensor_trigger_angle", false]], "set_acceleration_sensor_trigger_angle() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.set_acceleration_sensor_trigger_angle", false]], "set_acceleration_sensor_trigger_angle() (homematicip.base.functionalchannels.tiltvibrationsensorchannel method)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel.set_acceleration_sensor_trigger_angle", false]], "set_acceleration_sensor_trigger_angle() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.set_acceleration_sensor_trigger_angle", false]], "set_acceleration_sensor_trigger_angle() (homematicip.device.tiltvibrationsensor method)": [[2, "homematicip.device.TiltVibrationSensor.set_acceleration_sensor_trigger_angle", false]], "set_acoustic_alarm_signal() (homematicip.aio.device.asyncwatersensor method)": [[3, "homematicip.aio.device.AsyncWaterSensor.set_acoustic_alarm_signal", false]], "set_acoustic_alarm_signal() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.set_acoustic_alarm_signal", false]], "set_acoustic_alarm_signal() (homematicip.device.watersensor method)": [[2, "homematicip.device.WaterSensor.set_acoustic_alarm_signal", false]], "set_acoustic_alarm_timing() (homematicip.aio.device.asyncwatersensor method)": [[3, "homematicip.aio.device.AsyncWaterSensor.set_acoustic_alarm_timing", false]], "set_acoustic_alarm_timing() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.set_acoustic_alarm_timing", false]], "set_acoustic_alarm_timing() (homematicip.device.watersensor method)": [[2, "homematicip.device.WaterSensor.set_acoustic_alarm_timing", false]], "set_acoustic_water_alarm_trigger() (homematicip.aio.device.asyncwatersensor method)": [[3, "homematicip.aio.device.AsyncWaterSensor.set_acoustic_water_alarm_trigger", false]], "set_acoustic_water_alarm_trigger() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.set_acoustic_water_alarm_trigger", false]], "set_acoustic_water_alarm_trigger() (homematicip.device.watersensor method)": [[2, "homematicip.device.WaterSensor.set_acoustic_water_alarm_trigger", false]], "set_active_profile() (homematicip.aio.group.asyncheatinggroup method)": [[3, "homematicip.aio.group.AsyncHeatingGroup.set_active_profile", false]], "set_active_profile() (homematicip.group.heatinggroup method)": [[2, "homematicip.group.HeatingGroup.set_active_profile", false]], "set_auth_token() (homematicip.base.base_connection.baseconnection method)": [[4, "homematicip.base.base_connection.BaseConnection.set_auth_token", false]], "set_auth_token() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_auth_token", false]], "set_boost() (homematicip.aio.group.asyncheatinggroup method)": [[3, "homematicip.aio.group.AsyncHeatingGroup.set_boost", false]], "set_boost() (homematicip.group.heatinggroup method)": [[2, "homematicip.group.HeatingGroup.set_boost", false]], "set_boost_duration() (homematicip.aio.group.asyncheatinggroup method)": [[3, "homematicip.aio.group.AsyncHeatingGroup.set_boost_duration", false]], "set_boost_duration() (homematicip.group.heatinggroup method)": [[2, "homematicip.group.HeatingGroup.set_boost_duration", false]], "set_control_mode() (homematicip.aio.group.asyncheatinggroup method)": [[3, "homematicip.aio.group.AsyncHeatingGroup.set_control_mode", false]], "set_control_mode() (homematicip.group.heatinggroup method)": [[2, "homematicip.group.HeatingGroup.set_control_mode", false]], "set_cooling() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_cooling", false]], "set_cooling() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_cooling", false]], "set_dim_level (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SET_DIM_LEVEL", false]], "set_dim_level() (homematicip.aio.device.asyncdimmer method)": [[3, "homematicip.aio.device.AsyncDimmer.set_dim_level", false]], "set_dim_level() (homematicip.aio.device.asyncwiredpushbutton method)": [[3, "homematicip.aio.device.AsyncWiredPushButton.set_dim_level", false]], "set_dim_level() (homematicip.base.functionalchannels.dimmerchannel method)": [[4, "homematicip.base.functionalChannels.DimmerChannel.set_dim_level", false]], "set_dim_level() (homematicip.device.dimmer method)": [[2, "homematicip.device.Dimmer.set_dim_level", false]], "set_dim_level() (homematicip.device.wiredpushbutton method)": [[2, "homematicip.device.WiredPushButton.set_dim_level", false]], "set_display() (homematicip.aio.device.asynctemperaturehumiditysensordisplay method)": [[3, "homematicip.aio.device.AsyncTemperatureHumiditySensorDisplay.set_display", false]], "set_display() (homematicip.base.functionalchannels.wallmountedthermostatprochannel method)": [[4, "homematicip.base.functionalChannels.WallMountedThermostatProChannel.set_display", false]], "set_display() (homematicip.device.temperaturehumiditysensordisplay method)": [[2, "homematicip.device.TemperatureHumiditySensorDisplay.set_display", false]], "set_group_channels() (homematicip.aio.group.asyncswitchingprofilegroup method)": [[3, "homematicip.aio.group.AsyncSwitchingProfileGroup.set_group_channels", false]], "set_group_channels() (homematicip.group.switchingprofilegroup method)": [[2, "homematicip.group.SwitchingProfileGroup.set_group_channels", false]], "set_inapp_water_alarm_trigger() (homematicip.aio.device.asyncwatersensor method)": [[3, "homematicip.aio.device.AsyncWaterSensor.set_inapp_water_alarm_trigger", false]], "set_inapp_water_alarm_trigger() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.set_inapp_water_alarm_trigger", false]], "set_inapp_water_alarm_trigger() (homematicip.device.watersensor method)": [[2, "homematicip.device.WaterSensor.set_inapp_water_alarm_trigger", false]], "set_intrusion_alert_through_smoke_detectors() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_intrusion_alert_through_smoke_detectors", false]], "set_intrusion_alert_through_smoke_detectors() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_intrusion_alert_through_smoke_detectors", false]], "set_label() (homematicip.aio.device.asyncdevice method)": [[3, "homematicip.aio.device.AsyncDevice.set_label", false]], "set_label() (homematicip.aio.group.asyncgroup method)": [[3, "homematicip.aio.group.AsyncGroup.set_label", false]], "set_label() (homematicip.aio.rule.asyncrule method)": [[3, "homematicip.aio.rule.AsyncRule.set_label", false]], "set_label() (homematicip.device.device method)": [[2, "homematicip.device.Device.set_label", false]], "set_label() (homematicip.group.group method)": [[2, "homematicip.group.Group.set_label", false]], "set_label() (homematicip.rule.rule method)": [[2, "homematicip.rule.Rule.set_label", false]], "set_light_group_switches() (homematicip.aio.group.asynclinkedswitchinggroup method)": [[3, "homematicip.aio.group.AsyncLinkedSwitchingGroup.set_light_group_switches", false]], "set_light_group_switches() (homematicip.group.linkedswitchinggroup method)": [[2, "homematicip.group.LinkedSwitchingGroup.set_light_group_switches", false]], "set_location() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_location", false]], "set_location() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_location", false]], "set_lock_state (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SET_LOCK_STATE", false]], "set_lock_state() (homematicip.aio.device.asyncdoorlockdrive method)": [[3, "homematicip.aio.device.AsyncDoorLockDrive.set_lock_state", false]], "set_lock_state() (homematicip.base.functionalchannels.doorlockchannel method)": [[4, "homematicip.base.functionalChannels.DoorLockChannel.set_lock_state", false]], "set_lock_state() (homematicip.device.doorlockdrive method)": [[2, "homematicip.device.DoorLockDrive.set_lock_state", false]], "set_minimum_floor_heating_valve_position() (homematicip.aio.device.asyncfloorterminalblock12 method)": [[3, "homematicip.aio.device.AsyncFloorTerminalBlock12.set_minimum_floor_heating_valve_position", false]], "set_minimum_floor_heating_valve_position() (homematicip.base.functionalchannels.devicebasefloorheatingchannel method)": [[4, "homematicip.base.functionalChannels.DeviceBaseFloorHeatingChannel.set_minimum_floor_heating_valve_position", false]], "set_minimum_floor_heating_valve_position() (homematicip.device.floorterminalblock12 method)": [[2, "homematicip.device.FloorTerminalBlock12.set_minimum_floor_heating_valve_position", false]], "set_notification_sound_type() (homematicip.aio.device.asyncaccelerationsensor method)": [[3, "homematicip.aio.device.AsyncAccelerationSensor.set_notification_sound_type", false]], "set_notification_sound_type() (homematicip.base.functionalchannels.accelerationsensorchannel method)": [[4, "homematicip.base.functionalChannels.AccelerationSensorChannel.set_notification_sound_type", false]], "set_notification_sound_type() (homematicip.device.accelerationsensor method)": [[2, "homematicip.device.AccelerationSensor.set_notification_sound_type", false]], "set_on_time() (homematicip.aio.group.asyncalarmswitchinggroup method)": [[3, "homematicip.aio.group.AsyncAlarmSwitchingGroup.set_on_time", false]], "set_on_time() (homematicip.aio.group.asyncextendedlinkedswitchinggroup method)": [[3, "homematicip.aio.group.AsyncExtendedLinkedSwitchingGroup.set_on_time", false]], "set_on_time() (homematicip.group.alarmswitchinggroup method)": [[2, "homematicip.group.AlarmSwitchingGroup.set_on_time", false]], "set_on_time() (homematicip.group.extendedlinkedswitchinggroup method)": [[2, "homematicip.group.ExtendedLinkedSwitchingGroup.set_on_time", false]], "set_operation_lock() (homematicip.aio.device.asyncoperationlockabledevice method)": [[3, "homematicip.aio.device.AsyncOperationLockableDevice.set_operation_lock", false]], "set_operation_lock() (homematicip.base.functionalchannels.deviceoperationlockchannel method)": [[4, "homematicip.base.functionalChannels.DeviceOperationLockChannel.set_operation_lock", false]], "set_operation_lock() (homematicip.device.operationlockabledevice method)": [[2, "homematicip.device.OperationLockableDevice.set_operation_lock", false]], "set_optical_signal() (homematicip.aio.device.asyncwiredpushbutton method)": [[3, "homematicip.aio.device.AsyncWiredPushButton.set_optical_signal", false]], "set_optical_signal() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.set_optical_signal", false]], "set_optical_signal() (homematicip.device.wiredpushbutton method)": [[2, "homematicip.device.WiredPushButton.set_optical_signal", false]], "set_pin() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_pin", false]], "set_pin() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_pin", false]], "set_point_temperature() (homematicip.aio.group.asyncheatinggroup method)": [[3, "homematicip.aio.group.AsyncHeatingGroup.set_point_temperature", false]], "set_point_temperature() (homematicip.group.heatinggroup method)": [[2, "homematicip.group.HeatingGroup.set_point_temperature", false]], "set_powermeter_unit_price() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_powermeter_unit_price", false]], "set_powermeter_unit_price() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_powermeter_unit_price", false]], "set_primary_shading_level() (homematicip.aio.device.asyncblindmodule method)": [[3, "homematicip.aio.device.AsyncBlindModule.set_primary_shading_level", false]], "set_primary_shading_level() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.set_primary_shading_level", false]], "set_primary_shading_level() (homematicip.device.blindmodule method)": [[2, "homematicip.device.BlindModule.set_primary_shading_level", false]], "set_profile_mode() (homematicip.aio.group.asynchotwatergroup method)": [[3, "homematicip.aio.group.AsyncHotWaterGroup.set_profile_mode", false]], "set_profile_mode() (homematicip.aio.group.asyncshutterprofile method)": [[3, "homematicip.aio.group.AsyncShutterProfile.set_profile_mode", false]], "set_profile_mode() (homematicip.aio.group.asyncswitchingprofilegroup method)": [[3, "homematicip.aio.group.AsyncSwitchingProfileGroup.set_profile_mode", false]], "set_profile_mode() (homematicip.group.hotwatergroup method)": [[2, "homematicip.group.HotWaterGroup.set_profile_mode", false]], "set_profile_mode() (homematicip.group.shutterprofile method)": [[2, "homematicip.group.ShutterProfile.set_profile_mode", false]], "set_profile_mode() (homematicip.group.switchingprofilegroup method)": [[2, "homematicip.group.SwitchingProfileGroup.set_profile_mode", false]], "set_rgb_dim_level() (homematicip.aio.device.asyncbrandswitchnotificationlight method)": [[3, "homematicip.aio.device.AsyncBrandSwitchNotificationLight.set_rgb_dim_level", false]], "set_rgb_dim_level() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.set_rgb_dim_level", false]], "set_rgb_dim_level() (homematicip.device.brandswitchnotificationlight method)": [[2, "homematicip.device.BrandSwitchNotificationLight.set_rgb_dim_level", false]], "set_rgb_dim_level_with_time() (homematicip.aio.device.asyncbrandswitchnotificationlight method)": [[3, "homematicip.aio.device.AsyncBrandSwitchNotificationLight.set_rgb_dim_level_with_time", false]], "set_rgb_dim_level_with_time() (homematicip.base.functionalchannels.notificationlightchannel method)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.set_rgb_dim_level_with_time", false]], "set_rgb_dim_level_with_time() (homematicip.device.brandswitchnotificationlight method)": [[2, "homematicip.device.BrandSwitchNotificationLight.set_rgb_dim_level_with_time", false]], "set_router_module_enabled() (homematicip.aio.device.asyncdevice method)": [[3, "homematicip.aio.device.AsyncDevice.set_router_module_enabled", false]], "set_router_module_enabled() (homematicip.device.device method)": [[2, "homematicip.device.Device.set_router_module_enabled", false]], "set_rule_enabled_state() (homematicip.aio.rule.asyncsimplerule method)": [[3, "homematicip.aio.rule.AsyncSimpleRule.set_rule_enabled_state", false]], "set_rule_enabled_state() (homematicip.rule.simplerule method)": [[2, "homematicip.rule.SimpleRule.set_rule_enabled_state", false]], "set_secondary_shading_level() (homematicip.aio.device.asyncblindmodule method)": [[3, "homematicip.aio.device.AsyncBlindModule.set_secondary_shading_level", false]], "set_secondary_shading_level() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.set_secondary_shading_level", false]], "set_secondary_shading_level() (homematicip.device.blindmodule method)": [[2, "homematicip.device.BlindModule.set_secondary_shading_level", false]], "set_security_zones_activation() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_security_zones_activation", false]], "set_security_zones_activation() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_security_zones_activation", false]], "set_shutter_level (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SET_SHUTTER_LEVEL", false]], "set_shutter_level() (homematicip.aio.device.asyncshutter method)": [[3, "homematicip.aio.device.AsyncShutter.set_shutter_level", false]], "set_shutter_level() (homematicip.aio.group.asyncextendedlinkedshuttergroup method)": [[3, "homematicip.aio.group.AsyncExtendedLinkedShutterGroup.set_shutter_level", false]], "set_shutter_level() (homematicip.aio.group.asyncshutterprofile method)": [[3, "homematicip.aio.group.AsyncShutterProfile.set_shutter_level", false]], "set_shutter_level() (homematicip.aio.group.asyncswitchinggroup method)": [[3, "homematicip.aio.group.AsyncSwitchingGroup.set_shutter_level", false]], "set_shutter_level() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.set_shutter_level", false]], "set_shutter_level() (homematicip.base.functionalchannels.shutterchannel method)": [[4, "homematicip.base.functionalChannels.ShutterChannel.set_shutter_level", false]], "set_shutter_level() (homematicip.device.shutter method)": [[2, "homematicip.device.Shutter.set_shutter_level", false]], "set_shutter_level() (homematicip.group.extendedlinkedshuttergroup method)": [[2, "homematicip.group.ExtendedLinkedShutterGroup.set_shutter_level", false]], "set_shutter_level() (homematicip.group.shutterprofile method)": [[2, "homematicip.group.ShutterProfile.set_shutter_level", false]], "set_shutter_level() (homematicip.group.switchinggroup method)": [[2, "homematicip.group.SwitchingGroup.set_shutter_level", false]], "set_shutter_stop (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SET_SHUTTER_STOP", false]], "set_shutter_stop() (homematicip.aio.device.asyncshutter method)": [[3, "homematicip.aio.device.AsyncShutter.set_shutter_stop", false]], "set_shutter_stop() (homematicip.aio.group.asyncextendedlinkedshuttergroup method)": [[3, "homematicip.aio.group.AsyncExtendedLinkedShutterGroup.set_shutter_stop", false]], "set_shutter_stop() (homematicip.aio.group.asyncshutterprofile method)": [[3, "homematicip.aio.group.AsyncShutterProfile.set_shutter_stop", false]], "set_shutter_stop() (homematicip.aio.group.asyncswitchinggroup method)": [[3, "homematicip.aio.group.AsyncSwitchingGroup.set_shutter_stop", false]], "set_shutter_stop() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.set_shutter_stop", false]], "set_shutter_stop() (homematicip.base.functionalchannels.shadingchannel method)": [[4, "homematicip.base.functionalChannels.ShadingChannel.set_shutter_stop", false]], "set_shutter_stop() (homematicip.base.functionalchannels.shutterchannel method)": [[4, "homematicip.base.functionalChannels.ShutterChannel.set_shutter_stop", false]], "set_shutter_stop() (homematicip.device.shutter method)": [[2, "homematicip.device.Shutter.set_shutter_stop", false]], "set_shutter_stop() (homematicip.group.extendedlinkedshuttergroup method)": [[2, "homematicip.group.ExtendedLinkedShutterGroup.set_shutter_stop", false]], "set_shutter_stop() (homematicip.group.shutterprofile method)": [[2, "homematicip.group.ShutterProfile.set_shutter_stop", false]], "set_shutter_stop() (homematicip.group.switchinggroup method)": [[2, "homematicip.group.SwitchingGroup.set_shutter_stop", false]], "set_signal_acoustic() (homematicip.aio.group.asyncalarmswitchinggroup method)": [[3, "homematicip.aio.group.AsyncAlarmSwitchingGroup.set_signal_acoustic", false]], "set_signal_acoustic() (homematicip.group.alarmswitchinggroup method)": [[2, "homematicip.group.AlarmSwitchingGroup.set_signal_acoustic", false]], "set_signal_optical() (homematicip.aio.group.asyncalarmswitchinggroup method)": [[3, "homematicip.aio.group.AsyncAlarmSwitchingGroup.set_signal_optical", false]], "set_signal_optical() (homematicip.group.alarmswitchinggroup method)": [[2, "homematicip.group.AlarmSwitchingGroup.set_signal_optical", false]], "set_silent_alarm() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_silent_alarm", false]], "set_siren_water_alarm_trigger() (homematicip.aio.device.asyncwatersensor method)": [[3, "homematicip.aio.device.AsyncWaterSensor.set_siren_water_alarm_trigger", false]], "set_siren_water_alarm_trigger() (homematicip.base.functionalchannels.watersensorchannel method)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel.set_siren_water_alarm_trigger", false]], "set_siren_water_alarm_trigger() (homematicip.device.watersensor method)": [[2, "homematicip.device.WaterSensor.set_siren_water_alarm_trigger", false]], "set_slats_level (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SET_SLATS_LEVEL", false]], "set_slats_level() (homematicip.aio.device.asyncblind method)": [[3, "homematicip.aio.device.AsyncBlind.set_slats_level", false]], "set_slats_level() (homematicip.aio.group.asyncextendedlinkedshuttergroup method)": [[3, "homematicip.aio.group.AsyncExtendedLinkedShutterGroup.set_slats_level", false]], "set_slats_level() (homematicip.aio.group.asyncshutterprofile method)": [[3, "homematicip.aio.group.AsyncShutterProfile.set_slats_level", false]], "set_slats_level() (homematicip.aio.group.asyncswitchinggroup method)": [[3, "homematicip.aio.group.AsyncSwitchingGroup.set_slats_level", false]], "set_slats_level() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.set_slats_level", false]], "set_slats_level() (homematicip.device.blind method)": [[2, "homematicip.device.Blind.set_slats_level", false]], "set_slats_level() (homematicip.group.extendedlinkedshuttergroup method)": [[2, "homematicip.group.ExtendedLinkedShutterGroup.set_slats_level", false]], "set_slats_level() (homematicip.group.shutterprofile method)": [[2, "homematicip.group.ShutterProfile.set_slats_level", false]], "set_slats_level() (homematicip.group.switchinggroup method)": [[2, "homematicip.group.SwitchingGroup.set_slats_level", false]], "set_switch_state (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.SET_SWITCH_STATE", false]], "set_switch_state() (homematicip.aio.device.asyncswitch method)": [[3, "homematicip.aio.device.AsyncSwitch.set_switch_state", false]], "set_switch_state() (homematicip.aio.device.asyncwiredpushbutton method)": [[3, "homematicip.aio.device.AsyncWiredPushButton.set_switch_state", false]], "set_switch_state() (homematicip.aio.group.asyncswitchgroupbase method)": [[3, "homematicip.aio.group.AsyncSwitchGroupBase.set_switch_state", false]], "set_switch_state() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.set_switch_state", false]], "set_switch_state() (homematicip.device.switch method)": [[2, "homematicip.device.Switch.set_switch_state", false]], "set_switch_state() (homematicip.device.wiredpushbutton method)": [[2, "homematicip.device.WiredPushButton.set_switch_state", false]], "set_switch_state() (homematicip.group.switchgroupbase method)": [[2, "homematicip.group.SwitchGroupBase.set_switch_state", false]], "set_timezone() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_timezone", false]], "set_timezone() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_timezone", false]], "set_token_and_characteristics() (homematicip.base.base_connection.baseconnection method)": [[4, "homematicip.base.base_connection.BaseConnection.set_token_and_characteristics", false]], "set_zone_activation_delay() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_zone_activation_delay", false]], "set_zone_activation_delay() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_zone_activation_delay", false]], "set_zones_device_assignment() (homematicip.aio.home.asynchome method)": [[3, "homematicip.aio.home.AsyncHome.set_zones_device_assignment", false]], "set_zones_device_assignment() (homematicip.home.home method)": [[2, "homematicip.home.Home.set_zones_device_assignment", false]], "setpoint (homematicip.base.enums.climatecontroldisplay attribute)": [[4, "homematicip.base.enums.ClimateControlDisplay.SETPOINT", false]], "setpointtemperature (homematicip.base.functionalchannels.heatingthermostatchannel attribute)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.setPointTemperature", false]], "setpointtemperature (homematicip.device.heatingthermostat attribute)": [[2, "homematicip.device.HeatingThermostat.setPointTemperature", false]], "setpointtemperature (homematicip.device.heatingthermostatcompact attribute)": [[2, "homematicip.device.HeatingThermostatCompact.setPointTemperature", false]], "setpointtemperature (homematicip.device.heatingthermostatevo attribute)": [[2, "homematicip.device.HeatingThermostatEvo.setPointTemperature", false]], "shading_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SHADING_CHANNEL", false]], "shadingchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ShadingChannel", false]], "shadingpackageposition (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ShadingPackagePosition", false]], "shadingstatetype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ShadingStateType", false]], "shutter (class in homematicip.device)": [[2, "homematicip.device.Shutter", false]], "shutter_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SHUTTER_CHANNEL", false]], "shutter_contact (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.SHUTTER_CONTACT", false]], "shutter_contact_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SHUTTER_CONTACT_CHANNEL", false]], "shutter_contact_interface (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.SHUTTER_CONTACT_INTERFACE", false]], "shutter_contact_invisible (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.SHUTTER_CONTACT_INVISIBLE", false]], "shutter_contact_magnetic (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.SHUTTER_CONTACT_MAGNETIC", false]], "shutter_contact_optical_plus (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.SHUTTER_CONTACT_OPTICAL_PLUS", false]], "shutter_profile (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SHUTTER_PROFILE", false]], "shutter_wind_protection_rule (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SHUTTER_WIND_PROTECTION_RULE", false]], "shutterchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ShutterChannel", false]], "shuttercontact (class in homematicip.device)": [[2, "homematicip.device.ShutterContact", false]], "shuttercontactchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.ShutterContactChannel", false]], "shuttercontactmagnetic (class in homematicip.device)": [[2, "homematicip.device.ShutterContactMagnetic", false]], "shuttercontactopticalplus (class in homematicip.device)": [[2, "homematicip.device.ShutterContactOpticalPlus", false]], "shutterprofile (class in homematicip.group)": [[2, "homematicip.group.ShutterProfile", false]], "shutterwindprotectionrule (class in homematicip.group)": [[2, "homematicip.group.ShutterWindProtectionRule", false]], "silence_changed (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.SILENCE_CHANGED", false]], "silencechangedevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.SilenceChangedEvent", false]], "silent_alarm (homematicip.base.enums.alarmsignaltype attribute)": [[4, "homematicip.base.enums.AlarmSignalType.SILENT_ALARM", false]], "simple (homematicip.base.enums.automationruletype attribute)": [[4, "homematicip.base.enums.AutomationRuleType.SIMPLE", false]], "simplergbcolorstate (homematicip.base.functionalchannels.notificationlightchannel attribute)": [[4, "homematicip.base.functionalChannels.NotificationLightChannel.simpleRGBColorState", false]], "simplerule (class in homematicip.rule)": [[2, "homematicip.rule.SimpleRule", false]], "single_key_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SINGLE_KEY_CHANNEL", false]], "singlekeychannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.SingleKeyChannel", false]], "six (homematicip.base.enums.ecoduration attribute)": [[4, "homematicip.base.enums.EcoDuration.SIX", false]], "six_minutes (homematicip.base.enums.acousticalarmtiming attribute)": [[4, "homematicip.base.enums.AcousticAlarmTiming.SIX_MINUTES", false]], "slow_speed (homematicip.base.enums.drivespeed attribute)": [[4, "homematicip.base.enums.DriveSpeed.SLOW_SPEED", false]], "smoke_alarm (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.SMOKE_ALARM", false]], "smoke_alarm_detection_rule (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SMOKE_ALARM_DETECTION_RULE", false]], "smoke_detector (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.SMOKE_DETECTOR", false]], "smoke_detector_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SMOKE_DETECTOR_CHANNEL", false]], "smokealarmdetectionrule (class in homematicip.group)": [[2, "homematicip.group.SmokeAlarmDetectionRule", false]], "smokealarmevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.SmokeAlarmEvent", false]], "smokedetector (class in homematicip.device)": [[2, "homematicip.device.SmokeDetector", false]], "smokedetectoralarmtype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.SmokeDetectorAlarmType", false]], "smokedetectorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.SmokeDetectorChannel", false]], "sound_long (homematicip.base.enums.notificationsoundtype attribute)": [[4, "homematicip.base.enums.NotificationSoundType.SOUND_LONG", false]], "sound_no_sound (homematicip.base.enums.notificationsoundtype attribute)": [[4, "homematicip.base.enums.NotificationSoundType.SOUND_NO_SOUND", false]], "sound_short (homematicip.base.enums.notificationsoundtype attribute)": [[4, "homematicip.base.enums.NotificationSoundType.SOUND_SHORT", false]], "sound_short_short (homematicip.base.enums.notificationsoundtype attribute)": [[4, "homematicip.base.enums.NotificationSoundType.SOUND_SHORT_SHORT", false]], "split (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.SPLIT", false]], "start_inclusion() (homematicip.home.home method)": [[2, "homematicip.home.Home.start_inclusion", false]], "state_not_available (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.STATE_NOT_AVAILABLE", false]], "stop (homematicip.base.enums.doorcommand attribute)": [[4, "homematicip.base.enums.DoorCommand.STOP", false]], "stop() (homematicip.aio.device.asyncblindmodule method)": [[3, "homematicip.aio.device.AsyncBlindModule.stop", false]], "stop() (homematicip.base.functionalchannels.blindchannel method)": [[4, "homematicip.base.functionalChannels.BlindChannel.stop", false]], "stop() (homematicip.device.blindmodule method)": [[2, "homematicip.device.BlindModule.stop", false]], "stopped (homematicip.base.enums.motorstate attribute)": [[4, "homematicip.base.enums.MotorState.STOPPED", false]], "strong_wind (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.STRONG_WIND", false]], "switch (class in homematicip.device)": [[2, "homematicip.device.Switch", false]], "switch_behavior (homematicip.base.enums.multimodeinputmode attribute)": [[4, "homematicip.base.enums.MultiModeInputMode.SWITCH_BEHAVIOR", false]], "switch_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SWITCH_CHANNEL", false]], "switch_measuring_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.SWITCH_MEASURING_CHANNEL", false]], "switchchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.SwitchChannel", false]], "switchgroupbase (class in homematicip.group)": [[2, "homematicip.group.SwitchGroupBase", false]], "switching (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SWITCHING", false]], "switching_profile (homematicip.base.enums.grouptype attribute)": [[4, "homematicip.base.enums.GroupType.SWITCHING_PROFILE", false]], "switchinggroup (class in homematicip.group)": [[2, "homematicip.group.SwitchingGroup", false]], "switchingprofilegroup (class in homematicip.group)": [[2, "homematicip.group.SwitchingProfileGroup", false]], "switchmeasuring (class in homematicip.device)": [[2, "homematicip.device.SwitchMeasuring", false]], "switchmeasuringchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.SwitchMeasuringChannel", false]], "tdbu (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.TDBU", false]], "temperature (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.temperature", false]], "temperature_humidity_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.TEMPERATURE_HUMIDITY_SENSOR", false]], "temperature_humidity_sensor_display (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.TEMPERATURE_HUMIDITY_SENSOR_DISPLAY", false]], "temperature_humidity_sensor_outdoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.TEMPERATURE_HUMIDITY_SENSOR_OUTDOOR", false]], "temperature_sensor_2_external_delta (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.TEMPERATURE_SENSOR_2_EXTERNAL_DELTA", false]], "temperature_sensor_2_external_delta_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL", false]], "temperaturedifferencesensor2 (class in homematicip.device)": [[2, "homematicip.device.TemperatureDifferenceSensor2", false]], "temperaturedifferencesensor2channel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel", false]], "temperatureexternaldelta (homematicip.base.functionalchannels.temperaturedifferencesensor2channel attribute)": [[4, "homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel.temperatureExternalDelta", false]], "temperatureexternaldelta (homematicip.device.temperaturedifferencesensor2 attribute)": [[2, "homematicip.device.TemperatureDifferenceSensor2.temperatureExternalDelta", false]], "temperatureexternalone (homematicip.base.functionalchannels.temperaturedifferencesensor2channel attribute)": [[4, "homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel.temperatureExternalOne", false]], "temperatureexternalone (homematicip.device.temperaturedifferencesensor2 attribute)": [[2, "homematicip.device.TemperatureDifferenceSensor2.temperatureExternalOne", false]], "temperatureexternaltwo (homematicip.base.functionalchannels.temperaturedifferencesensor2channel attribute)": [[4, "homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel.temperatureExternalTwo", false]], "temperatureexternaltwo (homematicip.device.temperaturedifferencesensor2 attribute)": [[2, "homematicip.device.TemperatureDifferenceSensor2.temperatureExternalTwo", false]], "temperaturehumiditysensordisplay (class in homematicip.device)": [[2, "homematicip.device.TemperatureHumiditySensorDisplay", false]], "temperaturehumiditysensoroutdoor (class in homematicip.device)": [[2, "homematicip.device.TemperatureHumiditySensorOutdoor", false]], "temperaturehumiditysensorwithoutdisplay (class in homematicip.device)": [[2, "homematicip.device.TemperatureHumiditySensorWithoutDisplay", false]], "temperatureoffset (homematicip.base.functionalchannels.heatingthermostatchannel attribute)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.temperatureOffset", false]], "temperatureoffset (homematicip.device.heatingthermostat attribute)": [[2, "homematicip.device.HeatingThermostat.temperatureOffset", false]], "temperatureoffset (homematicip.device.heatingthermostatcompact attribute)": [[2, "homematicip.device.HeatingThermostatCompact.temperatureOffset", false]], "temperatureoffset (homematicip.device.heatingthermostatevo attribute)": [[2, "homematicip.device.HeatingThermostatEvo.temperatureOffset", false]], "test_signal_acoustic() (homematicip.aio.group.asyncalarmswitchinggroup method)": [[3, "homematicip.aio.group.AsyncAlarmSwitchingGroup.test_signal_acoustic", false]], "test_signal_acoustic() (homematicip.group.alarmswitchinggroup method)": [[2, "homematicip.group.AlarmSwitchingGroup.test_signal_acoustic", false]], "test_signal_optical() (homematicip.aio.group.asyncalarmswitchinggroup method)": [[3, "homematicip.aio.group.AsyncAlarmSwitchingGroup.test_signal_optical", false]], "test_signal_optical() (homematicip.group.alarmswitchinggroup method)": [[2, "homematicip.group.AlarmSwitchingGroup.test_signal_optical", false]], "three_minutes (homematicip.base.enums.acousticalarmtiming attribute)": [[4, "homematicip.base.enums.AcousticAlarmTiming.THREE_MINUTES", false]], "tilt_used (homematicip.base.enums.shadingstatetype attribute)": [[4, "homematicip.base.enums.ShadingStateType.TILT_USED", false]], "tilt_vibration_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.TILT_VIBRATION_SENSOR", false]], "tilt_vibration_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.TILT_VIBRATION_SENSOR_CHANNEL", false]], "tilted (homematicip.base.enums.windowstate attribute)": [[4, "homematicip.base.enums.WindowState.TILTED", false]], "tiltvibrationsensor (class in homematicip.device)": [[2, "homematicip.device.TiltVibrationSensor", false]], "tiltvibrationsensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.TiltVibrationSensorChannel", false]], "timeprofile (class in homematicip.group)": [[2, "homematicip.group.TimeProfile", false]], "timeprofileperiod (class in homematicip.group)": [[2, "homematicip.group.TimeProfilePeriod", false]], "toggle_garage_door (homematicip.base.enums.cliactions attribute)": [[4, "homematicip.base.enums.CliActions.TOGGLE_GARAGE_DOOR", false]], "too_tight (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.TOO_TIGHT", false]], "top (homematicip.base.enums.shadingpackageposition attribute)": [[4, "homematicip.base.enums.ShadingPackagePosition.TOP", false]], "toplightchannelindex (homematicip.device.brandswitchnotificationlight attribute)": [[2, "homematicip.device.BrandSwitchNotificationLight.topLightChannelIndex", false]], "tormatic_module (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.TORMATIC_MODULE", false]], "transfering_update (homematicip.base.enums.deviceupdatestate attribute)": [[4, "homematicip.base.enums.DeviceUpdateState.TRANSFERING_UPDATE", false]], "triggered (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.triggered", false]], "turn_off() (homematicip.aio.device.asyncswitch method)": [[3, "homematicip.aio.device.AsyncSwitch.turn_off", false]], "turn_off() (homematicip.aio.device.asyncwiredpushbutton method)": [[3, "homematicip.aio.device.AsyncWiredPushButton.turn_off", false]], "turn_off() (homematicip.aio.group.asyncswitchgroupbase method)": [[3, "homematicip.aio.group.AsyncSwitchGroupBase.turn_off", false]], "turn_off() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.turn_off", false]], "turn_off() (homematicip.device.switch method)": [[2, "homematicip.device.Switch.turn_off", false]], "turn_off() (homematicip.device.wiredpushbutton method)": [[2, "homematicip.device.WiredPushButton.turn_off", false]], "turn_off() (homematicip.group.switchgroupbase method)": [[2, "homematicip.group.SwitchGroupBase.turn_off", false]], "turn_on() (homematicip.aio.device.asyncswitch method)": [[3, "homematicip.aio.device.AsyncSwitch.turn_on", false]], "turn_on() (homematicip.aio.device.asyncwiredpushbutton method)": [[3, "homematicip.aio.device.AsyncWiredPushButton.turn_on", false]], "turn_on() (homematicip.aio.group.asyncswitchgroupbase method)": [[3, "homematicip.aio.group.AsyncSwitchGroupBase.turn_on", false]], "turn_on() (homematicip.base.functionalchannels.switchchannel method)": [[4, "homematicip.base.functionalChannels.SwitchChannel.turn_on", false]], "turn_on() (homematicip.device.switch method)": [[2, "homematicip.device.Switch.turn_on", false]], "turn_on() (homematicip.device.wiredpushbutton method)": [[2, "homematicip.device.WiredPushButton.turn_on", false]], "turn_on() (homematicip.group.switchgroupbase method)": [[2, "homematicip.group.SwitchGroupBase.turn_on", false]], "turquoise (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.TURQUOISE", false]], "twilight (homematicip.base.enums.weatherdaytime attribute)": [[4, "homematicip.base.enums.WeatherDayTime.TWILIGHT", false]], "two (homematicip.base.enums.ecoduration attribute)": [[4, "homematicip.base.enums.EcoDuration.TWO", false]], "universal_actuator_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.UNIVERSAL_ACTUATOR_CHANNEL", false]], "universal_light_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.UNIVERSAL_LIGHT_CHANNEL", false]], "universal_light_group_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.UNIVERSAL_LIGHT_GROUP_CHANNEL", false]], "universalactuatorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.UniversalActuatorChannel", false]], "universallightchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.UniversalLightChannel", false]], "universallightchannelgroup (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.UniversalLightChannelGroup", false]], "unknown (homematicip.base.enums.weathercondition attribute)": [[4, "homematicip.base.enums.WeatherCondition.UNKNOWN", false]], "unlocked (homematicip.base.enums.lockstate attribute)": [[4, "homematicip.base.enums.LockState.UNLOCKED", false]], "up_to_date (homematicip.base.enums.deviceupdatestate attribute)": [[4, "homematicip.base.enums.DeviceUpdateState.UP_TO_DATE", false]], "up_to_date (homematicip.base.enums.homeupdatestate attribute)": [[4, "homematicip.base.enums.HomeUpdateState.UP_TO_DATE", false]], "up_to_date (homematicip.base.enums.liveupdatestate attribute)": [[4, "homematicip.base.enums.LiveUpdateState.UP_TO_DATE", false]], "update_authorized (homematicip.base.enums.deviceupdatestate attribute)": [[4, "homematicip.base.enums.DeviceUpdateState.UPDATE_AUTHORIZED", false]], "update_available (homematicip.base.enums.deviceupdatestate attribute)": [[4, "homematicip.base.enums.DeviceUpdateState.UPDATE_AVAILABLE", false]], "update_available (homematicip.base.enums.homeupdatestate attribute)": [[4, "homematicip.base.enums.HomeUpdateState.UPDATE_AVAILABLE", false]], "update_available (homematicip.base.enums.liveupdatestate attribute)": [[4, "homematicip.base.enums.LiveUpdateState.UPDATE_AVAILABLE", false]], "update_home() (homematicip.home.home method)": [[2, "homematicip.home.Home.update_home", false]], "update_home_only() (homematicip.home.home method)": [[2, "homematicip.home.Home.update_home_only", false]], "update_incomplete (homematicip.base.enums.liveupdatestate attribute)": [[4, "homematicip.base.enums.LiveUpdateState.UPDATE_INCOMPLETE", false]], "update_profile() (homematicip.group.heatingcoolingprofile method)": [[2, "homematicip.group.HeatingCoolingProfile.update_profile", false]], "urlrest (homematicip.base.base_connection.baseconnection property)": [[4, "homematicip.base.base_connection.BaseConnection.urlREST", false]], "urlwebsocket (homematicip.base.base_connection.baseconnection property)": [[4, "homematicip.base.base_connection.BaseConnection.urlWebSocket", false]], "vacation (homematicip.base.enums.absencetype attribute)": [[4, "homematicip.base.enums.AbsenceType.VACATION", false]], "validationtimeout (homematicip.group.heatingfailurealertrulegroup attribute)": [[2, "homematicip.group.HeatingFailureAlertRuleGroup.validationTimeout", false]], "valveactualtemperature (homematicip.base.functionalchannels.heatingthermostatchannel attribute)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.valveActualTemperature", false]], "valveactualtemperature (homematicip.device.heatingthermostat attribute)": [[2, "homematicip.device.HeatingThermostat.valveActualTemperature", false]], "valveactualtemperature (homematicip.device.heatingthermostatcompact attribute)": [[2, "homematicip.device.HeatingThermostatCompact.valveActualTemperature", false]], "valveactualtemperature (homematicip.device.heatingthermostatevo attribute)": [[2, "homematicip.device.HeatingThermostatEvo.valveActualTemperature", false]], "valveposition (homematicip.base.functionalchannels.heatingthermostatchannel attribute)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.valvePosition", false]], "valveposition (homematicip.device.heatingthermostat attribute)": [[2, "homematicip.device.HeatingThermostat.valvePosition", false]], "valveposition (homematicip.device.heatingthermostatcompact attribute)": [[2, "homematicip.device.HeatingThermostatCompact.valvePosition", false]], "valveposition (homematicip.device.heatingthermostatevo attribute)": [[2, "homematicip.device.HeatingThermostatEvo.valvePosition", false]], "valvestate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.ValveState", false]], "valvestate (homematicip.base.functionalchannels.floorterminalblockmechanicchannel attribute)": [[4, "homematicip.base.functionalChannels.FloorTerminalBlockMechanicChannel.valveState", false]], "valvestate (homematicip.base.functionalchannels.heatingthermostatchannel attribute)": [[4, "homematicip.base.functionalChannels.HeatingThermostatChannel.valveState", false]], "valvestate (homematicip.device.heatingthermostat attribute)": [[2, "homematicip.device.HeatingThermostat.valveState", false]], "valvestate (homematicip.device.heatingthermostatcompact attribute)": [[2, "homematicip.device.HeatingThermostatCompact.valveState", false]], "valvestate (homematicip.device.heatingthermostatevo attribute)": [[2, "homematicip.device.HeatingThermostatEvo.valveState", false]], "vaporamount (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.vaporAmount", false]], "ventilation_position (homematicip.base.enums.doorstate attribute)": [[4, "homematicip.base.enums.DoorState.VENTILATION_POSITION", false]], "ventilationrecommended (homematicip.group.humiditywarningrulegroup attribute)": [[2, "homematicip.group.HumidityWarningRuleGroup.ventilationRecommended", false]], "vertical (homematicip.base.enums.accelerationsensorneutralposition attribute)": [[4, "homematicip.base.enums.AccelerationSensorNeutralPosition.VERTICAL", false]], "visible (homematicip.base.enums.groupvisibility attribute)": [[4, "homematicip.base.enums.GroupVisibility.VISIBLE", false]], "wait_for_adaption (homematicip.base.enums.valvestate attribute)": [[4, "homematicip.base.enums.ValveState.WAIT_FOR_ADAPTION", false]], "wall_mounted_garage_door_controller (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WALL_MOUNTED_GARAGE_DOOR_CONTROLLER", false]], "wall_mounted_thermostat_basic_humidity (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WALL_MOUNTED_THERMOSTAT_BASIC_HUMIDITY", false]], "wall_mounted_thermostat_pro (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WALL_MOUNTED_THERMOSTAT_PRO", false]], "wall_mounted_thermostat_pro_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL", false]], "wall_mounted_thermostat_without_display_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL", false]], "wall_mounted_universal_actuator (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WALL_MOUNTED_UNIVERSAL_ACTUATOR", false]], "wallmountedgaragedoorcontroller (class in homematicip.device)": [[2, "homematicip.device.WallMountedGarageDoorController", false]], "wallmountedthermostatbasichumidity (class in homematicip.device)": [[2, "homematicip.device.WallMountedThermostatBasicHumidity", false]], "wallmountedthermostatpro (class in homematicip.device)": [[2, "homematicip.device.WallMountedThermostatPro", false]], "wallmountedthermostatprochannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.WallMountedThermostatProChannel", false]], "wallmountedthermostatwithoutdisplaychannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.WallMountedThermostatWithoutDisplayChannel", false]], "water_detection (homematicip.base.enums.wateralarmtrigger attribute)": [[4, "homematicip.base.enums.WaterAlarmTrigger.WATER_DETECTION", false]], "water_detection_event (homematicip.base.enums.securityeventtype attribute)": [[4, "homematicip.base.enums.SecurityEventType.WATER_DETECTION_EVENT", false]], "water_moisture_detection (homematicip.base.enums.wateralarmtrigger attribute)": [[4, "homematicip.base.enums.WaterAlarmTrigger.WATER_MOISTURE_DETECTION", false]], "water_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WATER_SENSOR", false]], "water_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.WATER_SENSOR_CHANNEL", false]], "wateralarmtrigger (class in homematicip.base.enums)": [[4, "homematicip.base.enums.WaterAlarmTrigger", false]], "waterdetectionevent (class in homematicip.securityevent)": [[2, "homematicip.securityEvent.WaterDetectionEvent", false]], "watersensor (class in homematicip.device)": [[2, "homematicip.device.WaterSensor", false]], "watersensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.WaterSensorChannel", false]], "weather (class in homematicip.weather)": [[2, "homematicip.weather.Weather", false]], "weather (homematicip.home.home attribute)": [[2, "homematicip.home.Home.weather", false]], "weather_and_environment (homematicip.base.enums.functionalhometype attribute)": [[4, "homematicip.base.enums.FunctionalHomeType.WEATHER_AND_ENVIRONMENT", false]], "weather_sensor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WEATHER_SENSOR", false]], "weather_sensor_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.WEATHER_SENSOR_CHANNEL", false]], "weather_sensor_plus (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WEATHER_SENSOR_PLUS", false]], "weather_sensor_plus_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.WEATHER_SENSOR_PLUS_CHANNEL", false]], "weather_sensor_pro (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WEATHER_SENSOR_PRO", false]], "weather_sensor_pro_channel (homematicip.base.enums.functionalchanneltype attribute)": [[4, "homematicip.base.enums.FunctionalChannelType.WEATHER_SENSOR_PRO_CHANNEL", false]], "weatherandenvironmenthome (class in homematicip.functionalhomes)": [[2, "homematicip.functionalHomes.WeatherAndEnvironmentHome", false]], "weathercondition (class in homematicip.base.enums)": [[4, "homematicip.base.enums.WeatherCondition", false]], "weathercondition (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.weatherCondition", false]], "weatherdaytime (class in homematicip.base.enums)": [[4, "homematicip.base.enums.WeatherDayTime", false]], "weatherdaytime (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.weatherDayTime", false]], "weathersensor (class in homematicip.device)": [[2, "homematicip.device.WeatherSensor", false]], "weathersensorchannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.WeatherSensorChannel", false]], "weathersensorplus (class in homematicip.device)": [[2, "homematicip.device.WeatherSensorPlus", false]], "weathersensorpluschannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.WeatherSensorPlusChannel", false]], "weathersensorpro (class in homematicip.device)": [[2, "homematicip.device.WeatherSensorPro", false]], "weathersensorprochannel (class in homematicip.base.functionalchannels)": [[4, "homematicip.base.functionalChannels.WeatherSensorProChannel", false]], "websocket_reconnect_on_error (homematicip.home.home attribute)": [[2, "homematicip.home.Home.websocket_reconnect_on_error", false]], "white (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.WHITE", false]], "winddirection (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.windDirection", false]], "window_door_contact (homematicip.base.enums.alarmcontacttype attribute)": [[4, "homematicip.base.enums.AlarmContactType.WINDOW_DOOR_CONTACT", false]], "windowstate (class in homematicip.base.enums)": [[4, "homematicip.base.enums.WindowState", false]], "windspeed (homematicip.weather.weather attribute)": [[2, "homematicip.weather.Weather.windSpeed", false]], "windvaluetype (class in homematicip.base.enums)": [[4, "homematicip.base.enums.WindValueType", false]], "wired_blind_4 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_BLIND_4", false]], "wired_dimmer_3 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_DIMMER_3", false]], "wired_din_rail_access_point (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_DIN_RAIL_ACCESS_POINT", false]], "wired_floor_terminal_block_12 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_FLOOR_TERMINAL_BLOCK_12", false]], "wired_input_32 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_INPUT_32", false]], "wired_input_switch_6 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_INPUT_SWITCH_6", false]], "wired_motion_detector_push_button (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_MOTION_DETECTOR_PUSH_BUTTON", false]], "wired_presence_detector_indoor (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_PRESENCE_DETECTOR_INDOOR", false]], "wired_push_button_2 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_PUSH_BUTTON_2", false]], "wired_push_button_6 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_PUSH_BUTTON_6", false]], "wired_switch_4 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_SWITCH_4", false]], "wired_switch_8 (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_SWITCH_8", false]], "wired_wall_mounted_thermostat (homematicip.base.enums.devicetype attribute)": [[4, "homematicip.base.enums.DeviceType.WIRED_WALL_MOUNTED_THERMOSTAT", false]], "wireddimmer3 (class in homematicip.device)": [[2, "homematicip.device.WiredDimmer3", false]], "wireddinrailaccesspoint (class in homematicip.device)": [[2, "homematicip.device.WiredDinRailAccessPoint", false]], "wireddinrailblind4 (class in homematicip.device)": [[2, "homematicip.device.WiredDinRailBlind4", false]], "wiredfloorterminalblock12 (class in homematicip.device)": [[2, "homematicip.device.WiredFloorTerminalBlock12", false]], "wiredinput32 (class in homematicip.device)": [[2, "homematicip.device.WiredInput32", false]], "wiredinputswitch6 (class in homematicip.device)": [[2, "homematicip.device.WiredInputSwitch6", false]], "wiredmotiondetectorpushbutton (class in homematicip.device)": [[2, "homematicip.device.WiredMotionDetectorPushButton", false]], "wiredpushbutton (class in homematicip.device)": [[2, "homematicip.device.WiredPushButton", false]], "wiredswitch4 (class in homematicip.device)": [[2, "homematicip.device.WiredSwitch4", false]], "wiredswitch8 (class in homematicip.device)": [[2, "homematicip.device.WiredSwitch8", false]], "ws_connect() (homematicip.aio.connection.asyncconnection method)": [[3, "homematicip.aio.connection.AsyncConnection.ws_connect", false]], "ws_connected (homematicip.aio.connection.asyncconnection property)": [[3, "homematicip.aio.connection.AsyncConnection.ws_connected", false]], "yellow (homematicip.base.enums.rgbcolorstate attribute)": [[4, "homematicip.base.enums.RGBColorState.YELLOW", false]]}, "objects": {"": [[2, 0, 0, "-", "homematicip"]], "homematicip": [[2, 0, 0, "-", "EventHook"], [2, 1, 1, "", "HmipConfig"], [2, 0, 0, "-", "HomeMaticIPObject"], [2, 0, 0, "-", "access_point_update_state"], [3, 0, 0, "-", "aio"], [2, 0, 0, "-", "auth"], [4, 0, 0, "-", "base"], [2, 0, 0, "-", "class_maps"], [2, 0, 0, "-", "client"], [2, 0, 0, "-", "connection"], [2, 0, 0, "-", "device"], [2, 6, 1, "", "find_and_load_config_file"], [2, 0, 0, "-", "functionalHomes"], [2, 6, 1, "", "get_config_file_locations"], [2, 0, 0, "-", "group"], [2, 0, 0, "-", "home"], [2, 6, 1, "", "load_config_file"], [2, 0, 0, "-", "location"], [2, 0, 0, "-", "oauth_otk"], [2, 0, 0, "-", "rule"], [2, 0, 0, "-", "securityEvent"], [2, 0, 0, "-", "weather"]], "homematicip.EventHook": [[2, 1, 1, "", "EventHook"]], "homematicip.EventHook.EventHook": [[2, 2, 1, "", "fire"]], "homematicip.HmipConfig": [[2, 3, 1, "", "access_point"], [2, 3, 1, "", "auth_token"], [2, 3, 1, "", "log_file"], [2, 3, 1, "", "log_level"], [2, 3, 1, "", "raw_config"]], "homematicip.access_point_update_state": [[2, 1, 1, "", "AccessPointUpdateState"]], "homematicip.access_point_update_state.AccessPointUpdateState": [[2, 2, 1, "", "from_json"]], "homematicip.aio": [[3, 0, 0, "-", "auth"], [3, 0, 0, "-", "class_maps"], [3, 0, 0, "-", "connection"], [3, 0, 0, "-", "device"], [3, 0, 0, "-", "group"], [3, 0, 0, "-", "home"], [3, 0, 0, "-", "rule"], [3, 0, 0, "-", "securityEvent"]], "homematicip.aio.auth": [[3, 1, 1, "", "AsyncAuth"], [3, 1, 1, "", "AsyncAuthConnection"]], "homematicip.aio.auth.AsyncAuth": [[3, 2, 1, "", "confirmAuthToken"], [3, 2, 1, "", "connectionRequest"], [3, 2, 1, "", "init"], [3, 2, 1, "", "isRequestAcknowledged"], [3, 2, 1, "", "requestAuthToken"]], "homematicip.aio.connection": [[3, 1, 1, "", "AsyncConnection"]], "homematicip.aio.connection.AsyncConnection": [[3, 2, 1, "", "api_call"], [3, 2, 1, "", "close_websocket_connection"], [3, 3, 1, "", "connect_timeout"], [3, 2, 1, "", "full_url"], [3, 2, 1, "", "init"], [3, 3, 1, "", "ping_loop"], [3, 3, 1, "", "ping_timeout"], [3, 2, 1, "", "ws_connect"], [3, 4, 1, "", "ws_connected"]], "homematicip.aio.device": [[3, 1, 1, "", "AsyncAccelerationSensor"], [3, 1, 1, "", "AsyncAlarmSirenIndoor"], [3, 1, 1, "", "AsyncAlarmSirenOutdoor"], [3, 1, 1, "", "AsyncBaseDevice"], [3, 1, 1, "", "AsyncBlind"], [3, 1, 1, "", "AsyncBlindModule"], [3, 1, 1, "", "AsyncBrandBlind"], [3, 1, 1, "", "AsyncBrandDimmer"], [3, 1, 1, "", "AsyncBrandPushButton"], [3, 1, 1, "", "AsyncBrandSwitch2"], [3, 1, 1, "", "AsyncBrandSwitchMeasuring"], [3, 1, 1, "", "AsyncBrandSwitchNotificationLight"], [3, 1, 1, "", "AsyncCarbonDioxideSensor"], [3, 1, 1, "", "AsyncContactInterface"], [3, 1, 1, "", "AsyncDaliGateway"], [3, 1, 1, "", "AsyncDevice"], [3, 1, 1, "", "AsyncDimmer"], [3, 1, 1, "", "AsyncDinRailBlind4"], [3, 1, 1, "", "AsyncDinRailDimmer3"], [3, 1, 1, "", "AsyncDinRailSwitch"], [3, 1, 1, "", "AsyncDinRailSwitch4"], [3, 1, 1, "", "AsyncDoorBellButton"], [3, 1, 1, "", "AsyncDoorBellContactInterface"], [3, 1, 1, "", "AsyncDoorLockDrive"], [3, 1, 1, "", "AsyncDoorLockSensor"], [3, 1, 1, "", "AsyncDoorModule"], [3, 1, 1, "", "AsyncEnergySensorsInterface"], [3, 1, 1, "", "AsyncExternalDevice"], [3, 1, 1, "", "AsyncFloorTerminalBlock10"], [3, 1, 1, "", "AsyncFloorTerminalBlock12"], [3, 1, 1, "", "AsyncFloorTerminalBlock6"], [3, 1, 1, "", "AsyncFullFlushBlind"], [3, 1, 1, "", "AsyncFullFlushContactInterface"], [3, 1, 1, "", "AsyncFullFlushContactInterface6"], [3, 1, 1, "", "AsyncFullFlushDimmer"], [3, 1, 1, "", "AsyncFullFlushInputSwitch"], [3, 1, 1, "", "AsyncFullFlushShutter"], [3, 1, 1, "", "AsyncFullFlushSwitchMeasuring"], [3, 1, 1, "", "AsyncGarageDoorModuleTormatic"], [3, 1, 1, "", "AsyncHeatingSwitch2"], [3, 1, 1, "", "AsyncHeatingThermostat"], [3, 1, 1, "", "AsyncHeatingThermostatCompact"], [3, 1, 1, "", "AsyncHeatingThermostatEvo"], [3, 1, 1, "", "AsyncHoermannDrivesModule"], [3, 1, 1, "", "AsyncHomeControlAccessPoint"], [3, 1, 1, "", "AsyncHomeControlUnit"], [3, 1, 1, "", "AsyncKeyRemoteControl4"], [3, 1, 1, "", "AsyncKeyRemoteControlAlarm"], [3, 1, 1, "", "AsyncLightSensor"], [3, 1, 1, "", "AsyncMotionDetectorIndoor"], [3, 1, 1, "", "AsyncMotionDetectorOutdoor"], [3, 1, 1, "", "AsyncMotionDetectorPushButton"], [3, 1, 1, "", "AsyncMultiIOBox"], [3, 1, 1, "", "AsyncOpenCollector8Module"], [3, 1, 1, "", "AsyncOperationLockableDevice"], [3, 1, 1, "", "AsyncPassageDetector"], [3, 1, 1, "", "AsyncPlugableSwitch"], [3, 1, 1, "", "AsyncPlugableSwitchMeasuring"], [3, 1, 1, "", "AsyncPluggableDimmer"], [3, 1, 1, "", "AsyncPluggableMainsFailureSurveillance"], [3, 1, 1, "", "AsyncPresenceDetectorIndoor"], [3, 1, 1, "", "AsyncPrintedCircuitBoardSwitch2"], [3, 1, 1, "", "AsyncPrintedCircuitBoardSwitchBattery"], [3, 1, 1, "", "AsyncPushButton"], [3, 1, 1, "", "AsyncPushButton6"], [3, 1, 1, "", "AsyncPushButtonFlat"], [3, 1, 1, "", "AsyncRainSensor"], [3, 1, 1, "", "AsyncRemoteControl8"], [3, 1, 1, "", "AsyncRemoteControl8Module"], [3, 1, 1, "", "AsyncRgbwDimmer"], [3, 1, 1, "", "AsyncRoomControlDevice"], [3, 1, 1, "", "AsyncRoomControlDeviceAnalog"], [3, 1, 1, "", "AsyncRotaryHandleSensor"], [3, 1, 1, "", "AsyncSabotageDevice"], [3, 1, 1, "", "AsyncShutter"], [3, 1, 1, "", "AsyncShutterContact"], [3, 1, 1, "", "AsyncShutterContactMagnetic"], [3, 1, 1, "", "AsyncShutterContactOpticalPlus"], [3, 1, 1, "", "AsyncSmokeDetector"], [3, 1, 1, "", "AsyncSwitch"], [3, 1, 1, "", "AsyncSwitchMeasuring"], [3, 1, 1, "", "AsyncTemperatureDifferenceSensor2"], [3, 1, 1, "", "AsyncTemperatureHumiditySensorDisplay"], [3, 1, 1, "", "AsyncTemperatureHumiditySensorOutdoor"], [3, 1, 1, "", "AsyncTemperatureHumiditySensorWithoutDisplay"], [3, 1, 1, "", "AsyncTiltVibrationSensor"], [3, 1, 1, "", "AsyncWallMountedGarageDoorController"], [3, 1, 1, "", "AsyncWallMountedThermostatBasicHumidity"], [3, 1, 1, "", "AsyncWallMountedThermostatPro"], [3, 1, 1, "", "AsyncWaterSensor"], [3, 1, 1, "", "AsyncWeatherSensor"], [3, 1, 1, "", "AsyncWeatherSensorPlus"], [3, 1, 1, "", "AsyncWeatherSensorPro"], [3, 1, 1, "", "AsyncWiredDimmer3"], [3, 1, 1, "", "AsyncWiredDinRailAccessPoint"], [3, 1, 1, "", "AsyncWiredDinRailBlind4"], [3, 1, 1, "", "AsyncWiredFloorTerminalBlock12"], [3, 1, 1, "", "AsyncWiredInput32"], [3, 1, 1, "", "AsyncWiredInputSwitch6"], [3, 1, 1, "", "AsyncWiredMotionDetectorPushButton"], [3, 1, 1, "", "AsyncWiredPushButton"], [3, 1, 1, "", "AsyncWiredSwitch4"], [3, 1, 1, "", "AsyncWiredSwitch8"]], "homematicip.aio.device.AsyncAccelerationSensor": [[3, 2, 1, "", "set_acceleration_sensor_event_filter_period"], [3, 2, 1, "", "set_acceleration_sensor_mode"], [3, 2, 1, "", "set_acceleration_sensor_neutral_position"], [3, 2, 1, "", "set_acceleration_sensor_sensitivity"], [3, 2, 1, "", "set_acceleration_sensor_trigger_angle"], [3, 2, 1, "", "set_notification_sound_type"]], "homematicip.aio.device.AsyncBlind": [[3, 2, 1, "", "set_slats_level"]], "homematicip.aio.device.AsyncBlindModule": [[3, 2, 1, "", "set_primary_shading_level"], [3, 2, 1, "", "set_secondary_shading_level"], [3, 2, 1, "", "stop"]], "homematicip.aio.device.AsyncBrandSwitchNotificationLight": [[3, 2, 1, "", "set_rgb_dim_level"], [3, 2, 1, "", "set_rgb_dim_level_with_time"]], "homematicip.aio.device.AsyncDevice": [[3, 2, 1, "", "authorizeUpdate"], [3, 2, 1, "", "delete"], [3, 2, 1, "", "is_update_applicable"], [3, 2, 1, "", "set_label"], [3, 2, 1, "", "set_router_module_enabled"]], "homematicip.aio.device.AsyncDimmer": [[3, 2, 1, "", "set_dim_level"]], "homematicip.aio.device.AsyncDoorLockDrive": [[3, 2, 1, "", "set_lock_state"]], "homematicip.aio.device.AsyncDoorModule": [[3, 2, 1, "", "send_door_command"]], "homematicip.aio.device.AsyncFloorTerminalBlock12": [[3, 2, 1, "", "set_minimum_floor_heating_valve_position"]], "homematicip.aio.device.AsyncOperationLockableDevice": [[3, 2, 1, "", "set_operation_lock"]], "homematicip.aio.device.AsyncRoomControlDeviceAnalog": [[3, 2, 1, "", "from_json"]], "homematicip.aio.device.AsyncShutter": [[3, 2, 1, "", "set_shutter_level"], [3, 2, 1, "", "set_shutter_stop"]], "homematicip.aio.device.AsyncSwitch": [[3, 2, 1, "", "set_switch_state"], [3, 2, 1, "", "turn_off"], [3, 2, 1, "", "turn_on"]], "homematicip.aio.device.AsyncSwitchMeasuring": [[3, 2, 1, "", "reset_energy_counter"]], "homematicip.aio.device.AsyncTemperatureHumiditySensorDisplay": [[3, 2, 1, "", "set_display"]], "homematicip.aio.device.AsyncTiltVibrationSensor": [[3, 2, 1, "", "set_acceleration_sensor_event_filter_period"], [3, 2, 1, "", "set_acceleration_sensor_mode"], [3, 2, 1, "", "set_acceleration_sensor_sensitivity"], [3, 2, 1, "", "set_acceleration_sensor_trigger_angle"]], "homematicip.aio.device.AsyncWallMountedGarageDoorController": [[3, 2, 1, "", "send_start_impulse"]], "homematicip.aio.device.AsyncWaterSensor": [[3, 2, 1, "", "set_acoustic_alarm_signal"], [3, 2, 1, "", "set_acoustic_alarm_timing"], [3, 2, 1, "", "set_acoustic_water_alarm_trigger"], [3, 2, 1, "", "set_inapp_water_alarm_trigger"], [3, 2, 1, "", "set_siren_water_alarm_trigger"]], "homematicip.aio.device.AsyncWiredPushButton": [[3, 2, 1, "", "set_dim_level"], [3, 2, 1, "", "set_optical_signal"], [3, 2, 1, "", "set_switch_state"], [3, 2, 1, "", "turn_off"], [3, 2, 1, "", "turn_on"]], "homematicip.aio.group": [[3, 1, 1, "", "AsyncAccessAuthorizationProfileGroup"], [3, 1, 1, "", "AsyncAccessControlGroup"], [3, 1, 1, "", "AsyncAlarmSwitchingGroup"], [3, 1, 1, "", "AsyncEnergyGroup"], [3, 1, 1, "", "AsyncEnvironmentGroup"], [3, 1, 1, "", "AsyncExtendedGarageDoorGroup"], [3, 1, 1, "", "AsyncExtendedLinkedShutterGroup"], [3, 1, 1, "", "AsyncExtendedLinkedSwitchingGroup"], [3, 1, 1, "", "AsyncGroup"], [3, 1, 1, "", "AsyncHeatingChangeoverGroup"], [3, 1, 1, "", "AsyncHeatingCoolingDemandBoilerGroup"], [3, 1, 1, "", "AsyncHeatingCoolingDemandGroup"], [3, 1, 1, "", "AsyncHeatingCoolingDemandPumpGroup"], [3, 1, 1, "", "AsyncHeatingDehumidifierGroup"], [3, 1, 1, "", "AsyncHeatingExternalClockGroup"], [3, 1, 1, "", "AsyncHeatingFailureAlertRuleGroup"], [3, 1, 1, "", "AsyncHeatingGroup"], [3, 1, 1, "", "AsyncHeatingHumidyLimiterGroup"], [3, 1, 1, "", "AsyncHeatingTemperatureLimiterGroup"], [3, 1, 1, "", "AsyncHotWaterGroup"], [3, 1, 1, "", "AsyncHumidityWarningRuleGroup"], [3, 1, 1, "", "AsyncInboxGroup"], [3, 1, 1, "", "AsyncIndoorClimateGroup"], [3, 1, 1, "", "AsyncLinkedSwitchingGroup"], [3, 1, 1, "", "AsyncLockOutProtectionRule"], [3, 1, 1, "", "AsyncMetaGroup"], [3, 1, 1, "", "AsyncOverHeatProtectionRule"], [3, 1, 1, "", "AsyncSecurityGroup"], [3, 1, 1, "", "AsyncSecurityZoneGroup"], [3, 1, 1, "", "AsyncShutterProfile"], [3, 1, 1, "", "AsyncShutterWindProtectionRule"], [3, 1, 1, "", "AsyncSmokeAlarmDetectionRule"], [3, 1, 1, "", "AsyncSwitchGroupBase"], [3, 1, 1, "", "AsyncSwitchingGroup"], [3, 1, 1, "", "AsyncSwitchingProfileGroup"]], "homematicip.aio.group.AsyncAlarmSwitchingGroup": [[3, 2, 1, "", "set_on_time"], [3, 2, 1, "", "set_signal_acoustic"], [3, 2, 1, "", "set_signal_optical"], [3, 2, 1, "", "test_signal_acoustic"], [3, 2, 1, "", "test_signal_optical"]], "homematicip.aio.group.AsyncExtendedLinkedShutterGroup": [[3, 2, 1, "", "set_shutter_level"], [3, 2, 1, "", "set_shutter_stop"], [3, 2, 1, "", "set_slats_level"]], "homematicip.aio.group.AsyncExtendedLinkedSwitchingGroup": [[3, 2, 1, "", "set_on_time"]], "homematicip.aio.group.AsyncGroup": [[3, 2, 1, "", "delete"], [3, 2, 1, "", "set_label"]], "homematicip.aio.group.AsyncHeatingGroup": [[3, 2, 1, "", "set_active_profile"], [3, 2, 1, "", "set_boost"], [3, 2, 1, "", "set_boost_duration"], [3, 2, 1, "", "set_control_mode"], [3, 2, 1, "", "set_point_temperature"]], "homematicip.aio.group.AsyncHotWaterGroup": [[3, 2, 1, "", "set_profile_mode"]], "homematicip.aio.group.AsyncLinkedSwitchingGroup": [[3, 2, 1, "", "set_light_group_switches"]], "homematicip.aio.group.AsyncShutterProfile": [[3, 2, 1, "", "set_profile_mode"], [3, 2, 1, "", "set_shutter_level"], [3, 2, 1, "", "set_shutter_stop"], [3, 2, 1, "", "set_slats_level"]], "homematicip.aio.group.AsyncSwitchGroupBase": [[3, 2, 1, "", "set_switch_state"], [3, 2, 1, "", "turn_off"], [3, 2, 1, "", "turn_on"]], "homematicip.aio.group.AsyncSwitchingGroup": [[3, 2, 1, "", "set_shutter_level"], [3, 2, 1, "", "set_shutter_stop"], [3, 2, 1, "", "set_slats_level"]], "homematicip.aio.group.AsyncSwitchingProfileGroup": [[3, 2, 1, "", "create"], [3, 2, 1, "", "set_group_channels"], [3, 2, 1, "", "set_profile_mode"]], "homematicip.aio.home": [[3, 1, 1, "", "AsyncHome"]], "homematicip.aio.home.AsyncHome": [[3, 2, 1, "", "activate_absence_permanent"], [3, 2, 1, "", "activate_absence_with_duration"], [3, 2, 1, "", "activate_absence_with_period"], [3, 2, 1, "", "activate_vacation"], [3, 2, 1, "", "deactivate_absence"], [3, 2, 1, "", "deactivate_vacation"], [3, 2, 1, "", "delete_group"], [3, 2, 1, "", "disable_events"], [3, 2, 1, "", "download_configuration"], [3, 2, 1, "", "enable_events"], [3, 2, 1, "", "get_OAuth_OTK"], [3, 2, 1, "", "get_current_state"], [3, 2, 1, "", "get_security_journal"], [3, 2, 1, "", "init"], [3, 2, 1, "", "set_cooling"], [3, 2, 1, "", "set_intrusion_alert_through_smoke_detectors"], [3, 2, 1, "", "set_location"], [3, 2, 1, "", "set_pin"], [3, 2, 1, "", "set_powermeter_unit_price"], [3, 2, 1, "", "set_security_zones_activation"], [3, 2, 1, "", "set_timezone"], [3, 2, 1, "", "set_zone_activation_delay"], [3, 2, 1, "", "set_zones_device_assignment"]], "homematicip.aio.rule": [[3, 1, 1, "", "AsyncRule"], [3, 1, 1, "", "AsyncSimpleRule"]], "homematicip.aio.rule.AsyncRule": [[3, 2, 1, "", "set_label"]], "homematicip.aio.rule.AsyncSimpleRule": [[3, 2, 1, "", "disable"], [3, 2, 1, "", "enable"], [3, 2, 1, "", "get_simple_rule"], [3, 2, 1, "", "set_rule_enabled_state"]], "homematicip.aio.securityEvent": [[3, 1, 1, "", "AsyncAccessPointConnectedEvent"], [3, 1, 1, "", "AsyncAccessPointDisconnectedEvent"], [3, 1, 1, "", "AsyncActivationChangedEvent"], [3, 1, 1, "", "AsyncExternalTriggeredEvent"], [3, 1, 1, "", "AsyncMainsFailureEvent"], [3, 1, 1, "", "AsyncMoistureDetectionEvent"], [3, 1, 1, "", "AsyncOfflineAlarmEvent"], [3, 1, 1, "", "AsyncOfflineWaterDetectionEvent"], [3, 1, 1, "", "AsyncSabotageEvent"], [3, 1, 1, "", "AsyncSecurityEvent"], [3, 1, 1, "", "AsyncSecurityZoneEvent"], [3, 1, 1, "", "AsyncSensorEvent"], [3, 1, 1, "", "AsyncSilenceChangedEvent"], [3, 1, 1, "", "AsyncSmokeAlarmEvent"], [3, 1, 1, "", "AsyncWaterDetectionEvent"]], "homematicip.auth": [[2, 1, 1, "", "Auth"]], "homematicip.auth.Auth": [[2, 2, 1, "", "confirmAuthToken"], [2, 2, 1, "", "connectionRequest"], [2, 2, 1, "", "isRequestAcknowledged"], [2, 2, 1, "", "requestAuthToken"]], "homematicip.base": [[4, 0, 0, "-", "base_connection"], [4, 0, 0, "-", "constants"], [4, 0, 0, "-", "enums"], [4, 0, 0, "-", "functionalChannels"], [4, 0, 0, "-", "helpers"]], "homematicip.base.base_connection": [[4, 1, 1, "", "BaseConnection"], [4, 5, 1, "", "HmipConnectionError"], [4, 5, 1, "", "HmipServerCloseError"], [4, 5, 1, "", "HmipThrottlingError"], [4, 5, 1, "", "HmipWrongHttpStatusError"]], "homematicip.base.base_connection.BaseConnection": [[4, 4, 1, "", "accesspoint_id"], [4, 4, 1, "", "auth_token"], [4, 4, 1, "", "clientCharacteristics"], [4, 4, 1, "", "clientauth_token"], [4, 2, 1, "", "init"], [4, 2, 1, "", "set_auth_token"], [4, 2, 1, "", "set_token_and_characteristics"], [4, 4, 1, "", "urlREST"], [4, 4, 1, "", "urlWebSocket"]], "homematicip.base.enums": [[4, 1, 1, "", "AbsenceType"], [4, 1, 1, "", "AccelerationSensorMode"], [4, 1, 1, "", "AccelerationSensorNeutralPosition"], [4, 1, 1, "", "AccelerationSensorSensitivity"], [4, 1, 1, "", "AcousticAlarmSignal"], [4, 1, 1, "", "AcousticAlarmTiming"], [4, 1, 1, "", "AlarmContactType"], [4, 1, 1, "", "AlarmSignalType"], [4, 1, 1, "", "ApExchangeState"], [4, 1, 1, "", "AutoNameEnum"], [4, 1, 1, "", "AutomationRuleType"], [4, 1, 1, "", "BinaryBehaviorType"], [4, 1, 1, "", "ChannelEventTypes"], [4, 1, 1, "", "CliActions"], [4, 1, 1, "", "ClientType"], [4, 1, 1, "", "ClimateControlDisplay"], [4, 1, 1, "", "ClimateControlMode"], [4, 1, 1, "", "ConnectionType"], [4, 1, 1, "", "ContactType"], [4, 1, 1, "", "DeviceArchetype"], [4, 1, 1, "", "DeviceType"], [4, 1, 1, "", "DeviceUpdateState"], [4, 1, 1, "", "DeviceUpdateStrategy"], [4, 1, 1, "", "DoorCommand"], [4, 1, 1, "", "DoorState"], [4, 1, 1, "", "DriveSpeed"], [4, 1, 1, "", "EcoDuration"], [4, 1, 1, "", "EventType"], [4, 1, 1, "", "FunctionalChannelType"], [4, 1, 1, "", "FunctionalHomeType"], [4, 1, 1, "", "GroupType"], [4, 1, 1, "", "GroupVisibility"], [4, 1, 1, "", "HeatingFailureValidationType"], [4, 1, 1, "", "HeatingLoadType"], [4, 1, 1, "", "HeatingValveType"], [4, 1, 1, "", "HomeUpdateState"], [4, 1, 1, "", "HumidityValidationType"], [4, 1, 1, "", "LiveUpdateState"], [4, 1, 1, "", "LockState"], [4, 1, 1, "", "MotionDetectionSendInterval"], [4, 1, 1, "", "MotorState"], [4, 1, 1, "", "MultiModeInputMode"], [4, 1, 1, "", "NotificationSoundType"], [4, 1, 1, "", "OpticalAlarmSignal"], [4, 1, 1, "", "OpticalSignalBehaviour"], [4, 1, 1, "", "PassageDirection"], [4, 1, 1, "", "ProfileMode"], [4, 1, 1, "", "RGBColorState"], [4, 1, 1, "", "SecurityEventType"], [4, 1, 1, "", "SecurityZoneActivationMode"], [4, 1, 1, "", "ShadingPackagePosition"], [4, 1, 1, "", "ShadingStateType"], [4, 1, 1, "", "SmokeDetectorAlarmType"], [4, 1, 1, "", "ValveState"], [4, 1, 1, "", "WaterAlarmTrigger"], [4, 1, 1, "", "WeatherCondition"], [4, 1, 1, "", "WeatherDayTime"], [4, 1, 1, "", "WindValueType"], [4, 1, 1, "", "WindowState"]], "homematicip.base.enums.AbsenceType": [[4, 3, 1, "", "NOT_ABSENT"], [4, 3, 1, "", "PARTY"], [4, 3, 1, "", "PERIOD"], [4, 3, 1, "", "PERMANENT"], [4, 3, 1, "", "VACATION"]], "homematicip.base.enums.AccelerationSensorMode": [[4, 3, 1, "", "ANY_MOTION"], [4, 3, 1, "", "FLAT_DECT"]], "homematicip.base.enums.AccelerationSensorNeutralPosition": [[4, 3, 1, "", "HORIZONTAL"], [4, 3, 1, "", "VERTICAL"]], "homematicip.base.enums.AccelerationSensorSensitivity": [[4, 3, 1, "", "SENSOR_RANGE_16G"], [4, 3, 1, "", "SENSOR_RANGE_2G"], [4, 3, 1, "", "SENSOR_RANGE_2G_2PLUS_SENSE"], [4, 3, 1, "", "SENSOR_RANGE_2G_PLUS_SENS"], [4, 3, 1, "", "SENSOR_RANGE_4G"], [4, 3, 1, "", "SENSOR_RANGE_8G"]], "homematicip.base.enums.AcousticAlarmSignal": [[4, 3, 1, "", "DELAYED_EXTERNALLY_ARMED"], [4, 3, 1, "", "DELAYED_INTERNALLY_ARMED"], [4, 3, 1, "", "DISABLE_ACOUSTIC_SIGNAL"], [4, 3, 1, "", "DISARMED"], [4, 3, 1, "", "ERROR"], [4, 3, 1, "", "EVENT"], [4, 3, 1, "", "EXTERNALLY_ARMED"], [4, 3, 1, "", "FREQUENCY_ALTERNATING_LOW_HIGH"], [4, 3, 1, "", "FREQUENCY_ALTERNATING_LOW_MID_HIGH"], [4, 3, 1, "", "FREQUENCY_FALLING"], [4, 3, 1, "", "FREQUENCY_HIGHON_LONGOFF"], [4, 3, 1, "", "FREQUENCY_HIGHON_OFF"], [4, 3, 1, "", "FREQUENCY_LOWON_LONGOFF_HIGHON_LONGOFF"], [4, 3, 1, "", "FREQUENCY_LOWON_OFF_HIGHON_OFF"], [4, 3, 1, "", "FREQUENCY_RISING"], [4, 3, 1, "", "FREQUENCY_RISING_AND_FALLING"], [4, 3, 1, "", "INTERNALLY_ARMED"], [4, 3, 1, "", "LOW_BATTERY"]], "homematicip.base.enums.AcousticAlarmTiming": [[4, 3, 1, "", "ONCE_PER_MINUTE"], [4, 3, 1, "", "PERMANENT"], [4, 3, 1, "", "SIX_MINUTES"], [4, 3, 1, "", "THREE_MINUTES"]], "homematicip.base.enums.AlarmContactType": [[4, 3, 1, "", "PASSIVE_GLASS_BREAKAGE_DETECTOR"], [4, 3, 1, "", "WINDOW_DOOR_CONTACT"]], "homematicip.base.enums.AlarmSignalType": [[4, 3, 1, "", "FULL_ALARM"], [4, 3, 1, "", "NO_ALARM"], [4, 3, 1, "", "SILENT_ALARM"]], "homematicip.base.enums.ApExchangeState": [[4, 3, 1, "", "DONE"], [4, 3, 1, "", "IN_PROGRESS"], [4, 3, 1, "", "NONE"], [4, 3, 1, "", "REJECTED"], [4, 3, 1, "", "REQUESTED"]], "homematicip.base.enums.AutoNameEnum": [[4, 2, 1, "", "from_str"]], "homematicip.base.enums.AutomationRuleType": [[4, 3, 1, "", "SIMPLE"]], "homematicip.base.enums.BinaryBehaviorType": [[4, 3, 1, "", "NORMALLY_CLOSE"], [4, 3, 1, "", "NORMALLY_OPEN"]], "homematicip.base.enums.ChannelEventTypes": [[4, 3, 1, "", "DOOR_BELL_SENSOR_EVENT"]], "homematicip.base.enums.CliActions": [[4, 3, 1, "", "RESET_ENERGY_COUNTER"], [4, 3, 1, "", "SEND_DOOR_COMMAND"], [4, 3, 1, "", "SET_DIM_LEVEL"], [4, 3, 1, "", "SET_LOCK_STATE"], [4, 3, 1, "", "SET_SHUTTER_LEVEL"], [4, 3, 1, "", "SET_SHUTTER_STOP"], [4, 3, 1, "", "SET_SLATS_LEVEL"], [4, 3, 1, "", "SET_SWITCH_STATE"], [4, 3, 1, "", "TOGGLE_GARAGE_DOOR"]], "homematicip.base.enums.ClientType": [[4, 3, 1, "", "APP"], [4, 3, 1, "", "C2C"]], "homematicip.base.enums.ClimateControlDisplay": [[4, 3, 1, "", "ACTUAL"], [4, 3, 1, "", "ACTUAL_HUMIDITY"], [4, 3, 1, "", "SETPOINT"]], "homematicip.base.enums.ClimateControlMode": [[4, 3, 1, "", "AUTOMATIC"], [4, 3, 1, "", "ECO"], [4, 3, 1, "", "MANUAL"]], "homematicip.base.enums.ConnectionType": [[4, 3, 1, "", "EXTERNAL"], [4, 3, 1, "", "HMIP_LAN"], [4, 3, 1, "", "HMIP_RF"], [4, 3, 1, "", "HMIP_WIRED"], [4, 3, 1, "", "HMIP_WLAN"]], "homematicip.base.enums.ContactType": [[4, 3, 1, "", "NORMALLY_CLOSE"], [4, 3, 1, "", "NORMALLY_OPEN"]], "homematicip.base.enums.DeviceArchetype": [[4, 3, 1, "", "EXTERNAL"], [4, 3, 1, "", "HMIP"]], "homematicip.base.enums.DeviceType": [[4, 3, 1, "", "ACCELERATION_SENSOR"], [4, 3, 1, "", "ACCESS_POINT"], [4, 3, 1, "", "ALARM_SIREN_INDOOR"], [4, 3, 1, "", "ALARM_SIREN_OUTDOOR"], [4, 3, 1, "", "BASE_DEVICE"], [4, 3, 1, "", "BLIND_MODULE"], [4, 3, 1, "", "BRAND_BLIND"], [4, 3, 1, "", "BRAND_DIMMER"], [4, 3, 1, "", "BRAND_PUSH_BUTTON"], [4, 3, 1, "", "BRAND_SHUTTER"], [4, 3, 1, "", "BRAND_SWITCH_2"], [4, 3, 1, "", "BRAND_SWITCH_MEASURING"], [4, 3, 1, "", "BRAND_SWITCH_NOTIFICATION_LIGHT"], [4, 3, 1, "", "BRAND_WALL_MOUNTED_THERMOSTAT"], [4, 3, 1, "", "CARBON_DIOXIDE_SENSOR"], [4, 3, 1, "", "DALI_GATEWAY"], [4, 3, 1, "", "DEVICE"], [4, 3, 1, "", "DIN_RAIL_BLIND_4"], [4, 3, 1, "", "DIN_RAIL_DIMMER_3"], [4, 3, 1, "", "DIN_RAIL_SWITCH"], [4, 3, 1, "", "DIN_RAIL_SWITCH_4"], [4, 3, 1, "", "DOOR_BELL_BUTTON"], [4, 3, 1, "", "DOOR_BELL_CONTACT_INTERFACE"], [4, 3, 1, "", "DOOR_LOCK_DRIVE"], [4, 3, 1, "", "DOOR_LOCK_SENSOR"], [4, 3, 1, "", "ENERGY_SENSORS_INTERFACE"], [4, 3, 1, "", "EXTERNAL"], [4, 3, 1, "", "FLOOR_TERMINAL_BLOCK_10"], [4, 3, 1, "", "FLOOR_TERMINAL_BLOCK_12"], [4, 3, 1, "", "FLOOR_TERMINAL_BLOCK_6"], [4, 3, 1, "", "FULL_FLUSH_BLIND"], [4, 3, 1, "", "FULL_FLUSH_CONTACT_INTERFACE"], [4, 3, 1, "", "FULL_FLUSH_CONTACT_INTERFACE_6"], [4, 3, 1, "", "FULL_FLUSH_DIMMER"], [4, 3, 1, "", "FULL_FLUSH_INPUT_SWITCH"], [4, 3, 1, "", "FULL_FLUSH_SHUTTER"], [4, 3, 1, "", "FULL_FLUSH_SWITCH_MEASURING"], [4, 3, 1, "", "HEATING_SWITCH_2"], [4, 3, 1, "", "HEATING_THERMOSTAT"], [4, 3, 1, "", "HEATING_THERMOSTAT_COMPACT"], [4, 3, 1, "", "HEATING_THERMOSTAT_COMPACT_PLUS"], [4, 3, 1, "", "HEATING_THERMOSTAT_EVO"], [4, 3, 1, "", "HOERMANN_DRIVES_MODULE"], [4, 3, 1, "", "HOME_CONTROL_ACCESS_POINT"], [4, 3, 1, "", "KEY_REMOTE_CONTROL_4"], [4, 3, 1, "", "KEY_REMOTE_CONTROL_ALARM"], [4, 3, 1, "", "LIGHT_SENSOR"], [4, 3, 1, "", "MOTION_DETECTOR_INDOOR"], [4, 3, 1, "", "MOTION_DETECTOR_OUTDOOR"], [4, 3, 1, "", "MOTION_DETECTOR_PUSH_BUTTON"], [4, 3, 1, "", "MULTI_IO_BOX"], [4, 3, 1, "", "OPEN_COLLECTOR_8_MODULE"], [4, 3, 1, "", "PASSAGE_DETECTOR"], [4, 3, 1, "", "PLUGABLE_SWITCH"], [4, 3, 1, "", "PLUGABLE_SWITCH_MEASURING"], [4, 3, 1, "", "PLUGGABLE_DIMMER"], [4, 3, 1, "", "PLUGGABLE_MAINS_FAILURE_SURVEILLANCE"], [4, 3, 1, "", "PRESENCE_DETECTOR_INDOOR"], [4, 3, 1, "", "PRINTED_CIRCUIT_BOARD_SWITCH_2"], [4, 3, 1, "", "PRINTED_CIRCUIT_BOARD_SWITCH_BATTERY"], [4, 3, 1, "", "PUSH_BUTTON"], [4, 3, 1, "", "PUSH_BUTTON_6"], [4, 3, 1, "", "PUSH_BUTTON_FLAT"], [4, 3, 1, "", "RAIN_SENSOR"], [4, 3, 1, "", "REMOTE_CONTROL_8"], [4, 3, 1, "", "REMOTE_CONTROL_8_MODULE"], [4, 3, 1, "", "RGBW_DIMMER"], [4, 3, 1, "", "ROOM_CONTROL_DEVICE"], [4, 3, 1, "", "ROOM_CONTROL_DEVICE_ANALOG"], [4, 3, 1, "", "ROTARY_HANDLE_SENSOR"], [4, 3, 1, "", "SHUTTER_CONTACT"], [4, 3, 1, "", "SHUTTER_CONTACT_INTERFACE"], [4, 3, 1, "", "SHUTTER_CONTACT_INVISIBLE"], [4, 3, 1, "", "SHUTTER_CONTACT_MAGNETIC"], [4, 3, 1, "", "SHUTTER_CONTACT_OPTICAL_PLUS"], [4, 3, 1, "", "SMOKE_DETECTOR"], [4, 3, 1, "", "TEMPERATURE_HUMIDITY_SENSOR"], [4, 3, 1, "", "TEMPERATURE_HUMIDITY_SENSOR_DISPLAY"], [4, 3, 1, "", "TEMPERATURE_HUMIDITY_SENSOR_OUTDOOR"], [4, 3, 1, "", "TEMPERATURE_SENSOR_2_EXTERNAL_DELTA"], [4, 3, 1, "", "TILT_VIBRATION_SENSOR"], [4, 3, 1, "", "TORMATIC_MODULE"], [4, 3, 1, "", "WALL_MOUNTED_GARAGE_DOOR_CONTROLLER"], [4, 3, 1, "", "WALL_MOUNTED_THERMOSTAT_BASIC_HUMIDITY"], [4, 3, 1, "", "WALL_MOUNTED_THERMOSTAT_PRO"], [4, 3, 1, "", "WALL_MOUNTED_UNIVERSAL_ACTUATOR"], [4, 3, 1, "", "WATER_SENSOR"], [4, 3, 1, "", "WEATHER_SENSOR"], [4, 3, 1, "", "WEATHER_SENSOR_PLUS"], [4, 3, 1, "", "WEATHER_SENSOR_PRO"], [4, 3, 1, "", "WIRED_BLIND_4"], [4, 3, 1, "", "WIRED_DIMMER_3"], [4, 3, 1, "", "WIRED_DIN_RAIL_ACCESS_POINT"], [4, 3, 1, "", "WIRED_FLOOR_TERMINAL_BLOCK_12"], [4, 3, 1, "", "WIRED_INPUT_32"], [4, 3, 1, "", "WIRED_INPUT_SWITCH_6"], [4, 3, 1, "", "WIRED_MOTION_DETECTOR_PUSH_BUTTON"], [4, 3, 1, "", "WIRED_PRESENCE_DETECTOR_INDOOR"], [4, 3, 1, "", "WIRED_PUSH_BUTTON_2"], [4, 3, 1, "", "WIRED_PUSH_BUTTON_6"], [4, 3, 1, "", "WIRED_SWITCH_4"], [4, 3, 1, "", "WIRED_SWITCH_8"], [4, 3, 1, "", "WIRED_WALL_MOUNTED_THERMOSTAT"]], "homematicip.base.enums.DeviceUpdateState": [[4, 3, 1, "", "BACKGROUND_UPDATE_NOT_SUPPORTED"], [4, 3, 1, "", "TRANSFERING_UPDATE"], [4, 3, 1, "", "UPDATE_AUTHORIZED"], [4, 3, 1, "", "UPDATE_AVAILABLE"], [4, 3, 1, "", "UP_TO_DATE"]], "homematicip.base.enums.DeviceUpdateStrategy": [[4, 3, 1, "", "AUTOMATICALLY_IF_POSSIBLE"], [4, 3, 1, "", "MANUALLY"]], "homematicip.base.enums.DoorCommand": [[4, 3, 1, "", "CLOSE"], [4, 3, 1, "", "OPEN"], [4, 3, 1, "", "PARTIAL_OPEN"], [4, 3, 1, "", "STOP"]], "homematicip.base.enums.DoorState": [[4, 3, 1, "", "CLOSED"], [4, 3, 1, "", "OPEN"], [4, 3, 1, "", "POSITION_UNKNOWN"], [4, 3, 1, "", "VENTILATION_POSITION"]], "homematicip.base.enums.DriveSpeed": [[4, 3, 1, "", "CREEP_SPEED"], [4, 3, 1, "", "NOMINAL_SPEED"], [4, 3, 1, "", "OPTIONAL_SPEED"], [4, 3, 1, "", "SLOW_SPEED"]], "homematicip.base.enums.EcoDuration": [[4, 3, 1, "", "FOUR"], [4, 3, 1, "", "ONE"], [4, 3, 1, "", "PERMANENT"], [4, 3, 1, "", "SIX"], [4, 3, 1, "", "TWO"]], "homematicip.base.enums.EventType": [[4, 3, 1, "", "CLIENT_ADDED"], [4, 3, 1, "", "CLIENT_CHANGED"], [4, 3, 1, "", "CLIENT_REMOVED"], [4, 3, 1, "", "DEVICE_ADDED"], [4, 3, 1, "", "DEVICE_CHANGED"], [4, 3, 1, "", "DEVICE_CHANNEL_EVENT"], [4, 3, 1, "", "DEVICE_REMOVED"], [4, 3, 1, "", "GROUP_ADDED"], [4, 3, 1, "", "GROUP_CHANGED"], [4, 3, 1, "", "GROUP_REMOVED"], [4, 3, 1, "", "HOME_CHANGED"], [4, 3, 1, "", "SECURITY_JOURNAL_CHANGED"]], "homematicip.base.enums.FunctionalChannelType": [[4, 3, 1, "", "ACCELERATION_SENSOR_CHANNEL"], [4, 3, 1, "", "ACCESS_AUTHORIZATION_CHANNEL"], [4, 3, 1, "", "ACCESS_CONTROLLER_CHANNEL"], [4, 3, 1, "", "ACCESS_CONTROLLER_WIRED_CHANNEL"], [4, 3, 1, "", "ALARM_SIREN_CHANNEL"], [4, 3, 1, "", "ANALOG_OUTPUT_CHANNEL"], [4, 3, 1, "", "ANALOG_ROOM_CONTROL_CHANNEL"], [4, 3, 1, "", "BLIND_CHANNEL"], [4, 3, 1, "", "CARBON_DIOXIDE_SENSOR_CHANNEL"], [4, 3, 1, "", "CHANGE_OVER_CHANNEL"], [4, 3, 1, "", "CLIMATE_SENSOR_CHANNEL"], [4, 3, 1, "", "CONTACT_INTERFACE_CHANNEL"], [4, 3, 1, "", "DEHUMIDIFIER_DEMAND_CHANNEL"], [4, 3, 1, "", "DEVICE_BASE"], [4, 3, 1, "", "DEVICE_BASE_FLOOR_HEATING"], [4, 3, 1, "", "DEVICE_GLOBAL_PUMP_CONTROL"], [4, 3, 1, "", "DEVICE_INCORRECT_POSITIONED"], [4, 3, 1, "", "DEVICE_OPERATIONLOCK"], [4, 3, 1, "", "DEVICE_OPERATIONLOCK_WITH_SABOTAGE"], [4, 3, 1, "", "DEVICE_PERMANENT_FULL_RX"], [4, 3, 1, "", "DEVICE_RECHARGEABLE_WITH_SABOTAGE"], [4, 3, 1, "", "DEVICE_SABOTAGE"], [4, 3, 1, "", "DIMMER_CHANNEL"], [4, 3, 1, "", "DOOR_CHANNEL"], [4, 3, 1, "", "DOOR_LOCK_CHANNEL"], [4, 3, 1, "", "DOOR_LOCK_SENSOR_CHANNEL"], [4, 3, 1, "", "ENERGY_SENSORS_INTERFACE_CHANNEL"], [4, 3, 1, "", "EXTERNAL_BASE_CHANNEL"], [4, 3, 1, "", "EXTERNAL_UNIVERSAL_LIGHT_CHANNEL"], [4, 3, 1, "", "FLOOR_TERMINAL_BLOCK_CHANNEL"], [4, 3, 1, "", "FLOOR_TERMINAL_BLOCK_LOCAL_PUMP_CHANNEL"], [4, 3, 1, "", "FLOOR_TERMINAL_BLOCK_MECHANIC_CHANNEL"], [4, 3, 1, "", "FUNCTIONAL_CHANNEL"], [4, 3, 1, "", "GENERIC_INPUT_CHANNEL"], [4, 3, 1, "", "HEATING_THERMOSTAT_CHANNEL"], [4, 3, 1, "", "HEAT_DEMAND_CHANNEL"], [4, 3, 1, "", "IMPULSE_OUTPUT_CHANNEL"], [4, 3, 1, "", "INTERNAL_SWITCH_CHANNEL"], [4, 3, 1, "", "LIGHT_SENSOR_CHANNEL"], [4, 3, 1, "", "MAINS_FAILURE_CHANNEL"], [4, 3, 1, "", "MOTION_DETECTION_CHANNEL"], [4, 3, 1, "", "MULTI_MODE_INPUT_BLIND_CHANNEL"], [4, 3, 1, "", "MULTI_MODE_INPUT_CHANNEL"], [4, 3, 1, "", "MULTI_MODE_INPUT_DIMMER_CHANNEL"], [4, 3, 1, "", "MULTI_MODE_INPUT_SWITCH_CHANNEL"], [4, 3, 1, "", "NOTIFICATION_LIGHT_CHANNEL"], [4, 3, 1, "", "OPTICAL_SIGNAL_CHANNEL"], [4, 3, 1, "", "OPTICAL_SIGNAL_GROUP_CHANNEL"], [4, 3, 1, "", "PASSAGE_DETECTOR_CHANNEL"], [4, 3, 1, "", "PRESENCE_DETECTION_CHANNEL"], [4, 3, 1, "", "RAIN_DETECTION_CHANNEL"], [4, 3, 1, "", "ROTARY_HANDLE_CHANNEL"], [4, 3, 1, "", "SHADING_CHANNEL"], [4, 3, 1, "", "SHUTTER_CHANNEL"], [4, 3, 1, "", "SHUTTER_CONTACT_CHANNEL"], [4, 3, 1, "", "SINGLE_KEY_CHANNEL"], [4, 3, 1, "", "SMOKE_DETECTOR_CHANNEL"], [4, 3, 1, "", "SWITCH_CHANNEL"], [4, 3, 1, "", "SWITCH_MEASURING_CHANNEL"], [4, 3, 1, "", "TEMPERATURE_SENSOR_2_EXTERNAL_DELTA_CHANNEL"], [4, 3, 1, "", "TILT_VIBRATION_SENSOR_CHANNEL"], [4, 3, 1, "", "UNIVERSAL_ACTUATOR_CHANNEL"], [4, 3, 1, "", "UNIVERSAL_LIGHT_CHANNEL"], [4, 3, 1, "", "UNIVERSAL_LIGHT_GROUP_CHANNEL"], [4, 3, 1, "", "WALL_MOUNTED_THERMOSTAT_PRO_CHANNEL"], [4, 3, 1, "", "WALL_MOUNTED_THERMOSTAT_WITHOUT_DISPLAY_CHANNEL"], [4, 3, 1, "", "WATER_SENSOR_CHANNEL"], [4, 3, 1, "", "WEATHER_SENSOR_CHANNEL"], [4, 3, 1, "", "WEATHER_SENSOR_PLUS_CHANNEL"], [4, 3, 1, "", "WEATHER_SENSOR_PRO_CHANNEL"]], "homematicip.base.enums.FunctionalHomeType": [[4, 3, 1, "", "ACCESS_CONTROL"], [4, 3, 1, "", "ENERGY"], [4, 3, 1, "", "INDOOR_CLIMATE"], [4, 3, 1, "", "LIGHT_AND_SHADOW"], [4, 3, 1, "", "SECURITY_AND_ALARM"], [4, 3, 1, "", "WEATHER_AND_ENVIRONMENT"]], "homematicip.base.enums.GroupType": [[4, 3, 1, "", "ACCESS_AUTHORIZATION_PROFILE"], [4, 3, 1, "", "ACCESS_CONTROL"], [4, 3, 1, "", "ALARM_SWITCHING"], [4, 3, 1, "", "ENERGY"], [4, 3, 1, "", "ENVIRONMENT"], [4, 3, 1, "", "EXTENDED_LINKED_GARAGE_DOOR"], [4, 3, 1, "", "EXTENDED_LINKED_SHUTTER"], [4, 3, 1, "", "EXTENDED_LINKED_SWITCHING"], [4, 3, 1, "", "GROUP"], [4, 3, 1, "", "HEATING"], [4, 3, 1, "", "HEATING_CHANGEOVER"], [4, 3, 1, "", "HEATING_COOLING_DEMAND"], [4, 3, 1, "", "HEATING_COOLING_DEMAND_BOILER"], [4, 3, 1, "", "HEATING_COOLING_DEMAND_PUMP"], [4, 3, 1, "", "HEATING_DEHUMIDIFIER"], [4, 3, 1, "", "HEATING_EXTERNAL_CLOCK"], [4, 3, 1, "", "HEATING_FAILURE_ALERT_RULE_GROUP"], [4, 3, 1, "", "HEATING_HUMIDITY_LIMITER"], [4, 3, 1, "", "HEATING_TEMPERATURE_LIMITER"], [4, 3, 1, "", "HOT_WATER"], [4, 3, 1, "", "HUMIDITY_WARNING_RULE_GROUP"], [4, 3, 1, "", "INBOX"], [4, 3, 1, "", "INDOOR_CLIMATE"], [4, 3, 1, "", "LINKED_SWITCHING"], [4, 3, 1, "", "LOCK_OUT_PROTECTION_RULE"], [4, 3, 1, "", "OVER_HEAT_PROTECTION_RULE"], [4, 3, 1, "", "SECURITY"], [4, 3, 1, "", "SECURITY_BACKUP_ALARM_SWITCHING"], [4, 3, 1, "", "SECURITY_ZONE"], [4, 3, 1, "", "SHUTTER_PROFILE"], [4, 3, 1, "", "SHUTTER_WIND_PROTECTION_RULE"], [4, 3, 1, "", "SMOKE_ALARM_DETECTION_RULE"], [4, 3, 1, "", "SWITCHING"], [4, 3, 1, "", "SWITCHING_PROFILE"]], "homematicip.base.enums.GroupVisibility": [[4, 3, 1, "", "INVISIBLE_CONTROL"], [4, 3, 1, "", "INVISIBLE_GROUP_AND_CONTROL"], [4, 3, 1, "", "VISIBLE"]], "homematicip.base.enums.HeatingFailureValidationType": [[4, 3, 1, "", "HEATING_FAILURE_ALARM"], [4, 3, 1, "", "HEATING_FAILURE_WARNING"], [4, 3, 1, "", "NO_HEATING_FAILURE"]], "homematicip.base.enums.HeatingLoadType": [[4, 3, 1, "", "LOAD_BALANCING"], [4, 3, 1, "", "LOAD_COLLECTION"]], "homematicip.base.enums.HeatingValveType": [[4, 3, 1, "", "NORMALLY_CLOSE"], [4, 3, 1, "", "NORMALLY_OPEN"]], "homematicip.base.enums.HomeUpdateState": [[4, 3, 1, "", "PERFORMING_UPDATE"], [4, 3, 1, "", "PERFORM_UPDATE_SENT"], [4, 3, 1, "", "UPDATE_AVAILABLE"], [4, 3, 1, "", "UP_TO_DATE"]], "homematicip.base.enums.HumidityValidationType": [[4, 3, 1, "", "GREATER_LOWER_LESSER_UPPER_THRESHOLD"], [4, 3, 1, "", "GREATER_UPPER_THRESHOLD"], [4, 3, 1, "", "LESSER_LOWER_THRESHOLD"]], "homematicip.base.enums.LiveUpdateState": [[4, 3, 1, "", "LIVE_UPDATE_NOT_SUPPORTED"], [4, 3, 1, "", "UPDATE_AVAILABLE"], [4, 3, 1, "", "UPDATE_INCOMPLETE"], [4, 3, 1, "", "UP_TO_DATE"]], "homematicip.base.enums.LockState": [[4, 3, 1, "", "LOCKED"], [4, 3, 1, "", "NONE"], [4, 3, 1, "", "OPEN"], [4, 3, 1, "", "UNLOCKED"]], "homematicip.base.enums.MotionDetectionSendInterval": [[4, 3, 1, "", "SECONDS_120"], [4, 3, 1, "", "SECONDS_240"], [4, 3, 1, "", "SECONDS_30"], [4, 3, 1, "", "SECONDS_480"], [4, 3, 1, "", "SECONDS_60"]], "homematicip.base.enums.MotorState": [[4, 3, 1, "", "CLOSING"], [4, 3, 1, "", "OPENING"], [4, 3, 1, "", "STOPPED"]], "homematicip.base.enums.MultiModeInputMode": [[4, 3, 1, "", "BINARY_BEHAVIOR"], [4, 3, 1, "", "KEY_BEHAVIOR"], [4, 3, 1, "", "SWITCH_BEHAVIOR"]], "homematicip.base.enums.NotificationSoundType": [[4, 3, 1, "", "SOUND_LONG"], [4, 3, 1, "", "SOUND_NO_SOUND"], [4, 3, 1, "", "SOUND_SHORT"], [4, 3, 1, "", "SOUND_SHORT_SHORT"]], "homematicip.base.enums.OpticalAlarmSignal": [[4, 3, 1, "", "BLINKING_ALTERNATELY_REPEATING"], [4, 3, 1, "", "BLINKING_BOTH_REPEATING"], [4, 3, 1, "", "CONFIRMATION_SIGNAL_0"], [4, 3, 1, "", "CONFIRMATION_SIGNAL_1"], [4, 3, 1, "", "CONFIRMATION_SIGNAL_2"], [4, 3, 1, "", "DISABLE_OPTICAL_SIGNAL"], [4, 3, 1, "", "DOUBLE_FLASHING_REPEATING"], [4, 3, 1, "", "FLASHING_BOTH_REPEATING"]], "homematicip.base.enums.OpticalSignalBehaviour": [[4, 3, 1, "", "BILLOW_MIDDLE"], [4, 3, 1, "", "BLINKING_MIDDLE"], [4, 3, 1, "", "FLASH_MIDDLE"], [4, 3, 1, "", "OFF"], [4, 3, 1, "", "ON"]], "homematicip.base.enums.PassageDirection": [[4, 3, 1, "", "LEFT"], [4, 3, 1, "", "RIGHT"]], "homematicip.base.enums.ProfileMode": [[4, 3, 1, "", "AUTOMATIC"], [4, 3, 1, "", "MANUAL"]], "homematicip.base.enums.RGBColorState": [[4, 3, 1, "", "BLACK"], [4, 3, 1, "", "BLUE"], [4, 3, 1, "", "GREEN"], [4, 3, 1, "", "PURPLE"], [4, 3, 1, "", "RED"], [4, 3, 1, "", "TURQUOISE"], [4, 3, 1, "", "WHITE"], [4, 3, 1, "", "YELLOW"]], "homematicip.base.enums.SecurityEventType": [[4, 3, 1, "", "ACCESS_POINT_CONNECTED"], [4, 3, 1, "", "ACCESS_POINT_DISCONNECTED"], [4, 3, 1, "", "ACTIVATION_CHANGED"], [4, 3, 1, "", "EXTERNAL_TRIGGERED"], [4, 3, 1, "", "MAINS_FAILURE_EVENT"], [4, 3, 1, "", "MOISTURE_DETECTION_EVENT"], [4, 3, 1, "", "OFFLINE_ALARM"], [4, 3, 1, "", "OFFLINE_WATER_DETECTION_EVENT"], [4, 3, 1, "", "SABOTAGE"], [4, 3, 1, "", "SENSOR_EVENT"], [4, 3, 1, "", "SILENCE_CHANGED"], [4, 3, 1, "", "SMOKE_ALARM"], [4, 3, 1, "", "WATER_DETECTION_EVENT"]], "homematicip.base.enums.SecurityZoneActivationMode": [[4, 3, 1, "", "ACTIVATION_IF_ALL_IN_VALID_STATE"], [4, 3, 1, "", "ACTIVATION_WITH_DEVICE_IGNORELIST"]], "homematicip.base.enums.ShadingPackagePosition": [[4, 3, 1, "", "BOTTOM"], [4, 3, 1, "", "CENTER"], [4, 3, 1, "", "LEFT"], [4, 3, 1, "", "NOT_USED"], [4, 3, 1, "", "RIGHT"], [4, 3, 1, "", "SPLIT"], [4, 3, 1, "", "TDBU"], [4, 3, 1, "", "TOP"]], "homematicip.base.enums.ShadingStateType": [[4, 3, 1, "", "MIXED"], [4, 3, 1, "", "NOT_EXISTENT"], [4, 3, 1, "", "NOT_POSSIBLE"], [4, 3, 1, "", "NOT_USED"], [4, 3, 1, "", "POSITION_USED"], [4, 3, 1, "", "TILT_USED"]], "homematicip.base.enums.SmokeDetectorAlarmType": [[4, 3, 1, "", "IDLE_OFF"], [4, 3, 1, "", "INTRUSION_ALARM"], [4, 3, 1, "", "PRIMARY_ALARM"], [4, 3, 1, "", "SECONDARY_ALARM"]], "homematicip.base.enums.ValveState": [[4, 3, 1, "", "ADAPTION_DONE"], [4, 3, 1, "", "ADAPTION_IN_PROGRESS"], [4, 3, 1, "", "ADJUSTMENT_TOO_BIG"], [4, 3, 1, "", "ADJUSTMENT_TOO_SMALL"], [4, 3, 1, "", "ERROR_POSITION"], [4, 3, 1, "", "RUN_TO_START"], [4, 3, 1, "", "STATE_NOT_AVAILABLE"], [4, 3, 1, "", "TOO_TIGHT"], [4, 3, 1, "", "WAIT_FOR_ADAPTION"]], "homematicip.base.enums.WaterAlarmTrigger": [[4, 3, 1, "", "MOISTURE_DETECTION"], [4, 3, 1, "", "NO_ALARM"], [4, 3, 1, "", "WATER_DETECTION"], [4, 3, 1, "", "WATER_MOISTURE_DETECTION"]], "homematicip.base.enums.WeatherCondition": [[4, 3, 1, "", "CLEAR"], [4, 3, 1, "", "CLOUDY"], [4, 3, 1, "", "CLOUDY_WITH_RAIN"], [4, 3, 1, "", "CLOUDY_WITH_SNOW_RAIN"], [4, 3, 1, "", "FOGGY"], [4, 3, 1, "", "HEAVILY_CLOUDY"], [4, 3, 1, "", "HEAVILY_CLOUDY_WITH_RAIN"], [4, 3, 1, "", "HEAVILY_CLOUDY_WITH_RAIN_AND_THUNDER"], [4, 3, 1, "", "HEAVILY_CLOUDY_WITH_SNOW"], [4, 3, 1, "", "HEAVILY_CLOUDY_WITH_SNOW_RAIN"], [4, 3, 1, "", "HEAVILY_CLOUDY_WITH_STRONG_RAIN"], [4, 3, 1, "", "HEAVILY_CLOUDY_WITH_THUNDER"], [4, 3, 1, "", "LIGHT_CLOUDY"], [4, 3, 1, "", "STRONG_WIND"], [4, 3, 1, "", "UNKNOWN"]], "homematicip.base.enums.WeatherDayTime": [[4, 3, 1, "", "DAY"], [4, 3, 1, "", "NIGHT"], [4, 3, 1, "", "TWILIGHT"]], "homematicip.base.enums.WindValueType": [[4, 3, 1, "", "AVERAGE_VALUE"], [4, 3, 1, "", "CURRENT_VALUE"], [4, 3, 1, "", "MAX_VALUE"], [4, 3, 1, "", "MIN_VALUE"]], "homematicip.base.enums.WindowState": [[4, 3, 1, "", "CLOSED"], [4, 3, 1, "", "OPEN"], [4, 3, 1, "", "TILTED"]], "homematicip.base.functionalChannels": [[4, 1, 1, "", "AccelerationSensorChannel"], [4, 1, 1, "", "AccessAuthorizationChannel"], [4, 1, 1, "", "AccessControllerChannel"], [4, 1, 1, "", "AccessControllerWiredChannel"], [4, 1, 1, "", "AlarmSirenChannel"], [4, 1, 1, "", "AnalogOutputChannel"], [4, 1, 1, "", "AnalogRoomControlChannel"], [4, 1, 1, "", "BlindChannel"], [4, 1, 1, "", "CarbonDioxideSensorChannel"], [4, 1, 1, "", "ChangeOverChannel"], [4, 1, 1, "", "ClimateSensorChannel"], [4, 1, 1, "", "ContactInterfaceChannel"], [4, 1, 1, "", "DehumidifierDemandChannel"], [4, 1, 1, "", "DeviceBaseChannel"], [4, 1, 1, "", "DeviceBaseFloorHeatingChannel"], [4, 1, 1, "", "DeviceGlobalPumpControlChannel"], [4, 1, 1, "", "DeviceIncorrectPositionedChannel"], [4, 1, 1, "", "DeviceOperationLockChannel"], [4, 1, 1, "", "DeviceOperationLockChannelWithSabotage"], [4, 1, 1, "", "DevicePermanentFullRxChannel"], [4, 1, 1, "", "DeviceRechargeableWithSabotage"], [4, 1, 1, "", "DeviceSabotageChannel"], [4, 1, 1, "", "DimmerChannel"], [4, 1, 1, "", "DoorChannel"], [4, 1, 1, "", "DoorLockChannel"], [4, 1, 1, "", "DoorLockSensorChannel"], [4, 1, 1, "", "EnergySensorInterfaceChannel"], [4, 1, 1, "", "ExternalBaseChannel"], [4, 1, 1, "", "ExternalUniversalLightChannel"], [4, 1, 1, "", "FloorTeminalBlockChannel"], [4, 1, 1, "", "FloorTerminalBlockLocalPumpChannel"], [4, 1, 1, "", "FloorTerminalBlockMechanicChannel"], [4, 1, 1, "", "FunctionalChannel"], [4, 1, 1, "", "GenericInputChannel"], [4, 1, 1, "", "HeatDemandChannel"], [4, 1, 1, "", "HeatingThermostatChannel"], [4, 1, 1, "", "ImpulseOutputChannel"], [4, 1, 1, "", "InternalSwitchChannel"], [4, 1, 1, "", "LightSensorChannel"], [4, 1, 1, "", "MainsFailureChannel"], [4, 1, 1, "", "MotionDetectionChannel"], [4, 1, 1, "", "MultiModeInputBlindChannel"], [4, 1, 1, "", "MultiModeInputChannel"], [4, 1, 1, "", "MultiModeInputDimmerChannel"], [4, 1, 1, "", "MultiModeInputSwitchChannel"], [4, 1, 1, "", "NotificationLightChannel"], [4, 1, 1, "", "OpticalSignalChannel"], [4, 1, 1, "", "OpticalSignalGroupChannel"], [4, 1, 1, "", "PassageDetectorChannel"], [4, 1, 1, "", "PresenceDetectionChannel"], [4, 1, 1, "", "RainDetectionChannel"], [4, 1, 1, "", "RotaryHandleChannel"], [4, 1, 1, "", "ShadingChannel"], [4, 1, 1, "", "ShutterChannel"], [4, 1, 1, "", "ShutterContactChannel"], [4, 1, 1, "", "SingleKeyChannel"], [4, 1, 1, "", "SmokeDetectorChannel"], [4, 1, 1, "", "SwitchChannel"], [4, 1, 1, "", "SwitchMeasuringChannel"], [4, 1, 1, "", "TemperatureDifferenceSensor2Channel"], [4, 1, 1, "", "TiltVibrationSensorChannel"], [4, 1, 1, "", "UniversalActuatorChannel"], [4, 1, 1, "", "UniversalLightChannel"], [4, 1, 1, "", "UniversalLightChannelGroup"], [4, 1, 1, "", "WallMountedThermostatProChannel"], [4, 1, 1, "", "WallMountedThermostatWithoutDisplayChannel"], [4, 1, 1, "", "WaterSensorChannel"], [4, 1, 1, "", "WeatherSensorChannel"], [4, 1, 1, "", "WeatherSensorPlusChannel"], [4, 1, 1, "", "WeatherSensorProChannel"]], "homematicip.base.functionalChannels.AccelerationSensorChannel": [[4, 3, 1, "", "accelerationSensorEventFilterPeriod"], [4, 3, 1, "", "accelerationSensorMode"], [4, 3, 1, "", "accelerationSensorNeutralPosition"], [4, 3, 1, "", "accelerationSensorSensitivity"], [4, 3, 1, "", "accelerationSensorTriggerAngle"], [4, 3, 1, "", "accelerationSensorTriggered"], [4, 2, 1, "", "async_set_acceleration_sensor_event_filter_period"], [4, 2, 1, "", "async_set_acceleration_sensor_mode"], [4, 2, 1, "", "async_set_acceleration_sensor_neutral_position"], [4, 2, 1, "", "async_set_acceleration_sensor_sensitivity"], [4, 2, 1, "", "async_set_acceleration_sensor_trigger_angle"], [4, 2, 1, "", "async_set_notification_sound_type"], [4, 2, 1, "", "from_json"], [4, 3, 1, "", "notificationSoundTypeHighToLow"], [4, 3, 1, "", "notificationSoundTypeLowToHigh"], [4, 2, 1, "", "set_acceleration_sensor_event_filter_period"], [4, 2, 1, "", "set_acceleration_sensor_mode"], [4, 2, 1, "", "set_acceleration_sensor_neutral_position"], [4, 2, 1, "", "set_acceleration_sensor_sensitivity"], [4, 2, 1, "", "set_acceleration_sensor_trigger_angle"], [4, 2, 1, "", "set_notification_sound_type"]], "homematicip.base.functionalChannels.AccessAuthorizationChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.AccessControllerChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.AccessControllerWiredChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.AnalogOutputChannel": [[4, 3, 1, "", "analogOutputLevel"], [4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.AnalogRoomControlChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.BlindChannel": [[4, 2, 1, "", "async_set_shutter_level"], [4, 2, 1, "", "async_set_shutter_stop"], [4, 2, 1, "", "async_set_slats_level"], [4, 2, 1, "", "async_stop"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_shutter_level"], [4, 2, 1, "", "set_shutter_stop"], [4, 2, 1, "", "set_slats_level"], [4, 2, 1, "", "stop"]], "homematicip.base.functionalChannels.CarbonDioxideSensorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.ClimateSensorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.ContactInterfaceChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DeviceBaseChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DeviceBaseFloorHeatingChannel": [[4, 2, 1, "", "async_set_minimum_floor_heating_valve_position"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_minimum_floor_heating_valve_position"]], "homematicip.base.functionalChannels.DeviceGlobalPumpControlChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DeviceIncorrectPositionedChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DeviceOperationLockChannel": [[4, 2, 1, "", "async_set_operation_lock"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_operation_lock"]], "homematicip.base.functionalChannels.DevicePermanentFullRxChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DeviceRechargeableWithSabotage": [[4, 3, 1, "", "badBatteryHealth"], [4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DeviceSabotageChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.DimmerChannel": [[4, 2, 1, "", "async_set_dim_level"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_dim_level"]], "homematicip.base.functionalChannels.DoorChannel": [[4, 2, 1, "", "async_send_door_command"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "send_door_command"]], "homematicip.base.functionalChannels.DoorLockChannel": [[4, 2, 1, "", "async_set_lock_state"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_lock_state"]], "homematicip.base.functionalChannels.DoorLockSensorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.EnergySensorInterfaceChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.ExternalBaseChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.ExternalUniversalLightChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.FloorTerminalBlockLocalPumpChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.FloorTerminalBlockMechanicChannel": [[4, 2, 1, "", "from_json"], [4, 3, 1, "", "valveState"]], "homematicip.base.functionalChannels.FunctionalChannel": [[4, 2, 1, "", "add_on_channel_event_handler"], [4, 2, 1, "", "fire_channel_event"], [4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.HeatingThermostatChannel": [[4, 3, 1, "", "automaticValveAdaptionNeeded"], [4, 2, 1, "", "from_json"], [4, 3, 1, "", "setPointTemperature"], [4, 3, 1, "", "temperatureOffset"], [4, 3, 1, "", "valveActualTemperature"], [4, 3, 1, "", "valvePosition"], [4, 3, 1, "", "valveState"]], "homematicip.base.functionalChannels.ImpulseOutputChannel": [[4, 2, 1, "", "async_send_start_impulse"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "send_start_impulse"]], "homematicip.base.functionalChannels.InternalSwitchChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.LightSensorChannel": [[4, 3, 1, "", "averageIllumination"], [4, 3, 1, "", "currentIllumination"], [4, 2, 1, "", "from_json"], [4, 3, 1, "", "highestIllumination"], [4, 3, 1, "", "lowestIllumination"]], "homematicip.base.functionalChannels.MainsFailureChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.MotionDetectionChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.MultiModeInputBlindChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.MultiModeInputChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.MultiModeInputDimmerChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.MultiModeInputSwitchChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.NotificationLightChannel": [[4, 2, 1, "", "async_set_optical_signal"], [4, 2, 1, "", "async_set_rgb_dim_level"], [4, 2, 1, "", "async_set_rgb_dim_level_with_time"], [4, 2, 1, "", "from_json"], [4, 3, 1, "", "on"], [4, 2, 1, "", "set_optical_signal"], [4, 2, 1, "", "set_rgb_dim_level"], [4, 2, 1, "", "set_rgb_dim_level_with_time"], [4, 3, 1, "", "simpleRGBColorState"]], "homematicip.base.functionalChannels.OpticalSignalChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.OpticalSignalGroupChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.PassageDetectorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.PresenceDetectionChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.RainDetectionChannel": [[4, 2, 1, "", "from_json"], [4, 3, 1, "", "rainSensorSensitivity"], [4, 3, 1, "", "raining"]], "homematicip.base.functionalChannels.ShadingChannel": [[4, 2, 1, "", "async_set_primary_shading_level"], [4, 2, 1, "", "async_set_secondary_shading_level"], [4, 2, 1, "", "async_set_shutter_stop"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_primary_shading_level"], [4, 2, 1, "", "set_secondary_shading_level"], [4, 2, 1, "", "set_shutter_stop"]], "homematicip.base.functionalChannels.ShutterChannel": [[4, 2, 1, "", "async_set_shutter_level"], [4, 2, 1, "", "async_set_shutter_stop"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_shutter_level"], [4, 2, 1, "", "set_shutter_stop"]], "homematicip.base.functionalChannels.ShutterContactChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.SingleKeyChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.SmokeDetectorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.SwitchChannel": [[4, 2, 1, "", "async_set_switch_state"], [4, 2, 1, "", "async_turn_off"], [4, 2, 1, "", "async_turn_on"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_switch_state"], [4, 2, 1, "", "turn_off"], [4, 2, 1, "", "turn_on"]], "homematicip.base.functionalChannels.SwitchMeasuringChannel": [[4, 2, 1, "", "async_reset_energy_counter"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "reset_energy_counter"]], "homematicip.base.functionalChannels.TemperatureDifferenceSensor2Channel": [[4, 2, 1, "", "from_json"], [4, 3, 1, "", "temperatureExternalDelta"], [4, 3, 1, "", "temperatureExternalOne"], [4, 3, 1, "", "temperatureExternalTwo"]], "homematicip.base.functionalChannels.TiltVibrationSensorChannel": [[4, 3, 1, "", "accelerationSensorEventFilterPeriod"], [4, 3, 1, "", "accelerationSensorMode"], [4, 3, 1, "", "accelerationSensorSensitivity"], [4, 3, 1, "", "accelerationSensorTriggerAngle"], [4, 3, 1, "", "accelerationSensorTriggered"], [4, 2, 1, "", "async_set_acceleration_sensor_event_filter_period"], [4, 2, 1, "", "async_set_acceleration_sensor_mode"], [4, 2, 1, "", "async_set_acceleration_sensor_sensitivity"], [4, 2, 1, "", "async_set_acceleration_sensor_trigger_angle"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_acceleration_sensor_event_filter_period"], [4, 2, 1, "", "set_acceleration_sensor_mode"], [4, 2, 1, "", "set_acceleration_sensor_sensitivity"], [4, 2, 1, "", "set_acceleration_sensor_trigger_angle"]], "homematicip.base.functionalChannels.UniversalActuatorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.UniversalLightChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.UniversalLightChannelGroup": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.WallMountedThermostatProChannel": [[4, 2, 1, "", "async_set_display"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_display"]], "homematicip.base.functionalChannels.WallMountedThermostatWithoutDisplayChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.WaterSensorChannel": [[4, 2, 1, "", "async_set_acoustic_alarm_signal"], [4, 2, 1, "", "async_set_acoustic_alarm_timing"], [4, 2, 1, "", "async_set_acoustic_water_alarm_trigger"], [4, 2, 1, "", "async_set_inapp_water_alarm_trigger"], [4, 2, 1, "", "async_set_siren_water_alarm_trigger"], [4, 2, 1, "", "from_json"], [4, 2, 1, "", "set_acoustic_alarm_signal"], [4, 2, 1, "", "set_acoustic_alarm_timing"], [4, 2, 1, "", "set_acoustic_water_alarm_trigger"], [4, 2, 1, "", "set_inapp_water_alarm_trigger"], [4, 2, 1, "", "set_siren_water_alarm_trigger"]], "homematicip.base.functionalChannels.WeatherSensorChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.WeatherSensorPlusChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.functionalChannels.WeatherSensorProChannel": [[4, 2, 1, "", "from_json"]], "homematicip.base.helpers": [[4, 6, 1, "", "anonymizeConfig"], [4, 6, 1, "", "bytes2str"], [4, 6, 1, "", "detect_encoding"], [4, 6, 1, "", "get_functional_channel"], [4, 6, 1, "", "get_functional_channels"], [4, 6, 1, "", "handle_config"]], "homematicip.client": [[2, 1, 1, "", "Client"]], "homematicip.client.Client": [[2, 3, 1, "", "c2cServiceIdentifier"], [2, 3, 1, "", "clientType"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "homeId"], [2, 3, 1, "", "id"], [2, 3, 1, "", "label"]], "homematicip.connection": [[2, 1, 1, "", "Connection"]], "homematicip.connection.Connection": [[2, 2, 1, "", "init"]], "homematicip.device": [[2, 1, 1, "", "AccelerationSensor"], [2, 1, 1, "", "AlarmSirenIndoor"], [2, 1, 1, "", "AlarmSirenOutdoor"], [2, 1, 1, "", "BaseDevice"], [2, 1, 1, "", "Blind"], [2, 1, 1, "", "BlindModule"], [2, 1, 1, "", "BrandBlind"], [2, 1, 1, "", "BrandDimmer"], [2, 1, 1, "", "BrandPushButton"], [2, 1, 1, "", "BrandSwitch2"], [2, 1, 1, "", "BrandSwitchMeasuring"], [2, 1, 1, "", "BrandSwitchNotificationLight"], [2, 1, 1, "", "CarbonDioxideSensor"], [2, 1, 1, "", "ContactInterface"], [2, 1, 1, "", "DaliGateway"], [2, 1, 1, "", "Device"], [2, 1, 1, "", "Dimmer"], [2, 1, 1, "", "DinRailBlind4"], [2, 1, 1, "", "DinRailDimmer3"], [2, 1, 1, "", "DinRailSwitch"], [2, 1, 1, "", "DinRailSwitch4"], [2, 1, 1, "", "DoorBellButton"], [2, 1, 1, "", "DoorBellContactInterface"], [2, 1, 1, "", "DoorLockDrive"], [2, 1, 1, "", "DoorLockSensor"], [2, 1, 1, "", "DoorModule"], [2, 1, 1, "", "EnergySensorsInterface"], [2, 1, 1, "", "ExternalDevice"], [2, 1, 1, "", "FloorTerminalBlock10"], [2, 1, 1, "", "FloorTerminalBlock12"], [2, 1, 1, "", "FloorTerminalBlock6"], [2, 1, 1, "", "FullFlushBlind"], [2, 1, 1, "", "FullFlushContactInterface"], [2, 1, 1, "", "FullFlushContactInterface6"], [2, 1, 1, "", "FullFlushDimmer"], [2, 1, 1, "", "FullFlushInputSwitch"], [2, 1, 1, "", "FullFlushShutter"], [2, 1, 1, "", "FullFlushSwitchMeasuring"], [2, 1, 1, "", "GarageDoorModuleTormatic"], [2, 1, 1, "", "HeatingSwitch2"], [2, 1, 1, "", "HeatingThermostat"], [2, 1, 1, "", "HeatingThermostatCompact"], [2, 1, 1, "", "HeatingThermostatEvo"], [2, 1, 1, "", "HoermannDrivesModule"], [2, 1, 1, "", "HomeControlAccessPoint"], [2, 1, 1, "", "HomeControlUnit"], [2, 1, 1, "", "KeyRemoteControl4"], [2, 1, 1, "", "KeyRemoteControlAlarm"], [2, 1, 1, "", "LightSensor"], [2, 1, 1, "", "MotionDetectorIndoor"], [2, 1, 1, "", "MotionDetectorOutdoor"], [2, 1, 1, "", "MotionDetectorPushButton"], [2, 1, 1, "", "MultiIOBox"], [2, 1, 1, "", "OpenCollector8Module"], [2, 1, 1, "", "OperationLockableDevice"], [2, 1, 1, "", "PassageDetector"], [2, 1, 1, "", "PlugableSwitch"], [2, 1, 1, "", "PlugableSwitchMeasuring"], [2, 1, 1, "", "PluggableDimmer"], [2, 1, 1, "", "PluggableMainsFailureSurveillance"], [2, 1, 1, "", "PresenceDetectorIndoor"], [2, 1, 1, "", "PrintedCircuitBoardSwitch2"], [2, 1, 1, "", "PrintedCircuitBoardSwitchBattery"], [2, 1, 1, "", "PushButton"], [2, 1, 1, "", "PushButton6"], [2, 1, 1, "", "PushButtonFlat"], [2, 1, 1, "", "RainSensor"], [2, 1, 1, "", "RemoteControl8"], [2, 1, 1, "", "RemoteControl8Module"], [2, 1, 1, "", "RgbwDimmer"], [2, 1, 1, "", "RoomControlDevice"], [2, 1, 1, "", "RoomControlDeviceAnalog"], [2, 1, 1, "", "RotaryHandleSensor"], [2, 1, 1, "", "SabotageDevice"], [2, 1, 1, "", "Shutter"], [2, 1, 1, "", "ShutterContact"], [2, 1, 1, "", "ShutterContactMagnetic"], [2, 1, 1, "", "ShutterContactOpticalPlus"], [2, 1, 1, "", "SmokeDetector"], [2, 1, 1, "", "Switch"], [2, 1, 1, "", "SwitchMeasuring"], [2, 1, 1, "", "TemperatureDifferenceSensor2"], [2, 1, 1, "", "TemperatureHumiditySensorDisplay"], [2, 1, 1, "", "TemperatureHumiditySensorOutdoor"], [2, 1, 1, "", "TemperatureHumiditySensorWithoutDisplay"], [2, 1, 1, "", "TiltVibrationSensor"], [2, 1, 1, "", "WallMountedGarageDoorController"], [2, 1, 1, "", "WallMountedThermostatBasicHumidity"], [2, 1, 1, "", "WallMountedThermostatPro"], [2, 1, 1, "", "WaterSensor"], [2, 1, 1, "", "WeatherSensor"], [2, 1, 1, "", "WeatherSensorPlus"], [2, 1, 1, "", "WeatherSensorPro"], [2, 1, 1, "", "WiredDimmer3"], [2, 1, 1, "", "WiredDinRailAccessPoint"], [2, 1, 1, "", "WiredDinRailBlind4"], [2, 1, 1, "", "WiredFloorTerminalBlock12"], [2, 1, 1, "", "WiredInput32"], [2, 1, 1, "", "WiredInputSwitch6"], [2, 1, 1, "", "WiredMotionDetectorPushButton"], [2, 1, 1, "", "WiredPushButton"], [2, 1, 1, "", "WiredSwitch4"], [2, 1, 1, "", "WiredSwitch8"]], "homematicip.device.AccelerationSensor": [[2, 3, 1, "", "accelerationSensorEventFilterPeriod"], [2, 3, 1, "", "accelerationSensorMode"], [2, 3, 1, "", "accelerationSensorNeutralPosition"], [2, 3, 1, "", "accelerationSensorSensitivity"], [2, 3, 1, "", "accelerationSensorTriggerAngle"], [2, 3, 1, "", "accelerationSensorTriggered"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "notificationSoundTypeHighToLow"], [2, 3, 1, "", "notificationSoundTypeLowToHigh"], [2, 2, 1, "", "set_acceleration_sensor_event_filter_period"], [2, 2, 1, "", "set_acceleration_sensor_mode"], [2, 2, 1, "", "set_acceleration_sensor_neutral_position"], [2, 2, 1, "", "set_acceleration_sensor_sensitivity"], [2, 2, 1, "", "set_acceleration_sensor_trigger_angle"], [2, 2, 1, "", "set_notification_sound_type"]], "homematicip.device.AlarmSirenIndoor": [[2, 2, 1, "", "from_json"]], "homematicip.device.AlarmSirenOutdoor": [[2, 2, 1, "", "from_json"]], "homematicip.device.BaseDevice": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "load_functionalChannels"]], "homematicip.device.Blind": [[2, 2, 1, "", "set_slats_level"]], "homematicip.device.BlindModule": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_primary_shading_level"], [2, 2, 1, "", "set_secondary_shading_level"], [2, 2, 1, "", "stop"]], "homematicip.device.BrandSwitchNotificationLight": [[2, 3, 1, "", "bottomLightChannelIndex"], [2, 2, 1, "", "set_rgb_dim_level"], [2, 2, 1, "", "set_rgb_dim_level_with_time"], [2, 3, 1, "", "topLightChannelIndex"]], "homematicip.device.ContactInterface": [[2, 2, 1, "", "from_json"]], "homematicip.device.Device": [[2, 2, 1, "", "authorizeUpdate"], [2, 2, 1, "", "delete"], [2, 2, 1, "", "from_json"], [2, 2, 1, "", "is_update_applicable"], [2, 2, 1, "", "set_label"], [2, 2, 1, "", "set_router_module_enabled"]], "homematicip.device.Dimmer": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_dim_level"]], "homematicip.device.DinRailDimmer3": [[2, 2, 1, "", "from_json"]], "homematicip.device.DoorLockDrive": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_lock_state"]], "homematicip.device.DoorLockSensor": [[2, 2, 1, "", "from_json"]], "homematicip.device.DoorModule": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "send_door_command"]], "homematicip.device.ExternalDevice": [[2, 2, 1, "", "from_json"]], "homematicip.device.FloorTerminalBlock12": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_minimum_floor_heating_valve_position"]], "homematicip.device.FloorTerminalBlock6": [[2, 2, 1, "", "from_json"]], "homematicip.device.FullFlushBlind": [[2, 2, 1, "", "from_json"]], "homematicip.device.FullFlushContactInterface": [[2, 2, 1, "", "from_json"]], "homematicip.device.FullFlushInputSwitch": [[2, 2, 1, "", "from_json"]], "homematicip.device.FullFlushShutter": [[2, 2, 1, "", "from_json"]], "homematicip.device.HeatingThermostat": [[2, 3, 1, "", "automaticValveAdaptionNeeded"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "setPointTemperature"], [2, 3, 1, "", "temperatureOffset"], [2, 3, 1, "", "valveActualTemperature"], [2, 3, 1, "", "valvePosition"], [2, 3, 1, "", "valveState"]], "homematicip.device.HeatingThermostatCompact": [[2, 3, 1, "", "automaticValveAdaptionNeeded"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "setPointTemperature"], [2, 3, 1, "", "temperatureOffset"], [2, 3, 1, "", "valveActualTemperature"], [2, 3, 1, "", "valvePosition"], [2, 3, 1, "", "valveState"]], "homematicip.device.HeatingThermostatEvo": [[2, 3, 1, "", "automaticValveAdaptionNeeded"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "setPointTemperature"], [2, 3, 1, "", "temperatureOffset"], [2, 3, 1, "", "valveActualTemperature"], [2, 3, 1, "", "valvePosition"], [2, 3, 1, "", "valveState"]], "homematicip.device.HomeControlAccessPoint": [[2, 2, 1, "", "from_json"]], "homematicip.device.HomeControlUnit": [[2, 2, 1, "", "from_json"]], "homematicip.device.LightSensor": [[2, 3, 1, "", "averageIllumination"], [2, 3, 1, "", "currentIllumination"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "highestIllumination"], [2, 3, 1, "", "lowestIllumination"]], "homematicip.device.MotionDetectorIndoor": [[2, 2, 1, "", "from_json"]], "homematicip.device.MotionDetectorOutdoor": [[2, 2, 1, "", "from_json"]], "homematicip.device.MotionDetectorPushButton": [[2, 2, 1, "", "from_json"]], "homematicip.device.MultiIOBox": [[2, 2, 1, "", "from_json"]], "homematicip.device.OperationLockableDevice": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_operation_lock"]], "homematicip.device.PassageDetector": [[2, 2, 1, "", "from_json"]], "homematicip.device.PluggableMainsFailureSurveillance": [[2, 2, 1, "", "from_json"]], "homematicip.device.PresenceDetectorIndoor": [[2, 2, 1, "", "from_json"]], "homematicip.device.RainSensor": [[2, 2, 1, "", "from_json"], [2, 3, 1, "", "rainSensorSensitivity"], [2, 3, 1, "", "raining"]], "homematicip.device.RgbwDimmer": [[2, 3, 1, "", "fastColorChangeSupported"], [2, 2, 1, "", "from_json"]], "homematicip.device.RoomControlDeviceAnalog": [[2, 2, 1, "", "from_json"]], "homematicip.device.RotaryHandleSensor": [[2, 2, 1, "", "from_json"]], "homematicip.device.SabotageDevice": [[2, 2, 1, "", "from_json"]], "homematicip.device.Shutter": [[2, 2, 1, "", "set_shutter_level"], [2, 2, 1, "", "set_shutter_stop"]], "homematicip.device.ShutterContact": [[2, 2, 1, "", "from_json"]], "homematicip.device.ShutterContactMagnetic": [[2, 2, 1, "", "from_json"]], "homematicip.device.SmokeDetector": [[2, 2, 1, "", "from_json"]], "homematicip.device.Switch": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_switch_state"], [2, 2, 1, "", "turn_off"], [2, 2, 1, "", "turn_on"]], "homematicip.device.SwitchMeasuring": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "reset_energy_counter"]], "homematicip.device.TemperatureDifferenceSensor2": [[2, 2, 1, "", "from_json"], [2, 3, 1, "", "temperatureExternalDelta"], [2, 3, 1, "", "temperatureExternalOne"], [2, 3, 1, "", "temperatureExternalTwo"]], "homematicip.device.TemperatureHumiditySensorDisplay": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_display"]], "homematicip.device.TemperatureHumiditySensorOutdoor": [[2, 2, 1, "", "from_json"]], "homematicip.device.TemperatureHumiditySensorWithoutDisplay": [[2, 2, 1, "", "from_json"]], "homematicip.device.TiltVibrationSensor": [[2, 3, 1, "", "accelerationSensorEventFilterPeriod"], [2, 3, 1, "", "accelerationSensorMode"], [2, 3, 1, "", "accelerationSensorSensitivity"], [2, 3, 1, "", "accelerationSensorTriggerAngle"], [2, 3, 1, "", "accelerationSensorTriggered"], [2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_acceleration_sensor_event_filter_period"], [2, 2, 1, "", "set_acceleration_sensor_mode"], [2, 2, 1, "", "set_acceleration_sensor_sensitivity"], [2, 2, 1, "", "set_acceleration_sensor_trigger_angle"]], "homematicip.device.WallMountedGarageDoorController": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "send_start_impulse"]], "homematicip.device.WallMountedThermostatPro": [[2, 2, 1, "", "from_json"]], "homematicip.device.WaterSensor": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_acoustic_alarm_signal"], [2, 2, 1, "", "set_acoustic_alarm_timing"], [2, 2, 1, "", "set_acoustic_water_alarm_trigger"], [2, 2, 1, "", "set_inapp_water_alarm_trigger"], [2, 2, 1, "", "set_siren_water_alarm_trigger"]], "homematicip.device.WeatherSensor": [[2, 2, 1, "", "from_json"]], "homematicip.device.WeatherSensorPlus": [[2, 2, 1, "", "from_json"]], "homematicip.device.WeatherSensorPro": [[2, 2, 1, "", "from_json"]], "homematicip.device.WiredDinRailAccessPoint": [[2, 2, 1, "", "from_json"]], "homematicip.device.WiredPushButton": [[2, 2, 1, "", "set_dim_level"], [2, 2, 1, "", "set_optical_signal"], [2, 2, 1, "", "set_switch_state"], [2, 2, 1, "", "turn_off"], [2, 2, 1, "", "turn_on"]], "homematicip.functionalHomes": [[2, 1, 1, "", "AccessControlHome"], [2, 1, 1, "", "EnergyHome"], [2, 1, 1, "", "FunctionalHome"], [2, 1, 1, "", "IndoorClimateHome"], [2, 1, 1, "", "LightAndShadowHome"], [2, 1, 1, "", "SecurityAndAlarmHome"], [2, 1, 1, "", "WeatherAndEnvironmentHome"]], "homematicip.functionalHomes.AccessControlHome": [[2, 2, 1, "", "from_json"]], "homematicip.functionalHomes.FunctionalHome": [[2, 2, 1, "", "assignGroups"], [2, 2, 1, "", "from_json"]], "homematicip.functionalHomes.IndoorClimateHome": [[2, 2, 1, "", "from_json"]], "homematicip.functionalHomes.LightAndShadowHome": [[2, 2, 1, "", "from_json"]], "homematicip.functionalHomes.SecurityAndAlarmHome": [[2, 2, 1, "", "from_json"]], "homematicip.group": [[2, 1, 1, "", "AccessAuthorizationProfileGroup"], [2, 1, 1, "", "AccessControlGroup"], [2, 1, 1, "", "AlarmSwitchingGroup"], [2, 1, 1, "", "EnergyGroup"], [2, 1, 1, "", "EnvironmentGroup"], [2, 1, 1, "", "ExtendedLinkedGarageDoorGroup"], [2, 1, 1, "", "ExtendedLinkedShutterGroup"], [2, 1, 1, "", "ExtendedLinkedSwitchingGroup"], [2, 1, 1, "", "Group"], [2, 1, 1, "", "HeatingChangeoverGroup"], [2, 1, 1, "", "HeatingCoolingDemandBoilerGroup"], [2, 1, 1, "", "HeatingCoolingDemandGroup"], [2, 1, 1, "", "HeatingCoolingDemandPumpGroup"], [2, 1, 1, "", "HeatingCoolingPeriod"], [2, 1, 1, "", "HeatingCoolingProfile"], [2, 1, 1, "", "HeatingCoolingProfileDay"], [2, 1, 1, "", "HeatingDehumidifierGroup"], [2, 1, 1, "", "HeatingExternalClockGroup"], [2, 1, 1, "", "HeatingFailureAlertRuleGroup"], [2, 1, 1, "", "HeatingGroup"], [2, 1, 1, "", "HeatingHumidyLimiterGroup"], [2, 1, 1, "", "HeatingTemperatureLimiterGroup"], [2, 1, 1, "", "HotWaterGroup"], [2, 1, 1, "", "HumidityWarningRuleGroup"], [2, 1, 1, "", "InboxGroup"], [2, 1, 1, "", "IndoorClimateGroup"], [2, 1, 1, "", "LinkedSwitchingGroup"], [2, 1, 1, "", "LockOutProtectionRule"], [2, 1, 1, "", "MetaGroup"], [2, 1, 1, "", "OverHeatProtectionRule"], [2, 1, 1, "", "SecurityGroup"], [2, 1, 1, "", "SecurityZoneGroup"], [2, 1, 1, "", "ShutterProfile"], [2, 1, 1, "", "ShutterWindProtectionRule"], [2, 1, 1, "", "SmokeAlarmDetectionRule"], [2, 1, 1, "", "SwitchGroupBase"], [2, 1, 1, "", "SwitchingGroup"], [2, 1, 1, "", "SwitchingProfileGroup"], [2, 1, 1, "", "TimeProfile"], [2, 1, 1, "", "TimeProfilePeriod"]], "homematicip.group.AccessAuthorizationProfileGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.AccessControlGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.AlarmSwitchingGroup": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_on_time"], [2, 2, 1, "", "set_signal_acoustic"], [2, 2, 1, "", "set_signal_optical"], [2, 2, 1, "", "test_signal_acoustic"], [2, 2, 1, "", "test_signal_optical"]], "homematicip.group.EnvironmentGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.ExtendedLinkedGarageDoorGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.ExtendedLinkedShutterGroup": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_shutter_level"], [2, 2, 1, "", "set_shutter_stop"], [2, 2, 1, "", "set_slats_level"]], "homematicip.group.ExtendedLinkedSwitchingGroup": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_on_time"]], "homematicip.group.Group": [[2, 2, 1, "", "delete"], [2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_label"]], "homematicip.group.HeatingChangeoverGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingCoolingDemandBoilerGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingCoolingDemandGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingCoolingDemandPumpGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingCoolingPeriod": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingCoolingProfile": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "get_details"], [2, 2, 1, "", "update_profile"]], "homematicip.group.HeatingCoolingProfileDay": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingDehumidifierGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.HeatingFailureAlertRuleGroup": [[2, 3, 1, "", "checkInterval"], [2, 3, 1, "", "enabled"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "heatingFailureValidationResult"], [2, 3, 1, "", "lastExecutionTimestamp"], [2, 3, 1, "", "validationTimeout"]], "homematicip.group.HeatingGroup": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_active_profile"], [2, 2, 1, "", "set_boost"], [2, 2, 1, "", "set_boost_duration"], [2, 2, 1, "", "set_control_mode"], [2, 2, 1, "", "set_point_temperature"]], "homematicip.group.HotWaterGroup": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_profile_mode"]], "homematicip.group.HumidityWarningRuleGroup": [[2, 3, 1, "", "enabled"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "humidityLowerThreshold"], [2, 3, 1, "", "humidityUpperThreshold"], [2, 3, 1, "", "humidityValidationResult"], [2, 3, 1, "", "lastExecutionTimestamp"], [2, 3, 1, "", "lastStatusUpdate"], [2, 3, 1, "", "outdoorClimateSensor"], [2, 3, 1, "", "triggered"], [2, 3, 1, "", "ventilationRecommended"]], "homematicip.group.IndoorClimateGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.LinkedSwitchingGroup": [[2, 2, 1, "", "set_light_group_switches"]], "homematicip.group.LockOutProtectionRule": [[2, 2, 1, "", "from_json"]], "homematicip.group.MetaGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.OverHeatProtectionRule": [[2, 2, 1, "", "from_json"]], "homematicip.group.SecurityGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.SecurityZoneGroup": [[2, 2, 1, "", "from_json"]], "homematicip.group.ShutterProfile": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_profile_mode"], [2, 2, 1, "", "set_shutter_level"], [2, 2, 1, "", "set_shutter_stop"], [2, 2, 1, "", "set_slats_level"]], "homematicip.group.ShutterWindProtectionRule": [[2, 2, 1, "", "from_json"]], "homematicip.group.SmokeAlarmDetectionRule": [[2, 2, 1, "", "from_json"]], "homematicip.group.SwitchGroupBase": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_switch_state"], [2, 2, 1, "", "turn_off"], [2, 2, 1, "", "turn_on"]], "homematicip.group.SwitchingGroup": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_shutter_level"], [2, 2, 1, "", "set_shutter_stop"], [2, 2, 1, "", "set_slats_level"]], "homematicip.group.SwitchingProfileGroup": [[2, 2, 1, "", "create"], [2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_group_channels"], [2, 2, 1, "", "set_profile_mode"]], "homematicip.group.TimeProfile": [[2, 2, 1, "", "get_details"]], "homematicip.group.TimeProfilePeriod": [[2, 2, 1, "", "from_json"]], "homematicip.home": [[2, 1, 1, "", "Home"]], "homematicip.home.Home": [[2, 3, 1, "", "accessPointUpdateStates"], [2, 2, 1, "", "activate_absence_permanent"], [2, 2, 1, "", "activate_absence_with_duration"], [2, 2, 1, "", "activate_absence_with_period"], [2, 2, 1, "", "activate_vacation"], [2, 3, 1, "", "channels"], [2, 3, 1, "", "clients"], [2, 3, 1, "", "currentAPVersion"], [2, 2, 1, "", "deactivate_absence"], [2, 2, 1, "", "deactivate_vacation"], [2, 2, 1, "", "delete_group"], [2, 3, 1, "", "devices"], [2, 2, 1, "", "disable_events"], [2, 2, 1, "", "download_configuration"], [2, 2, 1, "", "enable_events"], [2, 2, 1, "", "fire_channel_event"], [2, 2, 1, "", "fire_create_event"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "functionalHomes"], [2, 2, 1, "", "get_OAuth_OTK"], [2, 2, 1, "", "get_current_state"], [2, 2, 1, "", "get_functionalHome"], [2, 2, 1, "", "get_security_journal"], [2, 2, 1, "", "get_security_zones_activation"], [2, 3, 1, "", "groups"], [2, 3, 1, "", "id"], [2, 2, 1, "", "init"], [2, 3, 1, "", "location"], [2, 2, 1, "", "on_channel_event"], [2, 2, 1, "", "on_create"], [2, 3, 1, "", "pinAssigned"], [2, 2, 1, "", "remove_callback"], [2, 2, 1, "", "remove_channel_event_handler"], [2, 3, 1, "", "rules"], [2, 2, 1, "", "search_channel"], [2, 2, 1, "", "search_client_by_id"], [2, 2, 1, "", "search_device_by_id"], [2, 2, 1, "", "search_group_by_id"], [2, 2, 1, "", "search_rule_by_id"], [2, 2, 1, "", "set_auth_token"], [2, 2, 1, "", "set_cooling"], [2, 2, 1, "", "set_intrusion_alert_through_smoke_detectors"], [2, 2, 1, "", "set_location"], [2, 2, 1, "", "set_pin"], [2, 2, 1, "", "set_powermeter_unit_price"], [2, 2, 1, "", "set_security_zones_activation"], [2, 2, 1, "", "set_silent_alarm"], [2, 2, 1, "", "set_timezone"], [2, 2, 1, "", "set_zone_activation_delay"], [2, 2, 1, "", "set_zones_device_assignment"], [2, 2, 1, "", "start_inclusion"], [2, 2, 1, "", "update_home"], [2, 2, 1, "", "update_home_only"], [2, 3, 1, "", "weather"], [2, 3, 1, "", "websocket_reconnect_on_error"]], "homematicip.location": [[2, 1, 1, "", "Location"]], "homematicip.location.Location": [[2, 3, 1, "", "city"], [2, 2, 1, "", "from_json"], [2, 3, 1, "", "latitude"], [2, 3, 1, "", "longitude"]], "homematicip.oauth_otk": [[2, 1, 1, "", "OAuthOTK"]], "homematicip.oauth_otk.OAuthOTK": [[2, 2, 1, "", "from_json"]], "homematicip.rule": [[2, 1, 1, "", "Rule"], [2, 1, 1, "", "SimpleRule"]], "homematicip.rule.Rule": [[2, 2, 1, "", "from_json"], [2, 2, 1, "", "set_label"]], "homematicip.rule.SimpleRule": [[2, 2, 1, "", "disable"], [2, 2, 1, "", "enable"], [2, 2, 1, "", "from_json"], [2, 2, 1, "", "get_simple_rule"], [2, 2, 1, "", "set_rule_enabled_state"]], "homematicip.securityEvent": [[2, 1, 1, "", "AccessPointConnectedEvent"], [2, 1, 1, "", "AccessPointDisconnectedEvent"], [2, 1, 1, "", "ActivationChangedEvent"], [2, 1, 1, "", "ExternalTriggeredEvent"], [2, 1, 1, "", "MainsFailureEvent"], [2, 1, 1, "", "MoistureDetectionEvent"], [2, 1, 1, "", "OfflineAlarmEvent"], [2, 1, 1, "", "OfflineWaterDetectionEvent"], [2, 1, 1, "", "SabotageEvent"], [2, 1, 1, "", "SecurityEvent"], [2, 1, 1, "", "SecurityZoneEvent"], [2, 1, 1, "", "SensorEvent"], [2, 1, 1, "", "SilenceChangedEvent"], [2, 1, 1, "", "SmokeAlarmEvent"], [2, 1, 1, "", "WaterDetectionEvent"]], "homematicip.securityEvent.SecurityEvent": [[2, 2, 1, "", "from_json"]], "homematicip.securityEvent.SecurityZoneEvent": [[2, 2, 1, "", "from_json"]], "homematicip.weather": [[2, 1, 1, "", "Weather"]], "homematicip.weather.Weather": [[2, 2, 1, "", "from_json"], [2, 3, 1, "", "humidity"], [2, 3, 1, "", "maxTemperature"], [2, 3, 1, "", "minTemperature"], [2, 3, 1, "", "temperature"], [2, 3, 1, "", "vaporAmount"], [2, 3, 1, "", "weatherCondition"], [2, 3, 1, "", "weatherDayTime"], [2, 3, 1, "", "windDirection"], [2, 3, 1, "", "windSpeed"]]}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "class", "Python class"], "2": ["py", "method", "Python method"], "3": ["py", "attribute", "Python attribute"], "4": ["py", "property", "Python property"], "5": ["py", "exception", "Python exception"], "6": ["py", "function", "Python function"]}, "objtypes": {"0": "py:module", "1": "py:class", "2": "py:method", "3": "py:attribute", "4": "py:property", "5": "py:exception", "6": "py:function"}, "terms": {"": 1, "0": [0, 2, 3, 4], "01": [2, 3, 4], "1": [2, 3, 4], "10x": [2, 3], "1234": 1, "12x": [2, 3], "16a": [2, 3], "1x": [2, 3], "2": [2, 3], "20": [2, 3], "200w": 2, "230": [2, 3], "230v": [2, 3], "24": 1, "24hour": 2, "24v": [2, 3], "2x": [2, 3], "3": [2, 3, 4, 5], "301400000000000000000000": 1, "32x": [2, 3], "360": 2, "3th": 2, "3x": [2, 3], "4": [2, 3], "48335": [2, 3], "4x": [2, 3], "5": [2, 4], "6": [2, 3], "60": 3, "8": [2, 3], "8x": [2, 3], "A": [0, 1, 2, 3], "For": 0, "If": 0, "In": 0, "It": 1, "ON": [2, 4], "ONE": [2, 4], "The": [0, 1], "There": 0, "These": 0, "To": 1, "_on_channel_ev": [2, 4], "_on_creat": 2, "_restcal": [2, 3, 4], "about": [0, 5], "absenc": [2, 3], "absencetyp": [2, 4], "ac": 1, "acceleration_sensor": [2, 4], "acceleration_sensor_channel": [2, 4], "accelerationsensor": [2, 3, 5, 6], "accelerationsensorchannel": [2, 4], "accelerationsensoreventfilterperiod": [2, 4, 6], "accelerationsensormod": [2, 3, 4, 6], "accelerationsensorneutralposit": [2, 3, 4, 6], "accelerationsensorsensit": [2, 3, 4, 6], "accelerationsensortrigg": [2, 4, 6], "accelerationsensortriggerangl": [2, 4, 6], "access": [1, 2, 5], "access_authorization_channel": [2, 4], "access_authorization_profil": [2, 4], "access_control": [2, 4], "access_controller_channel": [2, 4], "access_controller_wired_channel": [2, 4], "access_point": [2, 4, 6], "access_point_connect": [2, 4], "access_point_disconnect": [2, 4], "access_point_id": [2, 3], "access_point_update_st": [5, 6], "accessauthorizationchannel": [2, 4], "accessauthorizationprofilegroup": [2, 3, 5, 6], "accesscontrolgroup": [2, 3, 5, 6], "accesscontrolhom": [2, 5, 6], "accesscontrollerchannel": [2, 4], "accesscontrollerwiredchannel": [2, 4], "accesspoint_id": [2, 3, 4], "accesspointconnectedev": [2, 3, 5, 6], "accesspointdisconnectedev": [2, 3, 5, 6], "accesspointupdatest": [2, 5, 6], "acousticalarmsign": [2, 3, 4], "acousticalarmtim": [2, 3, 4], "acousticwateralarmtrigg": [2, 3, 4], "action": 1, "activ": [1, 2, 3], "activate_absence_perman": [2, 3, 6], "activate_absence_with_dur": [2, 3, 6], "activate_absence_with_period": [2, 3, 6], "activate_vac": [2, 3, 6], "activation_chang": [2, 4], "activation_if_all_in_valid_st": [2, 4], "activation_with_device_ignorelist": [2, 4], "activationchangedev": [2, 3, 5, 6], "actual": [2, 3, 4], "actual_humid": [2, 4], "actuat": [2, 3], "ad": [2, 3], "adapt": [2, 4], "adaption_don": [2, 4], "adaption_in_progress": [2, 4], "add": [2, 4], "add_on_channel_event_handl": [2, 4], "address": 1, "adjustment_too_big": [2, 4], "adjustment_too_smal": [2, 4], "affect": [2, 3], "aio": [2, 5, 6], "alarm": [0, 2, 3], "alarm_siren_channel": [2, 4], "alarm_siren_indoor": [2, 4], "alarm_siren_outdoor": [2, 4], "alarm_switch": [2, 4], "alarmcontacttyp": [2, 4], "alarmsignaltyp": [2, 4], "alarmsirenchannel": [2, 4], "alarmsirenindoor": [2, 3, 5, 6], "alarmsirenoutdoor": [2, 3, 5, 6], "alarmswitchinggroup": [2, 3, 5, 6], "alia": 2, "all": [1, 2, 3], "allow": 1, "alpha": [2, 3], "also": 0, "an": [1, 2, 3, 4], "analog": [2, 3, 4], "analog_output_channel": [2, 4], "analog_room_control_channel": [2, 4], "analogoutputchannel": [2, 4], "analogoutputlevel": [2, 4], "analogroomcontrolchannel": [2, 4], "angl": [2, 3, 4], "anonym": [1, 4], "anonymizeconfig": [2, 4], "any_mot": [2, 4], "ap": [2, 3], "apexchangest": [2, 4], "api": 1, "api_cal": [2, 3], "app": [0, 2, 4], "appdata": 1, "applic": 1, "ar": [0, 1, 2, 3], "archtetyp": 2, "arg": [2, 4], "argument": 1, "arm": [2, 3], "arr": [2, 3], "asir": [2, 3], "assigngroup": [2, 6], "async": [3, 4], "async_reset_energy_count": [2, 4], "async_send_door_command": [2, 4], "async_send_start_impuls": [2, 4], "async_set_acceleration_sensor_event_filter_period": [2, 4], "async_set_acceleration_sensor_mod": [2, 4], "async_set_acceleration_sensor_neutral_posit": [2, 4], "async_set_acceleration_sensor_sensit": [2, 4], "async_set_acceleration_sensor_trigger_angl": [2, 4], "async_set_acoustic_alarm_sign": [2, 4], "async_set_acoustic_alarm_tim": [2, 4], "async_set_acoustic_water_alarm_trigg": [2, 4], "async_set_dim_level": [2, 4], "async_set_displai": [2, 4], "async_set_inapp_water_alarm_trigg": [2, 4], "async_set_lock_st": [0, 2, 4], "async_set_minimum_floor_heating_valve_posit": [2, 4], "async_set_notification_sound_typ": [2, 4], "async_set_operation_lock": [2, 4], "async_set_optical_sign": [2, 4], "async_set_primary_shading_level": [2, 4], "async_set_rgb_dim_level": [2, 4], "async_set_rgb_dim_level_with_tim": [2, 4], "async_set_secondary_shading_level": [2, 4], "async_set_shutter_level": [2, 4], "async_set_shutter_stop": [2, 4], "async_set_siren_water_alarm_trigg": [2, 4], "async_set_slats_level": [2, 4], "async_set_switch_st": [2, 4], "async_stop": [2, 4], "async_turn_off": [2, 4], "async_turn_on": [2, 4], "asyncaccelerationsensor": [2, 3], "asyncaccessauthorizationprofilegroup": [2, 3], "asyncaccesscontrolgroup": [2, 3], "asyncaccesspointconnectedev": [2, 3], "asyncaccesspointdisconnectedev": [2, 3], "asyncactivationchangedev": [2, 3], "asyncalarmsirenindoor": [2, 3], "asyncalarmsirenoutdoor": [2, 3], "asyncalarmswitchinggroup": [2, 3], "asyncauth": [2, 3], "asyncauthconnect": [2, 3], "asyncbasedevic": [2, 3], "asyncblind": [2, 3], "asyncblindmodul": [2, 3], "asyncbrandblind": [2, 3], "asyncbranddimm": [2, 3], "asyncbrandpushbutton": [2, 3], "asyncbrandswitch2": [2, 3], "asyncbrandswitchmeasur": [2, 3], "asyncbrandswitchnotificationlight": [2, 3], "asynccarbondioxidesensor": [2, 3], "asyncconnect": [2, 3], "asynccontactinterfac": [2, 3], "asyncdaligatewai": [2, 3], "asyncdevic": [2, 3], "asyncdimm": [2, 3], "asyncdinrailblind4": [2, 3], "asyncdinraildimmer3": [2, 3], "asyncdinrailswitch": [2, 3], "asyncdinrailswitch4": [2, 3], "asyncdoorbellbutton": [2, 3], "asyncdoorbellcontactinterfac": [2, 3], "asyncdoorlockdr": [0, 2, 3], "asyncdoorlocksensor": [2, 3], "asyncdoormodul": [2, 3], "asyncenergygroup": [2, 3], "asyncenergysensorsinterfac": [2, 3], "asyncenvironmentgroup": [2, 3], "asyncextendedgaragedoorgroup": [2, 3], "asyncextendedlinkedshuttergroup": [2, 3], "asyncextendedlinkedswitchinggroup": [2, 3], "asyncexternaldevic": [2, 3], "asyncexternaltriggeredev": [2, 3], "asyncfloorterminalblock10": [2, 3], "asyncfloorterminalblock12": [2, 3], "asyncfloorterminalblock6": [2, 3], "asyncfullflushblind": [2, 3], "asyncfullflushcontactinterfac": [2, 3], "asyncfullflushcontactinterface6": [2, 3], "asyncfullflushdimm": [2, 3], "asyncfullflushinputswitch": [2, 3], "asyncfullflushshutt": [2, 3], "asyncfullflushswitchmeasur": [2, 3], "asyncgaragedoormoduletormat": [2, 3], "asyncgroup": [2, 3], "asyncheatingchangeovergroup": [2, 3], "asyncheatingcoolingdemandboilergroup": [2, 3], "asyncheatingcoolingdemandgroup": [2, 3], "asyncheatingcoolingdemandpumpgroup": [2, 3], "asyncheatingdehumidifiergroup": [2, 3], "asyncheatingexternalclockgroup": [2, 3], "asyncheatingfailurealertrulegroup": [2, 3], "asyncheatinggroup": [2, 3], "asyncheatinghumidylimitergroup": [2, 3], "asyncheatingswitch2": [2, 3], "asyncheatingtemperaturelimitergroup": [2, 3], "asyncheatingthermostat": [2, 3], "asyncheatingthermostatcompact": [2, 3], "asyncheatingthermostatevo": [2, 3], "asynchoermanndrivesmodul": [2, 3], "asynchom": [2, 3], "asynchomecontrolaccesspoint": [2, 3], "asynchomecontrolunit": [2, 3], "asynchotwatergroup": [2, 3], "asynchumiditywarningrulegroup": [2, 3], "asyncinboxgroup": [2, 3], "asyncindoorclimategroup": [2, 3], "asynckeyremotecontrol4": [2, 3], "asynckeyremotecontrolalarm": [2, 3], "asynclightsensor": [2, 3], "asynclinkedswitchinggroup": [2, 3], "asynclockoutprotectionrul": [2, 3], "asyncmainsfailureev": [2, 3], "asyncmetagroup": [2, 3], "asyncmoisturedetectionev": [2, 3], "asyncmotiondetectorindoor": [2, 3], "asyncmotiondetectoroutdoor": [2, 3], "asyncmotiondetectorpushbutton": [2, 3], "asyncmultiiobox": [2, 3], "asyncofflinealarmev": [2, 3], "asyncofflinewaterdetectionev": [2, 3], "asyncopencollector8modul": [2, 3], "asyncoperationlockabledevic": [2, 3], "asyncoverheatprotectionrul": [2, 3], "asyncpassagedetector": [2, 3], "asyncplugableswitch": [2, 3], "asyncplugableswitchmeasur": [2, 3], "asyncpluggabledimm": [2, 3], "asyncpluggablemainsfailuresurveil": [2, 3], "asyncpresencedetectorindoor": [2, 3], "asyncprintedcircuitboardswitch2": [2, 3], "asyncprintedcircuitboardswitchbatteri": [2, 3], "asyncpushbutton": [2, 3], "asyncpushbutton6": [2, 3], "asyncpushbuttonflat": [2, 3], "asyncrainsensor": [2, 3], "asyncremotecontrol8": [2, 3], "asyncremotecontrol8modul": [2, 3], "asyncrgbwdimm": [2, 3], "asyncroomcontroldevic": [2, 3], "asyncroomcontroldeviceanalog": [2, 3], "asyncrotaryhandlesensor": [2, 3], "asyncrul": [2, 3], "asyncsabotagedevic": [2, 3], "asyncsabotageev": [2, 3], "asyncsecurityev": [2, 3], "asyncsecuritygroup": [2, 3], "asyncsecurityzoneev": [2, 3], "asyncsecurityzonegroup": [2, 3], "asyncsensorev": [2, 3], "asyncshutt": [2, 3], "asyncshuttercontact": [2, 3], "asyncshuttercontactmagnet": [2, 3], "asyncshuttercontactopticalplu": [2, 3], "asyncshutterprofil": [2, 3], "asyncshutterwindprotectionrul": [2, 3], "asyncsilencechangedev": [2, 3], "asyncsimplerul": [2, 3], "asyncsmokealarmdetectionrul": [2, 3], "asyncsmokealarmev": [2, 3], "asyncsmokedetector": [2, 3], "asyncswitch": [2, 3], "asyncswitchgroupbas": [2, 3], "asyncswitchinggroup": [2, 3], "asyncswitchingprofilegroup": [2, 3], "asyncswitchmeasur": [2, 3], "asynctemperaturedifferencesensor2": [2, 3], "asynctemperaturehumiditysensordisplai": [2, 3], "asynctemperaturehumiditysensoroutdoor": [2, 3], "asynctemperaturehumiditysensorwithoutdisplai": [2, 3], "asynctiltvibrationsensor": [2, 3], "asyncwallmountedgaragedoorcontrol": [2, 3], "asyncwallmountedthermostatbasichumid": [2, 3], "asyncwallmountedthermostatpro": [2, 3], "asyncwaterdetectionev": [2, 3], "asyncwatersensor": [2, 3], "asyncweathersensor": [2, 3], "asyncweathersensorplu": [2, 3], "asyncweathersensorpro": [2, 3], "asyncwireddimmer3": [2, 3], "asyncwireddinrailaccesspoint": [2, 3], "asyncwireddinrailblind4": [2, 3], "asyncwiredfloorterminalblock12": [2, 3], "asyncwiredinput32": [2, 3], "asyncwiredinputswitch6": [2, 3], "asyncwiredmotiondetectorpushbutton": [2, 3], "asyncwiredpushbutton": [2, 3], "asyncwiredswitch4": [2, 3], "asyncwiredswitch8": [2, 3], "attribut": 4, "auth": [5, 6], "auth_token": [2, 4, 6], "authorizeupd": [2, 3, 6], "authtoken": [2, 3], "auto": 4, "autom": 2, "automat": [2, 3, 4], "automatically_if_poss": [2, 4], "automaticvalveadaptionneed": [2, 4, 6], "automationruletyp": [2, 4], "autonameenum": [2, 4], "averag": [2, 4], "average_valu": [2, 4], "averageillumin": [2, 4, 6], "b": [2, 3, 4], "b2": [2, 3], "background_update_not_support": [2, 4], "bad": 4, "badbatteryhealth": [2, 4], "base": [0, 2, 3, 5, 6], "base_connect": [2, 6], "base_devic": [2, 4], "baseconnect": [2, 3, 4], "basedevic": [2, 3, 5, 6], "basic": [2, 3], "bat": [2, 3], "batteri": [2, 3, 4], "bausatz": [2, 3], "bbl": [2, 3], "bdt": [2, 3], "befor": 1, "behaviour": [2, 3, 4], "being": [2, 3], "bell": 2, "belong": 2, "berlin": [2, 3], "between": [2, 3, 4], "billow_middl": [2, 4], "binary_behavior": [2, 4], "binarybehaviortyp": [2, 4], "black": [2, 4], "blind": [2, 3, 5, 6], "blind_channel": [2, 4], "blind_modul": [2, 4], "blindchannel": [2, 4], "blindmodul": [2, 3, 5, 6], "blinking_alternately_rep": [2, 3, 4], "blinking_both_rep": [2, 4], "blinking_middl": [2, 4], "blue": [1, 2, 4], "board": [2, 3], "bodi": 3, "bool": [2, 3, 4], "boolean": 4, "bottom": [2, 4], "bottomlightchannelindex": [2, 3, 4, 6], "bound": 1, "boundari": 4, "box": [2, 3], "brand": [2, 3], "brand_blind": [2, 4], "brand_dimm": [2, 4], "brand_push_button": [2, 4], "brand_shutt": [2, 4], "brand_switch_2": [2, 4], "brand_switch_measur": [2, 4], "brand_switch_notification_light": [2, 4], "brand_wall_mounted_thermostat": [2, 4], "brandblind": [2, 3, 5, 6], "branddimm": [2, 5, 6], "brandpushbutton": [2, 3, 5, 6], "brandswitch2": [2, 3, 5, 6], "brandswitchmeasur": [2, 3, 5, 6], "brandswitchnotificationlight": [2, 3, 5, 6], "brc2": [2, 3], "bright": [2, 3], "broll": [2, 3], "bs2": [2, 3], "bsl": [2, 3], "bsm": [2, 3], "button": [2, 3], "bwth": [2, 3], "bytes2str": [2, 4], "c": [2, 3], "c10": [2, 3], "c12": [2, 3], "c2c": [2, 4], "c2cserviceidentifi": [2, 6], "c6": [2, 3], "call": [0, 2, 3], "can": 1, "carbon_dioxide_sensor": [2, 4], "carbon_dioxide_sensor_channel": [2, 4], "carbondioxidesensor": [2, 3, 5, 6], "carbondioxidesensorchannel": [2, 4], "center": [2, 4], "chang": 1, "change_over_channel": [2, 4], "changeoverchannel": [2, 4], "channel": [0, 1, 2, 3, 4, 6], "channel_typ": 4, "channeleventtyp": [2, 4], "channelindex": [2, 3, 4], "check": 2, "checkinterv": [2, 6], "circuit": [2, 3], "citi": [2, 3, 6], "class": [0, 2, 3, 4], "class_map": [5, 6], "classmethod": 4, "clear": [2, 4], "clearconfig": [2, 3], "cli": 5, "cliaction": [2, 4], "client": [3, 5, 6], "client_ad": [2, 4], "client_chang": [2, 4], "client_remov": [2, 4], "clientauth_token": [2, 4], "clientcharacterist": [2, 4], "clientid": 2, "clienttyp": [2, 4, 6], "climat": 2, "climate_sensor_channel": [2, 4], "climatecontroldisplai": [2, 3, 4], "climatecontrolmod": [2, 3, 4], "climatesensorchannel": [2, 4], "close": [2, 3, 4], "close_websocket_connect": [2, 3], "cloud": [1, 2, 3], "cloudi": [2, 4], "cloudy_with_rain": [2, 4], "cloudy_with_snow_rain": [2, 4], "collect": [0, 2], "collector": [2, 3], "color": [2, 3, 4], "com": [2, 3], "combin": 1, "command": 1, "commun": 0, "compact": [2, 3], "condit": 4, "config": [1, 2, 3, 4], "config_fil": 2, "configur": [1, 2, 3], "confirmation_signal_0": [2, 4], "confirmation_signal_1": [2, 4], "confirmation_signal_2": [2, 4], "confirmauthtoken": [2, 3, 6], "connect": [4, 5, 6], "connect_timeout": [2, 3], "connectionrequest": [2, 3, 6], "connectiontyp": [2, 4], "conrad": 2, "constant": [2, 6], "contact": [0, 2, 3], "contact_interface_channel": [2, 4], "contactinterfac": [2, 3, 5, 6], "contactinterfacechannel": [2, 4], "contacttyp": [2, 4], "contain": 0, "content": [5, 6], "control": [2, 3, 4], "cool": [2, 3], "correct": 3, "could": 4, "couldn": 2, "creat": [2, 3, 4, 6], "creep_spe": [2, 4], "current": [1, 2, 3, 4], "current_valu": [2, 4], "currentapvers": [2, 6], "currentillumin": [2, 4, 6], "d": 1, "dai": [2, 4], "dali": 2, "dali_gatewai": [2, 4], "daligatewai": [2, 3, 5, 6], "datetim": [2, 3], "datim": 2, "dbb": 2, "deactiv": [2, 3], "deactivate_abs": [2, 3, 6], "deactivate_vac": [2, 3, 6], "default": [2, 4], "dehumidifier_demand_channel": [2, 4], "dehumidifierdemandchannel": [2, 4], "delai": [2, 3], "delayed_externally_arm": [2, 4], "delayed_internally_arm": [2, 4], "delet": [2, 3, 6], "delete_group": [2, 3, 6], "depend": [0, 1], "detect_encod": [2, 4], "detector": [2, 3], "determin": 2, "devic": [0, 4, 5, 6], "device_ad": [2, 4], "device_bas": [2, 4], "device_base_floor_h": [2, 4], "device_chang": [2, 4], "device_channel_ev": [2, 4], "device_global_pump_control": [2, 4], "device_incorrect_posit": [2, 4], "device_operationlock": [2, 4], "device_operationlock_with_sabotag": [2, 4], "device_permanent_full_rx": [2, 4], "device_rechargeable_with_sabotag": [2, 4], "device_remov": [2, 4], "device_sabotag": [2, 4], "devicearchetyp": [2, 4], "devicebasechannel": [2, 4], "devicebasefloorheatingchannel": [2, 4], "deviceglobalpumpcontrolchannel": [2, 4], "deviceid": [1, 2], "deviceincorrectpositionedchannel": [2, 4], "devicenam": [2, 3], "deviceoperationlockchannel": [2, 4], "deviceoperationlockchannelwithsabotag": [2, 4], "devicepermanentfullrxchannel": [2, 4], "devicerechargeablewithsabotag": [2, 4], "devicesabotagechannel": [2, 4], "devicetyp": [2, 4], "deviceupdatest": [2, 4], "deviceupdatestrategi": [2, 4], "dict": [2, 4], "differ": [1, 2, 3], "digit": 1, "dim": [2, 3], "dimlevel": [2, 3, 4], "dimmer": [0, 2, 3, 5, 6], "dimmer_channel": [2, 4], "dimmerchannel": [0, 2, 4], "din": [2, 3], "din_rail_blind_4": [2, 4], "din_rail_dimmer_3": [2, 4], "din_rail_switch": [2, 4], "din_rail_switch_4": [2, 4], "dinrailblind4": [2, 3, 5, 6], "dinraildimmer3": [2, 3, 5, 6], "dinrailswitch": [2, 3, 5, 6], "dinrailswitch4": [2, 3, 5, 6], "direct": 2, "directori": 1, "disabl": [2, 3, 6], "disable_acoustic_sign": [2, 4], "disable_ev": [2, 3, 6], "disable_optical_sign": [2, 4], "disarm": [2, 3, 4], "displai": [2, 3, 4], "dl": [2, 3], "dld": [0, 1, 2, 3], "doe": 2, "done": [2, 4, 5], "door": [1, 2, 3, 4], "door_bell_button": [2, 4], "door_bell_contact_interfac": [2, 4], "door_bell_sensor_ev": [2, 4], "door_channel": [2, 4], "door_lock_channel": [2, 4], "door_lock_dr": [2, 4], "door_lock_sensor": [2, 4], "door_lock_sensor_channel": [2, 4], "doorbellbutton": [2, 3, 5, 6], "doorbellcontactinterfac": [2, 3, 5, 6], "doorchannel": [2, 4], "doorcommand": [2, 3, 4], "doorlockchannel": [0, 2, 4], "doorlockdr": [0, 2, 3, 5, 6], "doorlocksensor": [2, 3, 5, 6], "doorlocksensorchannel": [2, 4], "doorlockst": [2, 3, 4], "doormodul": [2, 3, 5, 6], "doorstat": [2, 4], "double_flashing_rep": [2, 4], "dougla": [2, 3], "download": [2, 3], "download_configur": [2, 3, 6], "drap": 3, "drbl4": 2, "drbli4": [2, 3], "drd3": [2, 3], "drdi3": [2, 3], "drg": 2, "dri32": [2, 3], "drivespe": [2, 4], "drs4": [2, 3], "drs8": [2, 3], "drsi1": [2, 3], "drsi4": [2, 3], "dsd": 2, "dump": 1, "durat": [2, 3], "dure": [2, 3], "e": [0, 2, 3], "each": 0, "eco": [2, 4], "ecodur": [2, 4], "either": 1, "electr": 2, "elv": [2, 3], "enabl": [2, 3, 6], "enable_ev": [2, 3, 6], "enable_trac": 2, "endtim": [2, 3], "energi": [2, 4], "energy_sensors_interfac": [2, 4], "energy_sensors_interface_channel": [2, 4], "energygroup": [2, 5, 6], "energyhom": [2, 5, 6], "energysensorinterfacechannel": [2, 4], "energysensorsinterfac": [2, 3, 5, 6], "engin": 5, "enum": [2, 3, 6], "environ": [2, 4], "environmentgroup": [2, 3, 5, 6], "erfal": [2, 3], "error": [2, 4], "error_posit": [2, 4], "errorcod": [2, 3], "esi": 2, "etc": 1, "etrv": [2, 3], "europ": [2, 3], "event": [1, 2, 3, 4], "eventhook": [5, 6], "eventtyp": [2, 4], "everyth": 5, "evo": [2, 3], "exampl": [0, 2, 3], "except": 4, "execut": 2, "exist": 2, "extend": 3, "extended_linked_garage_door": [2, 4], "extended_linked_shutt": [2, 4], "extended_linked_switch": [2, 4], "extendedlinkedgaragedoorgroup": [2, 3, 5, 6], "extendedlinkedshuttergroup": [2, 3, 5, 6], "extendedlinkedswitchinggroup": [2, 3, 5, 6], "extern": [2, 3, 4], "external_base_channel": [2, 4], "external_devic": [2, 3], "external_trigg": [2, 4], "external_universal_light_channel": [2, 4], "externalbasechannel": [2, 4], "externaldevic": [2, 3, 5, 6], "externally_arm": [2, 4], "externaltriggeredev": [2, 3, 5, 6], "externaluniversallightchannel": [2, 4], "fach": [2, 3], "fail": 3, "failur": 2, "fal230": [2, 3], "fal24": [2, 3], "falmot": [2, 3], "fals": [2, 3], "fastcolorchangesupport": [2, 6], "fbl": [2, 3], "fci1": [2, 3], "fci6": [2, 3], "fdt": [2, 3], "few": [0, 1], "field": 2, "file": [1, 2], "filenotfounderror": 2, "find": 2, "find_and_load_config_fil": [2, 5, 6], "fio6": [2, 3], "fire": [2, 4, 6], "fire_channel_ev": [2, 4, 6], "fire_create_ev": [2, 6], "flag": 4, "flash_middl": [2, 4], "flashing_both_rep": [2, 4], "flat": [2, 3], "flat_dect": [2, 4], "float": [2, 3, 4], "floor": [2, 3], "floor_terminal_block_10": [2, 4], "floor_terminal_block_12": [2, 4], "floor_terminal_block_6": [2, 4], "floor_terminal_block_channel": [2, 4], "floor_terminal_block_local_pump_channel": [2, 4], "floor_terminal_block_mechanic_channel": [2, 4], "floorteminalblockchannel": [2, 4], "floorterminalblock10": [2, 3, 5, 6], "floorterminalblock12": [2, 3, 5, 6], "floorterminalblock6": [2, 3, 5, 6], "floorterminalblocklocalpumpchannel": [2, 4], "floorterminalblockmechanicchannel": [2, 4], "floot": [2, 3, 4], "flush": [2, 3], "foggi": [2, 4], "folder": 1, "follow": 1, "forev": [2, 3], "format": 4, "found": 2, "foundat": 2, "four": [2, 4], "frequency_alternating_low_high": [2, 4], "frequency_alternating_low_mid_high": [2, 4], "frequency_fal": [2, 3, 4], "frequency_highon_longoff": [2, 4], "frequency_highon_off": [2, 4], "frequency_lowon_longoff_highon_longoff": [2, 4], "frequency_lowon_off_highon_off": [2, 4], "frequency_ris": [2, 4], "frequency_rising_and_fal": [2, 4], "fresh": [2, 3], "froll": [2, 3], "from": [1, 2, 3, 4], "from_json": [2, 3, 4, 6], "from_str": [2, 4], "fsi16": [2, 3], "fsm": [2, 3], "fsm16": 2, "full": [2, 3], "full_alarm": [2, 4], "full_flush_blind": [2, 4], "full_flush_contact_interfac": [2, 4], "full_flush_contact_interface_6": [2, 4], "full_flush_dimm": [2, 4], "full_flush_input_switch": [2, 4], "full_flush_shutt": [2, 4], "full_flush_switch_measur": [2, 4], "full_url": [2, 3], "fullflushblind": [2, 3, 5, 6], "fullflushcontactinterfac": [2, 3, 5, 6], "fullflushcontactinterface6": [2, 3, 5, 6], "fullflushdimm": [2, 5, 6], "fullflushinputswitch": [2, 3, 5, 6], "fullflushshutt": [2, 3, 5, 6], "fullflushswitchmeasur": [2, 3, 5, 6], "function": [0, 2, 3, 4], "functional_channel": [2, 4], "functionalchannel": [2, 6], "functionalchanneltyp": [2, 4], "functionalhom": [5, 6], "functionalhometyp": [2, 4], "functionchannel": 0, "f\u00fcr": [2, 3], "g": [0, 1, 2, 3], "garag": [1, 2, 3, 4], "garagedoormoduletormat": [2, 3, 5, 6], "gatewai": 2, "gener": [1, 2, 3, 4], "generer": 3, "generic_input_channel": [2, 4], "genericinputchannel": [2, 4], "get": 2, "get_config_file_loc": [2, 5, 6], "get_current_st": [2, 3, 6], "get_detail": [2, 6], "get_functional_channel": [2, 4], "get_functionalhom": [2, 6], "get_oauth_otk": [2, 3, 6], "get_security_journ": [2, 3, 6], "get_security_zones_activ": [2, 6], "get_simple_rul": [2, 3, 6], "gethost": [2, 3], "gid": 2, "given": [2, 3, 4], "global": 1, "glow": 1, "googl": 2, "got": 2, "greater_lower_lesser_upper_threshold": [2, 4], "greater_upper_threshold": [2, 4], "green": [2, 4], "group": [0, 4, 5, 6], "group_ad": [2, 4], "group_chang": [2, 4], "group_remov": [2, 4], "groupid": 2, "grouptyp": [2, 4], "groupvis": [2, 4], "h": 1, "ha": [0, 2, 3], "handl": 3, "handle_config": [2, 4], "handler": [2, 4], "hap": 3, "hardwar": 0, "have": [0, 1, 2, 3], "hcu": 3, "hdm1": [2, 3], "heat": [0, 2, 3, 4], "heat_demand_channel": [2, 4], "heatdemandchannel": [2, 4], "heating_changeov": [2, 4], "heating_cooling_demand": [2, 4], "heating_cooling_demand_boil": [2, 4], "heating_cooling_demand_pump": [2, 4], "heating_dehumidifi": [2, 4], "heating_external_clock": [2, 4], "heating_failure_alarm": [2, 4], "heating_failure_alert_rule_group": [2, 4], "heating_failure_warn": [2, 4], "heating_humidity_limit": [2, 4], "heating_switch_2": [2, 4], "heating_temperature_limit": [2, 4], "heating_thermostat": [2, 4], "heating_thermostat_channel": [2, 4], "heating_thermostat_compact": [2, 4], "heating_thermostat_compact_plu": [2, 4], "heating_thermostat_evo": [2, 4], "heatingchangeovergroup": [2, 3, 5, 6], "heatingcoolingdemandboilergroup": [2, 3, 5, 6], "heatingcoolingdemandgroup": [2, 3, 5, 6], "heatingcoolingdemandpumpgroup": [2, 3, 5, 6], "heatingcoolingperiod": [2, 5, 6], "heatingcoolingprofil": [2, 5, 6], "heatingcoolingprofiledai": [2, 5, 6], "heatingdehumidifiergroup": [2, 3, 5, 6], "heatingexternalclockgroup": [2, 3, 5, 6], "heatingfailurealertrulegroup": [2, 3, 5, 6], "heatingfailurevalidationresult": [2, 6], "heatingfailurevalidationtyp": [2, 4], "heatinggroup": [2, 3, 5, 6], "heatinghumidylimitergroup": [2, 3, 5, 6], "heatingloadtyp": [2, 4], "heatingswitch2": [2, 3, 5, 6], "heatingtemperaturelimitergroup": [2, 3, 5, 6], "heatingthermostat": [2, 3, 5, 6], "heatingthermostatchannel": [2, 4], "heatingthermostatcompact": [2, 3, 5, 6], "heatingthermostatevo": [2, 3, 5, 6], "heatingvalvetyp": [2, 4], "heavily_cloudi": [2, 4], "heavily_cloudy_with_rain": [2, 4], "heavily_cloudy_with_rain_and_thund": [2, 4], "heavily_cloudy_with_snow": [2, 4], "heavily_cloudy_with_snow_rain": [2, 4], "heavily_cloudy_with_strong_rain": [2, 4], "heavily_cloudy_with_thund": [2, 4], "help": 1, "helper": [2, 6], "here": [2, 3], "highest": [2, 4], "highestillumin": [2, 4, 6], "hmip": [0, 1, 2, 3, 4], "hmip_cli": 1, "hmip_generate_auth_token": 1, "hmip_lan": [2, 4], "hmip_rf": [2, 4], "hmip_wir": [2, 4], "hmip_wlan": [2, 4], "hmipconfig": [2, 5, 6], "hmipconnectionerror": [2, 3, 4], "hmipservercloseerror": [2, 4], "hmipthrottlingerror": [2, 4], "hmipw": [2, 3], "hmipwronghttpstatuserror": [2, 3, 4], "ho": [2, 3], "hoermann_drives_modul": [2, 4], "hoermanndrivesmodul": [2, 3, 5, 6], "hold": 0, "home": [0, 5, 6], "home_chang": [2, 4], "home_control_access_point": [2, 4], "homecontrolaccesspoint": [2, 3, 5, 6], "homecontrolunit": [2, 5, 6], "homeid": [2, 6], "homemat": [2, 3], "homematicip": [0, 1, 5], "homematicipobject": [5, 6], "homeupdatest": [2, 4], "horizont": [2, 4], "hot_wat": [2, 4], "hotwatergroup": [2, 3, 5, 6], "how": 2, "http": [2, 3], "hue": [2, 3], "hull": [2, 3], "human": 2, "humid": [2, 3, 6], "humidity_warning_rule_group": [2, 4], "humiditylowerthreshold": [2, 6], "humidityupperthreshold": [2, 6], "humidityvalidationresult": [2, 6], "humidityvalidationtyp": [2, 4], "humiditywarningrulegroup": [2, 3, 5, 6], "hunter": [2, 3], "h\u00f6rmann": [2, 3], "i": [0, 2, 3, 4, 5], "id": [1, 2, 6], "idle_off": [2, 4], "ignorecas": 4, "illumin": [2, 4], "immedi": [2, 3], "implement": [2, 3], "import": 0, "impulse_output_channel": [2, 4], "impulseoutputchannel": [2, 4], "in_progress": [2, 4], "inappwateralarmtrigg": [2, 3, 4], "inbound": [2, 3], "inbox": [2, 4], "inboxgroup": [2, 3, 5, 6], "inclin": [2, 3], "includ": 2, "inclus": 2, "index": [0, 2, 3, 5], "indoor": [2, 3], "indoor_clim": [2, 4], "indoorclimategroup": [2, 3, 5, 6], "indoorclimatehom": [2, 5, 6], "info": 1, "inform": 0, "inherit": 4, "ini": [1, 2], "init": [2, 3, 4, 6], "input": [2, 3], "insid": [2, 3], "instal": [0, 5], "instead": [2, 3, 4], "instruct": 1, "int": [2, 3, 4], "inter": 2, "interfac": [2, 3], "intern": [2, 3], "internal_devic": [2, 3], "internal_switch_channel": [2, 4], "internally_arm": [2, 4], "internalswitchchannel": [2, 4], "introduct": 5, "intrusion_alarm": [2, 4], "invis": [2, 3], "invisible_control": [2, 4], "invisible_group_and_control": [2, 4], "io": [2, 3], "ip": [2, 3], "is_update_applic": [2, 3, 6], "ishightolow": [2, 3, 4], "isrequestacknowledg": [2, 3, 6], "iter": [2, 4], "its": [0, 1, 4], "j": [2, 3, 4], "js_home": 2, "json": [2, 3, 4], "json_stat": [2, 4], "just": [1, 2, 3], "kei": [0, 2, 3], "key_behavior": [2, 4], "key_remote_control_4": [2, 4], "key_remote_control_alarm": [2, 4], "keyremotecontrol4": [2, 3, 5, 6], "keyremotecontrolalarm": [2, 3, 5, 6], "keywarg": 2, "krc4": [2, 3], "krca": [2, 3], "kwarg": [2, 3, 4], "label": [2, 3, 6], "lamp": [2, 3, 4], "last": 2, "lastexecutiontimestamp": [2, 6], "laststatusupd": [2, 6], "latitud": [2, 3, 6], "led": [2, 3, 4], "left": [2, 4], "lesser_lower_threshold": [2, 4], "let": [2, 3], "level": [2, 3, 4], "librari": 1, "light": [2, 3, 4], "light_and_shadow": [2, 4], "light_cloudi": [2, 4], "light_sensor": [2, 4], "light_sensor_channel": [2, 4], "lightandshadowhom": [2, 5, 6], "lightsensor": [2, 3, 5, 6], "lightsensorchannel": [2, 4], "line": 1, "linked_switch": [2, 4], "linkedswitchinggroup": [2, 3, 5, 6], "linux": 1, "list": [1, 2, 3], "listen": [1, 3], "live_update_not_support": [2, 4], "liveupdatest": [2, 4], "load": [1, 2, 4], "load_balanc": [2, 4], "load_collect": [2, 4], "load_config_fil": [2, 5, 6], "load_functionalchannel": [2, 6], "locat": [5, 6], "lock": [0, 1, 2, 3, 4], "lock_out_protection_rul": [2, 4], "lockoutprotectionrul": [2, 3, 5, 6], "lockstat": [2, 3, 4], "log_fil": [2, 6], "log_level": [2, 6], "longitu": 2, "longitud": [2, 3, 6], "look": 1, "lookup": [2, 3, 4], "lookup_url": [2, 3], "loop": 3, "low_batteri": [2, 4], "lower": 2, "lowest": [2, 4], "lowestillumin": [2, 4, 6], "m": 2, "mac": 1, "magnet": [2, 3], "mains_failure_channel": [2, 4], "mains_failure_ev": [2, 4], "mainsfailurechannel": [2, 4], "mainsfailureev": [2, 3, 5, 6], "make": 3, "manual": [2, 4], "map": 2, "markenschalt": [2, 3], "max": [2, 3, 4], "max_valu": [2, 4], "maximum": 2, "maxtemperatur": [2, 6], "measur": [2, 3, 4], "meta": [2, 3], "metagroup": [0, 2, 3, 5, 6], "meter": [2, 3], "method": [2, 3, 4], "min_valu": [2, 4], "minimum": [2, 3, 4], "minimumfloorheatingvalveposit": [2, 3, 4], "mintemperatur": [2, 6], "minut": [2, 3], "miob": [2, 3], "mix": [2, 4], "mod": [2, 3], "mode": [2, 3, 4], "modul": [5, 6], "moisture_detect": [2, 4], "moisture_detection_ev": [2, 4], "moisturedetectionev": [2, 3, 5, 6], "monitor": [2, 3], "most": 0, "motion": [2, 3], "motion_detection_channel": [2, 4], "motion_detector_indoor": [2, 4], "motion_detector_outdoor": [2, 4], "motion_detector_push_button": [2, 4], "motiondetectionchannel": [2, 4], "motiondetectionsendinterv": [2, 4], "motiondetectorindoor": [2, 3, 5, 6], "motiondetectoroutdoor": [2, 3, 5, 6], "motiondetectorpushbutton": [2, 3, 5, 6], "motoris": [2, 3], "motorst": [2, 4], "mount": [2, 3, 4], "multi": [2, 3], "multi_io_box": [2, 4], "multi_mode_input_blind_channel": [2, 4], "multi_mode_input_channel": [2, 4], "multi_mode_input_dimmer_channel": [2, 4], "multi_mode_input_switch_channel": [2, 4], "multiiobox": [2, 3, 5, 6], "multimodeinputblindchannel": [2, 4], "multimodeinputchannel": [2, 4], "multimodeinputdimmerchannel": [2, 4], "multimodeinputmod": [2, 4], "multimodeinputswitchchannel": [2, 4], "multipl": 0, "must": [1, 2, 3, 4], "name": [2, 4], "need": [0, 1], "neutralposit": [2, 3, 4], "new": [2, 3, 4], "newpin": [2, 3], "night": [2, 4], "no_alarm": [2, 4], "no_heating_failur": [2, 4], "nominal_spe": [2, 4], "none": [2, 3, 4], "normal": [2, 4], "normally_clos": [2, 4], "normally_open": [2, 4], "north": 2, "not_abs": [2, 4], "not_exist": [2, 4], "not_poss": [2, 4], "not_us": [2, 4], "notification_light_channel": [2, 4], "notificationlightchannel": [2, 4], "notificationsoundtyp": [2, 3, 4], "notificationsoundtypehightolow": [2, 4, 6], "notificationsoundtypelowtohigh": [2, 4, 6], "now": 1, "number": 2, "o": [0, 1, 2, 3], "oauth_otk": [5, 6], "oauthotk": [2, 5, 6], "object": [0, 2, 3, 4], "oc8": [2, 3], "off": [2, 3, 4], "offici": 5, "offline_alarm": [2, 4], "offline_water_detection_ev": [2, 4], "offlinealarmev": [2, 3, 5, 6], "offlinewaterdetectionev": [2, 3, 5, 6], "offset": [2, 4], "often": 2, "old": [2, 3], "oldpin": [2, 3], "on_channel_ev": [2, 6], "on_creat": [2, 6], "on_error": 3, "on_messag": 3, "once_per_minut": [2, 4], "onli": 2, "ontim": [2, 3, 4], "ontimesecond": [2, 3], "open": [2, 3, 4], "open_collector_8_modul": [2, 4], "opencollector8modul": [2, 3, 5, 6], "openweathermap": 2, "oper": [2, 3, 4], "operationlock": [2, 3, 4], "operationlockabledevic": [2, 3, 5, 6], "optic": [2, 3], "optical_signal_channel": [2, 4], "optical_signal_group_channel": [2, 4], "opticalalarmsign": [2, 3, 4], "opticalsignalbehaviour": [2, 3, 4], "opticalsignalchannel": [2, 4], "opticalsignalgroupchannel": [2, 4], "option": [1, 2, 3], "optional_spe": [2, 4], "other": [2, 3], "otherwis": [1, 2, 3], "outdoor": [2, 3], "outdoorclimatesensor": [2, 6], "output": 4, "outsid": 2, "over_heat_protection_rul": [2, 4], "overheatprotectionrul": [2, 3, 5, 6], "overview": [0, 1], "own": 5, "p": [2, 3], "packag": [1, 5, 6], "page": 5, "param": [1, 2, 3], "paramet": [2, 3, 4], "pars": [2, 3], "parti": [2, 4], "partial_open": [2, 4], "partial_url": 3, "passag": [2, 3], "passage_detector": [2, 4], "passage_detector_channel": [2, 4], "passagedetector": [2, 3, 5, 6], "passagedetectorchannel": [2, 4], "passagedirect": [2, 4], "passive_glass_breakage_detector": [2, 4], "path": 3, "pattern": 4, "pcb": [2, 3], "pcbs2": [2, 3], "pdt": [2, 3], "per": 2, "perform_update_s": [2, 4], "performing_upd": [2, 4], "period": [2, 3, 4], "perman": [2, 4], "pin": [1, 2, 3, 4], "pinassign": [2, 6], "ping_interv": 2, "ping_loop": [2, 3], "ping_timeout": [2, 3], "pip3": 1, "pl": [2, 3], "place": 1, "plu": [2, 3], "plugabl": [2, 3], "plugable_switch": [2, 4], "plugable_switch_measur": [2, 4], "plugableswitch": [2, 3, 5, 6], "plugableswitchmeasur": [2, 3, 5, 6], "pluggabl": [2, 3], "pluggable_dimm": [2, 4], "pluggable_mains_failure_surveil": [2, 4], "pluggabledimm": [2, 5, 6], "pluggablemainsfailuresurveil": [2, 3, 5, 6], "pmf": [2, 3], "point": [1, 2, 5], "posit": [2, 3, 4], "position_unknown": [2, 4], "position_us": [2, 4], "possibl": [2, 3], "power": [2, 3], "pr": [2, 3], "prefer": 1, "presenc": [2, 3], "presence_detection_channel": [2, 4], "presence_detector_indoor": [2, 4], "presencedetectionchannel": [2, 4], "presencedetectorindoor": [2, 3, 5, 6], "price": [2, 3], "primary_alarm": [2, 4], "primaryshadinglevel": [2, 3, 4], "print": [1, 2, 3], "printed_circuit_board_switch_2": [2, 4], "printed_circuit_board_switch_batteri": [2, 4], "printedcircuitboardswitch2": [2, 3, 5, 6], "printedcircuitboardswitchbatteri": [2, 3, 5, 6], "profilemod": [2, 3, 4], "programdata": 1, "properti": [3, 4], "psm": [2, 3], "purpl": [2, 4], "push": [2, 3], "push_button": [2, 4], "push_button_6": [2, 4], "push_button_flat": [2, 4], "pushbutton": [2, 3, 5, 6], "pushbutton6": [2, 3, 5, 6], "pushbuttonflat": [2, 3, 5, 6], "py": [2, 3, 4], "python": [2, 5], "q": [2, 3], "qualnam": 4, "radiat": [2, 3], "rail": [2, 3], "rain": [2, 3, 4, 6], "rain_detection_channel": [2, 4], "rain_sensor": [2, 4], "raindetectionchannel": [2, 4], "rainsensor": [2, 3, 5, 6], "rainsensorsensit": [2, 4, 6], "rais": 2, "ramptim": [2, 3, 4], "raw_config": [2, 6], "rbg": [2, 3], "rbga": [2, 3], "rc8": [2, 3], "re": [2, 4], "reach": [2, 4], "receiv": 2, "reconnect": 2, "red": [2, 4], "refer": 2, "referenc": 4, "reject": [2, 4], "remot": [2, 3], "remote_control_8": [2, 4], "remote_control_8_modul": [2, 4], "remotecontrol8": [2, 3, 5, 6], "remotecontrol8modul": [2, 3, 5, 6], "remov": [2, 3], "remove_callback": [2, 6], "remove_channel_event_handl": [2, 6], "repars": [2, 3], "repres": [0, 2, 3, 4], "represent": 4, "request": [2, 4], "requestauthtoken": [2, 3, 6], "requir": 1, "reset_energy_count": [2, 3, 4, 6], "respons": [2, 3], "respres": 4, "rest": [0, 1], "result": [2, 3, 4], "return": [2, 3, 4], "revers": 5, "rgb": [2, 3, 4], "rgbcolorst": [2, 3, 4], "rgbw": [2, 3], "rgbw_dimmer": [2, 4], "rgbwdimmer": [2, 3, 5, 6], "right": [2, 4], "ring": [2, 3], "risk": 5, "room": [0, 2, 3, 4], "room_control_devic": [2, 4], "room_control_device_analog": [2, 4], "roomcontroldevic": [2, 3, 5, 6], "roomcontroldeviceanalog": [2, 5, 6], "rotary_handle_channel": [2, 4], "rotary_handle_sensor": [2, 4], "rotaryhandlechannel": [2, 4], "rotaryhandlesensor": [2, 3, 5, 6], "rule": [5, 6], "ruleid": 2, "run": [1, 2, 4], "run_to_start": [2, 4], "sabotag": [2, 3, 4], "sabotagedevic": [2, 3, 5, 6], "sabotageev": [2, 3, 5, 6], "sam": [2, 3], "schaltaktor": [2, 3], "sci": [2, 3], "script": 1, "scth230": [2, 3], "search": [2, 5], "search_channel": [2, 6], "search_client_by_id": [2, 6], "search_device_by_id": [2, 6], "search_group_by_id": [2, 6], "search_rule_by_id": [2, 6], "secondary_alarm": [2, 4], "secondaryshadinglevel": [2, 3, 4], "seconds_120": [2, 4], "seconds_240": [2, 4], "seconds_30": [2, 4], "seconds_480": [2, 4], "seconds_60": [2, 4], "secur": [0, 2, 3, 4], "security_and_alarm": [2, 4], "security_backup_alarm_switch": [2, 4], "security_journal_chang": [2, 4], "security_zon": [2, 4], "securityandalarmhom": [2, 5, 6], "securityev": [5, 6], "securityeventtyp": [2, 4], "securitygroup": [2, 3, 5, 6], "securityzoneactivationmod": [2, 4], "securityzoneev": [2, 3, 5, 6], "securityzonegroup": [2, 3, 5, 6], "securityzonevalu": [2, 3], "see": [2, 3, 4], "self": [2, 3, 4], "send": 1, "send_door_command": [2, 3, 4, 6], "send_start_impuls": [2, 3, 4, 6], "sender": [2, 3], "sensit": [2, 3, 4], "sensor": [2, 3], "sensor_ev": [2, 4], "sensor_range_16g": [2, 4], "sensor_range_2g": [2, 4], "sensor_range_2g_2plus_sens": [2, 4], "sensor_range_2g_plus_sen": [2, 4], "sensor_range_4g": [2, 4], "sensor_range_8g": [2, 4], "sensorev": [2, 3, 5, 6], "server": 3, "servic": 2, "session": 3, "set": [0, 1, 2, 3, 4], "set_acceleration_sensor_event_filter_period": [2, 3, 4, 6], "set_acceleration_sensor_mod": [2, 3, 4, 6], "set_acceleration_sensor_neutral_posit": [2, 3, 4, 6], "set_acceleration_sensor_sensit": [2, 3, 4, 6], "set_acceleration_sensor_trigger_angl": [2, 3, 4, 6], "set_acoustic_alarm_sign": [2, 3, 4, 6], "set_acoustic_alarm_tim": [2, 3, 4, 6], "set_acoustic_water_alarm_trigg": [2, 3, 4, 6], "set_active_profil": [2, 3, 6], "set_auth_token": [2, 4, 6], "set_boost": [2, 3, 6], "set_boost_dur": [2, 3, 6], "set_control_mod": [2, 3, 6], "set_cool": [2, 3, 6], "set_dim_level": [2, 3, 4, 6], "set_displai": [2, 3, 4, 6], "set_group_channel": [2, 3, 6], "set_inapp_water_alarm_trigg": [2, 3, 4, 6], "set_intrusion_alert_through_smoke_detector": [2, 3, 6], "set_label": [2, 3, 6], "set_light_group_switch": [2, 3, 6], "set_loc": [2, 3, 6], "set_lock_st": [0, 2, 3, 4, 6], "set_minimum_floor_heating_valve_posit": [2, 3, 4, 6], "set_notification_sound_typ": [2, 3, 4, 6], "set_on_tim": [2, 3, 6], "set_operation_lock": [2, 3, 4, 6], "set_optical_sign": [2, 3, 4, 6], "set_pin": [2, 3, 6], "set_point_temperatur": [2, 3, 6], "set_powermeter_unit_pric": [2, 3, 6], "set_primary_shading_level": [2, 3, 4, 6], "set_profile_mod": [2, 3, 6], "set_rgb_dim_level": [2, 3, 4, 6], "set_rgb_dim_level_with_tim": [2, 3, 4, 6], "set_router_module_en": [2, 3, 6], "set_rule_enabled_st": [2, 3, 6], "set_secondary_shading_level": [2, 3, 4, 6], "set_security_zones_activ": [2, 3, 6], "set_shutter_level": [2, 3, 4, 6], "set_shutter_stop": [2, 3, 4, 6], "set_signal_acoust": [2, 3, 6], "set_signal_opt": [2, 3, 6], "set_silent_alarm": [2, 6], "set_siren_water_alarm_trigg": [2, 3, 4, 6], "set_slats_level": [2, 3, 4, 6], "set_switch_st": [2, 3, 4, 6], "set_timezon": [2, 3, 6], "set_token_and_characterist": [2, 4], "set_zone_activation_delai": [2, 3, 6], "set_zones_device_assign": [2, 3, 6], "setpoint": [2, 4], "setpointtemperatur": [2, 4, 6], "settemperatur": [2, 3], "sgtin": [1, 2], "sh": [2, 3], "shading_channel": [2, 4], "shadingchannel": [2, 4], "shadingpackageposit": [2, 4], "shadingstatetyp": [2, 4], "should": [2, 3, 4], "shutter": [0, 2, 3, 4, 5, 6], "shutter_channel": [2, 4], "shutter_contact": [2, 4], "shutter_contact_channel": [2, 4], "shutter_contact_interfac": [2, 4], "shutter_contact_invis": [2, 4], "shutter_contact_magnet": [2, 4], "shutter_contact_optical_plu": [2, 4], "shutter_profil": [2, 4], "shutter_wind_protection_rul": [2, 4], "shutterchannel": [2, 4], "shuttercontact": [2, 3, 5, 6], "shuttercontactchannel": [2, 4], "shuttercontactmagnet": [2, 3, 5, 6], "shuttercontactopticalplu": [2, 3, 5, 6], "shutterlevel": [2, 3, 4], "shutterprofil": [2, 3, 5, 6], "shutterwindprotectionrul": [2, 3, 5, 6], "signal": [2, 3, 4], "signalacoust": [2, 3], "signalopt": [2, 3], "silence_chang": [2, 4], "silencechangedev": [2, 3, 5, 6], "silent": 2, "silent_alarm": [2, 4], "simpl": [2, 3, 4], "simplergbcolorst": [2, 4], "simplerul": [2, 3, 5, 6], "sinc": 5, "single_key_channel": [2, 4], "singlekeychannel": [2, 4], "siren": [0, 2, 3], "sirenwateralarmtrigg": [2, 3, 4], "six": [2, 4], "six_minut": [2, 4], "slat": [2, 3, 4], "slatslevel": [2, 3, 4], "slo": [2, 3], "slow_spe": [2, 4], "smart": [2, 3], "smartphon": 2, "smi": [2, 3], "smi55": [2, 3], "smo": [2, 3], "smoke": [2, 3], "smoke_alarm": [2, 4], "smoke_alarm_detection_rul": [2, 4], "smoke_detector": [2, 4], "smoke_detector_channel": [2, 4], "smokealarmdetectionrul": [2, 3, 5, 6], "smokealarmev": [2, 3, 5, 6], "smokedetector": [2, 3, 5, 6], "smokedetectoralarmtyp": [2, 4], "smokedetectorchannel": [2, 4], "sound_long": [2, 4], "sound_no_sound": [2, 4], "sound_short": [2, 4], "sound_short_short": [2, 4], "soundtyp": [2, 3, 4], "sourc": [2, 3, 4], "source_is_reading_loop": 3, "spdr": [2, 3], "specif": [0, 2], "specifi": [2, 3, 4], "spi": [2, 3], "split": [2, 4], "srd": [2, 3], "srh": [2, 3], "start": [2, 4], "start_inclus": [2, 6], "state": [0, 1, 2, 3, 4], "state_not_avail": [2, 4], "status_cod": 4, "ste2": [2, 3], "sth": [2, 3], "sthd": [2, 3], "stho": [2, 3], "stop": [2, 3, 4, 6], "str": [2, 3, 4], "string": [2, 3, 4], "strong_wind": [2, 4], "stv": [2, 3], "submodul": [5, 6], "subpackag": [5, 6], "suppli": [2, 3], "support": 1, "swd": [2, 3], "swdm": [2, 3], "swdo": [2, 3], "switch": [2, 3, 4, 5, 6], "switch_behavior": [2, 4], "switch_channel": [2, 4], "switch_measuring_channel": [2, 4], "switchchannel": [2, 4], "switchgroupbas": [2, 3, 5, 6], "switching_profil": [2, 4], "switchinggroup": [2, 3, 5, 6], "switchingprofilegroup": [2, 3, 5, 6], "switchmeasur": [2, 3, 5, 6], "switchmeasuringchannel": [2, 4], "swo": [2, 3], "swsd": [2, 3], "system": [1, 2, 3], "t": 2, "task": 3, "tdbu": [2, 4], "temperatur": [2, 3, 4, 6], "temperature_humidity_sensor": [2, 4], "temperature_humidity_sensor_displai": [2, 4], "temperature_humidity_sensor_outdoor": [2, 4], "temperature_sensor_2_external_delta": [2, 4], "temperature_sensor_2_external_delta_channel": [2, 4], "temperaturedifferencesensor2": [2, 3, 5, 6], "temperaturedifferencesensor2channel": [2, 4], "temperatureexternaldelta": [2, 4, 6], "temperatureexternalon": [2, 4, 6], "temperatureexternaltwo": [2, 4, 6], "temperaturehumiditysensordisplai": [2, 3, 5, 6], "temperaturehumiditysensoroutdoor": [2, 3, 5, 6], "temperaturehumiditysensorwithoutdisplai": [2, 3, 5, 6], "temperatureoffset": [2, 4, 6], "termin": 1, "test_signal_acoust": [2, 3, 6], "test_signal_opt": [2, 3, 6], "text": 4, "thei": 2, "them": [2, 3], "thermostat": [0, 2, 3, 4], "thi": [0, 1, 2, 3, 4, 5], "thread": 4, "three_minut": [2, 4], "threshold": 2, "throw": 3, "ti": [2, 4], "tilt": [2, 4], "tilt_us": [2, 4], "tilt_vibration_sensor": [2, 4], "tilt_vibration_sensor_channel": [2, 4], "tiltvibrationsensor": [2, 3, 5, 6], "tiltvibrationsensorchannel": [2, 4], "time": [2, 3], "timeprofil": [2, 5, 6], "timeprofileperiod": [2, 5, 6], "timezon": [2, 3], "tm": [2, 3], "toggl": [1, 2, 3, 4], "toggle_garage_door": [2, 4], "token": 5, "too_tight": [2, 4], "toogl": 1, "top": [2, 4], "toplightchannelindex": [2, 3, 4, 6], "tormat": [2, 3], "tormatic_modul": [2, 4], "traffic": 3, "transfering_upd": [2, 4], "trigger": [2, 4, 6], "true": [2, 3, 4], "trust": 1, "tupl": 2, "turn": 4, "turn_off": [2, 3, 4, 6], "turn_on": [2, 3, 4, 6], "turquois": [2, 4], "twilight": [2, 4], "two": [2, 4], "type": [1, 2, 3, 4], "u": 1, "understand": 2, "uniqu": [0, 2], "univers": 4, "universal_actuator_channel": [2, 4], "universal_light_channel": [2, 4], "universal_light_group_channel": [2, 4], "universalactuatorchannel": [2, 4], "universallightchannel": [2, 4], "universallightchannelgroup": [2, 4], "unknown": [2, 4], "unlock": [2, 4], "until": [2, 3], "up_to_d": [2, 4], "updat": [1, 2, 4], "update_author": [2, 4], "update_avail": [2, 4], "update_hom": [2, 6], "update_home_onli": [2, 6], "update_incomplet": [2, 4], "update_profil": [2, 6], "updatest": 2, "upper": 2, "urlrest": [2, 4], "urlwebsocket": [2, 4], "us": [2, 3, 4, 5], "usal": [2, 3, 4], "v": [2, 3], "vacat": [2, 3, 4], "valid": 2, "validationtimeout": [2, 6], "valu": [2, 3, 4], "valv": [2, 3, 4], "valveactualtemperatur": [2, 4, 6], "valveposit": [2, 4, 6], "valvest": [2, 4, 6], "vapor": 2, "vaporamount": [2, 6], "vatat": [2, 3], "ventilation_posit": [2, 4], "ventilationrecommend": [2, 6], "version": [2, 3], "vertic": [2, 4], "via": 5, "vibrat": [2, 3], "visibl": [2, 4], "volt": 4, "wa": 5, "wait_for_adapt": [2, 4], "wall": [2, 3, 4], "wall_mounted_garage_door_control": [2, 4], "wall_mounted_thermostat_basic_humid": [2, 4], "wall_mounted_thermostat_pro": [2, 4], "wall_mounted_thermostat_pro_channel": [2, 4], "wall_mounted_thermostat_without_display_channel": [2, 4], "wall_mounted_universal_actu": [2, 4], "wallmountedgaragedoorcontrol": [2, 3, 5, 6], "wallmountedthermostatbasichumid": [2, 5, 6], "wallmountedthermostatpro": [2, 3, 5, 6], "wallmountedthermostatprochannel": [2, 4], "wallmountedthermostatwithoutdisplaychannel": [2, 4], "water": 2, "water_detect": [2, 4], "water_detection_ev": [2, 4], "water_moisture_detect": [2, 4], "water_sensor": [2, 4], "water_sensor_channel": [2, 4], "wateralarmtrigg": [2, 3, 4], "waterdetectionev": [2, 3, 5, 6], "watersensor": [2, 3, 5, 6], "watersensorchannel": [2, 4], "weather": [5, 6], "weather_and_environ": [2, 4], "weather_sensor": [2, 4], "weather_sensor_channel": [2, 4], "weather_sensor_plu": [2, 4], "weather_sensor_plus_channel": [2, 4], "weather_sensor_pro": [2, 4], "weather_sensor_pro_channel": [2, 4], "weatherandenvironmenthom": [2, 5, 6], "weathercondit": [2, 4, 6], "weatherdaytim": [2, 4, 6], "weathersensor": [2, 3, 5, 6], "weathersensorchannel": [2, 4], "weathersensorplu": [2, 3, 5, 6], "weathersensorpluschannel": [2, 4], "weathersensorpro": [2, 3, 5, 6], "weathersensorprochannel": [2, 4], "websess": 3, "websocket": [2, 3], "websocket_reconnect_on_error": [2, 6], "wgc": [1, 2, 3], "when": [1, 2, 3, 4], "where": 2, "which": [0, 1, 2, 3, 4], "while": [2, 3], "white": [2, 4], "whole": 2, "whs2": [2, 3], "wind": 2, "winddirect": [2, 6], "window": [1, 2, 3], "window_door_contact": [2, 4], "windowst": [2, 4], "windspe": [2, 6], "windvaluetyp": [2, 4], "wire": [2, 3], "wired_blind_4": [2, 4], "wired_dimmer_3": [2, 4], "wired_din_rail_access_point": [2, 4], "wired_floor_terminal_block_12": [2, 4], "wired_input_32": [2, 4], "wired_input_switch_6": [2, 4], "wired_motion_detector_push_button": [2, 4], "wired_presence_detector_indoor": [2, 4], "wired_push_button_2": [2, 4], "wired_push_button_6": [2, 4], "wired_switch_4": [2, 4], "wired_switch_8": [2, 4], "wired_wall_mounted_thermostat": [2, 4], "wireddimmer3": [2, 3, 5, 6], "wireddinrailaccesspoint": [2, 3, 5, 6], "wireddinrailblind4": [2, 3, 5, 6], "wiredfloorterminalblock12": [2, 5, 6], "wiredinput32": [2, 3, 5, 6], "wiredinputswitch6": [2, 3, 5, 6], "wiredmotiondetectorpushbutton": [2, 3, 5, 6], "wiredpushbutton": [2, 3, 5, 6], "wiredswitch4": [2, 3, 5, 6], "wiredswitch8": [2, 3, 5, 6], "without": [2, 3], "work": 1, "wrapper": 5, "wrc2": [2, 3], "wrc6": [2, 3], "wrcc2": [2, 3], "write": 1, "ws_connect": [2, 3], "wth": [2, 3], "yellow": [2, 4], "you": [0, 1], "your": [1, 5], "zone": [2, 3]}, "titles": ["API Introduction", "Getting Started", "homematicip package", "homematicip.aio package", "homematicip.base package", "Welcome to Homematic IP Rest API\u2019s documentation!", "homematicip"], "titleterms": {"": 5, "about": 1, "access_point_update_st": 2, "aio": 3, "api": [0, 5], "auth": [1, 2, 3], "base": 4, "base_connect": 4, "class_map": [2, 3], "cli": 1, "client": 2, "connect": [2, 3], "constant": 4, "content": [2, 3, 4], "devic": [1, 2, 3], "document": 5, "enum": 4, "eventhook": 2, "exampl": 1, "functionalchannel": 4, "functionalhom": 2, "get": [1, 5], "group": [1, 2, 3], "helper": 4, "home": [2, 3], "homemat": 5, "homematicip": [2, 3, 4, 6], "homematicipobject": [2, 4], "indic": 5, "inform": 1, "instal": 1, "introduct": 0, "ip": 5, "locat": 2, "modul": [2, 3, 4], "oauth_otk": 2, "packag": [2, 3, 4], "rest": 5, "rule": [2, 3], "securityev": [2, 3], "start": [1, 5], "submodul": [2, 3, 4], "subpackag": 2, "tabl": 5, "token": 1, "us": 1, "weather": 2, "welcom": 5}}) \ No newline at end of file