1.1.0 - automations, clean only mode, bug fixes

server/automations/engine.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import threading
+from typing import Dict, List, Optional
+
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from logging_utils import get_logger
+from automations.actions import enumerate_srt_files, remove_lines_matching_patterns
+from automations.models import AutomationRule
+
+logger = get_logger(__name__)
+
+
+class AutomationEngine:
+    """Scheduler for automation rules."""
+
+    def __init__(self, db_manager):
+        self.db_manager = db_manager
+        self._scheduler = BackgroundScheduler(daemon=True)
+        self._lock = threading.Lock()
+        self._started = False
+
+    def start(self):
+        with self._lock:
+            if self._started:
+                return
+            self._scheduler.start()
+            self._started = True
+            self.reload_rules()
+            logger.info("Automation scheduler started")
+
+    def shutdown(self):
+        with self._lock:
+            if not self._started:
+                return
+            self._scheduler.shutdown(wait=False)
+            self._started = False
+            logger.info("Automation scheduler stopped")
+
+    def reload_rules(self):
+        """Reload all automation rules from storage."""
+        with self._lock:
+            self._scheduler.remove_all_jobs()
+            rules = self._load_rules()
+            for rule in rules:
+                if not rule.enabled:
+                    continue
+                self._schedule_rule(rule)
+
+    def run_rule_now(self, rule_id: str, dry_run: bool = False) -> dict:
+        rule = self._get_rule(rule_id)
+        if not rule:
+            return {"success": False, "error": "Rule not found"}
+        return self._execute_rule(rule, dry_run=dry_run)
+
+    def _load_rules(self) -> List[AutomationRule]:
+        rules_raw = self.db_manager.get_automation_rules()
+        return [AutomationRule.from_dict(r) for r in rules_raw]
+
+    def _get_rule(self, rule_id: str) -> Optional[AutomationRule]:
+        raw = self.db_manager.get_automation_rule(rule_id)
+        return AutomationRule.from_dict(raw) if raw else None
+
+    def _schedule_rule(self, rule: AutomationRule):
+        try:
+            trigger = CronTrigger.from_crontab(rule.schedule)
+        except ValueError as e:
+            logger.error("Invalid cron schedule for rule %s: %s", rule.id, e)
+            return
+        self._scheduler.add_job(
+            self._run_rule_job,
+            trigger=trigger,
+            args=[rule.id],
+            id=f"automation:{rule.id}",
+            replace_existing=True,
+            misfire_grace_time=300,
+            max_instances=1,
+        )
+
+    def _run_rule_job(self, rule_id: str):
+        rule = self._get_rule(rule_id)
+        if not rule or not rule.enabled:
+            return
+        self._execute_rule(rule, dry_run=False)
+
+    def _execute_rule(self, rule: AutomationRule, dry_run: bool) -> dict:
+        files = enumerate_srt_files(rule.target_folders)
+        modified = 0
+        total_removed = 0
+        errors: List[str] = []
+
+        for file_path in files:
+            try:
+                did_modify, removed_lines = remove_lines_matching_patterns(
+                    str(file_path),
+                    rule.patterns,
+                    dry_run=dry_run,
+                )
+                if did_modify:
+                    modified += 1
+                    total_removed += removed_lines
+                self.db_manager.add_automation_log(
+                    rule_id=rule.id,
+                    file_path=str(file_path),
+                    modified=did_modify,
+                    removed_lines=removed_lines,
+                    dry_run=dry_run,
+                    error_message=None,
+                )
+            except Exception as e:
+                errors.append(f"{file_path}: {e}")
+                self.db_manager.add_automation_log(
+                    rule_id=rule.id,
+                    file_path=str(file_path),
+                    modified=False,
+                    removed_lines=0,
+                    dry_run=dry_run,
+                    error_message=str(e),
+                )
+
+        return {
+            "success": True,
+            "rule_id": rule.id,
+            "files_scanned": len(files),
+            "files_modified": modified,
+            "removed_lines": total_removed,
+            "dry_run": dry_run,
+            "errors": errors,
+        }