truthound-dashboard 1.4.3__py3-none-any.whl → 1.5.0__py3-none-any.whl

truthound_dashboard/core/reporters/registry.py

@@ -105,27 +105,18 @@ def _register_default_reporters(registry: ReporterRegistry) -> None:
     Args:
         registry: Registry to populate.
 
-    Registers 6 reporters:
+    Registers 3 reporters:
     - HTML: Rich visual reports with themes
     - CSV: Spreadsheet-compatible format
     - JSON: Machine-readable structured data
-    - Markdown: Documentation-friendly format
-    - PDF: Print-ready documents
-    - JUnit: CI/CD integration (Jenkins, GitHub Actions, etc.)
     """
     from .csv_reporter import CSVReporter
     from .html_reporter import HTMLReporter
     from .json_reporter import JSONReporter
-    from .junit_reporter import JUnitReporter
-    from .markdown_reporter import MarkdownReporter
-    from .pdf_reporter import PDFReporter
 
     registry.register(ReportFormat.HTML, HTMLReporter)
     registry.register(ReportFormat.CSV, CSVReporter)
     registry.register(ReportFormat.JSON, JSONReporter)
-    registry.register(ReportFormat.MARKDOWN, MarkdownReporter)
-    registry.register(ReportFormat.PDF, PDFReporter)
-    registry.register(ReportFormat.JUNIT, JUnitReporter)
 
     logger.debug(f"Registered {len(registry.available_formats)} default reporters")
 

truthound_dashboard/core/scheduler.py

@@ -34,6 +34,8 @@ from .notifications.dispatcher import create_dispatcher
 from .services import ValidationService
 from .truthound_adapter import get_adapter
 from .triggers import TriggerFactory, TriggerContext, TriggerEvaluation
+from .schema_watcher import process_due_watchers
+from .tiering import process_tiering_policies
 
 logger = logging.getLogger(__name__)
 
@@ -76,6 +78,10 @@ class ValidationScheduler:
     DATA_CHANGE_CHECK_INTERVAL_SECONDS = 60  # 1 minute (reduced for better responsiveness)
     # Default per-schedule check interval
     DEFAULT_SCHEDULE_CHECK_INTERVAL_MINUTES = 5
+    # Schema watcher check interval (how often to check for due watchers)
+    SCHEMA_WATCHER_CHECK_INTERVAL_SECONDS = 10  # Check every 10 seconds for due watchers
+    # Storage tiering check interval (default: check every hour)
+    TIERING_CHECK_INTERVAL_SECONDS = 3600  # 1 hour
 
     def __init__(
         self,
@@ -99,9 +105,19 @@ class ValidationScheduler:
         self._maintenance_cron = maintenance_cron or self.DEFAULT_MAINTENANCE_CRON
         self._maintenance_job_id = "system_maintenance"
         self._data_change_job_id = "data_change_check"
+        self._schema_watcher_job_id = "schema_watcher_check"
         self._data_change_check_interval = (
             data_change_check_interval or self.DATA_CHANGE_CHECK_INTERVAL_SECONDS
         )
+        self._schema_watcher_check_interval = self.SCHEMA_WATCHER_CHECK_INTERVAL_SECONDS
+
+        # Tiering state
+        self._tiering_job_id = "tiering_policy_check"
+        self._tiering_running = False
+        self._last_tiering_run: datetime | None = None
+        self._tiering_check_count = 0
+        self._tiering_processed_count = 0
+        self._tiering_check_interval = self.TIERING_CHECK_INTERVAL_SECONDS
 
         # Trigger monitoring state
         self._trigger_check_times: dict[str, datetime] = {}  # schedule_id -> last_check_at
@@ -111,6 +127,12 @@ class ValidationScheduler:
         self._last_checker_run: datetime | None = None
         self._checker_running = False
 
+        # Schema watcher monitoring state
+        self._last_schema_watcher_run: datetime | None = None
+        self._schema_watcher_running = False
+        self._schema_watcher_check_count = 0
+        self._schema_watcher_processed_count = 0
+
     async def start(self) -> None:
         """Start the scheduler and load existing schedules."""
         logger.info("Starting validation scheduler")
@@ -124,6 +146,12 @@ class ValidationScheduler:
         # Start data change trigger checker
         self._schedule_data_change_checker()
 
+        # Start schema watcher checker
+        self._schedule_schema_watcher_checker()
+
+        # Start tiering policy checker
+        self._schedule_tiering_checker()
+
     async def stop(self) -> None:
         """Stop the scheduler."""
         logger.info("Stopping validation scheduler")
@@ -500,6 +528,143 @@ class ValidationScheduler:
         except Exception as e:
             logger.error(f"Failed to schedule data change checker: {e}")
 
+    def _schedule_schema_watcher_checker(self) -> None:
+        """Schedule periodic checker for schema watchers."""
+        try:
+            self._scheduler.add_job(
+                self._check_schema_watchers,
+                trigger=IntervalTrigger(seconds=self._schema_watcher_check_interval),
+                id=self._schema_watcher_job_id,
+                name="Schema Watcher Checker",
+                replace_existing=True,
+            )
+            logger.info(
+                f"Scheduled schema watcher checker: every {self._schema_watcher_check_interval}s"
+            )
+        except Exception as e:
+            logger.error(f"Failed to schedule schema watcher checker: {e}")
+
+    async def _check_schema_watchers(self) -> None:
+        """Check all schema watchers that are due for checking.
+
+        This runs periodically to process watchers whose next_check_at
+        timestamp has passed.
+
+        Features:
+        - Processes all due watchers in order
+        - Updates watcher state after each check
+        - Creates alerts for detected changes
+        - Sends notifications if enabled
+        """
+        if self._schema_watcher_running:
+            logger.debug("Schema watcher check already running, skipping")
+            return
+
+        self._schema_watcher_running = True
+        self._last_schema_watcher_run = datetime.utcnow()
+        self._schema_watcher_check_count += 1
+        logger.debug("Checking schema watchers")
+
+        try:
+            async with get_session() as session:
+                processed = await process_due_watchers(session)
+                self._schema_watcher_processed_count += processed
+
+                if processed > 0:
+                    logger.info(f"Processed {processed} schema watcher(s)")
+        except Exception as e:
+            logger.error(f"Error checking schema watchers: {e}")
+        finally:
+            self._schema_watcher_running = False
+
+    def get_schema_watcher_status(self) -> dict[str, Any]:
+        """Get current schema watcher checker status.
+
+        Returns:
+            Dictionary with schema watcher checker stats.
+        """
+        return {
+            "enabled": True,
+            "checker_running": self._schema_watcher_running,
+            "checker_interval_seconds": self._schema_watcher_check_interval,
+            "last_checker_run_at": (
+                self._last_schema_watcher_run.isoformat()
+                if self._last_schema_watcher_run else None
+            ),
+            "total_checks": self._schema_watcher_check_count,
+            "total_processed": self._schema_watcher_processed_count,
+        }
+
+    def _schedule_tiering_checker(self) -> None:
+        """Schedule periodic checker for storage tiering policies."""
+        try:
+            self._scheduler.add_job(
+                self._check_tiering_policies,
+                trigger=IntervalTrigger(seconds=self._tiering_check_interval),
+                id=self._tiering_job_id,
+                name="Tiering Policy Checker",
+                replace_existing=True,
+            )
+            logger.info(
+                f"Scheduled tiering policy checker: every {self._tiering_check_interval}s"
+            )
+        except Exception as e:
+            logger.error(f"Failed to schedule tiering policy checker: {e}")
+
+    async def _check_tiering_policies(self) -> None:
+        """Check and execute all active tiering policies.
+
+        This runs periodically to evaluate tier policies and migrate
+        eligible items between storage tiers.
+
+        Features:
+        - Processes all active policies in priority order
+        - Records migration history
+        - Respects batch size limits from configuration
+        """
+        if self._tiering_running:
+            logger.debug("Tiering policy check already running, skipping")
+            return
+
+        self._tiering_running = True
+        self._last_tiering_run = datetime.utcnow()
+        self._tiering_check_count += 1
+        logger.debug("Checking tiering policies")
+
+        try:
+            async with get_session() as session:
+                results = await process_tiering_policies(session)
+                total_migrated = sum(r.items_migrated for r in results)
+                self._tiering_processed_count += total_migrated
+
+                if total_migrated > 0:
+                    logger.info(
+                        f"Tiering: migrated {total_migrated} item(s) "
+                        f"across {len(results)} policy(ies)"
+                    )
+        except Exception as e:
+            logger.error(f"Error checking tiering policies: {e}")
+        finally:
+            self._tiering_running = False
+
+    def get_tiering_status(self) -> dict[str, Any]:
+        """Get current tiering checker status.
+
+        Returns:
+            Dictionary with tiering checker stats.
+        """
+        return {
+            "enabled": True,
+            "checker_running": self._tiering_running,
+            "checker_interval_seconds": self._tiering_check_interval,
+            "last_checker_run_at": (
+                self._last_tiering_run.isoformat()
+                if self._last_tiering_run else None
+            ),
+            "total_checks": self._tiering_check_count,
+            "total_migrated": self._tiering_processed_count,
+        }
+
     async def _check_data_change_triggers(self) -> None:
         """Check all data change and composite triggers.
 

truthound_dashboard/core/schema_evolution.py

@@ -84,7 +84,7 @@ class SchemaVersionRepository(BaseRepository[SchemaVersion]):
             offset=offset,
             limit=limit,
             filters=[SchemaVersion.source_id == source_id],
-            order_by=[SchemaVersion.version_number.desc()],
+            order_by=SchemaVersion.version_number.desc(),
         )
 
     async def get_next_version_number(self, source_id: str) -> int:
@@ -151,7 +151,7 @@ class SchemaChangeRepository(BaseRepository[SchemaChange]):
             offset=offset,
             limit=limit,
             filters=[SchemaChange.source_id == source_id],
-            order_by=[SchemaChange.created_at.desc()],
+            order_by=SchemaChange.created_at.desc(),
         )
 
     async def get_for_version(
@@ -167,7 +167,7 @@ class SchemaChangeRepository(BaseRepository[SchemaChange]):
         """
         return await self.list(
             filters=[SchemaChange.to_version_id == to_version_id],
-            order_by=[SchemaChange.created_at.desc()],
+            order_by=SchemaChange.created_at.desc(),
         )
 
     async def count_breaking_changes(self, source_id: str) -> int: