chore: Implement code review suggestions and format code.

leggend/services/notification_service.py

@@ -10,7 +10,9 @@ class NotificationService:
         self.notifications_config = config.notifications_config
         self.filters_config = config.filters_config
 
-    async def send_transaction_notifications(self, transactions: List[Dict[str, Any]]) -> None:
+    async def send_transaction_notifications(
+        self, transactions: List[Dict[str, Any]]
+    ) -> None:
         """Send notifications for new transactions that match filters"""
         if not self.filters_config:
             logger.info("No notification filters configured, skipping notifications")
@@ -18,7 +20,7 @@ class NotificationService:
 
         # Filter transactions that match notification criteria
         matching_transactions = self._filter_transactions(transactions)
-        
+
         if not matching_transactions:
             logger.info("No transactions matched notification filters")
             return
@@ -26,7 +28,7 @@ class NotificationService:
         # Send to enabled notification services
         if self._is_discord_enabled():
             await self._send_discord_notifications(matching_transactions)
-            
+
         if self._is_telegram_enabled():
             await self._send_telegram_notifications(matching_transactions)
 
@@ -40,7 +42,9 @@ class NotificationService:
                 await self._send_telegram_test(message)
                 return True
             else:
-                logger.error(f"Notification service '{service}' not enabled or not found")
+                logger.error(
+                    f"Notification service '{service}' not enabled or not found"
+                )
                 return False
         except Exception as e:
             logger.error(f"Failed to send test notification to {service}: {e}")
@@ -50,54 +54,66 @@ class NotificationService:
         """Send notification about account expiry"""
         if self._is_discord_enabled():
             await self._send_discord_expiry(notification_data)
-            
+
         if self._is_telegram_enabled():
             await self._send_telegram_expiry(notification_data)
 
-    def _filter_transactions(self, transactions: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _filter_transactions(
+        self, transactions: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
         """Filter transactions based on notification criteria"""
         matching = []
         filters_case_insensitive = self.filters_config.get("case-insensitive", {})
-        
+
         for transaction in transactions:
             description = transaction.get("description", "").lower()
-            
+
             # Check case-insensitive filters
             for filter_name, filter_value in filters_case_insensitive.items():
                 if filter_value.lower() in description:
-                    matching.append({
-                        "name": transaction["description"],
-                        "value": transaction["transactionValue"], 
-                        "currency": transaction["transactionCurrency"],
-                        "date": transaction["transactionDate"],
-                    })
+                    matching.append(
+                        {
+                            "name": transaction["description"],
+                            "value": transaction["transactionValue"],
+                            "currency": transaction["transactionCurrency"],
+                            "date": transaction["transactionDate"],
+                        }
+                    )
                     break
-        
+
         return matching
 
     def _is_discord_enabled(self) -> bool:
         """Check if Discord notifications are enabled"""
         discord_config = self.notifications_config.get("discord", {})
-        return bool(discord_config.get("webhook") and discord_config.get("enabled", True))
+        return bool(
+            discord_config.get("webhook") and discord_config.get("enabled", True)
+        )
 
     def _is_telegram_enabled(self) -> bool:
         """Check if Telegram notifications are enabled"""
         telegram_config = self.notifications_config.get("telegram", {})
         return bool(
-            telegram_config.get("token") and 
-            telegram_config.get("chat_id") and 
-            telegram_config.get("enabled", True)
+            telegram_config.get("token")
+            and telegram_config.get("chat_id")
+            and telegram_config.get("enabled", True)
         )
 
-    async def _send_discord_notifications(self, transactions: List[Dict[str, Any]]) -> None:
+    async def _send_discord_notifications(
+        self, transactions: List[Dict[str, Any]]
+    ) -> None:
         """Send Discord notifications - placeholder implementation"""
         # Would import and use leggen.notifications.discord
         logger.info(f"Sending {len(transactions)} transaction notifications to Discord")
 
-    async def _send_telegram_notifications(self, transactions: List[Dict[str, Any]]) -> None:
+    async def _send_telegram_notifications(
+        self, transactions: List[Dict[str, Any]]
+    ) -> None:
         """Send Telegram notifications - placeholder implementation"""
         # Would import and use leggen.notifications.telegram
-        logger.info(f"Sending {len(transactions)} transaction notifications to Telegram")
+        logger.info(
+            f"Sending {len(transactions)} transaction notifications to Telegram"
+        )
 
     async def _send_discord_test(self, message: str) -> None:
         """Send Discord test notification"""
@@ -113,4 +129,4 @@ class NotificationService:
 
     async def _send_telegram_expiry(self, notification_data: Dict[str, Any]) -> None:
         """Send Telegram expiry notification"""
-        logger.info(f"Sending Telegram expiry notification: {notification_data}")
+        logger.info(f"Sending Telegram expiry notification: {notification_data}")