qolsys-controller 0.0.2__py3-none-any.whl → 0.0.5__py3-none-any.whl

qolsys_controller/partition.py

@@ -9,31 +9,33 @@ from .observable import QolsysObservable
 
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysPartition(QolsysObservable):
 
-    EXIT_SOUNDS_ARRAY = ["ON","OFF",""]  # noqa: RUF012
-    ENTRY_DELAYS_ARRAY = ["ON","OFF",""]  # noqa: RUF012
+    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, settings_dict: dict, 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._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",""))
-        self._system_status_changed_time:str = settings_dict.get("SYSTEM_STATUS_CHANGED_TIME","")
-        self._exit_sounds:str = settings_dict.get("EXIT_SOUNDS","")
-        self._entry_delays:str = settings_dict.get("ENTRY_DELAYS","")
+        self._system_status: PartitionSystemStatus = PartitionSystemStatus(settings_dict.get("SYSTEM_STATUS", ""))
+        self._system_status_changed_time: str = settings_dict.get("SYSTEM_STATUS_CHANGED_TIME", "")
+        self._exit_sounds: str = settings_dict.get("EXIT_SOUNDS", "")
+        self._entry_delays: str = settings_dict.get("ENTRY_DELAYS", "")
 
         # Alarm State (state table)
-        self._alarm_state:PartitionAlarmState = alarm_state
+        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] = alarm_type_array
 
         # Other
         self._command_exit_sounds = True
@@ -80,31 +82,31 @@ class QolsysPartition(QolsysObservable):
         return self._command_arm_stay_instant
 
     @system_status.setter
-    def system_status(self, new_value:PartitionSystemStatus) -> None:
+    def system_status(self, new_value: PartitionSystemStatus) -> None:
         if self._system_status != new_value:
-            LOGGER.debug("Partition%s (%s) - system_status: %s",self.id,self.name,new_value)
+            LOGGER.debug("Partition%s (%s) - system_status: %s", self.id, self.name, new_value)
             self._system_status = new_value
             self.notify()
 
     @system_status_changed_time.setter
-    def system_status_changed_time(self,value:str) -> None:
+    def system_status_changed_time(self, value: str) -> None:
         if self._system_status_changed_time != value:
-            LOGGER.debug("Partition%s (%s) - system_status_changed_time: %s",self._id,self._name,value)
+            LOGGER.debug("Partition%s (%s) - system_status_changed_time: %s", self._id, self._name, value)
             self._system_status_changed_time = value
             self.notify()
 
     @alarm_state.setter
-    def alarm_state(self,new_value:PartitionAlarmState) -> None:
+    def alarm_state(self, new_value: PartitionAlarmState) -> None:
         if self._alarm_state != new_value:
-            LOGGER.debug("Partition%s (%s) - alarm_state: %s",self.id,self.name,new_value)
+            LOGGER.debug("Partition%s (%s) - alarm_state: %s", self.id, self.name, new_value)
             self._alarm_state = new_value
             self.notify()
 
     @alarm_type_array.setter
-    def alarm_type_array(self,new_alarm_type_array:list[PartitionAlarmType]) -> None:
+    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):
+        if sorted(new_alarm_type_array, key=lambda c: c.value) == sorted(self.alarm_type_array, key=lambda c: c.value):
             return
 
         # alarm_type_array are different:
@@ -112,20 +114,20 @@ class QolsysPartition(QolsysObservable):
 
         # If all alarm have been cleared
         if new_alarm_type_array == []:
-            LOGGER.debug("Partition%s (%s) - alarm_type: %s",self._id,self._name,"None")
+            LOGGER.debug("Partition%s (%s) - alarm_type: %s", self._id, self._name, "None")
             self.notify()
             return
 
         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)
+    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:
+    def append_alarm_type(self, new_alarm_type_array: list[PartitionAlarmType]) -> None:
 
         data_changed = False
 
@@ -141,47 +143,48 @@ class QolsysPartition(QolsysObservable):
         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)
+                LOGGER.debug("Partition%s (%s) - alarm_type: %s", self._id, self._name, alarm)
 
     @exit_sounds.setter
-    def exit_sounds(self,value:str) -> None:
+    def exit_sounds(self, value: str) -> None:
         if value not in self.EXIT_SOUNDS_ARRAY:
-            LOGGER.debug("Partition%s (%s) - Unknow exit_sounds %s",self._id,self._name,value)
+            LOGGER.debug("Partition%s (%s) - Unknow exit_sounds %s", self._id, self._name, value)
             return
 
         if self._exit_sounds != value:
-            LOGGER.debug("Partition%s (%s) - exit_sound: %s",self._id,self._name,value)
+            LOGGER.debug("Partition%s (%s) - exit_sound: %s", self._id, self._name, value)
             self._exit_sounds = value
             self.notify()
 
     @entry_delays.setter
-    def entry_delays(self,value:str) -> None:
+    def entry_delays(self, value: str) -> None:
         if value not in self.ENTRY_DELAYS_ARRAY:
-            LOGGER.debug("Partition%s (%s) - Unknow entry_delays %s",self._id,self._name,value)
+            LOGGER.debug("Partition%s (%s) - Unknow entry_delays %s", self._id, self._name, value)
             return
 
         if self._entry_delays != value:
-            LOGGER.debug("Partition%s (%s) - entry_delays: %s",self._id,self._name,value)
+            LOGGER.debug("Partition%s (%s) - entry_delays: %s", self._id, self._name, value)
             self._entry_delays = value
             self.notify()
 
     @command_exit_sounds.setter
-    def command_exit_sounds(self,value:str) -> None:
+    def command_exit_sounds(self, value: str) -> None:
         self._command_exit_sounds = value
-        LOGGER.debug("Partition%s (%s) - command_exit_sounds: %s",self._id,self._name,value)
+        LOGGER.debug("Partition%s (%s) - command_exit_sounds: %s", self._id, self._name, value)
         self.notify()
 
     @command_arm_stay_instant.setter
-    def command_arm_stay_instant(self,value:str) -> None:
+    def command_arm_stay_instant(self, value: str) -> None:
         self._command_arm_stay_instant = value
-        LOGGER.debug("Partition%s (%s) - arm_stay_instant: %s",self._id,self._name,value)
+        LOGGER.debug("Partition%s (%s) - arm_stay_instant: %s", self._id, self._name, value)
         self.notify()
 
-    def update_partition(self,data:dict) -> None:
+    def update_partition(self, data: dict) -> None:
         # Check if we are updating same partition_id
-        partition_id_update = data.get("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)
+            LOGGER.error(
+                "Updating Partition%s (%s) with Partition '%s' (different id)", self._id, self._name, partition_id_update)
             return
 
         self.start_batch_update()
@@ -196,7 +199,7 @@ class QolsysPartition(QolsysObservable):
 
         self.end_batch_update()
 
-    def update_settings(self,data:dict) -> None:
+    def update_settings(self, data: dict) -> None:
 
         self.start_batch_update()
 
@@ -227,8 +230,8 @@ class QolsysPartition(QolsysObservable):
 
     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,
+            "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,
         }

qolsys_controller/pki.py

@@ -2,6 +2,7 @@ import logging
 import os
 import re
 from datetime import datetime, timedelta
+from pathlib import Path
 
 from cryptography import x509
 from cryptography.hazmat.primitives import hashes, serialization
@@ -9,13 +10,15 @@ 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
+
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysPKI:
-    def __init__(self,keys_directory:str) -> None:
+    def __init__(self, settings: QolsysSettings) -> None:
         self._id = ""
-        self._keys_directory = keys_directory
-        self._subkeys_directory = ""
+        self._subkeys_directory: Path = Path
 
         self._key = None
         self._cer = None
@@ -23,6 +26,8 @@ class QolsysPKI:
         self._secure = None
         self._qolsys = None
 
+        self._settings = settings
+
     @property
     def id(self) -> str:
         return self._id
@@ -30,173 +35,176 @@ class QolsysPKI:
     def formatted_id(self) -> str:
         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(":","").upper()
-        LOGGER.debug("Using PKI: %s",self.formatted_id())
-        self._subkeys_directory = self._keys_directory + self.id + "/"
+    def set_id(self, pki_id: str) -> None:
+        self._id = pki_id.replace(":", "").upper()
+        LOGGER.debug("Using PKI: %s", self.formatted_id())
+        self._subkeys_directory = self._settings.pki_directory.joinpath(Path(self.id))
 
     @property
-    def key(self):
+    def key(self) -> str:
         return self._key
 
     @property
-    def cer(self):
+    def cer(self) -> str:
         return self._cer
 
     @property
-    def csr(self):
+    def csr(self) -> str:
         return self._csr
 
     @property
-    def secure(self):
+    def secure(self) -> str:
         return self._secure
 
     @property
-    def qolsys(self):
+    def qolsys(self) -> str:
         return self._qolsys
 
     def auto_discover_pki(self) -> bool:
         pattern = r"^[A-Fa-f0-9]{12}$"
 
         LOGGER.debug("Auto Discovery Enabled")
-        with os.scandir(self._keys_directory) as entries:
+        with os.scandir(self._settings.pki_directory) as entries:
             for entry in entries:
-                if entry.is_dir():
-                    if re.fullmatch(pattern, entry.name):
-                        self.set_id(entry.name)
-                        return True
+                if entry.is_dir() and re.fullmatch(pattern, entry.name):
+                    self.set_id(entry.name)
+                    return True
 
         return False
 
-    def load_private_key(self,key:str) -> bool:
+    def load_private_key(self, key: str) -> bool:
         try:
-            self._key = serialization.load_pem_private_key(key.encode(),password=None)
-            return True
+            self._key = serialization.load_pem_private_key(key.encode(), password=None)
         except ValueError:
             LOGGER.debug("Private Key Value Error")
             return False
 
-    def load_certificate(self,cer:str) -> bool:
+        return True
+
+    def load_certificate(self, cer: str) -> bool:
         try:
-            self._cer = x509.load_pem_x509_certificate(cer.encode(),None)
-            return True
+            self._cer = x509.load_pem_x509_certificate(cer.encode(), None)
         except ValueError:
             LOGGER.debug("Certificate Value Error")
             return False
 
-    def load_certificate_signing_request(self,csr:str) -> bool:
+        return True
+
+    def load_certificate_signing_request(self, csr: str) -> bool:
         try:
             self._csr = load_pem_x509_csr(csr.encode())
-            return True
         except ValueError:
             LOGGER.debug("Certificate Signing Request Value Error")
             return False
 
-    def load_qolsys_certificate(self,qolsys:str) -> bool:
+        return True
+
+    def load_qolsys_certificate(self, qolsys: str) -> bool:
         try:
-            self._qolsys = x509.load_pem_x509_certificate(qolsys.encode(),None)
-            return True
+            self._qolsys = x509.load_pem_x509_certificate(qolsys.encode(), None)
         except ValueError:
             LOGGER.debug("Qolsys Certificate Value Error")
             return False
 
-    def load_signed_client_certificate(self,secure:str) -> bool:
+        return True
+
+    def load_signed_client_certificate(self, secure: str) -> bool:
         try:
-            self._secure = x509.load_pem_x509_certificate(secure.encode(),None)
-            return True
+            self._secure = x509.load_pem_x509_certificate(secure.encode(), None)
         except ValueError:
             LOGGER.debug("Client Signed Certificate Value Error")
             return False
 
-    def check_key_file(self)->bool:
-        if os.path.exists(self._subkeys_directory + self.id + ".key"):
+        return True
+
+    def check_key_file(self) -> bool:
+        if self._subkeys_directory.joinpath(self.id + ".key").resolve().exists():
             LOGGER.debug("Found KEY")
             return True
         LOGGER.debug("No KEY File")
         return False
 
-    def check_cer_file(self)->bool:
-        if os.path.exists(self._subkeys_directory + self.id + ".cer"):
+    def check_cer_file(self) -> bool:
+        if self._subkeys_directory.joinpath(self.id + ".cer").resolve().exists():
             LOGGER.debug("Found CER")
             return True
         LOGGER.debug("No CER File")
         return False
 
-    def check_csr_file(self)->bool:
-        if os.path.exists(self._subkeys_directory + self.id + ".csr"):
+    def check_csr_file(self) -> bool:
+        if self._subkeys_directory.joinpath(self.id + ".csr").resolve().exists():
             LOGGER.debug("Found CSR")
             return True
         LOGGER.debug("No CSR File")
         return False
 
-    def check_secure_file(self)->bool:
-        if os.path.exists(self._subkeys_directory + self.id + ".secure"):
+    def check_secure_file(self) -> bool:
+        if self._subkeys_directory.joinpath(self.id + ".secure").resolve().exists():
             LOGGER.debug("Found Signed Client Certificate")
             return True
         LOGGER.debug("No Signed Client Certificate File")
         return False
 
-    def check_qolsys_cer_file(self)->bool:
-        if os.path.exists(self._subkeys_directory  + self.id + ".qolsys"):
+    def check_qolsys_cer_file(self) -> bool:
+        if self._subkeys_directory.joinpath(self.id + ".qolsys").resolve().exists():
             LOGGER.debug("Found Qolsys Certificate")
             return True
-
         LOGGER.debug("No Qolsys Certificate File")
         return False
 
     @property
-    def key_file_path(self) -> str:
-        return self._subkeys_directory + self.id + ".key"
+    def key_file_path(self) -> Path:
+        return self._subkeys_directory.joinpath(self.id + ".key")
 
     @property
     def csr_file_path(self) -> str:
-        return self._subkeys_directory + self.id + ".csr"
+        return self._subkeys_directory.joinpath(self.id + ".csr")
 
     @property
     def cer_file_path(self) -> str:
-        return self._subkeys_directory + self.id + ".cer"
+        return self._subkeys_directory.joinpath(self.id + ".cer")
 
     @property
     def secure_file_path(self) -> str:
-        return self._subkeys_directory + self.id + ".secure"
+        return self._subkeys_directory.joinpath(self.id + ".secure")
 
     @property
     def qolsys_cer_file_path(self) -> str:
-        return self._subkeys_directory + self.id + ".qolsys"
+        return self._subkeys_directory.joinpath(self.id + ".qolsys")
 
-    def create(self,mac:str,key_size:int)->bool:
+    def create(self, mac: str, key_size: int) -> bool:
 
         self.set_id(mac)
 
         # Check if directory exist
-        if os.path.exists(self._subkeys_directory + self.id + ".key"):
+        if self._subkeys_directory.resolve().exists():
             LOGGER.error("Create Directory Colision")
             return False
 
         # Check for private key colision
-        if os.path.exists(self._subkeys_directory + self.id + ".key"):
+        if self._subkeys_directory.joinpath(self.id + ".key").resolve().exists():
             LOGGER.error("Create KEY File Colision")
             return False
 
         # Check for CER file colision
-        if os.path.exists(self._subkeys_directory + self.id + ".cer"):
+        if self._subkeys_directory.joinpath(self.id + ".cer").resolve().exists():
             LOGGER.error("Create CER File Colision")
             return False
 
         # Check for CSR file colision
-        if os.path.exists(self._subkeys_directory + self.id + ".csr"):
+        if self._subkeys_directory.joinpath(self.id + ".csr").resolve().exists():
             LOGGER.error("Create CSR File Colision")
             return False
 
         # Check for CER file colision
-        if os.path.exists(self._subkeys_directory + self.id + ".secure"):
+        if self._subkeys_directory.joinpath(self.id + ".secure").resolve().exists():
             LOGGER.error("Create Signed Certificate File Colision")
             return False
 
-        LOGGER.debug("Creating PKI:  %s",mac)
+        LOGGER.debug("Creating PKI:  %s", self.formatted_id())
 
         LOGGER.debug("Creating PKI Directory")
-        os.makedirs(self._subkeys_directory)
+        self._subkeys_directory.resolve().mkdir(parents=True)
 
         LOGGER.debug("Creating KEY")
         private_key = rsa.generate_private_key(public_exponent=65537,
@@ -204,8 +212,8 @@ class QolsysPKI:
         private_pem = private_key.private_bytes(encoding=serialization.Encoding.PEM,
                                                 format=serialization.PrivateFormat.PKCS8,
                                                 encryption_algorithm=serialization.NoEncryption())
-        with open(self._subkeys_directory + self.id + ".key", "wb") as f:
-            f.write(private_pem)
+        with self._subkeys_directory.joinpath(self.id + ".key").open("wb") as file:
+            file.write(private_pem)
 
         LOGGER.debug("Creating CER")
         subject = issuer = x509.Name([
@@ -214,7 +222,7 @@ class QolsysPKI:
             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(
@@ -232,20 +240,19 @@ class QolsysPKI:
         ).sign(private_key, hashes.SHA256())
         cert_pem = cert.public_bytes(encoding=serialization.Encoding.PEM)
 
-        with open(self._subkeys_directory + self._file_prefix + ".cer" , "wb") as f:
-            f.write(cert_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
+            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)
-        with open(self._subkeys_directory + self.id + ".csr", "wb") as f:
-            f.write(csr_pem)
+        with self._subkeys_directory.joinpath(self.id + ".csr").open("wb") as file:
+            file.write(csr_pem)
 
         return True
-

qolsys_controller/plugin.py

@@ -7,12 +7,13 @@ from .state import QolsysState
 
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysPlugin:
-    def __init__(self,state:QolsysState,panel:QolsysPanel,settings:QolsysSettings) -> None:
+    def __init__(self, state: QolsysState, panel: QolsysPanel, settings: QolsysSettings) -> None:
 
-        self._state = state
-        self._panel = panel
-        self._settings = settings
+        self._state: QolsysState = state
+        self._panel: QolsysPanel = panel
+        self._settings: QolsysSettings = settings
 
         self.connected = False
         self.connected_observer = QolsysObservable()

qolsys_controller/plugin_c4.py

@@ -4,15 +4,14 @@ from .plugin import QolsysPlugin
 
 LOGGER = logging.getLogger(__name__)
 
-class QolsysPluginC4(QolsysPlugin):
-        def __init__(self) -> None:
-
-                # C4 Integration
-                self._token = ""
 
-        def config(self,panel_ip:str,token:str) -> bool:
-                LOGGER.warning("C4Plugin: Configuring Plugin")
-                super().config()
-                return True
+class QolsysPluginC4(QolsysPlugin):
+    def __init__(self) -> None:
 
+        # C4 Integration
+        self._token = ""
 
+    def config(self, panel_ip: str, token: str) -> bool:  # noqa: ARG002
+        LOGGER.warning("C4Plugin: Configuring Plugin")
+        super().config()
+        return True