sortmeout 1.0.0__py3-none-any.whl

sortmeout/config/manager.py

@@ -0,0 +1,313 @@
+"""
+Configuration file management.
+
+Handles reading and writing configuration files for SortMeOut.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+import appdirs
+
+from sortmeout.config.settings import Settings
+from sortmeout.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+# Application identifiers
+APP_NAME = "SortMeOut"
+APP_AUTHOR = "SortMeOut"
+
+
+def get_config_directory() -> Path:
+    """Get the configuration directory path."""
+    config_dir = Path(appdirs.user_config_dir(APP_NAME, APP_AUTHOR))
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_data_directory() -> Path:
+    """Get the data directory path."""
+    data_dir = Path(appdirs.user_data_dir(APP_NAME, APP_AUTHOR))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+class ConfigManager:
+    """
+    Manages configuration file operations.
+
+    Handles loading, saving, and migrating configuration files.
+    Supports both YAML and JSON formats.
+    """
+
+    def __init__(self, config_path: Optional[str] = None):
+        """
+        Initialize configuration manager.
+
+        Args:
+            config_path: Path to configuration file. If None, uses default.
+        """
+        if config_path:
+            self.config_path = Path(config_path)
+        else:
+            self.config_path = get_config_directory() / "config.yaml"
+
+        self.config_dir = self.config_path.parent
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Backup directory
+        self.backup_dir = self.config_dir / "backups"
+        self.backup_dir.mkdir(exist_ok=True)
+
+        logger.debug("Config path: %s", self.config_path)
+
+    def load_config(self) -> Dict[str, Any]:
+        """
+        Load configuration from file.
+
+        Returns:
+            Configuration dictionary.
+        """
+        if not self.config_path.exists():
+            logger.info("No config file found, using defaults")
+            return self._get_default_config()
+
+        try:
+            with open(self.config_path, "r") as f:
+                if self.config_path.suffix in (".yaml", ".yml"):
+                    config = yaml.safe_load(f) or {}
+                else:
+                    config = json.load(f)
+
+            logger.info("Loaded config from: %s", self.config_path)
+            return config
+
+        except Exception as e:
+            logger.error("Failed to load config: %s", e)
+            return self._get_default_config()
+
+    def save_config(self, config: Dict[str, Any]) -> bool:
+        """
+        Save configuration to file.
+
+        Args:
+            config: Configuration dictionary to save.
+
+        Returns:
+            True if save was successful.
+        """
+        try:
+            # Create backup before saving
+            if self.config_path.exists():
+                self._create_backup()
+
+            # Add metadata
+            config["_metadata"] = {
+                "version": "1.0",
+                "updated_at": datetime.now().isoformat(),
+                "app_version": "0.1.0",
+            }
+
+            with open(self.config_path, "w") as f:
+                if self.config_path.suffix in (".yaml", ".yml"):
+                    yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+                else:
+                    json.dump(config, f, indent=2)
+
+            logger.info("Saved config to: %s", self.config_path)
+            return True
+
+        except Exception as e:
+            logger.error("Failed to save config: %s", e)
+            return False
+
+    def load_settings(self) -> Settings:
+        """
+        Load application settings.
+
+        Returns:
+            Settings object.
+        """
+        settings_path = self.config_dir / "settings.yaml"
+
+        if settings_path.exists():
+            try:
+                with open(settings_path, "r") as f:
+                    data = yaml.safe_load(f) or {}
+                return Settings.from_dict(data)
+            except Exception as e:
+                logger.error("Failed to load settings: %s", e)
+
+        return Settings()
+
+    def save_settings(self, settings: Settings) -> bool:
+        """
+        Save application settings.
+
+        Args:
+            settings: Settings object to save.
+
+        Returns:
+            True if save was successful.
+        """
+        settings_path = self.config_dir / "settings.yaml"
+
+        try:
+            with open(settings_path, "w") as f:
+                yaml.dump(settings.to_dict(), f, default_flow_style=False)
+            return True
+        except Exception as e:
+            logger.error("Failed to save settings: %s", e)
+            return False
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration."""
+        return {
+            "folders": [],
+            "_metadata": {
+                "version": "1.0",
+                "created_at": datetime.now().isoformat(),
+                "app_version": "0.1.0",
+            },
+        }
+
+    def _create_backup(self) -> None:
+        """Create a backup of the current config file."""
+        if not self.config_path.exists():
+            return
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"config_backup_{timestamp}{self.config_path.suffix}"
+        backup_path = self.backup_dir / backup_name
+
+        shutil.copy2(self.config_path, backup_path)
+        logger.debug("Created config backup: %s", backup_path)
+
+        # Keep only last 10 backups
+        self._cleanup_old_backups()
+
+    def _cleanup_old_backups(self, keep: int = 10) -> None:
+        """Remove old backup files."""
+        backups = sorted(self.backup_dir.glob("config_backup_*"))
+
+        if len(backups) > keep:
+            for backup in backups[:-keep]:
+                backup.unlink()
+                logger.debug("Removed old backup: %s", backup)
+
+    def restore_backup(self, backup_name: Optional[str] = None) -> bool:
+        """
+        Restore configuration from a backup.
+
+        Args:
+            backup_name: Name of backup file. If None, uses most recent.
+
+        Returns:
+            True if restore was successful.
+        """
+        if backup_name:
+            backup_path = self.backup_dir / backup_name
+        else:
+            backups = sorted(self.backup_dir.glob("config_backup_*"))
+            if not backups:
+                logger.warning("No backups found")
+                return False
+            backup_path = backups[-1]
+
+        if not backup_path.exists():
+            logger.error("Backup not found: %s", backup_path)
+            return False
+
+        try:
+            shutil.copy2(backup_path, self.config_path)
+            logger.info("Restored config from: %s", backup_path)
+            return True
+        except Exception as e:
+            logger.error("Failed to restore backup: %s", e)
+            return False
+
+    def list_backups(self) -> list:
+        """List available backup files."""
+        return sorted([b.name for b in self.backup_dir.glob("config_backup_*")])
+
+    def export_config(self, output_path: str, format: str = "yaml") -> bool:
+        """
+        Export configuration to a file.
+
+        Args:
+            output_path: Path to export to.
+            format: Export format (yaml or json).
+
+        Returns:
+            True if export was successful.
+        """
+        config = self.load_config()
+
+        try:
+            with open(output_path, "w") as f:
+                if format == "yaml":
+                    yaml.dump(config, f, default_flow_style=False)
+                else:
+                    json.dump(config, f, indent=2)
+
+            logger.info("Exported config to: %s", output_path)
+            return True
+
+        except Exception as e:
+            logger.error("Failed to export config: %s", e)
+            return False
+
+    def import_config(self, input_path: str, merge: bool = False) -> bool:
+        """
+        Import configuration from a file.
+
+        Args:
+            input_path: Path to import from.
+            merge: Merge with existing config instead of replacing.
+
+        Returns:
+            True if import was successful.
+        """
+        try:
+            with open(input_path, "r") as f:
+                if input_path.endswith((".yaml", ".yml")):
+                    imported = yaml.safe_load(f) or {}
+                else:
+                    imported = json.load(f)
+
+            if merge:
+                current = self.load_config()
+                # Merge folders
+                current_folders = {f["path"]: f for f in current.get("folders", [])}
+                for folder in imported.get("folders", []):
+                    current_folders[folder["path"]] = folder
+                current["folders"] = list(current_folders.values())
+                config = current
+            else:
+                config = imported
+
+            return self.save_config(config)
+
+        except Exception as e:
+            logger.error("Failed to import config: %s", e)
+            return False
+
+    def reset_config(self) -> bool:
+        """
+        Reset configuration to defaults.
+
+        Creates a backup before resetting.
+
+        Returns:
+            True if reset was successful.
+        """
+        self._create_backup()
+        return self.save_config(self._get_default_config())

sortmeout/config/settings.py

@@ -0,0 +1,201 @@
+"""
+Application settings.
+
+User-configurable settings for SortMeOut behavior.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class TrashSettings:
+    """Settings for trash management."""
+    enabled: bool = False
+    max_age_days: int = 30
+    max_size_gb: float = 10.0
+    app_sweep_enabled: bool = True
+    app_sweep_prompt: bool = True  # Ask before cleaning app files
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "enabled": self.enabled,
+            "max_age_days": self.max_age_days,
+            "max_size_gb": self.max_size_gb,
+            "app_sweep_enabled": self.app_sweep_enabled,
+            "app_sweep_prompt": self.app_sweep_prompt,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TrashSettings":
+        return cls(
+            enabled=data.get("enabled", False),
+            max_age_days=data.get("max_age_days", 30),
+            max_size_gb=data.get("max_size_gb", 10.0),
+            app_sweep_enabled=data.get("app_sweep_enabled", True),
+            app_sweep_prompt=data.get("app_sweep_prompt", True),
+        )
+
+
+@dataclass
+class NotificationSettings:
+    """Settings for notifications."""
+    enabled: bool = True
+    show_rule_matches: bool = False
+    show_errors: bool = True
+    show_summary: bool = True
+    summary_interval_minutes: int = 60
+    sound_enabled: bool = True
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "enabled": self.enabled,
+            "show_rule_matches": self.show_rule_matches,
+            "show_errors": self.show_errors,
+            "show_summary": self.show_summary,
+            "summary_interval_minutes": self.summary_interval_minutes,
+            "sound_enabled": self.sound_enabled,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "NotificationSettings":
+        return cls(
+            enabled=data.get("enabled", True),
+            show_rule_matches=data.get("show_rule_matches", False),
+            show_errors=data.get("show_errors", True),
+            show_summary=data.get("show_summary", True),
+            summary_interval_minutes=data.get("summary_interval_minutes", 60),
+            sound_enabled=data.get("sound_enabled", True),
+        )
+
+
+@dataclass
+class LoggingSettings:
+    """Settings for logging."""
+    level: str = "INFO"
+    file_logging: bool = True
+    max_log_size_mb: int = 10
+    backup_count: int = 5
+    action_logging: bool = True
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "level": self.level,
+            "file_logging": self.file_logging,
+            "max_log_size_mb": self.max_log_size_mb,
+            "backup_count": self.backup_count,
+            "action_logging": self.action_logging,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "LoggingSettings":
+        return cls(
+            level=data.get("level", "INFO"),
+            file_logging=data.get("file_logging", True),
+            max_log_size_mb=data.get("max_log_size_mb", 10),
+            backup_count=data.get("backup_count", 5),
+            action_logging=data.get("action_logging", True),
+        )
+
+
+@dataclass
+class WatcherSettings:
+    """Settings for file watching."""
+    latency_seconds: float = 0.5
+    debounce_seconds: float = 0.5
+    ignore_hidden_files: bool = True
+    ignore_system_files: bool = True
+    custom_ignore_patterns: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "latency_seconds": self.latency_seconds,
+            "debounce_seconds": self.debounce_seconds,
+            "ignore_hidden_files": self.ignore_hidden_files,
+            "ignore_system_files": self.ignore_system_files,
+            "custom_ignore_patterns": self.custom_ignore_patterns,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WatcherSettings":
+        return cls(
+            latency_seconds=data.get("latency_seconds", 0.5),
+            debounce_seconds=data.get("debounce_seconds", 0.5),
+            ignore_hidden_files=data.get("ignore_hidden_files", True),
+            ignore_system_files=data.get("ignore_system_files", True),
+            custom_ignore_patterns=data.get("custom_ignore_patterns", []),
+        )
+
+
+@dataclass
+class Settings:
+    """
+    Main application settings.
+
+    Contains all user-configurable settings for SortMeOut.
+    """
+    # General
+    start_at_login: bool = False
+    show_menu_bar_icon: bool = True
+    preview_mode: bool = False
+    confirm_destructive_actions: bool = True
+
+    # Subsystems
+    trash: TrashSettings = field(default_factory=TrashSettings)
+    notifications: NotificationSettings = field(default_factory=NotificationSettings)
+    logging: LoggingSettings = field(default_factory=LoggingSettings)
+    watcher: WatcherSettings = field(default_factory=WatcherSettings)
+
+    # UI preferences
+    theme: str = "system"  # system, light, dark
+    language: str = "en"
+    show_preview_on_hover: bool = True
+
+    # Advanced
+    max_concurrent_actions: int = 5
+    action_timeout_seconds: int = 300
+    retry_failed_actions: bool = False
+    retry_count: int = 3
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert settings to dictionary."""
+        return {
+            "start_at_login": self.start_at_login,
+            "show_menu_bar_icon": self.show_menu_bar_icon,
+            "preview_mode": self.preview_mode,
+            "confirm_destructive_actions": self.confirm_destructive_actions,
+            "trash": self.trash.to_dict(),
+            "notifications": self.notifications.to_dict(),
+            "logging": self.logging.to_dict(),
+            "watcher": self.watcher.to_dict(),
+            "theme": self.theme,
+            "language": self.language,
+            "show_preview_on_hover": self.show_preview_on_hover,
+            "max_concurrent_actions": self.max_concurrent_actions,
+            "action_timeout_seconds": self.action_timeout_seconds,
+            "retry_failed_actions": self.retry_failed_actions,
+            "retry_count": self.retry_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Settings":
+        """Create settings from dictionary."""
+        return cls(
+            start_at_login=data.get("start_at_login", False),
+            show_menu_bar_icon=data.get("show_menu_bar_icon", True),
+            preview_mode=data.get("preview_mode", False),
+            confirm_destructive_actions=data.get("confirm_destructive_actions", True),
+            trash=TrashSettings.from_dict(data.get("trash", {})),
+            notifications=NotificationSettings.from_dict(data.get("notifications", {})),
+            logging=LoggingSettings.from_dict(data.get("logging", {})),
+            watcher=WatcherSettings.from_dict(data.get("watcher", {})),
+            theme=data.get("theme", "system"),
+            language=data.get("language", "en"),
+            show_preview_on_hover=data.get("show_preview_on_hover", True),
+            max_concurrent_actions=data.get("max_concurrent_actions", 5),
+            action_timeout_seconds=data.get("action_timeout_seconds", 300),
+            retry_failed_actions=data.get("retry_failed_actions", False),
+            retry_count=data.get("retry_count", 3),
+        )

sortmeout/core/__init__.py

@@ -0,0 +1,21 @@
+"""
+Core module for SortMeOut.
+
+Contains the fundamental building blocks of the file automation system.
+"""
+
+from sortmeout.core.rule import Rule
+from sortmeout.core.condition import Condition, ConditionGroup
+from sortmeout.core.action import Action
+from sortmeout.core.watcher import FolderWatcher, WatcherManager
+from sortmeout.core.engine import RuleEngine
+
+__all__ = [
+    "Rule",
+    "Condition",
+    "ConditionGroup",
+    "Action",
+    "FolderWatcher",
+    "WatcherManager",
+    "RuleEngine",
+]