- ruff/mypy fixes

- added example users in db - test/alice, location - test_data.py

Author: HardMax71

chat/api_client.py

@@ -4,7 +4,8 @@
 import queue
 import threading
 import time
-from datetime import datetime, timedelta, timezone
+from contextlib import suppress
+from datetime import UTC, datetime, timedelta
 
 import keyring
 import pytz
@@ -40,7 +41,7 @@ def __init__(self, base_url):
             self.logger.addHandler(handler)
 
         REDIS_HOST = os.environ.get("REDIS_HOST", "localhost")
-        REDIS_PORT = int(os.environ.get("REDIS_PORT", 6379))
+        REDIS_PORT = int(os.environ.get("REDIS_PORT", "6379"))
 
         # Initialize Redis client with error handling
         try:
@@ -68,7 +69,7 @@ def __init__(self, base_url):
             )
         except redis.ConnectionError as e:
             self.logger.error(
-                f"Unable to connect to Redis at {REDIS_HOST}:{REDIS_PORT}.\nERROR: {str(e)}"
+                f"Unable to connect to Redis at {REDIS_HOST}:{REDIS_PORT}.\nERROR: {e!s}"
             )
             self.redis_client = None
             self.pubsub = None
@@ -104,7 +105,7 @@ def _load_stored_tokens(self):
                     self.token_expiry = None
 
         except Exception as e:
-            self.logger.error(f"Error loading stored tokens: {str(e)}")
+            self.logger.error(f"Error loading stored tokens: {e!s}")
             # If there's an error, start with clean slate
             self.access_token = None
             self.refresh_token = None
@@ -142,26 +143,20 @@ def _store_tokens(self, access_token=None, refresh_token=None, token_expiry=None
                     self.logger.info("Removed stored token expiry")
 
         except Exception as e:
-            self.logger.error(f"Error storing tokens: {str(e)}")
+            self.logger.error(f"Error storing tokens: {e!s}")
 
     def _clear_stored_tokens(self):
         """
         Clears all stored tokens from secure storage.
         """
-        try:
+        with suppress(keyring.errors.PasswordDeleteError):
             keyring.delete_password("flet-chat", "access_token")
-        except keyring.errors.PasswordDeleteError:
-            pass  # Token doesn't exist
 
-        try:
+        with suppress(keyring.errors.PasswordDeleteError):
             keyring.delete_password("flet-chat", "refresh_token")
-        except keyring.errors.PasswordDeleteError:
-            pass  # Token doesn't exist
 
-        try:
+        with suppress(keyring.errors.PasswordDeleteError):
             keyring.delete_password("flet-chat", "token_expiry")
-        except keyring.errors.PasswordDeleteError:
-            pass  # Token doesn't exist
 
         self.logger.info("Cleared all stored tokens")
 
@@ -175,7 +170,7 @@ def is_authenticated(self):
 
         # Check if token is expired (with 5 minute buffer)
         if self.token_expiry:
-            current_time = datetime.now(timezone.utc)
+            current_time = datetime.now(UTC)
             if current_time >= self.token_expiry - timedelta(minutes=5):
                 return False
 
@@ -197,13 +192,13 @@ def _listen_to_pubsub(self):
                         self.message_queue.put({"channel": channel, "data": data})
             except redis.ConnectionError as e:
                 self.logger.error(
-                    f"Redis connection error: {str(e)}. Attempting to reconnect in 5 seconds..."
+                    f"Redis connection error: {e!s}. Attempting to reconnect in 5 seconds..."
                 )
                 time.sleep(5)  # Wait before reconnecting
                 self._reconnect_redis()
             except Exception as e:
                 self.logger.error(
-                    f"Unexpected error in pubsub listener: {str(e)}. Continuing..."
+                    f"Unexpected error in pubsub listener: {e!s}. Continuing..."
                 )
 
     def _process_messages(self):
@@ -221,7 +216,7 @@ def _process_messages(self):
                     callback(data)
                 except Exception as e:
                     self.logger.error(
-                        f"Error in callback for channel '{channel}': {str(e)}"
+                        f"Error in callback for channel '{channel}': {e!s}"
                     )
 
     def _handle_response(self, response):
@@ -278,7 +273,7 @@ def _refresh_token(self):
                 self._clear_stored_tokens()
                 return False
         except Exception as e:
-            self.logger.error(f"Exception during token refresh: {str(e)}")
+            self.logger.error(f"Exception during token refresh: {e!s}")
             return False
 
     def _request(self, method, endpoint, auth_required=True, **kwargs):
@@ -289,15 +284,17 @@ def _request(self, method, endpoint, auth_required=True, **kwargs):
         headers = kwargs.get("headers", {})
 
         if auth_required:
-            current_time = datetime.now(timezone.utc)
-            if not self.access_token or (
-                self.token_expiry
-                and current_time >= self.token_expiry - timedelta(minutes=5)
-            ):
-                if not self._refresh_token():
-                    return ApiResponse(
-                        False, error="Failed to refresh token. Please log in again."
+            current_time = datetime.now(UTC)
+            if (
+                    not self.access_token
+                    or (
+                            self.token_expiry
+                            and current_time >= self.token_expiry - timedelta(minutes=5)
                     )
+            ) and not self._refresh_token():
+                return ApiResponse(
+                    False, error="Failed to refresh token. Please log in again."
+                )
 
             headers["Authorization"] = f"Bearer {self.access_token}"
             kwargs["headers"] = headers
@@ -307,9 +304,9 @@ def _request(self, method, endpoint, auth_required=True, **kwargs):
             api_response = self._handle_response(response)
 
             if (
-                not api_response.success
-                and api_response.status_code == 401
-                and "Could not validate credentials" in (api_response.error or "")
+                    not api_response.success
+                    and api_response.status_code == 401
+                    and "Could not validate credentials" in (api_response.error or "")
             ):
                 self.logger.warning(
                     "Received 401 Unauthorized. Attempting to refresh token."
@@ -322,7 +319,7 @@ def _request(self, method, endpoint, auth_required=True, **kwargs):
 
             return api_response
         except Exception as e:
-            self.logger.error(f"HTTP request exception: {str(e)}")
+            self.logger.error(f"HTTP request exception: {e!s}")
             return ApiResponse(False, error=str(e))
 
     def subscribe_to_channel(self, channel_name, callback):
@@ -372,15 +369,15 @@ def _handle_redis_message(self, message):
                     self.subscriptions[channel](data)
                 except Exception as e:
                     self.logger.error(
-                        f"Error in callback for channel '{channel}': {str(e)}"
+                        f"Error in callback for channel '{channel}': {e!s}"
                     )
 
     def _reconnect_redis(self):
         """
         Attempts to reconnect to Redis and resubscribe to channels.
         """
         REDIS_HOST = os.environ.get("REDIS_HOST", "localhost")
-        REDIS_PORT = int(os.environ.get("REDIS_PORT", 6379))
+        REDIS_PORT = int(os.environ.get("REDIS_PORT", "6379"))
         try:
             self.redis_client = redis.Redis(
                 host=REDIS_HOST,
@@ -392,13 +389,13 @@ def _reconnect_redis(self):
             self.redis_client.ping()
             self.pubsub = self.redis_client.pubsub()
             # Resubscribe to existing channels
-            for channel in self.subscriptions.keys():
+            for channel in self.subscriptions:
                 self.pubsub.subscribe(**{channel: self._handle_redis_message})
                 self.logger.info(f"Resubscribed to Redis channel '{channel}'")
             self.logger.info(f"Reconnected to Redis at {REDIS_HOST}:{REDIS_PORT}")
         except redis.ConnectionError as e:
             self.logger.error(
-                f"Failed to reconnect to Redis: {str(e)}. Will retry in 5 seconds."
+                f"Failed to reconnect to Redis: {e!s}. Will retry in 5 seconds."
             )
             time.sleep(5)
             self._reconnect_redis()

chat/app.py

@@ -1,7 +1,6 @@
-import json
 import logging
 import os
-from typing import Dict, Any, Union
+from typing import Any
 
 import flet as ft
 
@@ -10,7 +9,7 @@
 from .chat_screen import ChatScreen
 from .login_screen import LoginScreen
 from .register_screen import RegisterScreen
-from .state_manager import StateManager, AppState, StateEvent
+from .state_manager import AppState, StateEvent, StateManager
 from .user_profile_screen import UserProfileScreen
 
 
@@ -48,11 +47,11 @@ def __init__(self, page: ft.Page) -> None:
         else:
             self.show_login()
 
-    def _on_user_logged_in(self, data: Dict[str, Any]) -> None:
+    def _on_user_logged_in(self, data: dict[str, Any]) -> None:
         self.logger.info("User logged in, updating UI")
         # UI will be updated by screens subscribing to state changes
 
-    def _on_user_logged_out(self, data: Dict[str, Any]) -> None:
+    def _on_user_logged_out(self, data: dict[str, Any]) -> None:
         self.logger.info("User logged out, showing login screen")
         self.show_login()
 
@@ -88,7 +87,7 @@ def show_user_profile(self) -> None:
         screen.build()
         self.switch_screen(screen)
 
-    def handle_successful_login(self, user_data: Dict[str, Any]) -> None:
+    def handle_successful_login(self, user_data: dict[str, Any]) -> None:
         self.logger.info(
             f"Handling successful login for user: {user_data.get('username', 'Unknown')}"
         )
@@ -106,7 +105,7 @@ def refresh_chats(self) -> bool:
     def show_error_dialog(self, title: str, error: Any) -> None:
         """Display an error dialog, converting any error to string."""
 
-        def close_dlg(e: ft.ControlEvent) -> None:
+        def close_dlg(_: ft.ControlEvent) -> None:
             self.page.close(dlg)
 
         dlg = ft.AlertDialog(

chat/chat_screen.py

@@ -425,18 +425,17 @@ def process_new_message(self, data):
                 # Update existing message (e.g., edited or status changed)
                 self.update_message_in_list(existing_message_row, message)
                 self.logger.info(f"Updated existing message {message['id']} in UI")
-            else:
+            elif message["user"]["id"] != self.current_user_id:
                 # Add new message only if it's not from the current user
                 # (current user's messages are added immediately in send_message)
-                if message["user"]["id"] != self.current_user_id:
-                    self.add_message_to_list(message)
-                    self.logger.info(
-                        f"Added new message {message['id']} from other user to UI"
-                    )
-                else:
-                    self.logger.info(
-                        f"Skipping message {message['id']} from current user (already added)"
-                    )
+                self.add_message_to_list(message)
+                self.logger.info(
+                    f"Added new message {message['id']} from other user to UI"
+                )
+            else:
+                self.logger.info(
+                    f"Skipping message {message['id']} from current user (already added)"
+                )
 
             # Only auto-scroll if user is at bottom
             if self._should_auto_scroll():
@@ -452,7 +451,7 @@ def process_new_message(self, data):
         except json.JSONDecodeError:
             self.logger.error(f"Failed to decode message: {data}")
         except Exception as e:
-            self.logger.error(f"Error processing new message: {str(e)}")
+            self.logger.error(f"Error processing new message: {e!s}")
 
     def update_message_in_list(self, existing_message_row, updated_message):
         """
@@ -479,8 +478,6 @@ def update_message_in_list(self, existing_message_row, updated_message):
         ):
             return
 
-        # [ Text(username), Text(message_content), time_info_row ]
-        # user_text = column_content.controls[0]   # ft.Text(username)
         message_text = column_content.controls[1]  # ft.Text(content or <deleted>)
         time_info = column_content.controls[2]  # ft.Row([... time info ...])
 

chat/login_screen.py

@@ -1,5 +1,6 @@
 import logging
 import re
+
 import flet as ft
 
 

chat/register_screen.py

@@ -261,7 +261,7 @@ def show_success_dialog(self):
         """
         self.logger.info("Showing registration success dialog")
 
-        def close_dlg(e):
+        def close_dlg(_):
             self.chat_app.page.close(dlg)
             self.chat_app.show_login()