simkl-mps 2.2.2__tar.gz → 2.3.1__tar.gz

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simkl-mps
-Version: 2.2.2
+Version: 2.3.1
 Summary: Automatic Media Scrobbler for Simkl
 License: GPL-3.0
 License-File: LICENSE
@@ -70,17 +70,6 @@ Description-Content-Type: text/markdown
 
 After installation, authenticate with SIMKL and **configure your media players** using the [Media Players Guide](docs/media-players.md) (this step is critical for accurate tracking).
 
-## 📚 Documentation
-
-- [Windows Guide](docs/windows-guide.md)
-- [Linux Guide](docs/linux-guide.md)
-- [Mac Guide](docs/mac-guide.md)
-- [Supported Media Players](docs/media-players.md)
-- [Usage Guide](docs/usage.md)
-- [Local Watch History](docs/watch-history.md)
-- [Advanced & Developer Guide](docs/configuration.md)
-- [Troubleshooting Guide](docs/troubleshooting.md)
-- [Todo List](docs/todo.md)
 
 ## 🔍 How It Works
 

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/README.md

@@ -26,17 +26,6 @@
 
 After installation, authenticate with SIMKL and **configure your media players** using the [Media Players Guide](docs/media-players.md) (this step is critical for accurate tracking).
 
-## 📚 Documentation
-
-- [Windows Guide](docs/windows-guide.md)
-- [Linux Guide](docs/linux-guide.md)
-- [Mac Guide](docs/mac-guide.md)
-- [Supported Media Players](docs/media-players.md)
-- [Usage Guide](docs/usage.md)
-- [Local Watch History](docs/watch-history.md)
-- [Advanced & Developer Guide](docs/configuration.md)
-- [Troubleshooting Guide](docs/troubleshooting.md)
-- [Todo List](docs/todo.md)
 
 ## 🔍 How It Works
 

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "simkl-mps"
-version = "2.2.2"
+version = "2.3.1"
 description = "Automatic Media Scrobbler for Simkl"
 authors = [
     "kavin <kavinthangavel.dev@gmail.com>",

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/simkl_mps/config_manager.py

@@ -36,9 +36,22 @@ DEFAULT_THRESHOLD = 80
 DEFAULT_SETTINGS = {
     "watch_completion_threshold": DEFAULT_THRESHOLD,
     "user_subdir": DEFAULT_USER_SUBDIR,
-    "auto_sync_interval": 120  # Auto sync backlog every 2 minutes by default
+    "auto_sync_interval": 120,  # Auto sync backlog every 2 minutes by default
+    "disable_notifications": False,  # Show all notifications by default
+    "allow_dirs": [],
+    "deny_dirs": []
 }
 
+def _sanitize_dir_list(value):
+    """Ensure allow/deny dir settings are stored as a list of strings."""
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, (list, tuple)):
+        return [str(item) for item in value if isinstance(item, str) and item.strip()]
+    return []
+
 def load_settings():
     """Loads settings from the JSON file in the user config directory."""
     if not SETTINGS_FILE.exists():
@@ -76,6 +89,13 @@ def load_settings():
                  settings['watch_completion_threshold'] = DEFAULT_THRESHOLD
                  settings_updated = True
 
+            # Sanitize allow/deny directory lists
+            for key in ("allow_dirs", "deny_dirs"):
+                sanitized = _sanitize_dir_list(settings.get(key))
+                if settings.get(key) != sanitized:
+                    settings[key] = sanitized
+                    settings_updated = True
+
             # Save the file only if defaults were added or invalid values corrected
             if settings_updated:
                 save_settings(settings)
@@ -125,6 +145,9 @@ def set_setting(key, value):
         except (ValueError, TypeError):
              log.error(f"Attempted to set non-integer watch_completion_threshold: {value}.")
              return # Do not save invalid value
+
+    if key in ('allow_dirs', 'deny_dirs'):
+        value = _sanitize_dir_list(value)
     
     log.debug(f"ConfigManager: set_setting proceeding for key='{key}' before user_subdir check.")
     if key == 'user_subdir' and value != get_setting('user_subdir'):

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/simkl_mps/media_scrobbler.py

@@ -40,6 +40,7 @@ except ImportError:
 from simkl_mps.utils.constants import PLAYING, PAUSED, STOPPED, DEFAULT_POLL_INTERVAL
 from simkl_mps.config_manager import get_setting, DEFAULT_THRESHOLD
 from simkl_mps.watch_history_manager import WatchHistoryManager
+from simkl_mps.utils.path_filter import is_path_allowed
 
 class MediaScrobbler:
     """
@@ -127,6 +128,23 @@ class MediaScrobbler:
         self._mpv_wrapper_integration = None
         self._potplayer_integration = None
         self.watch_history = WatchHistoryManager(self.app_data_dir) # Initialize watch history manager
+        self._allow_dirs = get_setting('allow_dirs', [])
+        self._deny_dirs = get_setting('deny_dirs', [])
+        self._dir_filter_last_refresh = 0
+
+    def _refresh_dir_filters(self, min_interval_seconds=60):
+        """Refresh directory allow/deny lists periodically to avoid frequent disk I/O."""
+        current_time = time.time()
+        if current_time - self._dir_filter_last_refresh < min_interval_seconds:
+            return
+        self._allow_dirs = get_setting('allow_dirs', [])
+        self._deny_dirs = get_setting('deny_dirs', [])
+        self._dir_filter_last_refresh = current_time
+
+    def signal_dir_filters_update(self):
+        """Signal that directory filters have been updated and should be refreshed on the next check."""
+        self._dir_filter_last_refresh = 0
+        logger.info("Received signal to refresh directory filters.")
 
     def set_notification_callback(self, callback):
         """Set a callback function for notifications"""
@@ -149,11 +167,23 @@ class MediaScrobbler:
             else:
                 logger.debug("Backlog processing state and notification throttles were already empty")
 
-    def _send_notification(self, title, message, online_only=False, offline_only=False):
+    def _send_notification(self, title, message, online_only=False, offline_only=False, critical=False):
         """
         Safely sends a notification if the callback is set, respecting online/offline constraints.
+        
+        Args:
+            title: Notification title
+            message: Notification message
+            online_only: Only send when internet is connected
+            offline_only: Only send when offline
+            critical: If True, always send regardless of user's disable_notifications setting
         """
         if self.notification_callback:
+            # Check if notifications are disabled for non-critical notifications
+            if not critical and get_setting('disable_notifications', False):
+                logger.debug(f"Notification '{title}' suppressed (disable_notifications setting is True).")
+                return
+            
             connected = is_internet_connected()
             if (online_only and not connected) or \
                (offline_only and connected):
@@ -314,21 +344,24 @@ class MediaScrobbler:
                 else:
                     logger.debug(f"{player_name} integration couldn't get position/duration.")
             except requests.RequestException as e:
+                # Connection errors during player shutdown are expected (debug level)
+                logger.debug(f"Could not connect to {process_name} web interface. Error: {e}")
+                # Only log warnings and notify for persistent connection issues (throttled to once per 5 minutes)
                 now = time.time()
                 last_log_time = self._last_connection_error_log.get(process_name, 0)
-                if now - last_log_time > 60: # Log connection errors at most once per minute per player
-                    logger.warning(f"Could not connect to {process_name} web interface. Error: {e}")
+                if now - last_log_time > 300:  # Notify at most once per 5 minutes per player
+                    logger.warning(f"Persistent connection issue with {process_name} web interface. {str(e)[:100]}")
                     self._last_connection_error_log[process_name] = now
                     # Only notify if currently tracking a file
                     if self.currently_tracking:
                         player_type = self._get_player_type(process_name_lower)
                         if player_type:
                             config_instructions = self._get_player_config_instructions(player_type)
-                            logger.info(f"[DEBUG] Sending notification for {player_type} connection error: {config_instructions}")
                             self._send_notification(
                                 f"{player_type} Connection Error",
                                 f"Could not connect to {player_type}. {config_instructions}",
-                                online_only=False
+                                online_only=False,
+                                critical=True
                             )
             except Exception as e:
                 logger.error(f"Error getting pos/dur from {process_name} ({getattr(integration, '__class__', type(integration)).__name__}): {e}", exc_info=True)
@@ -353,10 +386,13 @@ class MediaScrobbler:
                     logger.debug(f"Retrieved filepath from {player_name}: {filepath}")
                     return filepath
             except requests.RequestException as e:
+                # Connection errors during player shutdown are expected (debug level)
+                logger.debug(f"Could not connect to {process_name} web interface for filepath. Error: {e}")
+                # Only log warnings and notify for persistent connection issues (throttled to once per 5 minutes)
                 now = time.time()
                 last_log_time = self._last_connection_error_log.get(process_name, 0)
-                if now - last_log_time > 60: # Log and notify at most once per minute per player
-                    logger.warning(f"Could not connect to {process_name} web interface for filepath. Error: {e}")
+                if now - last_log_time > 300:  # Notify at most once per 5 minutes per player
+                    logger.warning(f"Persistent connection issue with {process_name} web interface. {str(e)[:100]}")
                     self._last_connection_error_log[process_name] = now
                     # Send notification about web interface connection error
                     player_type = self._get_player_type(process_name_lower)
@@ -365,7 +401,8 @@ class MediaScrobbler:
                         self._send_notification(
                             f"{player_type} Connection Error",
                             f"Could not connect to {player_type} web interface. {config_instructions}",
-                            online_only=False
+                            online_only=False,
+                            critical=True
                         )
             except Exception as e:
                 logger.error(f"Error getting filepath from {process_name} ({integration.__class__.__name__}): {e}", exc_info=True)
@@ -403,6 +440,13 @@ class MediaScrobbler:
                 self.stop_tracking()
             return None
 
+        self._refresh_dir_filters()
+        if not is_path_allowed(filepath, self._allow_dirs, self._deny_dirs):
+            logger.info("Filepath excluded by directory filters: '%s'", filepath)
+            if self.currently_tracking:
+                self.stop_tracking()
+            return None
+
         # Detect media switches even when guessit returns identical titles (e.g., sequential episodes)
         if self.currently_tracking and self.current_filepath and filepath:
             if self._has_media_file_changed(self.current_filepath, filepath):
@@ -1367,7 +1411,7 @@ class MediaScrobbler:
                     self.simkl_id, display_title, "missing_credentials",
                     {"simkl_id": self.simkl_id, "type": self.media_type, "season": self.season, "episode": self.episode}
                 )
-                self._send_notification("Auth Error", f"'{display_title}' needs sync (missing creds). Added to backlog.")
+                self._send_notification("Auth Error", f"'{display_title}' needs sync (missing creds). Added to backlog.", critical=True)
             return False
 
         # --- Identification Check ---

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/simkl_mps/monitor.py

@@ -153,7 +153,7 @@ class Monitor:
                             #     else:
                             #         logger.debug(f"Skipping repeated search for '{title}' (cooldown: {int(self.offline_search_cooldown - time_since_last_attempt)}s remaining)")
                         else:
-                            logger.warning(f"No scrobble info returned from process_window for {process_name}")
+                            logger.debug(f"No scrobble info returned from process_window for {process_name}")
                         # Update the persistent state *after* processing and logging checks
                         self.last_known_player_process = process_name
                         self.last_known_filepath = filepath

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/simkl_mps/tray_base.py

@@ -11,6 +11,8 @@ import queue # Added for thread-safe communication for custom threshold dialog
 import logging
 import webbrowser
 import subprocess
+import re
+from importlib import metadata as importlib_metadata
 from pathlib import Path
 from typing import Any, Optional, TYPE_CHECKING
 from PIL import Image, ImageDraw, ImageFont
@@ -86,6 +88,16 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
             The new threshold value (int) entered by the user, or None if cancelled.
          """       
         pass
+
+    @abc.abstractmethod
+    def _ask_directory_filter_dialog(self, title: str, current_value: str, help_text: str) -> str | None:
+        """
+        Platform-specific dialog for editing directory filters.
+
+        Returns:
+            Updated string (comma/newline separated) or None if cancelled.
+        """
+        pass
             
     def _show_confirmation_dialog(self, title, message):
         """
@@ -248,7 +260,116 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
         except (TypeError, ValueError):
             return DEFAULT_THRESHOLD
 
-    def check_updates_thread(self):
+    def _format_dir_list_for_dialog(self, values: Any) -> str:
+        """Format directory lists for dialog input."""
+        if not values:
+            return ""
+        if isinstance(values, str):
+            return values
+        try:
+            return "\n".join([str(value) for value in values if value])
+        except Exception:
+            return ""
+
+    def _parse_dir_list_input(self, input_text: str | None) -> list[str]:
+        """Parse dialog input into a normalized list of paths or patterns."""
+        if not input_text:
+            return []
+        parts: list[str] = []
+        for line in input_text.splitlines():
+            for token in re.split(r"[;,]", line):
+                cleaned = token.strip()
+                if cleaned:
+                    parts.append(cleaned)
+        return parts
+
+    def _apply_dir_filter_change(self, key: str, entries: list[str]) -> None:
+        """
+        Persist filter settings and signal the running scrobbler to refresh its configuration.
+        
+        This respects encapsulation by using the scrobbler's public signal_dir_filters_update()
+        method rather than directly modifying its private attributes.
+        """
+        try:
+            set_setting(key, entries)
+            media_scrobbler = self._get_media_scrobbler()
+            if media_scrobbler is not None:
+                # Signal the scrobbler to refresh configuration via public method
+                if hasattr(media_scrobbler, "signal_dir_filters_update"):
+                    media_scrobbler.signal_dir_filters_update()
+            label = "Allow" if key == "allow_dirs" else "Deny"
+            self.show_notification("Settings Updated", f"{label} directories updated.")
+        except Exception as exc:
+            logger.error(f"Failed to update {key}: {exc}", exc_info=True)
+            self.show_notification("Error", f"Failed to update directory filters: {exc}")
+
+    def set_allow_dirs(self, _=None):
+        current_value = self._format_dir_list_for_dialog(get_setting("allow_dirs", []))
+        help_text = "Enter paths or glob patterns, separated by commas or semicolons."
+        updated_text = self._ask_directory_filter_dialog("Set Allow Directories", current_value, help_text)
+        if updated_text is not None:
+            entries = self._parse_dir_list_input(updated_text)
+            self._apply_dir_filter_change("allow_dirs", entries)
+        self.update_icon()
+        return 0
+
+    def set_deny_dirs(self, _=None):
+        current_value = self._format_dir_list_for_dialog(get_setting("deny_dirs", []))
+        help_text = "Enter paths or glob patterns, separated by commas or semicolons."
+        updated_text = self._ask_directory_filter_dialog("Set Deny Directories", current_value, help_text)
+        if updated_text is not None:
+            entries = self._parse_dir_list_input(updated_text)
+            self._apply_dir_filter_change("deny_dirs", entries)
+        self.update_icon()
+        return 0
+
+    def clear_allow_dirs(self, _=None):
+        self._apply_dir_filter_change("allow_dirs", [])
+        self.update_icon()
+        return 0
+
+    def clear_deny_dirs(self, _=None):
+        self._apply_dir_filter_change("deny_dirs", [])
+        self.update_icon()
+        return 0
+
+    def _get_app_version(self) -> str:
+        """Resolve application version from installed metadata or local package source."""
+        # 1) Prefer installed package metadata
+        for dist_name in ("simkl-mps", "simkl_mps"):
+            try:
+                version = importlib_metadata.version(dist_name)
+                if version:
+                    return version
+            except importlib_metadata.PackageNotFoundError:
+                continue
+            except Exception:
+                logger.debug("Failed to read version from importlib.metadata for %s", dist_name, exc_info=True)
+
+        # 2) Fallback: parse local package __init__.py version constant
+        try:
+            init_file = Path(__file__).parent / "__init__.py"
+            if init_file.exists():
+                content = init_file.read_text(encoding="utf-8", errors="ignore")
+                match = re.search(r"__version__\s*=\s*[\"']([^\"']+)[\"']", content)
+                if match:
+                    return match.group(1).strip()
+        except Exception:
+            logger.debug("Failed to parse local __version__ from __init__.py", exc_info=True)
+
+        return "0.0.0"
+
+    def _build_about_text(self) -> str:
+        """Build standard About dialog text."""
+        return (
+            "Media Player Scrobbler for SIMKL\n"
+            f"Version: {self._get_app_version()}\n"
+            "Author: kavin\n"
+            "License: GNU GPL v3\n\n"
+            "Automatically track and scrobble your media to SIMKL."
+        )
+
+    def check_updates_thread(self, _=None):
         """Optional hook for subclasses that implement update checks."""
         logger.debug("Update check not implemented for this platform.")
 
@@ -646,7 +767,8 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
                     # Only show notification if:
                     # 1. This is the first run of the app after installation
                     # 2. User manually started the app from the menu
-                    if self.is_first_run or is_manual_start:
+                    # 3. Notifications are not disabled
+                    if (self.is_first_run or is_manual_start) and not get_setting('disable_notifications', False):
                         self.show_notification(
                             "simkl-mps",
                             "Media monitoring started"
@@ -1032,6 +1154,37 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
 
     # --- End Watch Threshold Logic --- 
     
+    def toggle_notifications_disabled(self, _=None):
+        """Toggle the disable_notifications setting and show confirmation."""
+        try:
+            current_value = get_setting('disable_notifications', False)
+            new_value = not current_value
+            set_setting('disable_notifications', new_value)
+            
+            status = "disabled" if new_value else "enabled"
+            logger.info(f"Notifications {status} via tray menu")
+            
+            # Show confirmation (always show this one, it's critical)
+            # Access the scrobbler to send critical notification
+            media_scrobbler = self._get_media_scrobbler()
+            if media_scrobbler:
+                media_scrobbler._send_notification(
+                    "Settings Updated",
+                    f"Notifications {status}. Critical alerts will still appear.",
+                    critical=True
+                )
+            else:
+                # Fallback if scrobbler not available
+                self.show_notification("Settings Updated", f"Notifications {status}. Critical alerts will still appear.")
+            
+            self.update_icon()  # Refresh menu to show new checkmark state
+            
+        except Exception as e:
+            logger.error(f"Error toggling notifications: {e}", exc_info=True)
+            self.show_notification("Error", f"Failed to toggle notifications: {e}")
+        
+        return 0
+    
     def check_first_run(self):
         """Check if this is the first time the app is being run"""
         # Platform-specific implementation required
@@ -1073,6 +1226,12 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
             pystray.MenuItem("Sync Backlog Now", self.process_backlog),
             pystray.MenuItem("Completion Threshold", threshold_submenu),
             pystray.Menu.SEPARATOR,
+            pystray.MenuItem(
+                "Disable Notifications",
+                self.toggle_notifications_disabled,
+                checked=lambda item: get_setting('disable_notifications', False)
+            ),
+            pystray.Menu.SEPARATOR,
             pystray.MenuItem("Open Local Watch History", self.open_watch_history),
         )))
         menu_items.append(pystray.Menu.SEPARATOR)
@@ -1093,6 +1252,13 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
         menu_items.append(pystray.MenuItem("Maintenance", pystray.Menu(
             pystray.MenuItem("Open Logs", self.open_logs),
             pystray.MenuItem("Open Data Folder", self.open_config_dir),
+            pystray.MenuItem("Directory Filters", pystray.Menu(
+                pystray.MenuItem("Edit Allow List", self.set_allow_dirs),
+                pystray.MenuItem("Edit Deny List", self.set_deny_dirs),
+                pystray.Menu.SEPARATOR,
+                pystray.MenuItem("Clear Allow List", self.clear_allow_dirs),
+                pystray.MenuItem("Clear Deny List", self.clear_deny_dirs),
+            )),
             pystray.Menu.SEPARATOR,
             pystray.MenuItem("Clear Backlog", self.clear_backlog),
             pystray.MenuItem("Clear Cache", self.clear_cache),
@@ -1106,7 +1272,7 @@ class TrayAppBase(abc.ABC): # Inherit from ABC for abstract methods
         menu_items.append(pystray.MenuItem("More", pystray.Menu(
             pystray.MenuItem("Donate ❤️", self.open_donation_page),
             pystray.Menu.SEPARATOR,
-            pystray.MenuItem("Check for Updates", lambda: self.check_updates_thread() if hasattr(self, 'check_updates_thread') else None),
+            pystray.MenuItem("Check for Updates", self.check_updates_thread),
             pystray.MenuItem("Help", self.show_help),
             pystray.MenuItem("About", self.show_about),
         )))        # --- Exit (always last, separated) ---

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/simkl_mps/tray_linux.py

@@ -208,6 +208,17 @@ class AppIndicatorTray:
             threshold_item.set_submenu(threshold_submenu)
             scrobbling_submenu.append(threshold_item)
             
+            scrobbling_submenu.append(gtk_module.SeparatorMenuItem())
+            
+            # Disable Notifications toggle
+            notifications_disabled = get_setting('disable_notifications', False)
+            notifications_item = gtk_module.CheckMenuItem(label="Disable Notifications")
+            notifications_item.set_active(notifications_disabled)
+            notifications_item.connect("activate", self._wrap_callback(self.app.toggle_notifications_disabled))
+            scrobbling_submenu.append(notifications_item)
+            
+            scrobbling_submenu.append(gtk_module.SeparatorMenuItem())
+            
             watch_history_item = gtk_module.MenuItem(label="Open Local Watch History")
             watch_history_item.connect("activate", self._wrap_callback(self.app.open_watch_history))
             scrobbling_submenu.append(watch_history_item)
@@ -251,6 +262,30 @@ class AppIndicatorTray:
             config_item = gtk_module.MenuItem(label="Open Data Folder")
             config_item.connect("activate", self._wrap_callback(self.app.open_config_dir))
             maintenance_submenu.append(config_item)
+
+            filters_item = gtk_module.MenuItem(label="Directory Filters")
+            filters_submenu = gtk_module.Menu()
+
+            allow_item = gtk_module.MenuItem(label="Edit Allow List")
+            allow_item.connect("activate", self._wrap_callback(self.app.set_allow_dirs))
+            filters_submenu.append(allow_item)
+
+            deny_item = gtk_module.MenuItem(label="Edit Deny List")
+            deny_item.connect("activate", self._wrap_callback(self.app.set_deny_dirs))
+            filters_submenu.append(deny_item)
+
+            filters_submenu.append(gtk_module.SeparatorMenuItem())
+
+            clear_allow_item = gtk_module.MenuItem(label="Clear Allow List")
+            clear_allow_item.connect("activate", self._wrap_callback(self.app.clear_allow_dirs))
+            filters_submenu.append(clear_allow_item)
+
+            clear_deny_item = gtk_module.MenuItem(label="Clear Deny List")
+            clear_deny_item.connect("activate", self._wrap_callback(self.app.clear_deny_dirs))
+            filters_submenu.append(clear_deny_item)
+
+            filters_item.set_submenu(filters_submenu)
+            maintenance_submenu.append(filters_item)
             
             maintenance_submenu.append(gtk_module.SeparatorMenuItem())
             
@@ -547,22 +582,7 @@ class TrayAppLinux(TrayAppBase):
     def show_about(self, _=None):
         """Show about dialog with Linux-specific implementation"""
         try:
-            # Try to get version information
-            version = "Unknown"
-            
-            try:
-                import pkg_resources
-                version = pkg_resources.get_distribution("simkl-mps").version
-            except:
-                pass
-                
-            # Build the about text
-            about_text = f"""Media Player Scrobbler for SIMKL
-Version: {version}
-Author: kavin
-License: GNU GPL v3
-
-Automatically track and scrobble your media to SIMKL."""
+            about_text = self._build_about_text()
 
             # Try using zenity for a nicer dialog
             try:
@@ -885,9 +905,33 @@ Automatically track and scrobble your media to SIMKL."""
             logger.error("zenity command not found, even after 'which' check (unexpected).")
             self.show_notification("Error", "zenity command not found.")
             return None
+
+    def _ask_directory_filter_dialog(self, title: str, current_value: str, help_text: str) -> Optional[str]:
+        """Ask user for directory filters using zenity entry (comma/semicolon separated)."""
+        try:
+            if subprocess.run(['which', 'zenity'], stdout=subprocess.PIPE, stderr=subprocess.PIPE).returncode != 0:
+                self.show_notification("Cannot Edit Filters", "zenity is not installed. Please install zenity.")
+                return None
+
+            initial_value = current_value.replace("\n", "; ") if current_value else ""
+            process = subprocess.run(
+                [
+                    'zenity', '--entry',
+                    f'--title={title}',
+                    f'--text={help_text}\nSeparate entries with commas or semicolons.',
+                    f'--entry-text={initial_value}'
+                ],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+
+            if process.returncode == 0:
+                return process.stdout.strip()
+            return None
         except Exception as e:
-            logger.error(f"Error using zenity for threshold input: {e}", exc_info=True)
-            self.show_notification("Error", f"Could not get custom threshold: {e}")
+            logger.error(f"Error using zenity for directory filters: {e}", exc_info=True)
+            self.show_notification("Error", f"Could not edit directory filters: {e}")
             return None
 
     # _set_preset_threshold is handled by base class

{simkl_mps-2.2.2 → simkl_mps-2.3.1}/simkl_mps/tray_mac.py

@@ -160,23 +160,7 @@ class TrayAppMac(TrayAppBase):
     def show_about(self, _=None):
         """Show application information on macOS"""
         try:
-            # Try to get version information
-            version = "Unknown"
-            
-            # Try to get from pkg_resources
-            try:
-                import pkg_resources
-                version = pkg_resources.get_distribution("simkl-mps").version
-            except:
-                pass
-            
-            # Build the about text
-            about_text = f"""Media Player Scrobbler for SIMKL
-Version: {version}
-Author: kavin
-License: GNU GPL v3
-
-Automatically track and scrobble your media to SIMKL."""
+            about_text = self._build_about_text()
 
             # Use AppleScript dialog on macOS
             escaped_text = about_text.replace('"', '\\"')
@@ -487,6 +471,30 @@ Automatically track and scrobble your media to SIMKL."""
             self.show_notification("Error", f"Could not get custom threshold: {e}")
             return None
 
+    def _ask_directory_filter_dialog(self, title: str, current_value: str, help_text: str) -> str | None:
+        """macOS-specific directory filter input using AppleScript dialog."""
+        try:
+            initial_value = current_value.replace("\n", "; ") if current_value else ""
+            escaped_help = help_text.replace('"', '\\"')
+            escaped_title = title.replace('"', '\\"')
+            escaped_value = initial_value.replace('"', '\\"')
+            cmd = f'''osascript -e '
+                set answer to text returned of (display dialog "{escaped_help} (comma or semicolon separated)" \
+                default answer "{escaped_value}" \
+                with title "{escaped_title}" \
+                buttons {{"Cancel", "OK"}} default button "OK")
+                return answer
+            ' '''
+
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+            return None
+        except Exception as e:
+            logger.error(f"Error showing directory filter dialog: {e}", exc_info=True)
+            self.show_notification("Error", f"Could not edit directory filters: {e}")
+            return None
+
 def run_tray_app():
     """Run the application in tray mode"""
     try: