pyg90alarm 2.0.1__tar.gz → 2.1.0__tar.gz

{pyg90alarm-2.0.1 → pyg90alarm-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg90alarm
-Version: 2.0.1
+Version: 2.1.0
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov
@@ -96,8 +96,8 @@ Python, and it opens up a way for further integrations.
 Supported hardware
 ==================
 
-It mightn't possible to list every system supported by the package due to
-manufacturers name the products differently.  Here is the list of hardware
+It might not be possible to list every system supported by the package due to
+manufacturers naming the products differently.  Here is the list of hardware
 known to work with the package:
 
 * `PST G90B Plus <http://www.cameralarms.com/products/auto_dial_alarm_system/185.html>`_
@@ -170,7 +170,7 @@ set the IP address allocation up.
    alert to be enabled in the mobile application, otherwise it won't be
    recorded in the history.
 
-For the local notifications to be enabled the ```G90Alarm.use_local_notifications()``` needs to be called upon contstucting an instance of ``G90Alarm`` class, then ```G90Alarm.listen_notifications()`z to start processing those coming from the panel - the code fragment below demonstrate that though being incomplete since callbacks (e.g. ``G90Alarm.on_armdisarm()``) should be set for the actual processing of the notifications.
+For the local notifications to be enabled the ``G90Alarm.use_local_notifications()`` needs to be called upon constructing an instance of ``G90Alarm`` class, then ``G90Alarm.listen_notifications()`` to start processing those coming from the panel - the code fragment below demonstrates that though being incomplete since callbacks (e.g. ``G90Alarm.on_armdisarm()``) should be set for the actual processing of the notifications.
 
 .. code:: python
 
@@ -189,10 +189,10 @@ Cloud notifications
 The cloud protocol is native to the panel and is used to interact with mobile application. The package can mimic the cloud server and interpret the messages the panel sends to the cloud, allowing to receive the notifications and alerts.
 While the protocol also allows to send commands to the panel, it is not implemented and local protocol is used for that - i.e. when cloud notifications are in use the local protocol still utilized for sending commands to the panel.
 
-The cloud protocol is TCP based and typically interacts with cloud service at known IP address and port (not customizeable at panel side). To process the cloud notifications all the traffic from panel towards the cloud (IP address ``47.88.7.61`` and TCP port ``5678`` as of writing) needs to be diverted to the node where the package is running - depending on your network equipment it could be port forwarding, DNAT or other means. It is unclear whether the panel utilizes DNS to resolve the cloud service IP address, hence the documentation only mentions IP-based traffic redirection.
+The cloud protocol is TCP based and typically interacts with cloud service at known IP address and port (not customizable at panel side). To process the cloud notifications all the traffic from panel towards the cloud (IP address ``47.88.7.61`` and TCP port ``5678`` as of writing) needs to be diverted to the node where the package is running - depending on your network equipment it could be port forwarding, DNAT or other means. It is unclear whether the panel utilizes DNS to resolve the cloud service IP address, hence the documentation only mentions IP-based traffic redirection.
 
 Please see
-`cloud-protocol.rst <docs/cloud-protocol.rst>`_ for further details on the protocol.
+`the section <docs/cloud-protocol.rst>`_ for further details on the protocol.
 
 The benefit of the cloud notifications is that the panel no longer required to have ``10.10.10.250`` IP address.
 
@@ -200,10 +200,10 @@ The package could act as:
 
 - Standalone cloud server with no Internet connectivity or cloud service
   required at all - good if you'd like to avoid having a vendor service involved. Please note the mobile application will show panel as offline in this mode
-- Chained cloud server, where in addition to intepreting the notifications it
-  will also forward all packets received from the panel to the cloud server, and pass its responses back to the panel. This allows to have notificaitons processed by the package and the mobile application working as well.
+- Chained cloud server, where in addition to interpreting the notifications it
+  will also forward all packets received from the panel to the cloud server, and pass its responses back to the panel. This allows to have notifications processed by the package and the mobile application working as well.
 
-  .. note:: Sending packets upstream to the known IP address and port of the cloud server might result in those looped back (since traffic from panel to cloud service has to be redirected to the host where package runs), if your network equipment can't account for source address in redirection rules (i.e. limiting the port redirection to the panel's IP address). In that case you'll need another redirection, from the host where the package runs to the cloud service using an IP from your network. That way those two redirection rules will coexist correctly. To illustate:
+  .. note:: Sending packets upstream to the known IP address and port of the cloud server might result in those looped back (since traffic from panel to cloud service has to be redirected to the host where package runs), if your network equipment can't account for source address in redirection rules (i.e. limiting the port redirection to the panel's IP address). In that case you'll need another redirection, from the host where the package runs to the cloud service using an IP from your network. That way those two redirection rules will coexist correctly. To illustrate:
 
    Port forwarding rule 1:
 
@@ -213,6 +213,7 @@ The package could act as:
    - Redirect to host: host where package runs
    - Redirect to port: 5678 (or other port if you want to use it)
 
+
    Port forwarding rule 2 (optional):
 
    - Source: host where package runs

{pyg90alarm-2.0.1 → pyg90alarm-2.1.0}/README.rst

@@ -49,8 +49,8 @@ Python, and it opens up a way for further integrations.
 Supported hardware
 ==================
 
-It mightn't possible to list every system supported by the package due to
-manufacturers name the products differently.  Here is the list of hardware
+It might not be possible to list every system supported by the package due to
+manufacturers naming the products differently.  Here is the list of hardware
 known to work with the package:
 
 * `PST G90B Plus <http://www.cameralarms.com/products/auto_dial_alarm_system/185.html>`_
@@ -123,7 +123,7 @@ set the IP address allocation up.
    alert to be enabled in the mobile application, otherwise it won't be
    recorded in the history.
 
-For the local notifications to be enabled the ```G90Alarm.use_local_notifications()``` needs to be called upon contstucting an instance of ``G90Alarm`` class, then ```G90Alarm.listen_notifications()`z to start processing those coming from the panel - the code fragment below demonstrate that though being incomplete since callbacks (e.g. ``G90Alarm.on_armdisarm()``) should be set for the actual processing of the notifications.
+For the local notifications to be enabled the ``G90Alarm.use_local_notifications()`` needs to be called upon constructing an instance of ``G90Alarm`` class, then ``G90Alarm.listen_notifications()`` to start processing those coming from the panel - the code fragment below demonstrates that though being incomplete since callbacks (e.g. ``G90Alarm.on_armdisarm()``) should be set for the actual processing of the notifications.
 
 .. code:: python
 
@@ -142,10 +142,10 @@ Cloud notifications
 The cloud protocol is native to the panel and is used to interact with mobile application. The package can mimic the cloud server and interpret the messages the panel sends to the cloud, allowing to receive the notifications and alerts.
 While the protocol also allows to send commands to the panel, it is not implemented and local protocol is used for that - i.e. when cloud notifications are in use the local protocol still utilized for sending commands to the panel.
 
-The cloud protocol is TCP based and typically interacts with cloud service at known IP address and port (not customizeable at panel side). To process the cloud notifications all the traffic from panel towards the cloud (IP address ``47.88.7.61`` and TCP port ``5678`` as of writing) needs to be diverted to the node where the package is running - depending on your network equipment it could be port forwarding, DNAT or other means. It is unclear whether the panel utilizes DNS to resolve the cloud service IP address, hence the documentation only mentions IP-based traffic redirection.
+The cloud protocol is TCP based and typically interacts with cloud service at known IP address and port (not customizable at panel side). To process the cloud notifications all the traffic from panel towards the cloud (IP address ``47.88.7.61`` and TCP port ``5678`` as of writing) needs to be diverted to the node where the package is running - depending on your network equipment it could be port forwarding, DNAT or other means. It is unclear whether the panel utilizes DNS to resolve the cloud service IP address, hence the documentation only mentions IP-based traffic redirection.
 
 Please see
-`cloud-protocol.rst <docs/cloud-protocol.rst>`_ for further details on the protocol.
+`the section <docs/cloud-protocol.rst>`_ for further details on the protocol.
 
 The benefit of the cloud notifications is that the panel no longer required to have ``10.10.10.250`` IP address.
 
@@ -153,10 +153,10 @@ The package could act as:
 
 - Standalone cloud server with no Internet connectivity or cloud service
   required at all - good if you'd like to avoid having a vendor service involved. Please note the mobile application will show panel as offline in this mode
-- Chained cloud server, where in addition to intepreting the notifications it
-  will also forward all packets received from the panel to the cloud server, and pass its responses back to the panel. This allows to have notificaitons processed by the package and the mobile application working as well.
+- Chained cloud server, where in addition to interpreting the notifications it
+  will also forward all packets received from the panel to the cloud server, and pass its responses back to the panel. This allows to have notifications processed by the package and the mobile application working as well.
 
-  .. note:: Sending packets upstream to the known IP address and port of the cloud server might result in those looped back (since traffic from panel to cloud service has to be redirected to the host where package runs), if your network equipment can't account for source address in redirection rules (i.e. limiting the port redirection to the panel's IP address). In that case you'll need another redirection, from the host where the package runs to the cloud service using an IP from your network. That way those two redirection rules will coexist correctly. To illustate:
+  .. note:: Sending packets upstream to the known IP address and port of the cloud server might result in those looped back (since traffic from panel to cloud service has to be redirected to the host where package runs), if your network equipment can't account for source address in redirection rules (i.e. limiting the port redirection to the panel's IP address). In that case you'll need another redirection, from the host where the package runs to the cloud service using an IP from your network. That way those two redirection rules will coexist correctly. To illustrate:
 
    Port forwarding rule 1:
 
@@ -166,6 +166,7 @@ The package could act as:
    - Redirect to host: host where package runs
    - Redirect to port: 5678 (or other port if you want to use it)
 
+
    Port forwarding rule 2 (optional):
 
    - Source: host where package runs

{pyg90alarm-2.0.1 → pyg90alarm-2.1.0}/src/pyg90alarm/__init__.py

@@ -28,7 +28,9 @@ from .local.paginated_result import G90PaginatedResult
 from .notifications.base import (
     G90DeviceAlert,
 )
-from .entities.sensor import G90Sensor, G90SensorTypes
+from .entities.sensor import (
+    G90Sensor, G90SensorTypes, G90SensorAlertModes, G90SensorUserFlags
+)
 from .entities.device import G90Device
 from .local.host_info import (
     G90HostInfo, G90HostInfoWifiStatus, G90HostInfoGsmStatus
@@ -48,8 +50,10 @@ from .exceptions import G90Error, G90TimeoutError
 
 __all__ = [
     'G90Alarm', 'G90BaseCommand', 'G90PaginatedResult', 'G90DeviceAlert',
-    'G90Sensor', 'G90SensorTypes', 'G90Device', 'G90HostInfo',
-    'G90HostInfoWifiStatus', 'G90HostInfoGsmStatus', 'G90HostStatus',
+    'G90Sensor', 'G90SensorTypes', 'G90SensorAlertModes', 'G90SensorUserFlags',
+    'G90Device',
+    'G90HostInfo', 'G90HostInfoWifiStatus', 'G90HostInfoGsmStatus',
+    'G90HostStatus',
     'G90MessageTypes', 'G90NotificationTypes', 'G90ArmDisarmTypes',
     'G90AlertTypes', 'G90AlertSources', 'G90AlertStates',
     'G90AlertStateChangeTypes', 'G90HistoryStates', 'G90Error',

{pyg90alarm-2.0.1 → pyg90alarm-2.1.0}/src/pyg90alarm/alarm.py

@@ -201,7 +201,7 @@ class G90Alarm(G90NotificationProtocol):
         ] = None
         self._tamper_cb: Optional[TamperCallback] = None
         self._reset_occupancy_interval = reset_occupancy_interval
-        self._alert_config: Optional[G90AlertConfigFlags] = None
+        self._alert_config = G90AlertConfig(self)
         self._sms_alert_when_armed = False
         self._alert_simulation_task: Optional[Task[Any]] = None
         self._alert_simulation_start_listener_back = False
@@ -385,50 +385,29 @@ class G90Alarm(G90NotificationProtocol):
         return G90HostStatus(*res)
 
     @property
-    async def alert_config(self) -> G90AlertConfigFlags:
+    def alert_config(self) -> G90AlertConfig:
         """
-        Property over new :meth:`.get_alert_config` method, retained for
-        compatibility.
-        """
-        return await self.get_alert_config()
-
-    async def get_alert_config(self) -> G90AlertConfigFlags:
-        """
-        Retrieves the alert configuration flags from the device. Please note
-        the configuration is cached upon first call, so you need to
-        re-instantiate the class to reflect any updates there.
+        Provides alert configuration object.
 
-        :return: The alerts configured
+        :return: Alert configuration object
         """
-        if not self._alert_config:
-            self._alert_config = await self._alert_config_uncached()
         return self._alert_config
 
-    async def _alert_config_uncached(self) -> G90AlertConfigFlags:
+    async def get_alert_config(self) -> G90AlertConfigFlags:
         """
-        Retrieves the alert configuration flags directly from the device.
+        Provides alert configuration flags, retained for compatibility - using
+        `:attr:alert_config` and `:class:G90AlertConfig` is preferred.
 
         :return: The alerts configured
         """
-        res = await self.command(G90Commands.GETNOTICEFLAG)
-        return G90AlertConfig(*res).flags
+        return await self.alert_config.flags
 
     async def set_alert_config(self, flags: G90AlertConfigFlags) -> None:
         """
-        Sets the alert configuration flags on the device.
+        Sets the alert configuration flags, retained for compatibility - using
+        `:attr:alert_config` and `:class:G90AlertConfig` is preferred.
         """
-        # Use uncached method retrieving the alert configuration, to ensure the
-        # actual value retrieved from the device
-        alert_config = await self._alert_config_uncached()
-        if alert_config != self._alert_config:
-            _LOGGER.warning(
-                'Alert configuration changed externally,'
-                ' overwriting (read "%s", will be set to "%s")',
-                str(alert_config), str(flags)
-            )
-        await self.command(G90Commands.SETNOTICEFLAG, [flags.value])
-        # Update the alert configuration stored
-        self._alert_config = flags
+        await self.alert_config.set(flags)
 
     @property
     async def user_data_crc(self) -> G90UserDataCRC:
@@ -514,9 +493,9 @@ class G90Alarm(G90NotificationProtocol):
 
             # Determine if door close notifications are available for the given
             # sensor
-            alert_config_flags = await self.alert_config
-            door_close_alert_enabled = (
-                G90AlertConfigFlags.DOOR_CLOSE in alert_config_flags)
+            door_close_alert_enabled = await self.alert_config.get_flag(
+                G90AlertConfigFlags.DOOR_CLOSE
+            )
             # The condition intentionally doesn't account for cord sensors of
             # subtype door, since those won't send door open/close alerts, only
             # notifications
@@ -532,7 +511,8 @@ class G90Alarm(G90NotificationProtocol):
                               ' (alert config flags %s) or is a cord sensor,'
                               ' closing event will be emulated upon'
                               ' %s seconds',
-                              name, sensor.type, alert_config_flags,
+                              name, sensor.type,
+                              await self.alert_config.flags,
                               self._reset_occupancy_interval)
                 G90Callback.invoke_delayed(
                     self._reset_occupancy_interval,
@@ -599,17 +579,12 @@ class G90Alarm(G90NotificationProtocol):
         :param state: Device state (armed, disarmed, armed home)
         """
         if self._sms_alert_when_armed:
-            if state == G90ArmDisarmTypes.DISARM:
-                # Disable SMS alerts from the device
-                await self.set_alert_config(
-                    await self.alert_config & ~G90AlertConfigFlags.SMS_PUSH
-                )
-            if state in (G90ArmDisarmTypes.ARM_AWAY,
-                         G90ArmDisarmTypes.ARM_HOME):
-                # Enable SMS alerts from the device
-                await self.set_alert_config(
-                    await self.alert_config | G90AlertConfigFlags.SMS_PUSH
+            await self.alert_config.set_flag(
+                G90AlertConfigFlags.SMS_PUSH,
+                state in (
+                    G90ArmDisarmTypes.ARM_AWAY, G90ArmDisarmTypes.ARM_HOME
                 )
+            )
 
         # Reset the tampered and door open when arming flags on all sensors
         # having those set

{pyg90alarm-2.0.1 → pyg90alarm-2.1.0}/src/pyg90alarm/entities/device.py

@@ -50,7 +50,7 @@ class G90Device(G90Sensor):
                                   [self.index, 1, self.subindex])
 
     @property
-    def supports_enable_disable(self) -> bool:
+    def supports_updates(self) -> bool:
         """
         Indicates if disabling/enabling the device (relay) is supported.
 
@@ -64,12 +64,12 @@ class G90Device(G90Sensor):
         # mostly.
         return False
 
-    async def set_enabled(self, value: bool) -> None:
+    async def delete(self) -> None:
         """
-        Changes the disabled/enabled state of the device (relay).
-
-        :param value: Whether to enable or disable the device
+        Deletes the device (relay) from the G90 alarm panel.
         """
-        _LOGGER.warning(
-            'Manipulating with enable/disable for device is unsupported'
-        )
+        _LOGGER.debug("Deleting device: %s", self)
+        # Mark the device as unavailable
+        self.is_unavailable = True
+        # Delete the device from the alarm panel
+        await self.parent.command(G90Commands.DELDEVICE, [self.index])

{pyg90alarm-2.0.1 → pyg90alarm-2.1.0}/src/pyg90alarm/entities/sensor.py

@@ -52,7 +52,7 @@ class G90SensorCommonData:  # pylint:disable=too-many-instance-attributes
     type_id: int
     subtype: int
     timeout: int
-    user_flag_data: int
+    user_flags_data: int
     baudrate: int
     protocol_id: int
     reserved_data: int
@@ -117,6 +117,35 @@ class G90SensorUserFlags(IntFlag):
     )
 
 
+class G90SensorAlertModes(IntEnum):
+    """
+    Dedicated alert modes for the sensors (subset of user flags).
+    """
+    ALERT_ALWAYS = 0
+    ALERT_WHEN_AWAY = 1
+    ALERT_WHEN_AWAY_AND_HOME = 2
+
+
+# Mapping of relevant user flags to alert modes
+ALERT_MODES_MAP_BY_FLAG = {
+    # No 'when away' or 'when away and home' flag set means 'alert always
+    G90SensorUserFlags.NONE:
+        G90SensorAlertModes.ALERT_ALWAYS,
+    G90SensorUserFlags.ALERT_WHEN_AWAY:
+        G90SensorAlertModes.ALERT_WHEN_AWAY,
+    G90SensorUserFlags.ALERT_WHEN_AWAY_AND_HOME:
+        G90SensorAlertModes.ALERT_WHEN_AWAY_AND_HOME,
+}
+
+# Reversed mapping of alert modes to corresponding user flags
+ALERT_MODES_MAP_BY_VALUE = dict(
+    zip(
+        ALERT_MODES_MAP_BY_FLAG.values(),
+        ALERT_MODES_MAP_BY_FLAG.keys()
+    )
+)
+
+
 class G90SensorProtocols(IntEnum):
     """
     Protocol types for the sensors.
@@ -363,12 +392,22 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
 
     @property
     def user_flag(self) -> G90SensorUserFlags:
+        """
+        User flags for the sensor, retained for compatibility - please use
+        `:attr:user_flags` instead.
+
+        :return: User flags
+        """
+        return self.user_flags
+
+    @property
+    def user_flags(self) -> G90SensorUserFlags:
         """
         User flags for the sensor (disabled/enabled, arming type etc).
 
         :return: User flags
         """
-        return G90SensorUserFlags(self._protocol_data.user_flag_data)
+        return G90SensorUserFlags(self._protocol_data.user_flags_data)
 
     @property
     def node_count(self) -> int:
@@ -417,6 +456,25 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
         """
         return self._proto_idx
 
+    @property
+    def supports_updates(self) -> bool:
+        """
+        Indicates if the sensor supports updates.
+
+        :return: Support for updates
+        """
+        if not self._definition:
+            _LOGGER.warning(
+                'Manipulating with user flags for sensor index=%s'
+                ' is unsupported - no sensor definition for'
+                ' type=%s, subtype=%s',
+                self.index,
+                self._protocol_data.type_id,
+                self._protocol_data.subtype
+            )
+            return False
+        return True
+
     @property
     def supports_enable_disable(self) -> bool:
         """
@@ -424,7 +482,7 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
 
         :return: Support for enabling/disabling the sensor
         """
-        return self._definition is not None
+        return self.supports_updates
 
     @property
     def protocol_data(self) -> G90SensorIncomingData:
@@ -518,16 +576,14 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
         )
         self._door_open_when_arming = value
 
-    @property
-    def enabled(self) -> bool:
+    async def set_user_flag(self, value: G90SensorUserFlags) -> None:
         """
-        Indicates if the sensor is enabled.
-
-        :return: If sensor is enabled
+        Sets user flags of the sensor, retained for compatibility - please use
+        `:meth:set_user_flags` instead.
         """
-        return self.user_flag & G90SensorUserFlags.ENABLED != 0
+        await self.set_user_flags(value)
 
-    async def set_user_flag(self, value: G90SensorUserFlags) -> None:
+    async def set_user_flags(self, value: G90SensorUserFlags) -> None:
         """
         Sets user flags of the sensor.
 
@@ -535,26 +591,21 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
           :attr:`.G90SensorUserFlags.USER_SETTABLE` will be ignored and
           preserved from existing sensor flags.
         """
+        if not self.supports_updates:
+            return
+
+        # Checking private attribute directly, since `mypy` doesn't recognize
+        # the check for sensor definition is done over
+        # `self.supports_updates` property
+        if not self._definition:
+            return
+
         if value & ~G90SensorUserFlags.USER_SETTABLE:
             _LOGGER.warning(
                 'User flags for sensor index=%s contain non-user settable'
                 ' flags, those will be ignored: %s',
                 self.index, repr(value & ~G90SensorUserFlags.USER_SETTABLE)
             )
-        # Checking private attribute directly, since `mypy` doesn't recognize
-        # the check for sensor definition to be defined if done over
-        # `self.supports_enable_disable` property
-        if not self._definition:
-            _LOGGER.warning(
-                'Manipulating with user flags for sensor index=%s'
-                ' is unsupported - no sensor definition for'
-                ' type=%s, subtype=%s',
-                self.index,
-                self._protocol_data.type_id,
-                self._protocol_data.subtype
-            )
-
-            return
 
         # Refresh actual sensor data from the alarm panel before modifying it.
         # This implies the sensor is at the same position within sensor list
@@ -593,24 +644,32 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
             )
             return
 
-        prev_user_flag = self.user_flag
+        prev_user_flags = self.user_flags
 
         # Re-instantiate the protocol data with modified user flags
         _data = asdict(self._protocol_data)
-        _data['user_flag_data'] = (
+        _data['user_flags_data'] = (
             # Preserve flags that are not user-settable
-            self.user_flag & ~G90SensorUserFlags.USER_SETTABLE
+            self.user_flags & ~G90SensorUserFlags.USER_SETTABLE
         ) | (
             # Combine them with the new user-settable flags
             value & G90SensorUserFlags.USER_SETTABLE
         )
         self._protocol_data = self._protocol_incoming_data_kls(**_data)
 
+        if self.user_flags == prev_user_flags:
+            _LOGGER.debug(
+                'Sensor index=%s: user flags %s have not changed,'
+                ' skipping update',
+                self._protocol_data.index, repr(prev_user_flags)
+            )
+            return
+
         _LOGGER.debug(
-            'Sensor index=%s: previous user_flag %s, resulting user_flag %s',
+            'Sensor index=%s: previous user flags %s, resulting flags %s',
             self._protocol_data.index,
-            repr(prev_user_flag),
-            repr(self.user_flag)
+            repr(prev_user_flags),
+            repr(self.user_flags)
         )
 
         # Generate protocol data from write operation, deriving values either
@@ -623,7 +682,7 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
             type_id=self._protocol_data.type_id,
             subtype=self._protocol_data.subtype,
             timeout=self._protocol_data.timeout,
-            user_flag_data=self._protocol_data.user_flag_data,
+            user_flags_data=self._protocol_data.user_flags_data,
             baudrate=self._protocol_data.baudrate,
             protocol_id=self._protocol_data.protocol_id,
             reserved_data=self._definition.reserved_data,
@@ -637,20 +696,110 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
             G90Commands.SETSINGLESENSOR, list(astuple(outgoing_data))
         )
 
-    async def set_enabled(self, value: bool) -> None:
+    def get_flag(self, flag: G90SensorUserFlags) -> bool:
         """
-        Sets the sensor enabled/disabled.
+        Gets the user flag for the sensor.
+
+        :param flag: User flag to get
+        :return: User flag value
         """
+        return flag in self.user_flag
 
-        # Modify the value of the user flag setting enabled/disabled one
-        # appropriately.
-        user_flag = self.user_flag
-        if value:
-            user_flag |= G90SensorUserFlags.ENABLED
-        else:
-            user_flag &= ~G90SensorUserFlags.ENABLED
+    async def set_flag(
+        self, flag: G90SensorUserFlags, value: bool
+    ) -> None:
+        """
+        Sets the user flag for the sensor.
+
+        :param flag: User flag to set
+        :param value: New value for the user flag
+        """
+        # Skip updating the flag if it has the desired value
+        if self.get_flag(flag) == value:
+            _LOGGER.debug(
+                'Sensor index=%s: user flag %s has not changed,'
+                ' skipping update',
+                self._protocol_data.index, repr(flag)
+            )
+            return
+
+        # Invert corresponding user flag and set it
+        user_flag = self.user_flag ^ flag
         await self.set_user_flag(user_flag)
 
+    @property
+    def enabled(self) -> bool:
+        """
+        Indicates if the sensor is enabled, using `:meth:get_user_flag` instead
+        is preferred.
+
+        :return: If sensor is enabled
+        """
+        return self.get_flag(G90SensorUserFlags.ENABLED)
+
+    async def set_enabled(self, value: bool) -> None:
+        """
+        Sets the sensor enabled/disabled, using `:meth:set_user_flag` instead
+        is preferred.
+
+        :param value: New the sensor should be enabled
+        """
+        await self.set_flag(G90SensorUserFlags.ENABLED, value)
+
+    @property
+    def alert_mode(self) -> G90SensorAlertModes:
+        """
+        Alert mode for the sensor.
+
+        :return: Alert mode
+        """
+        # Filter out irrelevant flags
+        mode = self.user_flag & (
+            G90SensorUserFlags.ALERT_WHEN_AWAY
+            | G90SensorUserFlags.ALERT_WHEN_AWAY_AND_HOME
+        )
+        # Map the relevant user flags to alert mode
+        result = ALERT_MODES_MAP_BY_FLAG.get(mode, None)
+
+        if result is None:
+            raise ValueError(
+                f"Unknown alert mode for sensor {self.name}: {mode}"
+                f" (user flag: {self.user_flag})"
+            )
+
+        return result
+
+    async def set_alert_mode(self, value: G90SensorAlertModes) -> None:
+        """
+        Sets the sensor alert mode.
+        """
+        # Skip update if the value is already set to the requested one
+        if self.alert_mode == value:
+            _LOGGER.debug(
+                'Sensor index=%s: alert mode %s has not changed,'
+                ' skipping update',
+                self._protocol_data.index, repr(value)
+            )
+            return
+
+        # Map the alert mode to user flag value
+        result = ALERT_MODES_MAP_BY_VALUE.get(value, None)
+
+        if result is None:
+            raise ValueError(
+                f"Attempting to set alert mode for sensor {self.name} to"
+                f" unknown value '{value}'"
+            )
+
+        # Add the mapped value over the user flags, filtering out previous
+        # value of the alert mode
+        user_flags = self.user_flag & ~(
+            G90SensorUserFlags.ALERT_WHEN_AWAY
+            | G90SensorUserFlags.ALERT_WHEN_AWAY_AND_HOME
+        ) | result
+        # Set the updated user flags
+        await self.set_user_flags(user_flags)
+
     @property
     def extra_data(self) -> Any:
         """
@@ -674,6 +823,19 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
     def is_unavailable(self, value: bool) -> None:
         self._unavailable = value
 
+    async def delete(self) -> None:
+        """
+        Deletes the sensor from the alarm panel.
+        """
+        _LOGGER.debug("Deleting sensor: %s", self)
+
+        # Mark the sensor as unavailable
+        self.is_unavailable = True
+        # Delete the sensor from the alarm panel
+        await self.parent.command(
+            G90Commands.DELSENSOR, [self.index]
+        )
+
     def _asdict(self) -> Dict[str, Any]:
         """
         Returns dictionary representation of the sensor.
@@ -693,8 +855,15 @@ class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
             'user_flag': self.user_flag,
             'reserved': self.reserved,
             'extra_data': self.extra_data,
-            'enabled': self.enabled,
-            'supports_enable_disable': self.supports_enable_disable,
+            'enabled': self.get_flag(G90SensorUserFlags.ENABLED),
+            'detect_door': self.get_flag(G90SensorUserFlags.DETECT_DOOR),
+            'door_chime': self.get_flag(G90SensorUserFlags.DOOR_CHIME),
+            'independent_zone': self.get_flag(
+                G90SensorUserFlags.INDEPENDENT_ZONE
+            ),
+            'arm_delay': self.get_flag(G90SensorUserFlags.ARM_DELAY),
+            'alert_mode': self.alert_mode,
+            'supports_updates': self.supports_updates,
             'is_wireless': self.is_wireless,
             'is_low_battery': self.is_low_battery,
             'is_tampered': self.is_tampered,