Add viewing of lock devices, also correcting minor typos (#127)

* Add lock devices

* adding lock devices

Author: wagnerism

README.md

@@ -60,6 +60,10 @@ async def main() -> None:
       devices = myq.lamps
       # >>> {"serial_number123": <Device>}
 
+      # Return only locks devices:
+      devices = myq.locks
+      # >>> {"serial_number123": <Device>}
+      
       # Return only gateway devices:
       devices = myq.gateways
       # >>> {"serial_number123": <Device>}
@@ -79,6 +83,7 @@ asyncio.get_event_loop().run_until_complete(main())
 - `devices`: dictionary with all devices (MyQDevice)
 - `gateways`: dictionary with all gateways (MyQDevice)
 - `lamps`: dictionary with all lamps (MyQLamp)
+- `locks`: dictionary with all locks (MyQLock)
 - `last_state_update`: datetime (in UTC) last state update was retrieved for all items
 - `password`: password used for authentication. Can only be set, not retrieved
 - `username`: username for authentication.
@@ -92,6 +97,7 @@ asyncio.get_event_loop().run_until_complete(main())
 - `devices`: dictionary with all devices for account (MyQDevice)
 - `gateways`: dictionary with all gateways for account (MyQDevice)
 - `lamps`: dictionary with all lamps for account (MyQLamp)
+- `locks`: dictionary with all locks for account (MyQLock)
 - `account_json`: Dictionary containing all account information as retrieved from MyQ
 - `last_state_update`: datetime (in UTC) last state update was retrieved for all devices within this account
 

example.py

@@ -144,6 +144,20 @@ async def print_lamps(account: MyQAccount):
         print("  ------------------------------")
 
 
+async def print_locks(account: MyQAccount):
+    """Print lock information - currently unable to control locks
+
+    Args:
+        account (MyQAccount): Account for which to retrieve locks
+    """
+    print(f"  Locks: {len(account.locks)}")
+    print("  ---------")
+    if len(account.locks) != 0:
+        for idx, device in enumerate(account.locks.values()):
+            print_info(number=idx, device=device)
+        print("  ------------------------------")
+
+
 async def print_gateways(account: MyQAccount):
     """Print gateways for account
 
@@ -193,8 +207,12 @@ async def main() -> None:
 
                 await print_lamps(account=account)
 
+                await print_locks(account=account)
+
                 await print_gateways(account=account)
 
+                await print_other(account=account)
+
         except MyQError as err:
             _LOGGER.error("There was an error: %s", err)
 

pymyq/account.py

@@ -8,13 +8,15 @@
 from .const import (
     DEVICE_FAMILY_GARAGEDOOR,
     DEVICE_FAMILY_GATEWAY,
-    DEVICE_FAMLY_LAMP,
+    DEVICE_FAMILY_LAMP,
+    DEVICE_FAMILY_LOCK,
     DEVICES_ENDPOINT,
 )
 from .device import MyQDevice
 from .errors import MyQError
 from .garagedoor import MyQGaragedoor
 from .lamp import MyQLamp
+from .lock import MyQLock
 
 if TYPE_CHECKING:
     from .api import API
@@ -82,9 +84,18 @@ def gateways(self) -> Dict[str, MyQDevice]:
             if device.device_json["device_family"] == DEVICE_FAMILY_GATEWAY
         }
 
+    @property
+    def locks(self) -> Dict[str, MyQDevice]:
+        """Return only those devices that are locks."""
+        return {
+            device_id: device
+            for device_id, device in self.devices.items()
+            if device.device_json["device_family"] == DEVICE_FAMILY_LOCK
+        }
+
     @property
     def other(self) -> Dict[str, MyQDevice]:
-        """Return only those devices that are covers."""
+        """Return only those devices that are others."""
         return {
             device_id: device
             for device_id, device in self.devices.items()
@@ -137,7 +148,7 @@ async def _get_devices(self) -> None:
                             device_json=device,
                             state_update=state_update_timestmp,
                         )
-                    elif device.get("device_family") == DEVICE_FAMLY_LAMP:
+                    elif device.get("device_family") == DEVICE_FAMILY_LAMP:
                         _LOGGER.debug(
                             "Adding new lamp with serial number %s", serial_number
                         )
@@ -146,6 +157,15 @@ async def _get_devices(self) -> None:
                             device_json=device,
                             state_update=state_update_timestmp,
                         )
+                    elif device.get("device_family") == DEVICE_FAMILY_LOCK:
+                        _LOGGER.debug(
+                            "Adding new lock with serial number %s", serial_number
+                        )
+                        new_device = MyQLock(
+                            account=self,
+                            device_json=device,
+                            state_update=state_update_timestmp,
+                        )
                     else:
                         if device.get("device_family") == DEVICE_FAMILY_GATEWAY:
                             _LOGGER.debug(

pymyq/api.py

@@ -25,6 +25,7 @@
 from .errors import AuthenticationError, InvalidCredentialsError, MyQError, RequestError
 from .garagedoor import MyQGaragedoor
 from .lamp import MyQLamp
+from .lock import MyQLock
 from .request import REQUEST_METHODS, MyQRequest
 
 _LOGGER = logging.getLogger(__name__)
@@ -60,7 +61,7 @@ def __init__(
         self.last_state_update = None  # type: Optional[datetime]
 
     @property
-    def devices(self) -> Dict[str, Union[MyQDevice, MyQGaragedoor, MyQLamp]]:
+    def devices(self) -> Dict[str, Union[MyQDevice, MyQGaragedoor, MyQLamp, MyQLock]]:
         """Return all devices."""
         devices = {}
         for account in self.accounts.values():
@@ -77,15 +78,23 @@ def covers(self) -> Dict[str, MyQGaragedoor]:
 
     @property
     def lamps(self) -> Dict[str, MyQLamp]:
-        """Return only those devices that are covers."""
+        """Return only those devices that are lamps."""
         lamps = {}
         for account in self.accounts.values():
             lamps.update(account.lamps)
         return lamps
 
+    @property
+    def locks(self) -> Dict[str, MyQLock]:
+        """Return only those devices that are locks."""
+        locks = {}
+        for account in self.accounts.values():
+            locks.update(account.locks)
+        return locks
+
     @property
     def gateways(self) -> Dict[str, MyQDevice]:
-        """Return only those devices that are covers."""
+        """Return only those devices that are gateways."""
         gateways = {}
         for account in self.accounts.values():
             gateways.update(account.gateways)

pymyq/const.py

@@ -19,7 +19,8 @@
 DEVICE_FAMILY = "device_family"
 DEVICE_FAMILY_GATEWAY = "gateway"
 DEVICE_FAMILY_GARAGEDOOR = "garagedoor"
-DEVICE_FAMLY_LAMP = "lamp"
+DEVICE_FAMILY_LAMP = "lamp"
+DEVICE_FAMILY_LOCK = "locks"
 DEVICE_STATE = "state"
 DEVICE_STATE_ONLINE = "online"
 

pymyq/lock.py

@@ -0,0 +1,44 @@
+"""Define MyQ devices."""
+import asyncio
+from datetime import datetime
+import logging
+from typing import TYPE_CHECKING, Optional, Union
+
+from .device import MyQDevice
+
+if TYPE_CHECKING:
+    from .account import MyQAccount
+
+_LOGGER = logging.getLogger(__name__)
+
+COMMAND_URI = (
+    "https://account-devices-lock.myq-cloud.com/api/v5.2/Accounts/{account_id}"
+    "/locks/{device_serial}/{command}"
+)
+
+
+class MyQLock(MyQDevice):
+    """Define a generic device."""
+
+    def __init__(
+        self,
+        device_json: dict,
+        account: "MyQAccount",
+        state_update: datetime,
+    ) -> None:
+        """Initialize.
+        :type account: str
+        """
+        super().__init__(
+            account=account, device_json=device_json, state_update=state_update
+        )
+
+    @property
+    def device_state(self) -> Optional[str]:
+        """Return the current state of the device."""
+        return (
+            self.device_json["state"].get("lock_state")
+            if self.device_json.get("state") is not None
+            else None
+        )
+