Fix typing, format issues

Author: AdityaMitra5102

nitrokeyapp/secrets_tab/__init__.py

@@ -319,11 +319,9 @@ def backup_credentials(self) -> None:
     @Slot(str)
     def save_credential_backup(self, credential_list_formatted: str) -> None:
         from PySide6.QtWidgets import QFileDialog
+
         path, _ = QFileDialog.getSaveFileName(
-            self,
-            "Save Credential Backup",
-            "credential_backup.json",
-            "JSON Files (*.json)",
+            self, "Save Credential Backup", "credential_backup.json", "JSON Files (*.json)"
         )
         if path:
             with open(path, "w") as f:
@@ -334,11 +332,9 @@ def restore_credentials(self) -> None:
         if not self.data:
             return
         from PySide6.QtWidgets import QFileDialog
+
         path, _ = QFileDialog.getOpenFileName(
-            self,
-            "Open Credential Backup",
-            "",
-            "JSON Files (*.json)",
+            self, "Open Credential Backup", "", "JSON Files (*.json)"
         )
         if not path:
             return

nitrokeyapp/secrets_tab/data.py

@@ -1,4 +1,4 @@
-from base64 import b64encode, b64decode
+from base64 import b64decode, b64encode
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum, auto, unique
@@ -75,6 +75,7 @@ def _kind_from_raw(kind: RawKind) -> Optional[Kind]:
     else:
         raise RuntimeError(f"Unexpected credential kind: {kind}")
 
+
 @dataclass
 class Credential:
     id: bytes
@@ -129,39 +130,45 @@ def extend_with_password_safe_entry(self, item: PasswordSafeEntry) -> "Credentia
     def serialize_credential(self) -> dict:
         if not self.loaded:
             raise RuntimeError("Cannot serialize credential which is not loaded yet")
-        credential_dict={
-            "id" : b64encode(self.id).decode(),
-            "kind" : self.otp.raw_kind().value if self.otp else self.other.raw_kind().value if self.other else RawKind.NotSet.value,
-            "login" : b64encode(self.login).decode() if self.login else "",
-            "password" : b64encode(self.password).decode() if self.password else "",
-            "comment" : b64encode(self.comment).decode() if self.comment else "",
-            "protected" : self.protected,
-            "touch_required" : self.touch_required
+        credential_dict = {
+            "id": b64encode(self.id).decode(),
+            "kind": self.otp.raw_kind().value
+            if self.otp
+            else self.other.raw_kind().value
+            if self.other
+            else RawKind.NotSet.value,
+            "login": b64encode(self.login).decode() if self.login else "",
+            "password": b64encode(self.password).decode() if self.password else "",
+            "comment": b64encode(self.comment).decode() if self.comment else "",
+            "protected": self.protected,
+            "touch_required": self.touch_required,
         }
         return credential_dict
 
     @classmethod
     def deserialize_credential(cls, credential_dict: dict) -> "Credential":
-        login=credential_dict.get("login", "")
-        password=credential_dict.get("password", "")
-        comment=credential_dict.get("comment", "")
+        id = credential_dict.get("id", "")
+        login = credential_dict.get("login", "")
+        password = credential_dict.get("password", "")
+        comment = credential_dict.get("comment", "")
         credential = cls(
-            id=b64decode(credential_dict.get("id")),
-            login=b64decode(login) if login else None
-            password=b64decode(password) if password else None
-            comment=b64decode(comment) if comment else None
+            id=id,
+            login=b64decode(login) if login else None,
+            password=b64decode(password) if password else None,
+            comment=b64decode(comment) if comment else None,
             protected=credential_dict.get("protected", False),
-            touch_required=credential_dict.get("touch_required", False)
+            touch_required=credential_dict.get("touch_required", False),
         )
 
-        kind= _kind_from_raw(RawKind(credential_dict.get("kind")))
+        kind = _kind_from_raw(RawKind(credential_dict.get("kind")))
         if isinstance(kind, OtpKind):
             credential.otp = kind
         elif isinstance(kind, OtherKind):
             credential.other = kind
 
         return credential
 
+
 @dataclass
 class OtpData:
     otp: str

nitrokeyapp/secrets_tab/worker.py

@@ -1,8 +1,8 @@
+import json
 import logging
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Dict, Optional
-import json
 
 from nitrokey.nk3 import NK3
 from nitrokey.nk3.secrets_app import SecretsApp, SecretsAppException
@@ -620,6 +620,7 @@ def get_credential(self) -> None:
             cred = self.credential.extend_with_password_safe_entry(pse)
             self.received_credential.emit(cred)
 
+
 class BackupCredentialJob(Job):
     credential_bkp = Signal(str)
 
@@ -629,14 +630,14 @@ def __init__(
         pin_cache: PinCache,
         pin_ui: PinUi,
         data: DeviceData,
-        pin_protected: bool
+        pin_protected: bool,
     ) -> None:
         super().__init__(common_ui)
 
         self.pin_cache = pin_cache
         self.pin_ui = pin_ui
         self.data = data
-        self.pin_protected=pin_protected
+        self.pin_protected = pin_protected
         self.credential_bkp.connect(lambda _: self.finished.emit())
 
     def run(self) -> None:
@@ -657,12 +658,12 @@ def get_credential_backup(self) -> None:
                 return
             secrets = SecretsApp(device)
 
-            credential_list=Credential.list(secrets=secrets)
-            credential_list_serialized=[]
+            credential_list = Credential.list(secrets=secrets)
+            credential_list_serialized = []
             for credential in credential_list:
                 try:
                     if credential.protected:
-                        pin= self.pin_cache.get(self.data)
+                        pin = self.pin_cache.get(self.data)
                         if pin:
                             secrets.verify_pin_raw(pin)
                     pse = secrets.get_credential(credential.id)
@@ -676,9 +677,10 @@ def get_credential_backup(self) -> None:
                 except SecretsAppException as e:
                     self.trigger_exception(e)
 
-            credential_list_formatted=json.dumps(credential_list_serialized, indent=4)
+            credential_list_formatted = json.dumps(credential_list_serialized, indent=4)
             self.credential_bkp.emit(credential_list_formatted)
 
+
 class RestoreCredentialJob(Job):
     credential_restore = Signal()
 
@@ -688,14 +690,14 @@ def __init__(
         pin_cache: PinCache,
         pin_ui: PinUi,
         data: DeviceData,
-        credential_backup: str
+        credential_backup: str,
     ) -> None:
         super().__init__(common_ui)
 
         self.pin_cache = pin_cache
         self.pin_ui = pin_ui
         self.data = data
-        self.credential_backup=credential_backup
+        self.credential_backup = credential_backup
         self.credential_restore.connect(lambda: self.finished.emit())
 
     def run(self) -> None:
@@ -708,37 +710,33 @@ def run(self) -> None:
     @Slot(list)
     def check_credential_backup(self, existing_credentials: list[Credential]) -> None:
         try:
-            serialized_credential_list=json.loads(self.credential_backup)
+            serialized_credential_list = json.loads(self.credential_backup)
         except json.JSONDecodeError as e:
-            self.trigger_error('Error: Invalid backup file')
-        credential_list=[]
+            self.trigger_exception(e)
+        credential_list = []
         for serialized_credential in serialized_credential_list:
             try:
                 credential = Credential.deserialize_credential(serialized_credential)
                 credential_list.append(credential)
             except SecretsAppException as e:
                 self.trigger_exception(e)
 
-        pin_required=False
+        pin_required = False
         ids = {credential.id for credential in existing_credentials}
-        temp_cred_list=[]
+        temp_cred_list = []
         for credential in credential_list:
             if credential.id in ids:
                 logger.warning("Warn: Credential with same ID already exists")
             else:
                 temp_cred_list.append(credential)
 
             if credential.protected:
-                pin_required=True
+                pin_required = True
 
-        self.credential_list=temp_cred_list
+        self.credential_list = temp_cred_list
         if pin_required:
             verify_pin_job = VerifyPinJob(
-                self.common_ui,
-                self.pin_cache,
-                self.pin_ui,
-                self.data,
-                set_pin=pin_required,
+                self.common_ui, self.pin_cache, self.pin_ui, self.data, set_pin=pin_required
             )
             verify_pin_job.pin_verified.connect(self.add_credential)
             self.spawn(verify_pin_job)
@@ -776,6 +774,7 @@ def add_credential(self, successful: bool = True) -> None:
 
         self.credential_restore.emit()
 
+
 class SecretsWorker(Worker):
     # TODO: remove DeviceData from signatures
 
@@ -852,7 +851,7 @@ def backup_credential(self, data: DeviceData, pin_protected: bool) -> None:
         self.run(job)
 
     @Slot(DeviceData, str)
-    def restore_credential(self, data:DeviceData, backup_conent: str) -> None:
+    def restore_credential(self, data: DeviceData, backup_conent: str) -> None:
         job = RestoreCredentialJob(self.common_ui, self.pin_cache, self.pin_ui, data, backup_conent)
         job.credential_restore.connect(self.credential_restore)
         self.run(job)