qolsys-controller 0.0.44__py3-none-any.whl → 0.0.87__py3-none-any.whl

qolsys_controller/partition.py

@@ -11,19 +11,22 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysPartition(QolsysObservable):
-
     EXIT_SOUNDS_ARRAY = ["ON", "OFF", ""]  # noqa: RUF012
     ENTRY_DELAYS_ARRAY = ["ON", "OFF", ""]  # noqa: RUF012
 
-    def __init__(self, partition_dict: dict, settings_dict: dict, alarm_state: PartitionAlarmState,
-                 alarm_type_array: list[PartitionAlarmType]) -> None:
-
+    def __init__(
+        self,
+        partition_dict: dict[str, str],
+        settings_dict: dict[str, str],
+        alarm_state: PartitionAlarmState,
+        alarm_type_array: list[PartitionAlarmType],
+    ) -> None:
         super().__init__()
 
         # Partition info (partition table)
-        self._id: str = partition_dict.get("partition_id")
-        self._name: str = partition_dict.get("name")
-        self._devices = partition_dict.get("devices")
+        self._id: str = partition_dict.get("partition_id", "")
+        self._name: str = partition_dict.get("name", "")
+        self._devices = partition_dict.get("devices", "")
 
         # Partition Settings (qolsyssettings table)
         self._system_status: PartitionSystemStatus = PartitionSystemStatus(settings_dict.get("SYSTEM_STATUS", ""))
@@ -35,61 +38,94 @@ class QolsysPartition(QolsysObservable):
         self._alarm_state: PartitionAlarmState = alarm_state
 
         # Alarm Type (alarmedsensor table)
-        self._alarm_type_array: list[PartitionAlarmType] = alarm_type_array
+        self._alarm_type_array: list[PartitionAlarmType] = []
+        self.append_alarm_type(alarm_type_array)
 
         # Other
-        self._command_exit_sounds = True
-        self._command_arm_stay_instant = True
-        self._command_arm_stay_silent_disarming = False
-        self._command_arm_entry_delay = True
+        self._command_exit_sounds: bool = True
+        self._command_arm_stay_instant: bool = True
+        self._command_arm_stay_silent_disarming: bool = False
+        self._command_arm_entry_delay: bool = True
 
-    @property
-    def id(self) -> int:
-        return self._id
+    def update_partition(self, data: dict[str, str]) -> None:
+        # Check if we are updating same partition_id
+        partition_id_update = data.get("partition_id", "")
+        if partition_id_update != self.id:
+            LOGGER.error(
+                "Updating Partition%s (%s) with Partition '%s' (different id)", self._id, self._name, partition_id_update
+            )
+            return
 
-    @property
-    def name(self) -> str:
-        return self._name
+        self.start_batch_update()
 
-    @property
-    def system_status(self) -> PartitionSystemStatus:
-        return self._system_status
+        # Update Partition Name
+        if "name" in data:
+            self.name = data.get("name", "")
 
-    @property
-    def system_status_changed_time(self) -> str:
-        return self._system_status_changed_time
+        # Update Partition Devices
+        if "devices" in data:
+            self._devices = data.get("devices", "")
 
-    @property
-    def alarm_state(self) -> PartitionAlarmState:
-        return self._alarm_state
+        self.end_batch_update()
 
-    @property
-    def alarm_type_array(self) -> list[PartitionAlarmType]:
-        return self._alarm_type_array
+    def update_settings(self, data: dict[str, str]) -> None:
+        self.start_batch_update()
 
-    @property
-    def exit_sounds(self) -> str:
-        return self._exit_sounds
+        # Update system_status
+        if "SYSTEM_STATUS" in data:
+            self.system_status = PartitionSystemStatus(data.get("SYSTEM_STATUS", ""))
 
-    @property
-    def entry_delays(self) -> str:
-        return self._entry_delays
+        # Update system_status_changed_time
+        if "SYSTEM_STATUS_CHANGED_TIME" in data:
+            self.system_status_changed_time = data.get("SYSTEM_STATUS_CHANGED_TIME", "")
 
-    @property
-    def command_exit_sounds(self) -> bool:
-        return self._command_exit_sounds
+        # Update exit_sounds
+        if "EXIT_SOUNDS" in data:
+            self.exit_sounds = data.get("EXIT_SOUNDS", "")
+
+        # Update entry_delays
+        if "ENTRY_DELAYS" in data:
+            self.entry_delays = data.get("ENTRY_DELAYS", "")
+
+        self.end_batch_update()
+
+    def to_dict_partition(self) -> dict[str, str]:
+        return {
+            "partition_id": self.id,
+            "name": self.name,
+            "devices": self._devices,
+        }
+
+    def to_dict_settings(self) -> dict[str, str]:
+        return {
+            "SYSTEM_STATUS": self.system_status.value,
+            "SYSTEM_STATUS_CHANGED_TIME": self.system_status_changed_time,
+            "EXIT_SOUNDS": self.exit_sounds,
+            "ENTRY_DELAYS": self.entry_delays,
+        }
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
 
     @property
-    def command_arm_stay_instant(self) -> bool:
-        return self._command_arm_stay_instant
+    def id(self) -> str:
+        return self._id
 
     @property
-    def command_arm_stay_silent_disarming(self) -> bool:
-        return self._command_arm_stay_silent_disarming
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        if self._name != value:
+            LOGGER.debug("Partition%s (%s) - name: %s", self._id, self._name, value)
+            self._name = value
+            self.notify()
 
     @property
-    def command_arm_entry_delay(self) -> bool:
-        return self._command_arm_entry_delay
+    def system_status(self) -> PartitionSystemStatus:
+        return self._system_status
 
     @system_status.setter
     def system_status(self, new_value: PartitionSystemStatus) -> None:
@@ -98,6 +134,10 @@ class QolsysPartition(QolsysObservable):
             self._system_status = new_value
             self.notify()
 
+    @property
+    def system_status_changed_time(self) -> str:
+        return self._system_status_changed_time
+
     @system_status_changed_time.setter
     def system_status_changed_time(self, value: str) -> None:
         if self._system_status_changed_time != value:
@@ -105,6 +145,10 @@ class QolsysPartition(QolsysObservable):
             self._system_status_changed_time = value
             self.notify()
 
+    @property
+    def alarm_state(self) -> PartitionAlarmState:
+        return self._alarm_state
+
     @alarm_state.setter
     def alarm_state(self, new_value: PartitionAlarmState) -> None:
         if self._alarm_state != new_value:
@@ -112,9 +156,12 @@ class QolsysPartition(QolsysObservable):
             self._alarm_state = new_value
             self.notify()
 
+    @property
+    def alarm_type_array(self) -> list[PartitionAlarmType]:
+        return self._alarm_type_array
+
     @alarm_type_array.setter
     def alarm_type_array(self, new_alarm_type_array: list[PartitionAlarmType]) -> None:
-
         # If no changes are detected: return without notification
         if sorted(new_alarm_type_array, key=lambda c: c.value) == sorted(self.alarm_type_array, key=lambda c: c.value):
             return
@@ -130,30 +177,9 @@ class QolsysPartition(QolsysObservable):
 
         self.append_alarm_type(new_alarm_type_array)
 
-    @name.setter
-    def name(self, value: str) -> None:
-        if self._name != value:
-            LOGGER.debug("Partition%s (%s) - name: %s", self._id, self._name, value)
-            self._name = value
-            self.notify()
-
-    def append_alarm_type(self, new_alarm_type_array: list[PartitionAlarmType]) -> None:
-
-        data_changed = False
-
-        for new_alarm_type in new_alarm_type_array:
-
-            # Value already in array
-            if new_alarm_type in self._alarm_type_array:
-                continue
-
-            self._alarm_type_array.append(new_alarm_type)
-            data_changed = True
-
-        if data_changed:
-            self.notify()
-            for alarm in self._alarm_type_array:
-                LOGGER.debug("Partition%s (%s) - alarm_type: %s", self._id, self._name, alarm)
+    @property
+    def exit_sounds(self) -> str:
+        return self._exit_sounds
 
     @exit_sounds.setter
     def exit_sounds(self, value: str) -> None:
@@ -166,6 +192,10 @@ class QolsysPartition(QolsysObservable):
             self._exit_sounds = value
             self.notify()
 
+    @property
+    def entry_delays(self) -> str:
+        return self._entry_delays
+
     @entry_delays.setter
     def entry_delays(self, value: str) -> None:
         if value not in self.ENTRY_DELAYS_ARRAY:
@@ -177,85 +207,77 @@ class QolsysPartition(QolsysObservable):
             self._entry_delays = value
             self.notify()
 
+    @property
+    def command_exit_sounds(self) -> bool:
+        return self._command_exit_sounds
+
     @command_exit_sounds.setter
-    def command_exit_sounds(self, value: str) -> None:
+    def command_exit_sounds(self, value: bool) -> None:
         self._command_exit_sounds = value
         LOGGER.debug("Partition%s (%s) - command_exit_sounds: %s", self._id, self._name, value)
         self.notify()
 
+    @property
+    def command_arm_stay_instant(self) -> bool:
+        return self._command_arm_stay_instant
+
     @command_arm_stay_instant.setter
-    def command_arm_stay_instant(self, value: str) -> None:
+    def command_arm_stay_instant(self, value: bool) -> None:
         self._command_arm_stay_instant = value
         LOGGER.debug("Partition%s (%s) - arm_stay_instant: %s", self._id, self._name, value)
         self.notify()
 
+    @property
+    def command_arm_stay_silent_disarming(self) -> bool:
+        return self._command_arm_stay_silent_disarming
+
     @command_arm_stay_silent_disarming.setter
     def command_arm_stay_silent_disarming(self, value: bool) -> None:
         self._command_arm_stay_silent_disarming = value
         LOGGER.debug("Partition%s (%s) - arm_stay_silent_disarming: %s", self._id, self._name, value)
         self.notify()
 
+    @property
+    def command_arm_entry_delay(self) -> bool:
+        return self._command_arm_entry_delay
+
     @command_arm_entry_delay.setter
-    def command_arm_entry_delay(self, value:bool) -> None:
+    def command_arm_entry_delay(self, value: bool) -> None:
         self._command_arm_entry_delay = value
         LOGGER.debug("Partition%s (%s) - command_arm_entry_delay: %s", self._id, self._name, value)
         self.notify()
 
+    def append_alarm_type(self, new_alarm_type_array: list[PartitionAlarmType]) -> None:
+        data_changed = False
 
+        for new_alarm_type in new_alarm_type_array:
+            # Map values to Police Emergency if needed
+            if new_alarm_type in {
+                PartitionAlarmType.GLASS_BREAK,
+                PartitionAlarmType.GLASS_BREAK_AWAY_ONLY,
+                PartitionAlarmType.ENTRY_EXIT_LONG_DELAY,
+                PartitionAlarmType.ENTRY_EXIT_NORMAL_DELAY,
+                PartitionAlarmType.INSTANT_PERIMETER_DW,
+                PartitionAlarmType.INSTANT_INTERIOR_DOOR,
+                PartitionAlarmType.AWAY_DELAY_MOTION,
+                PartitionAlarmType.AWAY_INSTANT_MOTION,
+                PartitionAlarmType.REPORTING_SAFETY_SENSOR,
+                PartitionAlarmType.DELAYED_REPORTING_SAFETY_SENSOR,
+                PartitionAlarmType.AWAY_INSTANT_FOLLOWER_DELAY,
+                PartitionAlarmType.STAY_INSTANT_MOTION,
+                PartitionAlarmType.STAY_DELAY_MOTION,
+                PartitionAlarmType.EMPTY,
+            }:
+                new_alarm_type = PartitionAlarmType.POLICE_EMERGENCY
 
-    def update_partition(self, data: dict) -> None:
-        # Check if we are updating same partition_id
-        partition_id_update = data.get("partition_id", "")
-        if int(partition_id_update) != int(self.id):
-            LOGGER.error(
-                "Updating Partition%s (%s) with Partition '%s' (different id)", self._id, self._name, partition_id_update)
-            return
-
-        self.start_batch_update()
-
-        # Update Partition Name
-        if "name" in data:
-            self.name = data.get("name")
-
-        # Update Partition Devices
-        if "devices" in data:
-            self._devices = data.get("devices")
-
-        self.end_batch_update()
-
-    def update_settings(self, data: dict) -> None:
-
-        self.start_batch_update()
-
-        # Update system_status
-        if "SYSTEM_STATUS" in data:
-            self.system_status = data.get("SYSTEM_STATUS")
-
-        # Update system_status_changed_time
-        if "SYSTEM_STATUS_CHANGED_TIME" in data:
-            self.system_status_changed_time = data.get("SYSTEM_STATUS_CHANGED_TIME")
-
-        # Update exit_sounds
-        if "EXIT_SOUNDS" in data:
-            self.exit_sounds = data.get("EXIT_SOUNDS")
-
-        # Update entry_delays
-        if "ENTRY_DELAYS" in data:
-            self.entry_delays = data.get("ENTRY_DELAYS")
-
-        self.end_batch_update()
+            # Value already in array
+            if new_alarm_type in self._alarm_type_array:
+                continue
 
-    def to_dict_partition(self) -> dict:
-        return {
-            "partition_id": self.id,
-            "name": self.name,
-            "devices": self._devices,
-        }
+            self._alarm_type_array.append(new_alarm_type)
+            data_changed = True
 
-    def to_dict_settings(self) -> dict:
-        return {
-            "SYSTEM_STATUS": self.system_status.value,
-            "SYSTEM_STATUS_CHANGED_TIME": self.system_status_changed_time,
-            "EXIT_SOUNDS": self.exit_sounds,
-            "ENTRY_DELAYS": self.entry_delays,
-        }
+        if data_changed:
+            self.notify()
+            for alarm in self._alarm_type_array:
+                LOGGER.debug("Partition%s (%s) - alarm_type: %s", self._id, self._name, alarm)

qolsys_controller/pki.py

@@ -1,13 +1,12 @@
 import logging
 import os
 import re
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
 from cryptography import x509
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.x509 import load_pem_x509_csr
 from cryptography.x509.oid import NameOID
 
 from .settings import QolsysSettings
@@ -18,13 +17,12 @@ LOGGER = logging.getLogger(__name__)
 class QolsysPKI:
     def __init__(self, settings: QolsysSettings) -> None:
         self._id = ""
-        self._subkeys_directory: Path = Path
-
-        self._key = None
-        self._cer = None
-        self._csr = None
-        self._secure = None
-        self._qolsys = None
+        self._subkeys_directory: Path = Path()
+        self._key: Path = Path()
+        self._cer: Path = Path()
+        self._csr: Path = Path()
+        self._secure: Path = Path()
+        self._qolsys: Path = Path()
 
         self._settings = settings
 
@@ -33,7 +31,7 @@ class QolsysPKI:
         return self._id
 
     def formatted_id(self) -> str:
-        return ":".join(self.id[i:i+2] for i in range(0, len(self.id), 2))
+        return ":".join(self.id[i : i + 2] for i in range(0, len(self.id), 2))
 
     def set_id(self, pki_id: str) -> None:
         self._id = pki_id.replace(":", "").lower()
@@ -41,23 +39,23 @@ class QolsysPKI:
         self._subkeys_directory = self._settings.pki_directory.joinpath(Path(self.id))
 
     @property
-    def key(self) -> str:
+    def key(self) -> Path:
         return self._key
 
     @property
-    def cer(self) -> str:
+    def cer(self) -> Path:
         return self._cer
 
     @property
-    def csr(self) -> str:
+    def csr(self) -> Path:
         return self._csr
 
     @property
-    def secure(self) -> str:
+    def secure(self) -> Path:
         return self._secure
 
     @property
-    def qolsys(self) -> str:
+    def qolsys(self) -> Path:
         return self._qolsys
 
     def auto_discover_pki(self) -> bool:
@@ -72,51 +70,6 @@ class QolsysPKI:
 
         return False
 
-    def load_private_key(self, key: str) -> bool:
-        try:
-            self._key = serialization.load_pem_private_key(key.encode(), password=None)
-        except ValueError:
-            LOGGER.debug("Private Key Value Error")
-            return False
-
-        return True
-
-    def load_certificate(self, cer: str) -> bool:
-        try:
-            self._cer = x509.load_pem_x509_certificate(cer.encode(), None)
-        except ValueError:
-            LOGGER.debug("Certificate Value Error")
-            return False
-
-        return True
-
-    def load_certificate_signing_request(self, csr: str) -> bool:
-        try:
-            self._csr = load_pem_x509_csr(csr.encode())
-        except ValueError:
-            LOGGER.debug("Certificate Signing Request Value Error")
-            return False
-
-        return True
-
-    def load_qolsys_certificate(self, qolsys: str) -> bool:
-        try:
-            self._qolsys = x509.load_pem_x509_certificate(qolsys.encode(), None)
-        except ValueError:
-            LOGGER.debug("Qolsys Certificate Value Error")
-            return False
-
-        return True
-
-    def load_signed_client_certificate(self, secure: str) -> bool:
-        try:
-            self._secure = x509.load_pem_x509_certificate(secure.encode(), None)
-        except ValueError:
-            LOGGER.debug("Client Signed Certificate Value Error")
-            return False
-
-        return True
-
     def check_key_file(self) -> bool:
         if self._subkeys_directory.joinpath(self.id + ".key").resolve().exists():
             LOGGER.debug("Found KEY")
@@ -157,23 +110,22 @@ class QolsysPKI:
         return self._subkeys_directory.joinpath(self.id + ".key")
 
     @property
-    def csr_file_path(self) -> str:
+    def csr_file_path(self) -> Path:
         return self._subkeys_directory.joinpath(self.id + ".csr")
 
     @property
-    def cer_file_path(self) -> str:
+    def cer_file_path(self) -> Path:
         return self._subkeys_directory.joinpath(self.id + ".cer")
 
     @property
-    def secure_file_path(self) -> str:
+    def secure_file_path(self) -> Path:
         return self._subkeys_directory.joinpath(self.id + ".secure")
 
     @property
-    def qolsys_cer_file_path(self) -> str:
+    def qolsys_cer_file_path(self) -> Path:
         return self._subkeys_directory.joinpath(self.id + ".qolsys")
 
     def create(self, mac: str, key_size: int) -> bool:
-
         self.set_id(mac)
 
         # Check if directory exist
@@ -207,48 +159,68 @@ class QolsysPKI:
         self._subkeys_directory.resolve().mkdir(parents=True)
 
         LOGGER.debug("Creating KEY")
-        private_key = rsa.generate_private_key(public_exponent=65537,
-                                               key_size=key_size)
-        private_pem = private_key.private_bytes(encoding=serialization.Encoding.PEM,
-                                                format=serialization.PrivateFormat.PKCS8,
-                                                encryption_algorithm=serialization.NoEncryption())
+        private_key = rsa.generate_private_key(public_exponent=65537, key_size=key_size)
+        private_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
         with self._subkeys_directory.joinpath(self.id + ".key").open("wb") as file:
             file.write(private_pem)
 
         LOGGER.debug("Creating CER")
-        subject = issuer = x509.Name([
-            x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
-            x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "SanJose"),
-            x509.NameAttribute(NameOID.LOCALITY_NAME, ""),
-            x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Qolsys Inc."),
-            x509.NameAttribute(NameOID.COMMON_NAME, "www.qolsys.com "),
-        ])
-        cert = x509.CertificateBuilder().subject_name(
-            subject,
-        ).issuer_name(
-            issuer,
-        ).public_key(
-            private_key.public_key(),
-        ).serial_number(
-            x509.random_serial_number(),
-        ).not_valid_before(
-            datetime.utcnow(),
-        ).not_valid_after(
-            datetime.utcnow() + timedelta(days=365),
-        ).add_extension(
-            x509.BasicConstraints(ca=False, path_length=None), critical=True,
-        ).sign(private_key, hashes.SHA256())
+        subject = issuer = x509.Name(
+            [
+                x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
+                x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "SanJose"),
+                x509.NameAttribute(NameOID.LOCALITY_NAME, ""),
+                x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Qolsys Inc."),
+                x509.NameAttribute(NameOID.COMMON_NAME, "www.qolsys.com "),
+            ]
+        )
+        cert = (
+            x509.CertificateBuilder()
+            .subject_name(
+                subject,
+            )
+            .issuer_name(
+                issuer,
+            )
+            .public_key(
+                private_key.public_key(),
+            )
+            .serial_number(
+                x509.random_serial_number(),
+            )
+            .not_valid_before(
+                datetime.now(timezone.utc),  # noqa: UP017
+            )
+            .not_valid_after(
+                datetime.now(timezone.utc) + timedelta(days=3650),  # noqa: UP017
+            )
+            .add_extension(
+                x509.BasicConstraints(ca=False, path_length=None),
+                critical=True,
+            )
+            .sign(private_key, hashes.SHA256())
+        )
         cert_pem = cert.public_bytes(encoding=serialization.Encoding.PEM)
 
         with self._subkeys_directory.joinpath(self.id + ".cer").open("wb") as file:
             file.write(cert_pem)
 
         LOGGER.debug("Creating CSR")
-        csr = x509.CertificateSigningRequestBuilder().subject_name(
-            subject,
-        ).add_extension(
-            x509.BasicConstraints(ca=False, path_length=None), critical=True,
-        ).sign(private_key, hashes.SHA256())
+        csr = (
+            x509.CertificateSigningRequestBuilder()
+            .subject_name(
+                subject,
+            )
+            .add_extension(
+                x509.BasicConstraints(ca=False, path_length=None),
+                critical=True,
+            )
+            .sign(private_key, hashes.SHA256())
+        )
 
         # Save CSR to file
         csr_pem = csr.public_bytes(encoding=serialization.Encoding.PEM)