aiokwikset 0.3.0a9__tar.gz

aiokwikset-0.3.0a9/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

aiokwikset-0.3.0a9/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: aiokwikset
+Version: 0.3.0a9
+Summary: Python interface for Kwikset Smart Locks
+Home-page: https://github.com/explosivo22/aiokwikset
+Author: Brad Barbour
+Author-email: explosivo22@protonmail.com
+License: Apache Software License
+Keywords: kwikset,home automation,kwikset halo,kwikset smart lock
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.6.1
+Requires-Dist: pycognito==2024.5.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+
+# aiokwikset - Python interface for the Kwikset API
+
+Python library for communicating with the [Kwikset Smart Locks](https://www.kwikset.com/products/electronic/electronic-smart-locks) via the Kwikset cloud API.
+
+***WARNING***
+* This library only works if you have signed up for and created a home/had a home shared with you from the Kwikset Application.
+* [IOS](https://apps.apple.com/us/app/kwikset/id1465996742)
+* [Android](https://play.google.com/store/apps/details?id=com.kwikset.blewifi)
+
+NOTE:
+
+* This library is community supported, please submit changes and improvements.
+* This is a very basic interface, not well thought out at this point, but works for the use cases that initially prompted spitting this out from.
+
+## Supports
+
+- locking/unlocking
+- retrieving basic information
+- Multi-Factor Authentication (MFA) support (SMS and Software Token)
+
+## Installation
+
+```
+pip install aiokwikset
+```
+
+## Examples
+
+### Basic Usage (No MFA)
+
+```python
+import asyncio
+
+from aiokwikset import API
+
+
+async def main() -> None:
+    """Run!"""
+    #initialize the API
+    api = API()
+
+    #start auth
+    await api.async_login('username','password')
+
+    # Get user account information:
+    user_info = await api.user.get_info()
+
+    # Get the homes
+    homes = await api.user.get_homes()
+
+    # Get the devices for the first home
+    devices = await api.device.get_devices(homes[0]['homeid'])
+
+    # Get information for a specific device
+    device_info = await api.device.get_device_info(devices[0]['deviceid'])
+
+    # Lock the specific device
+    lock = await api.device.lock_device(device_info, user_info)
+
+    # Set led status
+    led = await api.device.set_ledstatus(device_info, "false")
+
+    # Set audio status
+    audio = await api.device.set_audiostatus(device_info, "false")
+
+    # Set secure screen status
+    screen = await api.device.set_securescreenstatus(device_info, "false")
+
+
+asyncio.run(main())
+```
+
+### Usage with MFA (Multi-Factor Authentication)
+
+If your account has MFA enabled, you need to handle the MFA challenge:
+
+```python
+import asyncio
+
+from aiokwikset import API, MFAChallengeRequired
+
+
+async def main() -> None:
+    """Run with MFA support!"""
+    api = API()
+    
+    try:
+        # Attempt to login
+        await api.async_login('username', 'password')
+        
+    except MFAChallengeRequired as mfa_error:
+        # MFA is required - prompt user for code
+        print(f"MFA Required: {mfa_error.mfa_type}")
+        mfa_code = input("Enter your MFA code: ")
+        
+        # Complete MFA authentication
+        await api.async_respond_to_mfa_challenge(
+            mfa_code=mfa_code,
+            mfa_type=mfa_error.mfa_type,
+            mfa_tokens=mfa_error.mfa_tokens
+        )
+        
+        print("Successfully authenticated with MFA!")
+    
+    # Continue with normal API usage
+    user_info = await api.user.get_info()
+    homes = await api.user.get_homes()
+    
+    # ... rest of your code
+
+
+asyncio.run(main())
+```
+
+For detailed MFA documentation and advanced usage examples, see [MFA_USAGE.md](./MFA_USAGE.md).
+
+## Known Issues
+
+* not all APIs supported

aiokwikset-0.3.0a9/README.md

@@ -0,0 +1,119 @@
+# aiokwikset - Python interface for the Kwikset API
+
+Python library for communicating with the [Kwikset Smart Locks](https://www.kwikset.com/products/electronic/electronic-smart-locks) via the Kwikset cloud API.
+
+***WARNING***
+* This library only works if you have signed up for and created a home/had a home shared with you from the Kwikset Application.
+* [IOS](https://apps.apple.com/us/app/kwikset/id1465996742)
+* [Android](https://play.google.com/store/apps/details?id=com.kwikset.blewifi)
+
+NOTE:
+
+* This library is community supported, please submit changes and improvements.
+* This is a very basic interface, not well thought out at this point, but works for the use cases that initially prompted spitting this out from.
+
+## Supports
+
+- locking/unlocking
+- retrieving basic information
+- Multi-Factor Authentication (MFA) support (SMS and Software Token)
+
+## Installation
+
+```
+pip install aiokwikset
+```
+
+## Examples
+
+### Basic Usage (No MFA)
+
+```python
+import asyncio
+
+from aiokwikset import API
+
+
+async def main() -> None:
+    """Run!"""
+    #initialize the API
+    api = API()
+
+    #start auth
+    await api.async_login('username','password')
+
+    # Get user account information:
+    user_info = await api.user.get_info()
+
+    # Get the homes
+    homes = await api.user.get_homes()
+
+    # Get the devices for the first home
+    devices = await api.device.get_devices(homes[0]['homeid'])
+
+    # Get information for a specific device
+    device_info = await api.device.get_device_info(devices[0]['deviceid'])
+
+    # Lock the specific device
+    lock = await api.device.lock_device(device_info, user_info)
+
+    # Set led status
+    led = await api.device.set_ledstatus(device_info, "false")
+
+    # Set audio status
+    audio = await api.device.set_audiostatus(device_info, "false")
+
+    # Set secure screen status
+    screen = await api.device.set_securescreenstatus(device_info, "false")
+
+
+asyncio.run(main())
+```
+
+### Usage with MFA (Multi-Factor Authentication)
+
+If your account has MFA enabled, you need to handle the MFA challenge:
+
+```python
+import asyncio
+
+from aiokwikset import API, MFAChallengeRequired
+
+
+async def main() -> None:
+    """Run with MFA support!"""
+    api = API()
+    
+    try:
+        # Attempt to login
+        await api.async_login('username', 'password')
+        
+    except MFAChallengeRequired as mfa_error:
+        # MFA is required - prompt user for code
+        print(f"MFA Required: {mfa_error.mfa_type}")
+        mfa_code = input("Enter your MFA code: ")
+        
+        # Complete MFA authentication
+        await api.async_respond_to_mfa_challenge(
+            mfa_code=mfa_code,
+            mfa_type=mfa_error.mfa_type,
+            mfa_tokens=mfa_error.mfa_tokens
+        )
+        
+        print("Successfully authenticated with MFA!")
+    
+    # Continue with normal API usage
+    user_info = await api.user.get_info()
+    homes = await api.user.get_homes()
+    
+    # ... rest of your code
+
+
+asyncio.run(main())
+```
+
+For detailed MFA documentation and advanced usage examples, see [MFA_USAGE.md](./MFA_USAGE.md).
+
+## Known Issues
+
+* not all APIs supported

aiokwikset-0.3.0a9/aiokwikset/__init__.py

@@ -0,0 +1,8 @@
+"""
+apikwikset -- Python client for the Kwikset Halo API   
+"""
+
+from aiokwikset.api import API
+from aiokwikset.errors import MFAChallengeRequired, RequestError, KwiksetError
+
+__all__ = ["API", "MFAChallengeRequired", "RequestError", "KwiksetError"]

aiokwikset-0.3.0a9/aiokwikset/api.py

@@ -0,0 +1,351 @@
+import asyncio
+from functools import lru_cache, partial
+
+import boto3
+import botocore
+from botocore.exceptions import BotoCoreError, ClientError
+import pycognito
+from pycognito.exceptions import (
+    SoftwareTokenMFAChallengeException,
+    SMSMFAChallengeException,
+)
+import attr
+
+from typing import Any, Optional
+from urllib.parse import urlparse
+
+from aiohttp import ClientSession
+from aiohttp.client_exceptions import (
+    ClientResponseError, 
+    ClientConnectorError, 
+    ServerConnectionError, 
+    ClientPayloadError
+)
+
+from .errors import RequestError, MFAChallengeRequired
+from .device import Device
+from .user import User
+
+from aiokwikset.const import (
+    LOGGER,
+    POOL_ID,
+    CLIENT_ID,
+    POOL_REGION
+)
+
+LOGIN_HEADER_USER_AGENT = 'aws-sdk-kotlin/1.3.81 ua/2.1 api/cognito-identity-provider#1.3.81'
+DEFAULT_HEADER_USER_AGENT = 'okhttp/5.0.0-alpha.14'
+DEFAULT_HEADER_ACCEPT_ENCODING = 'gzip'
+
+class CloudError(Exception):
+    """Base class for cloud related errors."""
+
+
+class Unauthenticated(CloudError):
+    """Raised when authentication failed."""
+
+
+class UserNotFound(CloudError):
+    """Raised when a user is not found."""
+
+
+class UserExists(CloudError):
+    """Raised when a username already exists."""
+
+
+class UserNotConfirmed(CloudError):
+    """Raised when a user has not confirmed email yet."""
+
+
+class PasswordChangeRequired(CloudError):
+    """Raised when a password change is required."""
+
+    # https://github.com/PyCQA/pylint/issues/1085
+    # pylint: disable=useless-super-delegation
+    def __init__(self, message: str = "Password change required.") -> None:
+        """Initialize a password change required error."""
+        super().__init__(message)
+
+
+class UnknownError(CloudError):
+    """Raised when an unknown error occurs."""
+
+AWS_EXCEPTIONS: dict[str, type[CloudError]] = {
+    "UserNotFoundException": UserNotFound,
+    "UserNotConfirmedException": UserNotConfirmed,
+    "UsernameExistsException": UserExists,
+    "NotAuthorizedException": Unauthenticated,
+    "PasswordResetRequiredException": PasswordChangeRequired,
+}
+
+@attr.s
+class API(object):
+    user_pool_region = attr.ib()
+    username = attr.ib(default=None)
+    code_type = attr.ib(default=None)
+    id_token = attr.ib(default=None)
+    access_token = attr.ib(default=None)
+    refresh_token = attr.ib(default=None)
+    client_secret = attr.ib(default=None)
+    expires_at = attr.ib(default=None)
+    access_key = attr.ib(default=None)
+    secret_key = attr.ib(default=None)
+    client_callback = attr.ib(default=None)
+
+    user_pool_id = POOL_ID
+    client_id = CLIENT_ID
+    pool_region = POOL_REGION
+    aws = None
+    loop = None
+    session: boto3.Session | None = None
+    _request_lock = asyncio.Lock()
+
+    device: Optional[Device] = None
+    user: Optional[User] = None
+
+    def get_session(self):
+        return ClientSession()
+
+    async def _request(self, method: str, url: str, **kwargs) -> dict:
+        """Make a request against the API."""
+        await self.async_check_token()
+
+        kwargs.setdefault("headers", {})
+        kwargs["headers"].update(
+            {
+                "Host": urlparse(url).netloc,
+                "User-Agent": DEFAULT_HEADER_USER_AGENT,
+                "Accept-Encoding": DEFAULT_HEADER_ACCEPT_ENCODING
+            }
+        )
+
+        if self.id_token:
+            kwargs["headers"]["Authorization"] = "Bearer {}".format(self.id_token)
+
+        session = self.get_session()
+
+        try:
+            async with session.request(method, url, **kwargs) as resp:
+                data: dict = await resp.json(content_type=None)
+                resp.raise_for_status()
+                return data
+
+        except ClientResponseError as err:
+            raise RequestError(f"There was a response error while requesting {url}: {err}") from err
+        except ClientConnectorError as err:
+            raise RequestError(f"There was a client connection error while requesting {url}: {err}") from err
+        except ServerConnectionError as err:
+            raise RequestError(f"There was a server connection error while requesting {url}: {err}") from err
+        except ClientPayloadError as err:
+            raise RequestError(f"There was a client payload error while requesting {url}: {err}") from err
+        except ClientError as err:
+            raise RequestError(f"There was the following error while requesting {url}: {err}") from err
+        finally:
+            await session.close()
+
+    async def update_token(
+            self,
+            id_token: str,
+            access_token: str,
+            refresh_token: str | None = None,
+    ) -> asyncio.Task | None:
+        self.id_token = id_token
+        self.access_token = access_token
+        if refresh_token is not None:
+            self.refresh_token = refresh_token
+
+        if not self.device:
+                self.device = Device(self._request)
+
+        if not self.user:
+            self.user = User(self._request)
+
+        return None
+
+    async def async_login(self, email: str, password: str = None, access_token: str = None, refresh_token: str = None) -> None:
+        self.loop = asyncio.get_event_loop()
+
+        try:
+            cognito = await self.loop.run_in_executor(None, partial(self._create_cognito_client, username=email),)
+            await self.loop.run_in_executor(None, partial(cognito.authenticate,password=password),)
+
+            task = await self.update_token(cognito.id_token, cognito.access_token, cognito.refresh_token)
+
+            if task:
+                await task
+
+        except SoftwareTokenMFAChallengeException as err:
+            # Store the cognito instance for later MFA response
+            self._mfa_cognito = cognito
+            raise MFAChallengeRequired(
+                message="Software Token MFA challenge required. Please provide the MFA code.",
+                mfa_type="SOFTWARE_TOKEN_MFA",
+                mfa_tokens=err.get_tokens()
+            ) from err
+        
+        except SMSMFAChallengeException as err:
+            # Store the cognito instance for later MFA response
+            self._mfa_cognito = cognito
+            raise MFAChallengeRequired(
+                message="SMS MFA challenge required. Please provide the MFA code.",
+                mfa_type="SMS_MFA",
+                mfa_tokens=err.get_tokens()
+            ) from err
+
+        except ClientError as err:
+            raise _map_aws_exception(err) from err
+        
+        except BotoCoreError as err:
+            raise UnknownError from err
+
+    async def async_respond_to_mfa_challenge(self, mfa_code: str, mfa_type: Optional[str] = None, mfa_tokens: Optional[dict] = None) -> None:
+        """
+        Respond to an MFA challenge with the user's MFA code.
+        
+        :param mfa_code: The MFA code from the user's authenticator app or SMS
+        :param mfa_type: The type of MFA challenge ('SMS_MFA' or 'SOFTWARE_TOKEN_MFA')
+        :param mfa_tokens: Optional tokens from the MFA exception if cognito instance was recreated
+        """
+        if self.loop is None:
+            self.loop = asyncio.get_event_loop()
+        
+        try:
+            # If we have mfa_tokens, we need to recreate the cognito instance
+            if mfa_tokens:
+                cognito = await self.loop.run_in_executor(
+                    None, 
+                    partial(self._create_cognito_client, username=self.username)
+                )
+            elif hasattr(self, '_mfa_cognito'):
+                cognito = self._mfa_cognito
+            else:
+                raise Unauthenticated("No MFA challenge in progress. Please login first.")
+            
+            # Respond to the appropriate MFA challenge
+            if mfa_type == "SOFTWARE_TOKEN_MFA" or (not mfa_type and hasattr(self, '_mfa_cognito')):
+                await self.loop.run_in_executor(
+                    None,
+                    partial(cognito.respond_to_software_token_mfa_challenge, mfa_code, mfa_tokens)
+                )
+            elif mfa_type == "SMS_MFA":
+                await self.loop.run_in_executor(
+                    None,
+                    partial(cognito.respond_to_sms_mfa_challenge, mfa_code, mfa_tokens)
+                )
+            else:
+                raise UnknownError("Unknown MFA type")
+            
+            # Update tokens after successful MFA verification
+            task = await self.update_token(cognito.id_token, cognito.access_token, cognito.refresh_token)
+            
+            if task:
+                await task
+            
+            # Clean up stored cognito instance
+            if hasattr(self, '_mfa_cognito'):
+                delattr(self, '_mfa_cognito')
+        
+        except ClientError as err:
+            raise _map_aws_exception(err) from err
+        
+        except BotoCoreError as err:
+            raise UnknownError from err
+
+    async def async_check_token(self) -> None:
+        """Check that the token is valid and renew if necessary."""
+        async with self._request_lock:
+            cognito = await self._async_authenticated_cognito()
+            if not cognito.check_token(renew=False):
+                return
+
+            try:
+                await self.async_renew_access_token()
+            except (Unauthenticated, UserNotFound) as err:
+                LOGGER.error("Unable to refresh token: %s", err)
+
+                raise
+
+    async def async_renew_access_token(self, access_token: str = None, refresh_token: str = None) -> None:
+        if self.loop is None:
+            self.loop = asyncio.get_event_loop()
+        if access_token is not None:
+            self.access_token = access_token
+        if refresh_token is not None:
+            self.refresh_token = refresh_token
+
+        cognito = await self._async_authenticated_cognito()
+
+        try:
+            await self.loop.run_in_executor(None, cognito.renew_access_token)
+            await self.update_token(cognito.id_token, cognito.access_token)
+
+        except ClientError as err:
+            raise _map_aws_exception(err) from err
+
+        except BotoCoreError as err:
+            raise UnknownError from err
+        
+    async def _async_authenticated_cognito(self) -> pycognito.Cognito:
+        """Return an authenticated cognito instance."""
+        if self.access_token is None or self.refresh_token is None:
+            raise Unauthenticated("No authentication found")
+
+        return await self.loop.run_in_executor(
+            None,
+            partial(
+                self._create_cognito_client,
+                access_token=self.access_token,
+                refresh_token=self.refresh_token,
+            ),
+        )
+
+    def _create_cognito_client(self, **kwargs: Any) -> pycognito.Cognito:
+        """Create a new cognito client.
+
+        NOTE: This will do I/O
+        """
+        if self.session is None:
+            self.session = boto3.session.Session()
+
+        # Add custom user agent
+        config = botocore.config.Config(
+            signature_version=botocore.UNSIGNED,
+            user_agent_extra=LOGIN_HEADER_USER_AGENT
+        )
+
+        return _cached_cognito(
+            user_pool_id=self.user_pool_id,
+            client_id=self.client_id,
+            user_pool_region=self.pool_region,
+            botocore_config=config,
+            session=self.session,
+            **kwargs,
+        )
+    
+def _map_aws_exception(err: ClientError) -> CloudError:
+    """Map AWS exception to our exceptions."""
+    ex = AWS_EXCEPTIONS.get(err.response["Error"]["Code"], UnknownError)
+    print(ex)
+    return ex(err.response["Error"]["Message"])
+
+@lru_cache(maxsize=2)
+def _cached_cognito(
+    user_pool_id: str,
+    client_id: str,
+    user_pool_region: str,
+    botocore_config: Any,
+    session: Any,
+    **kwargs: Any,
+) -> pycognito.Cognito:
+    """Create a cached cognito client.
+
+    NOTE: This will do I/O
+    """
+    return pycognito.Cognito(
+        user_pool_id=user_pool_id,
+        client_id=client_id,
+        user_pool_region=user_pool_region,
+        botocore_config=botocore_config,
+        session=session,
+        **kwargs,
+    )

aiokwikset-0.3.0a9/aiokwikset/const.py

@@ -0,0 +1,17 @@
+"""Constants used by Kwikset Halo API"""
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+POOL_ID = 'us-east-1_6B3uo6uKN'
+CLIENT_ID = '5eu1cdkjp1itd1fi7b91m6g79s'
+POOL_REGION = 'us-east-1'
+
+GET_USER_URL = 'https://ynk95r1v52.execute-api.us-east-1.amazonaws.com/prod_v1/users/me'
+GET_HOMES_URL = 'https://ynk95r1v52.execute-api.us-east-1.amazonaws.com/prod_v1/users/me/homes?top=200'
+GET_HOME_DEVICES_URL = 'https://ynk95r1v52.execute-api.us-east-1.amazonaws.com/prod_v1/homes/%s/devices'
+GET_DEVICE_URL = 'https://ynk95r1v52.execute-api.us-east-1.amazonaws.com/prod_v1/devices_v2/%s'
+
+LOCK_COMMAND_URL = 'https://ynk95r1v52.execute-api.us-east-1.amazonaws.com/prod_v1/devices/%s/status'
+ACCESSORY_COMMAND_URL = 'https://ynk95r1v52.execute-api.us-east-1.amazonaws.com/prod_v1/devices/%s/%s'

aiokwikset-0.3.0a9/aiokwikset/device.py

@@ -0,0 +1,80 @@
+"""Define /device endpoints."""
+from typing import Awaitable, Callable
+import json
+
+from .const import LOCK_COMMAND_URL, ACCESSORY_COMMAND_URL, GET_HOME_DEVICES_URL, GET_DEVICE_URL
+
+
+class Device():  # pylint: disable=too-few-public-methods
+    """Define an object to handle the endpoints."""
+
+    def __init__(self, request: Callable[..., Awaitable]) -> None:
+        """Initialize."""
+        self._request: Callable[..., Awaitable] = request
+
+    async def get_devices(self, home_id: str) -> dict:
+        """Return device specific data.
+        :param home_id: Unique identifier for the device
+        :type home_id: ``str``
+        :rtype: ``dict``
+        """
+        devices: dict = await self._request(
+            "get",
+            GET_HOME_DEVICES_URL % (home_id)
+        )
+
+        return devices['data']
+
+    async def get_device_info(self, device_id: str) -> dict:
+        """Return device specific data.
+        :param home_id: Unique identifier for the device
+        :type home_id: ``str``
+        :rtype: ``dict``
+        """
+        device_info: dict = await self._request(
+            "get",
+            GET_DEVICE_URL % (device_id)
+        )
+
+        for items in device_info['data']:
+            return items
+
+    async def _lock_action(self, dev, user, action: str):
+        data = json.dumps({
+          "action": action,
+          "source": "{\"name\":\"%s\",\"device\":\"%s\"}"
+        }) % ((user['firstname']+user['lastname'])[0:7],'apikwikset'[0:7])
+
+        r = await self._request(
+            'patch',
+            LOCK_COMMAND_URL % (dev['serialnumber']),
+            data=data,
+        )
+        return r['data']
+
+    async def _set_action(self, dev, action, status):
+        data = json.dumps({
+          action: status,
+        })
+
+        r = await self._request(
+            'patch',
+            ACCESSORY_COMMAND_URL % (dev['serialnumber'], action),
+            data=data,
+        )
+        return r['data']
+
+    async def lock_device(self, dev, user):
+        return await self._lock_action(dev, user, 'lock')
+
+    async def unlock_device(self, dev, user):
+        return await self._lock_action(dev, user, 'unlock')
+
+    async def set_ledstatus(self, dev, status):
+        return await self._set_action(dev, 'ledstatus', status)
+
+    async def set_audiostatus(self, dev, status):
+        return await self._set_action(dev, 'audiostatus', status)
+
+    async def set_securescreenstatus(self, dev, status):
+        return await self._set_action(dev, 'securescreenstatus', status)

aiokwikset-0.3.0a9/aiokwikset/errors.py

@@ -0,0 +1,25 @@
+"""Define package errors."""
+
+from typing import Optional
+
+
+class KwiksetError(Exception):
+    """Define a base error."""
+
+    pass
+
+
+class RequestError(KwiksetError):
+    """Define an error related to invalid requests."""
+
+    pass
+
+
+class MFAChallengeRequired(KwiksetError):
+    """Define an error when MFA challenge is required."""
+    
+    def __init__(self, message: str = "MFA challenge required.", mfa_type: Optional[str] = None, mfa_tokens: Optional[dict] = None) -> None:
+        """Initialize an MFA challenge required error."""
+        super().__init__(message)
+        self.mfa_type = mfa_type  # 'SMS_MFA' or 'SOFTWARE_TOKEN_MFA'
+        self.mfa_tokens = mfa_tokens or {}

aiokwikset-0.3.0a9/aiokwikset/user.py

@@ -0,0 +1,44 @@
+"""Define /user endpoints."""
+from typing import Awaitable, Callable
+
+from .const import GET_HOMES_URL, GET_USER_URL
+
+
+class User:  # pylint: disable=too-few-public-methods
+    """Define an object to handle the endpoints."""
+
+    def __init__(self, request: Callable[..., Awaitable]) -> None:
+        """Initialize."""
+        self._request: Callable[..., Awaitable] = request
+
+    async def get_info(
+        self
+    ) -> dict:
+        """Return user account data.
+
+        :rtype: ``dict``
+        """
+        
+
+        user_info: dict = await self._request(
+            "get",
+            GET_USER_URL
+        )
+
+        for items in user_info['data']:
+            return items
+
+    async def get_homes(
+        self
+    ) -> dict:
+        """Return user homes data
+
+        :rtype: ``dict``
+        """
+
+        homes_info: dict = await self._request(
+            "get",
+            GET_HOMES_URL
+        )
+
+        return homes_info['data']

aiokwikset-0.3.0a9/aiokwikset.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: aiokwikset
+Version: 0.3.0a9
+Summary: Python interface for Kwikset Smart Locks
+Home-page: https://github.com/explosivo22/aiokwikset
+Author: Brad Barbour
+Author-email: explosivo22@protonmail.com
+License: Apache Software License
+Keywords: kwikset,home automation,kwikset halo,kwikset smart lock
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.6.1
+Requires-Dist: pycognito==2024.5.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+
+# aiokwikset - Python interface for the Kwikset API
+
+Python library for communicating with the [Kwikset Smart Locks](https://www.kwikset.com/products/electronic/electronic-smart-locks) via the Kwikset cloud API.
+
+***WARNING***
+* This library only works if you have signed up for and created a home/had a home shared with you from the Kwikset Application.
+* [IOS](https://apps.apple.com/us/app/kwikset/id1465996742)
+* [Android](https://play.google.com/store/apps/details?id=com.kwikset.blewifi)
+
+NOTE:
+
+* This library is community supported, please submit changes and improvements.
+* This is a very basic interface, not well thought out at this point, but works for the use cases that initially prompted spitting this out from.
+
+## Supports
+
+- locking/unlocking
+- retrieving basic information
+- Multi-Factor Authentication (MFA) support (SMS and Software Token)
+
+## Installation
+
+```
+pip install aiokwikset
+```
+
+## Examples
+
+### Basic Usage (No MFA)
+
+```python
+import asyncio
+
+from aiokwikset import API
+
+
+async def main() -> None:
+    """Run!"""
+    #initialize the API
+    api = API()
+
+    #start auth
+    await api.async_login('username','password')
+
+    # Get user account information:
+    user_info = await api.user.get_info()
+
+    # Get the homes
+    homes = await api.user.get_homes()
+
+    # Get the devices for the first home
+    devices = await api.device.get_devices(homes[0]['homeid'])
+
+    # Get information for a specific device
+    device_info = await api.device.get_device_info(devices[0]['deviceid'])
+
+    # Lock the specific device
+    lock = await api.device.lock_device(device_info, user_info)
+
+    # Set led status
+    led = await api.device.set_ledstatus(device_info, "false")
+
+    # Set audio status
+    audio = await api.device.set_audiostatus(device_info, "false")
+
+    # Set secure screen status
+    screen = await api.device.set_securescreenstatus(device_info, "false")
+
+
+asyncio.run(main())
+```
+
+### Usage with MFA (Multi-Factor Authentication)
+
+If your account has MFA enabled, you need to handle the MFA challenge:
+
+```python
+import asyncio
+
+from aiokwikset import API, MFAChallengeRequired
+
+
+async def main() -> None:
+    """Run with MFA support!"""
+    api = API()
+    
+    try:
+        # Attempt to login
+        await api.async_login('username', 'password')
+        
+    except MFAChallengeRequired as mfa_error:
+        # MFA is required - prompt user for code
+        print(f"MFA Required: {mfa_error.mfa_type}")
+        mfa_code = input("Enter your MFA code: ")
+        
+        # Complete MFA authentication
+        await api.async_respond_to_mfa_challenge(
+            mfa_code=mfa_code,
+            mfa_type=mfa_error.mfa_type,
+            mfa_tokens=mfa_error.mfa_tokens
+        )
+        
+        print("Successfully authenticated with MFA!")
+    
+    # Continue with normal API usage
+    user_info = await api.user.get_info()
+    homes = await api.user.get_homes()
+    
+    # ... rest of your code
+
+
+asyncio.run(main())
+```
+
+For detailed MFA documentation and advanced usage examples, see [MFA_USAGE.md](./MFA_USAGE.md).
+
+## Known Issues
+
+* not all APIs supported

aiokwikset-0.3.0a9/aiokwikset.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+aiokwikset/__init__.py
+aiokwikset/api.py
+aiokwikset/const.py
+aiokwikset/device.py
+aiokwikset/errors.py
+aiokwikset/user.py
+aiokwikset.egg-info/PKG-INFO
+aiokwikset.egg-info/SOURCES.txt
+aiokwikset.egg-info/dependency_links.txt
+aiokwikset.egg-info/requires.txt
+aiokwikset.egg-info/top_level.txt
+aiokwikset.egg-info/zip-safe

aiokwikset-0.3.0a9/aiokwikset.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiokwikset-0.3.0a9/aiokwikset.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp>=3.6.1
+pycognito==2024.5.1

aiokwikset-0.3.0a9/aiokwikset.egg-info/top_level.txt

@@ -0,0 +1 @@
+aiokwikset

aiokwikset-0.3.0a9/aiokwikset.egg-info/zip-safe

@@ -0,0 +1 @@
+

aiokwikset-0.3.0a9/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aiokwikset-0.3.0a9/setup.py

@@ -0,0 +1,33 @@
+import io
+import os
+
+from setuptools import setup
+
+# The text of the README file
+here = os.path.abspath(os.path.dirname(__file__))
+try:
+    with io.open(os.path.join(here, 'README.md'), encoding='utf-8') as f:
+        long_description = '\n' + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+setup(
+    name="aiokwikset",
+    version="0.3.0a9",
+    description="Python interface for Kwikset Smart Locks",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url="https://github.com/explosivo22/aiokwikset",
+    author="Brad Barbour",
+    author_email="explosivo22@protonmail.com",
+    license='Apache Software License',
+    install_requires=[ 'aiohttp>=3.6.1', 'pycognito==2024.5.1' ],
+    keywords=[ 'kwikset', 'home automation', 'kwikset halo', 'kwikset smart lock' ],
+    packages=[ 'aiokwikset' ],
+    zip_safe=True,
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+)