sortmeout 1.0.0__py3-none-any.whl

sortmeout/gui/app.py

@@ -0,0 +1,325 @@
+"""
+macOS Menu Bar application for SortMeOut.
+
+Provides a menu bar interface for controlling SortMeOut.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import webbrowser
+from typing import Optional
+
+try:
+    import rumps
+except ImportError:
+    rumps = None
+
+from sortmeout import SortMeOut, __version__
+from sortmeout.config.manager import ConfigManager
+from sortmeout.macos.trash import get_trash_info, empty_trash
+from sortmeout.utils.logger import setup_logging, get_logger
+
+logger = get_logger(__name__)
+
+
+class MenuBarApp:
+    """
+    Menu bar application for SortMeOut.
+
+    Provides quick access to:
+    - Start/stop watching
+    - View status
+    - Access settings
+    - View recent activity
+    """
+
+    def __init__(self):
+        """Initialize the menu bar app."""
+        if rumps is None:
+            raise ImportError("rumps is required for the GUI. Install with: pip install rumps")
+
+        self.app = rumps.App(
+            "SortMeOut",
+            icon=self._get_icon_path(),
+            quit_button=None,  # We'll add our own
+        )
+
+        # Initialize SortMeOut
+        self.sortmeout = SortMeOut()
+        self._running = False
+        self._preview_mode = False
+
+        # Build menu
+        self._build_menu()
+
+        # Set up timer for status updates
+        self._status_timer = rumps.Timer(self._update_status, 30)
+        self._status_timer.start()
+
+    def _get_icon_path(self) -> Optional[str]:
+        """Get path to menu bar icon."""
+        # Try to find icon in resources
+        resource_paths = [
+            os.path.join(os.path.dirname(__file__), "..", "resources", "icon.png"),
+            os.path.join(os.path.dirname(__file__), "..", "resources", "MenuBarIcon.png"),
+        ]
+
+        for path in resource_paths:
+            if os.path.exists(path):
+                return path
+
+        return None
+
+    def _build_menu(self) -> None:
+        """Build the menu bar menu."""
+        self.app.menu = [
+            rumps.MenuItem("Start Watching", callback=self._toggle_watching),
+            rumps.MenuItem("Preview Mode", callback=self._toggle_preview),
+            None,  # Separator
+            rumps.MenuItem("Folders", callback=None),
+            rumps.MenuItem("Recent Activity", callback=self._show_activity),
+            None,
+            rumps.MenuItem("Trash", [
+                rumps.MenuItem("View Trash Status", callback=self._show_trash_status),
+                rumps.MenuItem("Empty Trash", callback=self._empty_trash),
+            ]),
+            None,
+            rumps.MenuItem("Preferences...", callback=self._show_preferences),
+            rumps.MenuItem("Help", [
+                rumps.MenuItem("Documentation", callback=self._open_docs),
+                rumps.MenuItem("Report Issue", callback=self._report_issue),
+                rumps.MenuItem(f"About SortMeOut v{__version__}", callback=self._show_about),
+            ]),
+            None,
+            rumps.MenuItem("Quit SortMeOut", callback=self._quit),
+        ]
+
+        # Update folders submenu
+        self._update_folders_menu()
+
+    def _update_folders_menu(self) -> None:
+        """Update the folders submenu."""
+        folders_menu = self.app.menu["Folders"]
+
+        # Clear existing items
+        folders_menu.clear()
+
+        folders = self.sortmeout.get_folders()
+
+        if not folders:
+            folders_menu.add(rumps.MenuItem("No folders configured", callback=None))
+            folders_menu["No folders configured"].set_callback(None)
+        else:
+            for folder in folders:
+                rules = self.sortmeout.get_rules(folder)
+                folder_name = os.path.basename(folder) or folder
+                item = rumps.MenuItem(
+                    f"{folder_name} ({len(rules)} rules)",
+                    callback=lambda _, f=folder: self._show_folder_details(f)
+                )
+                folders_menu.add(item)
+
+        # Add separator and "Add Folder" option
+        folders_menu.add(None)
+        folders_menu.add(rumps.MenuItem("Add Folder...", callback=self._add_folder))
+
+    def _toggle_watching(self, sender: rumps.MenuItem) -> None:
+        """Toggle watching on/off."""
+        if self._running:
+            self.sortmeout.stop()
+            self._running = False
+            sender.title = "Start Watching"
+            self.app.title = "SortMeOut"
+            rumps.notification(
+                "SortMeOut",
+                "Stopped",
+                "File watching has been stopped."
+            )
+        else:
+            self.sortmeout.start_background()
+            self._running = True
+            sender.title = "Stop Watching"
+            self.app.title = "SortMeOut ●"
+            rumps.notification(
+                "SortMeOut",
+                "Started",
+                f"Watching {len(self.sortmeout.get_folders())} folder(s)."
+            )
+
+    def _toggle_preview(self, sender: rumps.MenuItem) -> None:
+        """Toggle preview mode."""
+        self._preview_mode = not self._preview_mode
+        self.sortmeout.preview_mode = self._preview_mode
+
+        if self._preview_mode:
+            sender.state = 1  # Checkmark
+            rumps.notification(
+                "SortMeOut",
+                "Preview Mode",
+                "Actions will be logged but not executed."
+            )
+        else:
+            sender.state = 0
+
+    def _show_activity(self, _) -> None:
+        """Show recent activity."""
+        stats = self.sortmeout.get_stats()
+
+        rumps.alert(
+            title="Recent Activity",
+            message=(
+                f"Files processed: {stats['files_processed']}\n"
+                f"Rules matched: {stats['rules_matched']}\n"
+                f"Actions executed: {stats['actions_executed']}\n"
+                f"Errors: {stats['errors']}"
+            )
+        )
+
+    def _show_folder_details(self, folder: str) -> None:
+        """Show details for a folder."""
+        rules = self.sortmeout.get_rules(folder)
+
+        if not rules:
+            message = "No rules configured"
+        else:
+            rule_names = "\n".join(f"• {r.name}" for r in rules)
+            message = f"Rules:\n{rule_names}"
+
+        response = rumps.alert(
+            title=f"Folder: {os.path.basename(folder)}",
+            message=message,
+            ok="Close",
+            cancel="Process Now"
+        )
+
+        if response == 0:  # Cancel = Process Now
+            self.sortmeout.process_folder(folder)
+            rumps.notification(
+                "SortMeOut",
+                "Processing Complete",
+                f"Processed files in {os.path.basename(folder)}"
+            )
+
+    def _add_folder(self, _) -> None:
+        """Open dialog to add a folder."""
+        try:
+            # Use AppleScript to show folder picker
+            import subprocess
+            script = '''
+                tell application "System Events"
+                    activate
+                    set theFolder to choose folder with prompt "Select a folder to watch:"
+                    return POSIX path of theFolder
+                end tell
+            '''
+            result = subprocess.run(
+                ["osascript", "-e", script],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode == 0 and result.stdout.strip():
+                folder = result.stdout.strip()
+                if self.sortmeout.add_folder(folder):
+                    self._update_folders_menu()
+                    rumps.notification(
+                        "SortMeOut",
+                        "Folder Added",
+                        f"Now watching: {os.path.basename(folder)}"
+                    )
+        except Exception as e:
+            logger.error("Failed to add folder: %s", e)
+
+    def _show_trash_status(self, _) -> None:
+        """Show Trash status."""
+        info = get_trash_info()
+
+        rumps.alert(
+            title="Trash Status",
+            message=(
+                f"Items: {info.item_count}\n"
+                f"Size: {info.size_human}\n"
+                f"Oldest item: {info.oldest_item_date.strftime('%Y-%m-%d') if info.oldest_item_date else 'N/A'}"
+            )
+        )
+
+    def _empty_trash(self, _) -> None:
+        """Empty the Trash."""
+        response = rumps.alert(
+            title="Empty Trash",
+            message="Are you sure you want to empty the Trash? This cannot be undone.",
+            ok="Empty Trash",
+            cancel="Cancel"
+        )
+
+        if response == 1:  # OK
+            if empty_trash():
+                rumps.notification(
+                    "SortMeOut",
+                    "Trash Emptied",
+                    "The Trash has been emptied."
+                )
+
+    def _show_preferences(self, _) -> None:
+        """Show preferences window."""
+        # In a full implementation, this would open a preferences window
+        rumps.alert(
+            title="Preferences",
+            message="Preferences window coming soon!\n\nFor now, use the CLI:\nsortmeout config show"
+        )
+
+    def _open_docs(self, _) -> None:
+        """Open documentation."""
+        webbrowser.open("https://github.com/yourusername/sortmeout/docs")
+
+    def _report_issue(self, _) -> None:
+        """Open issue tracker."""
+        webbrowser.open("https://github.com/yourusername/sortmeout/issues")
+
+    def _show_about(self, _) -> None:
+        """Show about dialog."""
+        rumps.alert(
+            title="About SortMeOut",
+            message=(
+                f"SortMeOut v{__version__}\n\n"
+                "Open-source file automation for macOS.\n\n"
+                "Inspired by Noodlesoft Hazel.\n\n"
+                "https://github.com/yourusername/sortmeout"
+            )
+        )
+
+    def _update_status(self, _) -> None:
+        """Periodic status update."""
+        if self._running:
+            stats = self.sortmeout.get_stats()
+            # Could update menu bar icon or title based on activity
+
+    def _quit(self, _) -> None:
+        """Quit the application."""
+        if self._running:
+            self.sortmeout.stop()
+        rumps.quit_application()
+
+    def run(self) -> None:
+        """Run the menu bar app."""
+        self.app.run()
+
+
+def main():
+    """Main entry point for GUI application."""
+    setup_logging()
+
+    if rumps is None:
+        print("Error: rumps is required for the GUI.")
+        print("Install with: pip install rumps")
+        sys.exit(1)
+
+    app = MenuBarApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

sortmeout/macos/__init__.py

@@ -0,0 +1,19 @@
+"""
+macOS-specific integrations for SortMeOut.
+"""
+
+from sortmeout.macos.tags import get_tags, set_tags, add_tags, remove_tags
+from sortmeout.macos.spotlight import search_spotlight, get_metadata
+from sortmeout.macos.trash import get_trash_info, empty_trash, TrashManager
+
+__all__ = [
+    "get_tags",
+    "set_tags",
+    "add_tags",
+    "remove_tags",
+    "search_spotlight",
+    "get_metadata",
+    "get_trash_info",
+    "empty_trash",
+    "TrashManager",
+]

sortmeout/macos/spotlight.py

@@ -0,0 +1,337 @@
+"""
+macOS Spotlight integration.
+
+Provides functions for searching and retrieving Spotlight metadata.
+"""
+
+from __future__ import annotations
+
+import plistlib
+import subprocess
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from sortmeout.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_metadata(file_path: str) -> Dict[str, Any]:
+    """
+    Get all Spotlight metadata for a file.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        Dictionary of metadata attributes.
+    """
+    try:
+        result = subprocess.run(
+            ["mdls", "-plist", "-", file_path],
+            capture_output=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            return {}
+
+        metadata = plistlib.loads(result.stdout)
+        return metadata
+
+    except Exception as e:
+        logger.error("Failed to get metadata for %s: %s", file_path, e)
+        return {}
+
+
+def get_attribute(file_path: str, attribute: str) -> Optional[Any]:
+    """
+    Get a specific Spotlight attribute for a file.
+
+    Args:
+        file_path: Path to the file.
+        attribute: Spotlight attribute name (e.g., "kMDItemKind").
+
+    Returns:
+        Attribute value or None.
+    """
+    try:
+        result = subprocess.run(
+            ["mdls", "-name", attribute, "-raw", file_path],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            return None
+
+        value = result.stdout.strip()
+        if value == "(null)":
+            return None
+
+        return value
+
+    except Exception as e:
+        logger.debug("Failed to get attribute %s: %s", attribute, e)
+        return None
+
+
+def search_spotlight(
+    query: str,
+    folder: Optional[str] = None,
+    limit: int = 100,
+    attributes: Optional[List[str]] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Search for files using Spotlight.
+
+    Args:
+        query: Spotlight query string (e.g., "kMDItemKind == 'PDF Document'").
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+        attributes: Specific attributes to retrieve.
+
+    Returns:
+        List of matching files with their metadata.
+    """
+    try:
+        cmd = ["mdfind"]
+
+        if folder:
+            cmd.extend(["-onlyin", folder])
+
+        cmd.append(query)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        if result.returncode != 0:
+            return []
+
+        files = result.stdout.strip().split("\n")[:limit]
+
+        if not attributes:
+            return [{"path": f} for f in files if f]
+
+        # Get attributes for each file
+        results = []
+        for file_path in files:
+            if not file_path:
+                continue
+
+            metadata = {"path": file_path}
+            for attr in attributes:
+                value = get_attribute(file_path, attr)
+                if value is not None:
+                    metadata[attr] = value
+
+            results.append(metadata)
+
+        return results
+
+    except Exception as e:
+        logger.error("Spotlight search failed: %s", e)
+        return []
+
+
+def find_by_kind(kind: str, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files by their kind (e.g., "PDF Document", "JPEG image").
+
+    Args:
+        kind: File kind to search for.
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    query = f'kMDItemKind == "{kind}"'
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def find_by_extension(extension: str, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files by extension.
+
+    Args:
+        extension: File extension (without dot).
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    extension = extension.lstrip(".")
+    query = f'kMDItemFSName == "*.{extension}"'
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def find_by_tag(tag: str, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files by Finder tag.
+
+    Args:
+        tag: Tag name to search for.
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    query = f'kMDItemUserTags == "{tag}"'
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def find_by_content(text: str, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files containing specific text.
+
+    Args:
+        text: Text to search for in file contents.
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    query = f'kMDItemTextContent == "{text}"c'  # c for case-insensitive
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def find_modified_after(date: datetime, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files modified after a specific date.
+
+    Args:
+        date: Cutoff date.
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    date_str = date.strftime("%Y-%m-%d")
+    query = f'kMDItemFSContentChangeDate >= $time.iso({date_str})'
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def find_created_after(date: datetime, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files created after a specific date.
+
+    Args:
+        date: Cutoff date.
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    date_str = date.strftime("%Y-%m-%d")
+    query = f'kMDItemFSCreationDate >= $time.iso({date_str})'
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def find_by_author(author: str, folder: Optional[str] = None, limit: int = 100) -> List[str]:
+    """
+    Find files by author.
+
+    Args:
+        author: Author name to search for.
+        folder: Optional folder to search in.
+        limit: Maximum number of results.
+
+    Returns:
+        List of file paths.
+    """
+    query = f'kMDItemAuthors == "{author}"c'
+    results = search_spotlight(query, folder, limit)
+    return [r["path"] for r in results]
+
+
+def get_download_source(file_path: str) -> Optional[str]:
+    """
+    Get the URL from which a file was downloaded.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        Download URL or None.
+    """
+    metadata = get_metadata(file_path)
+    where_froms = metadata.get("kMDItemWhereFroms", [])
+
+    if where_froms:
+        return where_froms[0] if isinstance(where_froms, list) else where_froms
+
+    return None
+
+
+def get_uti(file_path: str) -> Optional[str]:
+    """
+    Get the Uniform Type Identifier for a file.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        UTI string or None.
+    """
+    return get_attribute(file_path, "kMDItemContentType")
+
+
+def file_matches_uti(file_path: str, uti: str) -> bool:
+    """
+    Check if a file conforms to a UTI.
+
+    Args:
+        file_path: Path to the file.
+        uti: UTI to check against.
+
+    Returns:
+        True if file conforms to UTI.
+    """
+    file_uti = get_uti(file_path)
+    if not file_uti:
+        return False
+
+    # Check if file UTI equals or conforms to target UTI
+    if file_uti == uti:
+        return True
+
+    # Use mdls to check conformance
+    type_tree = get_attribute(file_path, "kMDItemContentTypeTree")
+    if type_tree:
+        if isinstance(type_tree, str):
+            type_tree = [type_tree]
+        return uti in type_tree
+
+    return False
+
+
+# Common UTI constants
+UTI_PDF = "com.adobe.pdf"
+UTI_IMAGE = "public.image"
+UTI_MOVIE = "public.movie"
+UTI_AUDIO = "public.audio"
+UTI_TEXT = "public.plain-text"
+UTI_RTF = "public.rtf"
+UTI_HTML = "public.html"
+UTI_XML = "public.xml"
+UTI_JSON = "public.json"
+UTI_ZIP = "com.pkware.zip-archive"
+UTI_FOLDER = "public.folder"
+UTI_APPLICATION = "com.apple.application-bundle"