Metadata-Version: 2.1
Name: aioautomower
Version: 2021.9.2b0
Summary: module to communicate to Husqvarna Automower API
Home-page: https://github.com/Thomas55555/aioautomower
Author: Thomas Protzner
Author-email: thomas.protzner@gmail.com
License: Apache License 2.0
Description: # Aioautomower
        
        Asynchronous library to communicate with the Automower Connect API
        
        ## REST API Examples
        
        ```python
        from aioautomower import GetAccessToken, GetMowerData, Return
        from aiohttp import ClientError
        from aiohttp.client_exceptions import ClientConnectorError
        import asyncio
        
        api_key = "12345678-abcd-1234-a1a1-efghijklmnop" ## Your API-Key
        username = "username" ## Your username
        password = "password" ## Your password
        
        
        class ExampleToken:
            """Returns the access token as dict."""
            def __init__(self, api_key, username, password):
                self.api_key = api_key
                self.username = username
                self.password = password
        
            async def token(self):
                try:
                    get_token = GetAccessToken(
                        self.api_key,
                        self.username,
                        self.password,
                    )
                    access_token_raw = await get_token.async_get_access_token()
                except (ClientConnectorError, ClientError):
                    raise KeyError
                return access_token_raw
        
        class MowerData:
            """Returns the data of all mowers as dict."""
            def __init__(self, api_key, access_token, provider, token_type):
                self.api_key = api_key
                self.access_token = access_token
                self.provider = provider
                self.token_type = token_type
        
            async def mowers(self):
                try:
                    get_mower_data = GetMowerData(
                        self.api_key,
                        self.access_token,
                        self.provider,
                        self.token_type,
                    )
                    mower_data = await get_mower_data.async_mower_state()
                except (ClientConnectorError, ClientError):
                    return "Make sure, you are connected to the Authentication API and the Automower API"
                return mower_data
        
        class SendingCommand:
            """Returns the data of all mowers as dict."""
            def __init__(self, api_key, access_token, provider, token_type, mower_id, payload):
                self.api_key = api_key
                self.access_token = access_token
                self.provider = provider
                self.token_type = token_type
                self.mower_id = mower_id
                self.payload = payload
        
            async def mowers(self):
                try:
                    send = Return(
                        self.api_key,
                        self.access_token,
                        self.provider,
                        self.token_type,
                        self.mower_id ,
                    )
                    send = await send.async_mower_command()
                except Exception:
                    return "Something went wrong"
                return send
        
        
        example = ExampleToken(api_key, username, password)
        token_output = asyncio.run(example.token())
        print(token_output)
        
        access_token = token_output["access_token"]
        provider = token_output["provider"]
        token_type = token_output["token_type"]
        
        example2 = MowerData(api_key, access_token, provider, token_type)
        mower_output = asyncio.run(example2.mowers())
        print(mower_output)
        
        mower_id = mower_output["data"][0]["id"] ## '0' is your first mower
        print (mower_id)
        payload = '{"data": {"type": "ResumeSchedule"}}'  ## For more commands see: https://developer.husqvarnagroup.cloud/apis/Automower+Connect+API#/swagger
        SendingCommand(api_key, access_token, provider, token_type, mower_id, payload)
        ```
        
        ## AutomowerSession examples
        
        An AutomowerSession keeps track of the access token, refreshing it whenever
        needed and monitors a websocket for updates, whose data is sent to callbacks
        provided by the user.
        
        ```python
        import asyncio
        import logging
        
        import aioautomower
        
        USERNAME = "user@name.com"
        PASSWORD = "mystringpassword"
        API_KEY = "12312312-0126-6222-2662-3e6c49f0012c"
        
        
        async def main():
            sess = aioautomower.AutomowerSession(API_KEY, token=None)
        
            # Add a callback, can be done at any point in time and
            # multiple callbacks can be added.
            sess.register_cb(lambda data:print(data))
        
            # If no token was passed to the constructor, we need to call login()
            # before connect(). The token can be stored somewhere and passed to
            # the constructor later on.
            token = await sess.login(USERNAME, PASSWORD)
        
            if not await sess.connect():
                # If the token is still None or too old, the connect will fail.
                print("Connect failed")
                return
            await asyncio.sleep(5)
            status = await sess.get_status()
            print(status)
            await asyncio.sleep(30)
        
            # The close() will stop the websocket and the token refresh tasks
            await sess.close()
        
        asyncio.run(main())
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
