Remove inline comments and extra whitespace

Author: Nakshatra Sharma

backend/app/config/settings.py

@@ -20,6 +20,4 @@
 DATABASE_PATH = "app/database/PictoPy.db"
 THUMBNAIL_IMAGES_PATH = "./images/thumbnails"
 IMAGES_PATH = "./images"
-
-# Backend API URL (used by watcher to call backend endpoints)
 BACKEND_URL = "http://localhost:52123"

backend/app/utils/API.py

@@ -2,7 +2,6 @@
 
 logger = logging.getLogger(__name__)
 
-
 def API_util_restart_sync_microservice_watcher():
     """
     Restart the folder watcher (now integrated into the backend).
@@ -11,18 +10,14 @@ def API_util_restart_sync_microservice_watcher():
         bool: True if restart was successful, False otherwise
     """
     try:
-        # Import here to avoid circular dependencies
         from app.utils.watcher import watcher_util_restart_folder_watcher
-        
         success = watcher_util_restart_folder_watcher()
-        
         if success:
             logger.info("Successfully restarted folder watcher")
             return True
         else:
             logger.warning("Failed to restart folder watcher")
             return False
-
     except Exception as e:
         logger.error(f"Unexpected error restarting folder watcher: {e}")
         return False

backend/app/utils/watcher.py

@@ -9,7 +9,6 @@
 from app.config.settings import *
 from app.logging.setup_logging import get_logger
 
-# Configure third-party loggers
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("httpcore").setLevel(logging.WARNING)
 logging.getLogger("watchfiles").setLevel(logging.WARNING)  # Silence watchfiles logger
@@ -21,7 +20,6 @@
 
 FolderIdPath = Tuple[str, str]
 
-# Global variables to track watcher state
 watcher_thread: Optional[threading.Thread] = None
 stop_event = threading.Event()
 watched_folders: List[FolderIdPath] = []
@@ -38,10 +36,8 @@ def watcher_util_get_folder_id_if_watched(file_path: str) -> Optional[str]:
     Returns:
         Folder ID if the path is a watched folder, None otherwise
     """
-    # Normalize the file path
     normalized_path = os.path.abspath(file_path)
 
-    # Check if this path matches any of our watched folders
     for folder_id, folder_path in watched_folders:
         if os.path.abspath(folder_path) == normalized_path:
             return folder_id
@@ -60,28 +56,23 @@ def watcher_util_handle_file_changes(changes: set) -> None:
 
     affected_folders = {}  # folder_path -> folder_id mapping
 
-    # First pass - count changes and identify affected folders
     for change, file_path in changes:
-        # Process deletions
         if change == Change.deleted:
             deleted_folder_id = watcher_util_get_folder_id_if_watched(file_path)
             if deleted_folder_id:
                 deleted_folder_ids.append(deleted_folder_id)
                 continue
 
-        # Find affected folder
         closest_folder = watcher_util_find_closest_parent_folder(
             file_path, watched_folders
         )
         if closest_folder:
             folder_id, folder_path = closest_folder
             affected_folders[folder_path] = folder_id
 
-    # Process affected folders
     for folder_path, folder_id in affected_folders.items():
         watcher_util_call_sync_folder_api(folder_id, folder_path)
 
-    # Handle deleted folders
     if deleted_folder_ids:
         logger.info(f"Processing {len(deleted_folder_ids)} deleted folders")
         watcher_util_call_delete_folders_api(deleted_folder_ids)
@@ -101,21 +92,16 @@ def watcher_util_find_closest_parent_folder(
     Returns:
         Tuple of (folder_id, folder_path) if found, None otherwise
     """
-    # Normalize the file path
     file_path = os.path.abspath(file_path)
 
     best_match = None
     longest_match_length = 0
 
     for folder_id, folder_path in watched_folders:
-        # Normalize the folder path
         folder_path = os.path.abspath(folder_path)
 
-        # Check if this folder is a parent of the file
         if file_path.startswith(folder_path):
-            # Ensure it's a proper parent (not just a prefix)
             if file_path == folder_path or file_path[len(folder_path)] == os.sep:
-                # Choose the longest matching path (closest parent)
                 if len(folder_path) > longest_match_length:
                     longest_match_length = len(folder_path)
                     best_match = (folder_id, folder_path)
@@ -132,7 +118,6 @@ def watcher_util_call_sync_folder_api(folder_id: str, folder_path: str) -> None:
         folder_path: Path of the folder to sync
     """
     try:
-        # Import settings here to avoid circular dependencies
         from app.config.settings import BACKEND_URL
         url = f"{BACKEND_URL}/folders/sync-folder"
         payload = {"folder_path": folder_path, "folder_id": folder_id}
@@ -163,7 +148,6 @@ def watcher_util_call_delete_folders_api(folder_ids: List[str]) -> None:
         folder_ids: List of folder IDs to delete
     """
     try:
-        # Import settings here to avoid circular dependencies
         from app.config.settings import BACKEND_URL
         url = f"{BACKEND_URL}/folders/delete-folders"
         payload = {"folder_ids": folder_ids}
@@ -202,13 +186,11 @@ def watcher_util_watcher_worker(folder_paths: List[str]) -> None:
                 logger.info("Stop event detected in watcher loop")
                 break
 
-            # Log changes at debug level before processing
             if logger.isEnabledFor(10):  # DEBUG level is 10
                 from app.utils.watcher_helpers import format_debug_changes
 
                 logger.debug("Detailed changes:\n %s", format_debug_changes(changes))
 
-            # Process changes
             watcher_util_handle_file_changes(changes)
     except Exception as e:
         logger.error(f"Error in watcher worker: {e}")
@@ -259,11 +241,8 @@ def watcher_util_start_folder_watcher() -> bool:
     logger.debug("Debug logging is enabled")
 
     try:
-        # Get all folder details from database
-        # db_get_all_folder_details returns: List[Tuple[folder_id, folder_path, parent_folder_id, last_modified_time, AI_Tagging, taggingCompleted]]
         all_folder_details = db_get_all_folder_details()
 
-        # Extract just folder_id and folder_path (first two elements of tuple)
         folders = [(folder_id, folder_path) for folder_id, folder_path, *_ in all_folder_details]
 
         if not folders:
@@ -272,7 +251,6 @@ def watcher_util_start_folder_watcher() -> bool:
 
         logger.info(f"Found {len(folders)} folders in database")
 
-        # Simple synchronous file system checks
         existing_folders = watcher_util_get_existing_folders(folders)
         if not existing_folders:
             logger.info("No existing folders to watch")
@@ -289,7 +267,6 @@ def watcher_util_start_folder_watcher() -> bool:
         for folder_id, folder_path in existing_folders:
             logger.info(f"  - {folder_path} (ID: {folder_id})")
 
-        # Reset stop event and start background thread
         stop_event.clear()
         watcher_thread = threading.Thread(
             target=watcher_util_watcher_worker,
@@ -317,10 +294,8 @@ def watcher_util_stop_folder_watcher() -> None:
     try:
         logger.info("Stopping folder watcher...")
 
-        # Signal the watcher to stop
         stop_event.set()
 
-        # Wait for thread to finish
         watcher_thread.join(timeout=5.0)
 
         if watcher_thread.is_alive():
@@ -332,7 +307,6 @@ def watcher_util_stop_folder_watcher() -> None:
         logger.error(f"Error stopping watcher: {e}")
     finally:
         watcher_thread = None
-        # Clear state
         watched_folders = []
         folder_id_map = {}
 

backend/main.py

@@ -52,22 +52,17 @@ async def lifespan(app: FastAPI):
     db_create_albums_table()
     db_create_album_images_table()
     db_create_metadata_table()
-    # Create ProcessPoolExecutor and attach it to app.state
     app.state.executor = ProcessPoolExecutor(max_workers=1)
-
-    # Start folder watcher
     from app.utils.watcher import watcher_util_start_folder_watcher, watcher_util_stop_folder_watcher
     watcher_started = watcher_util_start_folder_watcher()
     if watcher_started:
         logger.info("Folder watcher started successfully")
     else:
         logger.warning("Folder watcher did not start (no folders to watch or already running)")
-
     try:
         yield
     finally:
         app.state.executor.shutdown(wait=True)
-        # Stop folder watcher
         if watcher_started:
             watcher_util_stop_folder_watcher()
             logger.info("Folder watcher stopped")