vsure 2.6.9__py3-none-any.whl

verisure/__init__.py

@@ -0,0 +1,29 @@
+"""
+A python module for reading and changing status of verisure devices through
+verisure app API.
+"""
+
+__all__ = [
+    'Error',
+    'LoginError',
+    'RequestError',
+    'ResponseError',
+    'Session',
+]
+
+from .session import ( # NOQA
+    Error,
+    LoginError,
+    RequestError,
+    VariableTypes,
+    ResponseError,
+    Session,
+)
+
+ALARM_ARMED_HOME = 'ARMED_HOME'
+ALARM_ARMED_AWAY = 'ARMED_AWAY'
+ALARM_DISARMED = 'DISARMED'
+LOCK_LOCKED = 'LOCKED'
+LOCK_UNLOCKED = 'UNLOCKED'
+SMARTPLUG_ON = 'on'
+SMARTPLUG_OFF = 'off'

verisure/__main__.py

@@ -0,0 +1,156 @@
+""" Command line interface for Verisure MyPages """
+
+import inspect
+import json
+import re
+import click
+import logging
+import getpass
+from verisure import VariableTypes, Session, ResponseError, LoginError
+
+
+class DeviceLabel(click.ParamType):
+    """Click param for device label"""
+    name = "DeviceLabel"
+
+    def convert(self, value, param, ctx):
+        if re.match(r"^([A-Z]|[0-9]){4} ([A-Z]|[0-9]){4}$", value):
+            return value
+        self.fail(f"{value!r} is not a device label", param, ctx)
+
+
+class ArmFutureState(click.ParamType):
+    """Click param for arm future state"""
+    name = "FutureState"
+
+
+class LockFutureState(click.ParamType):
+    """Click param for lock future state"""
+    name = "FutureState"
+
+
+class TransactionId(click.ParamType):
+    """Click param for transaction id"""
+    name = "TransactionId"
+
+
+class RequestId(click.ParamType):
+    """Click param for request id"""
+    name = "RequestId"
+
+
+class Code(click.ParamType):
+    """Click param for code"""
+    name = "Code"
+
+    def convert(self, value, param, ctx):
+        if re.match(r"^[0-9]{4,6}$", value):
+            return value
+        self.fail(f"{value!r} is not a code", param, ctx)
+
+
+VariableTypeMap = {
+    VariableTypes.DeviceLabel: DeviceLabel(),
+    VariableTypes.ArmFutureState: ArmFutureState(),
+    VariableTypes.LockFutureState: LockFutureState(),
+    bool: click.BOOL,
+    VariableTypes.TransactionId: TransactionId(),
+    VariableTypes.RequestId: RequestId(),
+    VariableTypes.Code: Code(),
+}
+
+
+def options_from_operator_list():
+    """Get all query operations and build query cli"""
+    def decorator(f):
+        ops = inspect.getmembers(Session, predicate=inspect.isfunction)
+        for name, operation in reversed(ops):
+            if not hasattr(operation, 'is_query'):
+                continue
+            variables = list(operation.__annotations__.values())
+            # Remove Giid type from variables, not supported by CLI
+            if VariableTypes.Giid in variables:
+                variables.remove(VariableTypes.Giid)
+            dashed_name = name.replace('_', '-')
+            if len(variables) == 0:
+                click.option(
+                    '--'+dashed_name,
+                    is_flag=True,
+                    help=operation.__doc__)(f)
+            elif len(variables) == 1:
+                click.option(
+                    '--'+dashed_name,
+                    type=VariableTypeMap[variables[0]],
+                    help=operation.__doc__)(f)
+            else:
+                types = [VariableTypeMap[variable] for variable in variables]
+                click.option(
+                    '--'+dashed_name,
+                    type=click.Tuple(types),
+                    help=operation.__doc__)(f)
+        return f
+    return decorator
+
+
+def make_query(session, name, arguments):
+    """make query operation"""
+    if arguments is True:
+        return getattr(session, name)()
+    if isinstance(arguments, str):
+        return getattr(session, name)(arguments)
+    return getattr(session, name)(*arguments)
+
+
+@click.command()
+@click.argument('username')
+@click.argument('password', required=False)
+@click.option('-i', '--installation', 'installation', help='Installation number', type=int, default=0)  # noqa: E501
+@click.option('-c', '--cookie', 'cookie', help='File to store cookie in', default='~/.verisure-cookie')  # noqa: E501
+@click.option('--mfa', 'mfa', help='Login using MFA', default=False, is_flag=True)  # noqa: E501
+@click.option('--log-level', type=click.Choice(['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], case_sensitive=False))  # noqa: E501
+@options_from_operator_list()
+def cli(username, password, installation, cookie, mfa, log_level, **kwargs):
+    """
+    Read and change status of verisure devices through verisure app API\n
+    PASSWORD will be prompted without echoing if not provided as an argument
+    """
+
+    if not password:
+        password = getpass.getpass(prompt='Password: ', stream=None)
+    if log_level:
+        logging.basicConfig(level=logging.getLevelName(log_level))
+
+    session = Session(username, password, cookie)
+
+    try:
+        # try using the cookie first
+        installations = session.login_cookie()
+    except LoginError:
+        installations = None
+
+    try:
+        if mfa and not installations:
+            session.request_mfa()
+            code = input("Enter verification code: ")
+            session.validate_mfa(code)
+            installations = session.login_cookie()
+        elif not installations:
+            installations = session.login()
+
+        session.set_giid(
+            installations['data']['account']
+            ['installations'][installation]['giid'])
+        queries = [
+            make_query(session, name, arguments)
+            for name, arguments in kwargs.items()
+            if arguments]
+        result = session.request(*queries)
+        click.echo(json.dumps(result, indent=4, separators=(',', ': ')))
+
+    except ResponseError as ex:
+        click.echo(ex,err=True)
+
+
+if __name__ == "__main__":
+    # pylint: disable=no-value-for-parameter
+    cli()

verisure/session.py

@@ -0,0 +1,799 @@
+'''
+Verisure session, using verisure app api
+'''
+
+import json
+import logging
+import os
+import pickle
+
+import requests
+
+LOGGER = logging.getLogger(__package__)
+
+
+class Error(Exception):
+    ''' Verisure session error '''
+
+
+class RequestError(Error):
+    ''' Request '''
+
+
+class LoginError(Error):
+    ''' Login failed '''
+
+
+class LogoutError(Error):
+    ''' Logout failed '''
+
+
+class ResponseError(Error):
+    ''' Unexcpected response '''
+    def __init__(self, status_code, text):
+        super().__init__(
+            f'Invalid response, status code: {status_code} - Data: {text}')
+
+
+def query_func(f):
+    """A wrapper that indicates that the function is a query (used by CLI)"""
+    f.is_query = True
+    return f
+
+
+class VariableTypes:
+    """Types for query parameters"""
+    class DeviceLabel(str):
+        """Device label"""
+
+    class TransactionId(str):
+        """Transaction ID"""
+
+    class RequestId(str):
+        """Request ID"""
+
+    class ArmFutureState(str):
+        """Arm state"""
+        # ARMED_AWAY, DISARMED, ARMED_HOME
+
+    class LockFutureState(str):
+        """Lock state"""
+
+    class Code(str):
+        """Code"""
+
+    class Giid(str):
+        """Giid"""
+
+
+class Session(object):
+    """ Verisure app session
+
+    Args:
+        username (str): Username used to login to verisure app
+        password (str): Password used to login to verisure app
+        cookie_file_name (str): path to cookie file
+
+    """
+
+    def __init__(self, username, password,
+                 cookie_file_name='~/.verisure-cookie'):
+        LOGGER.info(f"Initialize Session ({username=}, {cookie_file_name=})")
+        self._username = username
+        self._password = password
+        self._cookies = None
+        self._cookie_file_name = os.path.expanduser(cookie_file_name)
+        self._trust_token = None
+        self._giid = None
+        self._base_url = None
+        self._base_urls = ['https://automation01.verisure.com',
+                           'https://automation02.verisure.com']
+        self._post = self._wrap_request(requests.post)
+        self._delete = self._wrap_request(requests.delete)
+        self._get = self._wrap_request(requests.get)
+
+
+    def _wrap_request(self, function):
+        """
+        Used to wrap methods from the requests module to try both urls and remember
+        the last working one.
+        """
+
+        def wrapper(url, *args, **kwargs):
+            last_exception = Error("Unknown error")
+            base_urls = self._base_urls.copy()
+            for base_url in base_urls:
+                try:
+                    response = function(base_url+url, *args, **kwargs)
+                    if response.status_code > 200 or "errors" in response.text:
+                        LOGGER.debug(
+                            f"{response.request.method} {response.request.url} "
+                            f"{response.status_code} f{response.text}"
+                        )
+                    if response.status_code >= 500:
+                        last_exception = ResponseError(response.status_code, response.text)
+                        self._base_urls.reverse()
+                        continue
+                    if response.status_code >= 400:
+                        last_exception = LoginError(response.text)
+                        break
+                    if response.status_code == 200:
+                        if "SYS_00004" in response.text:
+                            self._base_urls.reverse()
+                            continue
+                        return response
+ 
+                except requests.exceptions.RequestException as ex:
+                    LOGGER.warning(f"Unexpected error on '{base_url}{url}' ({ex=})")
+                    last_exception = RequestError(str(ex))
+                self._base_urls.reverse()
+            raise last_exception
+        return wrapper
+
+
+    def login(self):
+        """ Login to verisure app api
+        Login before calling any read or write commands
+        Return installations
+        """
+
+        response = self._post(
+            "/auth/login",
+            headers={'APPLICATION_ID': 'PS_PYTHON'},
+            auth=(self._username, self._password))
+
+        if "stepUpToken" in response.text:
+            raise LoginError("Multifactor authentication enabled, "
+                             "disable or create MFA cookie")
+
+        self._cookies = response.cookies
+        with open(self._cookie_file_name, 'wb') as f:
+            pickle.dump(self._cookies, f)
+
+        installations = self.get_installations()
+        if 'errors' not in installations:
+            return installations
+
+        raise LoginError("Failed to log in")
+
+    def request_mfa(self):
+        """ Request MFA verification code """
+
+        response = self._post(
+            url="/auth/login",
+            headers={'APPLICATION_ID': 'PS_PYTHON'},
+            auth=(self._username, self._password))
+
+        if "stepUpToken" not in response.text:
+            raise LoginError("Multifactor authentication disabled, "
+                             "use regular login instead")
+
+        self._cookies = response.cookies
+        for mfa_type in ['phone', 'email']:
+            try:
+                mfa_response = self._post(
+                    url=f"/auth/mfa?type={mfa_type}",
+                    headers={'APPLICATION_ID': 'PS_PYTHON'},
+                    cookies=self._cookies)
+                if mfa_response.status_code == 200:
+                    return
+            except Exception as ex:
+                raise LoginError("Failed to request MFA type") from ex
+
+        raise LoginError("Failed to log in")
+
+    def validate_mfa(self, code):
+        """ Validate mfa request
+        Return installations
+        """
+
+        response = self._post(
+            url="/auth/mfa/validate",
+            headers={
+                'APPLICATION_ID': 'PS_PYTHON',
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'},
+            cookies=self._cookies,
+            data=json.dumps({"token": code}))
+        self._cookies = response.cookies
+
+        trust_response = self._post(
+            url="/auth/trust",
+            headers={
+                'APPLICATION_ID': 'PS_PYTHON',
+                'Accept': 'application/json',
+            },
+            cookies=self._cookies)
+        self._cookies.update(trust_response.cookies)
+        with open(self._cookie_file_name, 'wb') as cookie_file:
+            pickle.dump(self._cookies, cookie_file)
+        self._trust_token = trust_response.json()
+
+        installations = self.get_installations()
+        if 'errors' not in installations:
+            return installations
+
+        raise LoginError("Failed to log in")
+
+    def _load_cookie_file_into_memory(self):
+        """Populate ``_cookies`` from the persisted pickle (used by cookie login paths)."""
+
+        try:
+            with open(self._cookie_file_name, 'rb') as cookie_file:
+                self._cookies = pickle.load(cookie_file)
+        except OSError as ex:
+            raise LoginError("Failed to read cookie") from ex
+        except (EOFError, pickle.UnpicklingError, AttributeError, TypeError, ValueError) as ex:
+            raise LoginError("Failed to read cookie") from ex
+
+    def login_cookie(self):
+        """ Login using cookie
+        Return installations
+        """
+
+        self._load_cookie_file_into_memory()
+
+        # Login
+        cookie_jar = requests.sessions.RequestsCookieJar()
+        for name, value in self._cookies.items():
+            if 'vs-trust' in name:
+                cookie_jar.set(name, value)
+        response = self._post(
+            url="/auth/login",
+            headers={'APPLICATION_ID': 'PS_PYTHON'},
+            auth=(self._username, self._password),
+            cookies=cookie_jar)
+        self._cookies.update(response.cookies)
+        with open(self._cookie_file_name, 'wb') as f:
+            pickle.dump(self._cookies, f)
+
+        installations = self.get_installations()
+        if 'errors' not in installations:
+            return installations
+
+        raise LoginError("Failed to log in")
+
+    def update_cookie(self):
+        """ Update expired cookie
+        Cookie can last 15 minutes before it needs to be updated.
+
+        Long-running callers may reset ``self._cookies`` while a valid pickle remains
+        on disk; hydrate from the file before calling ``/auth/token`` so the request
+        is not sent with an empty cookie jar.
+        """
+        if self._cookies is None:
+            self._load_cookie_file_into_memory()
+
+        cookie_jar = requests.sessions.RequestsCookieJar()
+        if self._cookies is not None:
+            for name, value in self._cookies.items():
+                if name in ['vid', 'vs-refresh']:
+                    cookie_jar[name] = value
+        response = self._get(
+            url="/auth/token",
+            headers={'APPLICATION_ID': 'PS_PYTHON'},
+            cookies=cookie_jar)
+
+        self._cookies.update(response.cookies)
+        with open(self._cookie_file_name, 'wb') as cookie_file:
+            pickle.dump(self._cookies, cookie_file)
+        LOGGER.debug(f"Saved cookies: {[cookie for cookie in self._cookies.keys()]}")
+
+    def logout(self):
+        """ Log out from the verisure app api """
+        try:
+            if self._trust_token is not None:
+                token = self._trust_token['trustTokenValue']
+                self._delete(
+                    url=f"/auth/trust/{token}",
+                    headers={
+                        'APPLICATION_ID': 'PS_PYTHON',
+                        'Accept': 'application/json',
+                    },
+                    cookies=self._cookies)
+            self._delete(
+                url="/auth/logout",
+                headers={'APPLICATION_ID': 'PS_PYTHON'},
+                cookies=self._cookies)
+        finally:
+            self._base_url = None
+            self._giid = None
+            self._cookies = None
+            self._trust_token = None
+            if os.path.exists(self._cookie_file_name):
+                os.remove(self._cookie_file_name)
+
+    def request(self, *operations):
+        """Request operations"""
+        if not operations:
+            # Return empty json if no operations were requested
+            return json.loads("{}")
+        response = self._post(
+            '/graphql',
+            headers={
+                'APPLICATION_ID': 'PS_PYTHON',
+                'Accept': 'application/json'},
+            cookies=self._cookies,
+            data=json.dumps(list(operations)))
+        return json.loads(response.text)
+
+    def get_installations(self):
+        """ Get information about installations """
+        return self.request(self.fetch_all_installations())
+
+    def set_giid(self, giid):
+        """ Set installation giid
+
+        Args:
+            giid (str): Installation identifier
+        """
+        self._giid = giid
+        LOGGER.info(f"Installation identifier set ({giid=})")
+
+    @query_func
+    def arm_away(self,
+                 code: VariableTypes.Code,
+                 giid: VariableTypes.Giid=None):
+        """Set arm status away"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "armAway",
+            "variables": {
+                "giid": giid or self._giid,
+                "code": code},
+            "query": "mutation armAway($giid: String!, $code: String!) {\n  armStateArmAway(giid: $giid, code: $code)\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def arm_home(self,
+                 code: VariableTypes.Code,
+                 giid: VariableTypes.Giid=None):
+        """Set arm state home"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "armHome",
+            "variables": {
+                "giid": giid or self._giid,
+                "code": code},
+            "query": "mutation armHome($giid: String!, $code: String!) {\n  armStateArmHome(giid: $giid, code: $code)\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def arm_state(self,
+                  giid: VariableTypes.Giid=None):
+        """Read arm state"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "ArmState",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query ArmState($giid: String!) {\n  installation(giid: $giid) {\n    armState {\n      type\n      statusType\n      date\n      name\n      changedVia\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def broadband(self,
+                  giid: VariableTypes.Giid=None):
+        """Get broadband status"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "Broadband",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query Broadband($giid: String!) {\n  installation(giid: $giid) {\n    broadband {\n      testDate\n      isBroadbandConnected\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def capability(self,
+                   giid: VariableTypes.Giid=None):
+        """Get capability"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "Capability",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query Capability($giid: String!) {\n  installation(giid: $giid) {\n    capability {\n      current\n      gained {\n        capability\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def charge_sms(self,
+                   giid: VariableTypes.Giid=None):
+        """Charge SMS"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "ChargeSms",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query ChargeSms($giid: String!) {\n  installation(giid: $giid) {\n    chargeSms {\n      chargeSmartPlugOnOff\n      chargeLockUnlock\n      chargeArmDisarm\n      chargeNotifications\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def climate(self,
+                giid: VariableTypes.Giid=None):
+        """Get climate"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "Climate",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query Climate($giid: String!) {\n  installation(giid: $giid) {\n    climates {\n      device {\n        deviceLabel\n        area\n        gui {\n          label\n          __typename\n        }\n        __typename\n      }\n      humidityEnabled\n      humidityTimestamp\n      humidityValue\n      temperatureTimestamp\n      temperatureValue\n      thresholds {\n        aboveMaxAlert\n        belowMinAlert\n        sensorType\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def disarm(self,
+               code: VariableTypes.Code,
+               giid: VariableTypes.Giid=None):
+        """Disarm alarm"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "disarm",
+            "variables": {
+                "giid": giid or self._giid,
+                "code": code},
+            "query": "mutation disarm($giid: String!, $code: String!) {\n  armStateDisarm(giid: $giid, code: $code)\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def door_lock(self,
+                  device_label: VariableTypes.DeviceLabel,
+                  code: VariableTypes.Code,
+                  giid: VariableTypes.Giid=None):
+        """Lock door"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "DoorLock",
+            "variables": {
+                "giid": giid or self._giid,
+                "deviceLabel": device_label,
+                "input": {
+                    "code": code,
+                },
+            },
+            "query": "mutation DoorLock($giid: String!, $deviceLabel: String!, $input: LockDoorInput!) {\n  DoorLock(giid: $giid, deviceLabel: $deviceLabel, input: $input)\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def door_lock_configuration(self,
+                                device_label: VariableTypes.DeviceLabel,
+                                giid: VariableTypes.Giid=None):
+        """Get door lock configuration"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "DoorLockConfiguration",
+            "variables": {
+                "giid": giid or self._giid,
+                "deviceLabel": device_label},
+            "query": "query DoorLockConfiguration($giid: String!, $deviceLabel: String!) {\n  installation(giid: $giid) {\n    smartLocks(filter: {deviceLabels: [$deviceLabel]}) {\n      device {\n        area\n        deviceLabel\n        __typename\n      }\n      configuration {\n        ... on YaleLockConfiguration {\n          autoLockEnabled\n          voiceLevel\n          volume\n          __typename\n        }\n        ... on DanaLockConfiguration {\n          holdBackLatchDuration\n          twistAssistEnabled\n          __typename\n        }\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def set_autolock_enabled(self,
+                             device_label: VariableTypes.DeviceLabel,
+                             auto_lock_enabled: bool,
+                             giid: VariableTypes.Giid=None):
+        """Enable or disable autolock"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "DoorLockUpdateConfig",
+            "variables": {
+                "giid": giid or self._giid,
+                "deviceLabel": device_label,
+                "input": {
+                    "autoLockEnabled": auto_lock_enabled
+                }
+            },
+            "query": "mutation DoorLockUpdateConfig($giid: String!, $deviceLabel: String!, $input: DoorLockUpdateConfigInput!) {\n  DoorLockUpdateConfig(giid: $giid, deviceLabel: $deviceLabel, input: $input)\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def door_unlock(self,
+                    device_label: VariableTypes.DeviceLabel,
+                    code: VariableTypes.Code,
+                    giid: VariableTypes.Giid=None):
+        """Unlock door"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "DoorUnlock",
+            "variables": {
+                "giid": giid or self._giid,
+                "deviceLabel": device_label,
+                "input": {
+                    "code": code,
+                },
+            },
+            "query": "mutation DoorUnlock($giid: String!, $deviceLabel: String!, $input: LockDoorInput!) {\n  DoorUnlock(giid: $giid, deviceLabel: $deviceLabel, input: $input)\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def door_window(self,
+                    giid: VariableTypes.Giid=None):
+        """Read status of door and window sensors"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "DoorWindow",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query DoorWindow($giid: String!) {\n  installation(giid: $giid) {\n    doorWindows {\n      device {\n        deviceLabel\n        __typename\n      }\n      type\n      area\n      state\n      wired\n      reportTime\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def event_log(self,
+                  giid: VariableTypes.Giid=None):
+        """Read event log"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "EventLog",
+            "variables": {
+                "giid": giid or self._giid,
+                "offset": 0,
+                "pagesize": 15,
+                "eventCategories": ["INTRUSION", "FIRE", "SOS", "WATER", "ANIMAL", "TECHNICAL", "WARNING", "ARM", "DISARM", "LOCK", "UNLOCK", "PICTURE", "CLIMATE", "CAMERA_SETTINGS"],  # noqa: E501
+                "eventContactIds": [],
+                "eventDeviceLabels": [],
+                "fromDate": None,
+                "toDate": None
+            },
+            "query": "query EventLog($giid: String!, $offset: Int!, $pagesize: Int!, $eventCategories: [String], $fromDate: String, $toDate: String, $eventContactIds: [String], $eventDeviceLabels: [String]) {\n  installation(giid: $giid) {\n    eventLog(offset: $offset, pagesize: $pagesize, eventCategories: $eventCategories, eventContactIds: $eventContactIds, eventDeviceLabels: $eventDeviceLabels, fromDate: $fromDate, toDate: $toDate) {\n      moreDataAvailable\n      pagedList {\n        device {\n          deviceLabel\n          area\n          gui {\n            label\n            __typename\n          }\n          __typename\n        }\n        arloDevice {\n          name\n          __typename\n        }\n        gatewayArea\n        eventType\n        eventCategory\n        eventSource\n        eventId\n        eventTime\n        userName\n        armState\n        userType\n        climateValue\n        sensorType\n        eventCount\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def fetch_all_installations(self):
+        """Fetch installations"""
+        return {
+            "operationName": "fetchAllInstallations",
+            "variables": {
+                "email": self._username},
+            "query": "query fetchAllInstallations($email: String!){\n  account(email: $email) {\n    installations {\n      giid\n      alias\n      customerType\n      dealerId\n      subsidiary\n      pinCodeLength\n      locale\n      address {\n        street\n        city\n        postalNumber\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+            }
+    
+    @query_func
+    def firmware(self,
+                 giid: VariableTypes.Giid=None):
+        """Get firmware information"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+	        "operationName": "Firmware",
+	        "variables": {
+		        "giid": giid or self._giid
+	        },
+	        "query": "query Firmware($giid: String!) {\n  installation(giid: $giid) {\n    firmware {\n      status {\n        latestFirmware\n        requestedFirmware\n        upgradeable\n        status\n        gateways {\n          reportedRunningFirmware\n          deviceLabel\n          status\n          __typename\n        }\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n" # noqa: E501
+        }
+
+    @query_func
+    def guardian_sos(self):
+        """Guardian SOS"""
+        return {
+            "operationName": "GuardianSos",
+            "variables": {},
+            "query": "query GuardianSos {\n  guardianSos {\n    serverTime\n    sos {\n      fullName\n      phone\n      deviceId\n      deviceName\n      giid\n      type\n      username\n      expireDate\n      warnBeforeExpireDate\n      contactId\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def is_guardian_activated(self,
+                              giid: VariableTypes.Giid=None):
+        """Is guardian activated"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "IsGuardianActivated",
+            "variables": {
+                "giid": giid or self._giid,
+                "featureName": "GUARDIAN"},
+            "query": "query IsGuardianActivated($giid: String!, $featureName: String!) {\n  installation(giid: $giid) {\n    activatedFeature {\n      isFeatureActivated(featureName: $featureName)\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def permissions(self,
+                    giid: VariableTypes.Giid=None):
+        """Permissions"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "Permissions",
+            "variables": {
+                "giid": giid or self._giid,
+                "email": self._username},
+            "query": "query Permissions($giid: String!, $email: String!) {\n  permissions(giid: $giid, email: $email) {\n    accountPermissionsHash\n    name\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def poll_arm_state(self,
+                       transaction_id: VariableTypes.TransactionId,
+                       future_state: VariableTypes.ArmFutureState,
+                       giid: VariableTypes.Giid=None):
+        """Poll arm state"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "pollArmState",
+            "variables": {
+                "giid": giid or self._giid,
+                "transactionId": transaction_id,
+                "futureState": future_state},
+            "query": "query pollArmState($giid: String!, $transactionId: String, $futureState: ArmStateStatusTypes!) {\n  installation(giid: $giid) {\n    armStateChangePollResult(transactionId: $transactionId, futureState: $futureState) {\n      result\n      createTime\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def poll_lock_state(self,
+                        transaction_id: VariableTypes.TransactionId,
+                        device_label: VariableTypes.DeviceLabel,
+                        future_state: VariableTypes.LockFutureState,
+                        giid: VariableTypes.Giid=None):
+        """Poll lock state"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "pollLockState",
+            "variables": {
+                "giid": giid or self._giid,
+                "transactionId": transaction_id,
+                "deviceLabel": device_label,
+                "futureState": future_state},
+            "query": "query pollLockState($giid: String!, $transactionId: String, $deviceLabel: String!, $futureState: DoorLockState!) {\n  installation(giid: $giid) {\n    doorLockStateChangePollResult(transactionId: $transactionId, deviceLabel: $deviceLabel, futureState: $futureState) {\n      result\n      createTime\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def remaining_sms(self,
+                      giid: VariableTypes.Giid=None):
+        """Get remaing number of SMS"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "RemainingSms",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query RemainingSms($giid: String!) {\n  installation(giid: $giid) {\n    remainingSms\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def smart_button(self,
+                     giid: VariableTypes.Giid=None):
+        """Get smart button state"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "SmartButton",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query SmartButton($giid: String!) {\n  installation(giid: $giid) {\n    smartButton {\n      entries {\n        smartButtonId\n        icon\n        label\n        color\n        active\n        action {\n          actionType\n          expectedState\n          target {\n            ... on Installation {\n              alias\n              __typename\n            }\n            ... on Device {\n              deviceLabel\n              area\n              gui {\n                label\n                __typename\n              }\n              featureStatuses(type: \"SmartPlug\") {\n                device {\n                  deviceLabel\n                  __typename\n                }\n                ... on SmartPlug {\n                  icon\n                  isHazardous\n                  __typename\n                }\n                __typename\n              }\n              __typename\n            }\n            __typename\n          }\n          __typename\n        }\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def smart_lock(self,
+                   giid: VariableTypes.Giid=None):
+        """Get smart lock state"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "SmartLock",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query SmartLock($giid: String!) {\n  installation(giid: $giid) {\n    smartLocks {\n      lockStatus\n      doorState\n      lockMethod\n      eventTime\n      doorLockType\n      secureMode\n      device {\n        deviceLabel\n        area\n        __typename\n      }\n      user {\n        name\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+        }
+
+    @query_func
+    def set_smartplug(self,
+                      device_label: VariableTypes.DeviceLabel,
+                      state: bool,
+                      giid: VariableTypes.Giid=None):
+        """Set state of smart plug"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "UpdateState",
+            "variables": {
+                "giid": giid or self._giid,
+                "deviceLabel": device_label,
+                "state": state},
+            "query": "mutation UpdateState($giid: String!, $deviceLabel: String!, $state: Boolean!) {\n  SmartPlugSetState(giid: $giid, input: [{deviceLabel: $deviceLabel, state: $state}])}",  # noqa: E501
+        }
+
+    @query_func
+    def smartplug(self,
+                  device_label: VariableTypes.DeviceLabel,
+                  giid: VariableTypes.Giid=None):
+        """Read status of a single smart plug"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "SmartPlug",
+            "variables": {
+                "giid": giid or self._giid,
+                "deviceLabel": device_label},
+            "query": "query SmartPlug($giid: String!, $deviceLabel: String!) {\n  installation(giid: $giid) {\n    smartplugs(filter: {deviceLabels: [$deviceLabel]}) {\n      device {\n        deviceLabel\n        area\n        __typename\n      }\n      currentState\n      icon\n      isHazardous\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+            }
+
+    @query_func
+    def smartplugs(self,
+                   giid: VariableTypes.Giid=None):
+        """Read status of all smart plugs"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "SmartPlug",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query SmartPlug($giid: String!) {\n  installation(giid: $giid) {\n    smartplugs {\n      device {\n        deviceLabel\n        area\n        __typename\n      }\n      currentState\n      icon\n      isHazardous\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+            }
+
+    @query_func
+    def user_trackings(self,
+                       giid: VariableTypes.Giid=None):
+        """Read user tracking status"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "userTrackings",
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query userTrackings($giid: String!) {\n  installation(giid: $giid) {\n    userTrackings {\n      isCallingUser\n      webAccount\n      status\n      xbnContactId\n      currentLocationName\n      deviceId\n      name\n      initials\n      currentLocationTimestamp\n      deviceName\n      currentLocationId\n      __typename\n    }\n    __typename\n  }\n}\n",  # noqa: E501
+            }
+
+    @query_func
+    def cameras(self,
+                giid: VariableTypes.Giid=None):
+        """Get cameras state"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "Camera",
+            "variables": {
+                "all": True,
+                "giid": giid or self._giid},
+            "query": "query Camera($giid: String!, $all: Boolean!) {\n    installation(giid: $giid) {\n        cameras(allCameras: $all) {\n            visibleOnCard\n            initiallyConfigured\n            imageCaptureAllowed\n            imageCaptureAllowedByArmstate\n            device {\n        deviceLabel\n        area\n        __typename\n      }\n            latestCameraSeries {\n                image {\n                    imageId\n                    imageStatus\n                    captureTime\n                    url\n                }\n            }\n        }\n    }\n}",  # noqa: E501
+            }
+
+    @query_func
+    def cameras_last_image(self,
+                           giid: VariableTypes.Giid=None):
+        """Get cameras last image"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "variables": {
+                "giid": giid or self._giid},
+            "query": "query queryCaptureImageRequestStatus($giid: String!) {\n  installation(giid: $giid) {\n    cameraContentProvider {\n      latestImage {\n        deviceLabel\n        mediaId\n        contentType\n        contentUrl\n        timestamp\n        duration\n        thumbnailUrl\n        bitRate\n        width\n        height\n        codec\n      }\n    }\n  }\n}",  # noqa: E501
+            }
+
+    @query_func
+    def cameras_image_series(self, 
+                             limit=50,
+                             offset=0,
+                             giid: VariableTypes.Giid=None):
+        """Get the cameras image series"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "operationName": "GQL_CCCP_SearchMedia",
+            "variables": {
+                "giid": giid or self._giid,
+                "limit": limit,
+                "offset": offset},
+            "query": "mutation GQL_CCCP_SearchMedia(\n	$giid: BigInt!\n	$offset: Int\n	$limit: Int\n	$fromDate: Date\n	$toDate: Date) {\n\n	ContentProviderMediaSearch(\n		giid: $giid\n		offset: $offset\n		limit: $limit\n		fromDate: $fromDate\n		toDate: $toDate\n	) {\n		totalNumberOfMediaSeries\n		mediaSeriesList {\n			seriesId\n			storageType\n			viewed\n			timestamp\n			deviceMediaList {\n				contentUrl\n				mediaAvailable\n				deviceLabel\n				mediaId\n				contentType\n				timestamp\n				requestTimestamp\n				duration\n				expiryDate\n				viewed\n				thumbnailUrl\n				bitRate\n				width\n				height\n				codec\n			}\n		}\n	}\n}",  # noqa: E501}
+        }
+
+    @query_func
+    def camera_get_request_id(self,
+                             device_label: VariableTypes.DeviceLabel,
+                             giid: VariableTypes.Giid=None):
+        """Get requestId for camera_capture"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "variables": {
+                "deviceIdentifier": "RandomString",
+                "deviceLabel": device_label,
+                "giid": giid or self._giid,
+                "resolution": "high"},
+            "query": "mutation cccp($giid: String!, $deviceLabel: String!, $resolution: String!, $deviceIdentifier: String) {\n  ContentProviderCaptureImageRequest(giid: $giid, deviceLabel: $deviceLabel, resolution: $resolution, deviceIdentifier: $deviceIdentifier) {\n    requestId\n  }\n}",  # noqa: E501
+            }
+
+    @query_func
+    def camera_capture(self,
+                       device_label: VariableTypes.DeviceLabel,
+                       request_id: VariableTypes.RequestId,
+                       giid: VariableTypes.Giid=None):
+        """Capture a new image from a camera"""
+        assert giid or self._giid, "Set default giid or pass explicit"
+        return {
+            "variables": {
+                "deviceLabel": device_label,
+                "giid": giid or self._giid,
+                "requestId": request_id},
+            "query": "query queryCaptureImageRequestStatus($giid: String!, $deviceLabel: String!, $requestId: BigInt!) {\n  installation(giid: $giid) {\n    cameraContentProvider {\n      captureImageRequestStatus(deviceLabel: $deviceLabel, requestId: $requestId) {\n        mediaRequestStatus\n      }\n    }\n  }\n}",  # noqa: E501
+            }
+
+    def download_image(self, image_url, file_name):
+        """Download image from url"""
+        try:
+            response = requests.get(image_url, stream=True)
+        except requests.exceptions.RequestException as ex:
+            raise RequestError("Failed to get image") from ex
+        with open(file_name, 'wb') as image_file:
+            for chunk in response.iter_content(chunk_size=1024):
+                if chunk:
+                    image_file.write(chunk)

vsure-2.6.9.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: vsure
+Version: 2.6.9
+Summary: Read and change status of verisure devices through mypages.
+Home-page: http://github.com/persandstrom/python-verisure
+Author: Per Sandstrom
+Author-email: per.j.sandstrom@gmail.com
+License: MIT
+Keywords: home automation verisure
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Home Automation
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: click>=8.0.0a1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+A python3 module for reading and changing status of verisure devices through mypages.

vsure-2.6.9.dist-info/RECORD

@@ -0,0 +1,10 @@
+verisure/__init__.py,sha256=PuC4CPVYgYz4aeowwyR56uIv9-_0QWqho122TVs-JCI,518
+verisure/__main__.py,sha256=yErcsdJP6LRsmk6ymBpyFJ7a1BFKWG5ca-anZ5Mx_ZY,5096
+verisure/session.py,sha256=MGJiWEfbZUE74rlBVo4iSaWKvhuWHPkxRQ4-_3IJTpQ,37673
+vsure-2.6.9.dist-info/licenses/LICENSE,sha256=vNvDUDugNXOM-bsuwrS_GvKmKEhdSJ08PY9jZT5tCWA,1082
+vsure-2.6.9.dist-info/METADATA,sha256=zFk6PSuNjF_zkvTTzIybc2EZubyHhjn-B-W95o2x_XM,977
+vsure-2.6.9.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vsure-2.6.9.dist-info/entry_points.txt,sha256=qlRnwjOscU3jpgC8rgPMyQ_OtUacPXz6RguLBTfmoSo,48
+vsure-2.6.9.dist-info/top_level.txt,sha256=-oNvWzMpVusfSzs0C1_43wC26DI9Bi7W6j-dGF65YGM,9
+vsure-2.6.9.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+vsure-2.6.9.dist-info/RECORD,,

vsure-2.6.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vsure-2.6.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vsure = verisure.__main__:cli

vsure-2.6.9.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Per Sandström
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vsure-2.6.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+verisure

vsure-2.6.9.dist-info/zip-safe

@@ -0,0 +1 @@
+