Upload 12 files

app.py

@@ -21,6 +21,7 @@ import os
 from urllib.parse import urljoin
 
 from database import Database
+from database import compat as db_compat  # noqa: F401  (monkey-patch DatabaseManager)
 from config import config as global_config
 
 class SentimentRequest(BaseModel):

database.py

@@ -107,81 +107,81 @@ class Database:
                 )
             """)
 
-              # Configuration table
-              cursor.execute("""
-                  CREATE TABLE IF NOT EXISTS configuration (
-                      key TEXT PRIMARY KEY,
-                      value TEXT NOT NULL,
-                      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                  )
-              """)
-
-              # Pools table
-              cursor.execute("""
-                  CREATE TABLE IF NOT EXISTS pools (
-                      id INTEGER PRIMARY KEY AUTOINCREMENT,
-                      name TEXT NOT NULL,
-                      category TEXT NOT NULL,
-                      rotation_strategy TEXT NOT NULL,
-                      description TEXT,
-                      enabled INTEGER DEFAULT 1,
-                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                  )
-              """)
-
-              # Pool members table
-              cursor.execute("""
-                  CREATE TABLE IF NOT EXISTS pool_members (
-                      id INTEGER PRIMARY KEY AUTOINCREMENT,
-                      pool_id INTEGER NOT NULL,
-                      provider_id TEXT NOT NULL,
-                      provider_name TEXT NOT NULL,
-                      priority INTEGER DEFAULT 1,
-                      weight INTEGER DEFAULT 1,
-                      use_count INTEGER DEFAULT 0,
-                      success_rate REAL DEFAULT 0,
-                      rate_limit_usage INTEGER DEFAULT 0,
-                      rate_limit_limit INTEGER DEFAULT 0,
-                      rate_limit_percentage REAL DEFAULT 0,
-                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                      FOREIGN KEY (pool_id) REFERENCES pools(id) ON DELETE CASCADE
-                  )
-              """)
-
-              # Pool rotation history
-              cursor.execute("""
-                  CREATE TABLE IF NOT EXISTS pool_rotations (
-                      id INTEGER PRIMARY KEY AUTOINCREMENT,
-                      pool_id INTEGER NOT NULL,
-                      provider_id TEXT NOT NULL,
-                      provider_name TEXT NOT NULL,
-                      reason TEXT NOT NULL,
-                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                      FOREIGN KEY (pool_id) REFERENCES pools(id) ON DELETE CASCADE
-                  )
-              """)
-
-              # Create indexes
-              cursor.execute("""
-                  CREATE INDEX IF NOT EXISTS idx_status_log_provider
-                  ON status_log(provider_name, timestamp)
-              """)
-              cursor.execute("""
-                  CREATE INDEX IF NOT EXISTS idx_status_log_timestamp
-                  ON status_log(timestamp)
-              """)
-              cursor.execute("""
-                  CREATE INDEX IF NOT EXISTS idx_incidents_provider
-                  ON incidents(provider_name, start_time)
-              """)
-              cursor.execute("""
-                  CREATE INDEX IF NOT EXISTS idx_pool_members_pool
-                  ON pool_members(pool_id, provider_id)
-              """)
-              cursor.execute("""
-                  CREATE INDEX IF NOT EXISTS idx_pool_rotations_pool
-                  ON pool_rotations(pool_id, created_at)
-              """)
+            # Configuration table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS configuration (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Pools table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS pools (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    category TEXT NOT NULL,
+                    rotation_strategy TEXT NOT NULL,
+                    description TEXT,
+                    enabled INTEGER DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Pool members table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS pool_members (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pool_id INTEGER NOT NULL,
+                    provider_id TEXT NOT NULL,
+                    provider_name TEXT NOT NULL,
+                    priority INTEGER DEFAULT 1,
+                    weight INTEGER DEFAULT 1,
+                    use_count INTEGER DEFAULT 0,
+                    success_rate REAL DEFAULT 0,
+                    rate_limit_usage INTEGER DEFAULT 0,
+                    rate_limit_limit INTEGER DEFAULT 0,
+                    rate_limit_percentage REAL DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (pool_id) REFERENCES pools(id) ON DELETE CASCADE
+                )
+            """)
+
+            # Pool rotation history
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS pool_rotations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pool_id INTEGER NOT NULL,
+                    provider_id TEXT NOT NULL,
+                    provider_name TEXT NOT NULL,
+                    reason TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (pool_id) REFERENCES pools(id) ON DELETE CASCADE
+                )
+            """)
+
+            # Create indexes
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_status_log_provider
+                ON status_log(provider_name, timestamp)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_status_log_timestamp
+                ON status_log(timestamp)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_incidents_provider
+                ON incidents(provider_name, start_time)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_pool_members_pool
+                ON pool_members(pool_id, provider_id)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_pool_rotations_pool
+                ON pool_rotations(pool_id, created_at)
+            """)
 
             logger.info("Database initialized successfully")
 
@@ -533,244 +533,244 @@ class Database:
 
                 logger.info(f"Exported {len(rows)} rows to {output_path}")
 
-      # ------------------------------------------------------------------
-      # Pool management helpers
-      # ------------------------------------------------------------------
-
-      def create_pool(
-          self,
-          name: str,
-          category: str,
-          rotation_strategy: str,
-          description: Optional[str] = None,
-          enabled: bool = True
-      ) -> int:
-          """Create a new pool and return its ID"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  INSERT INTO pools (name, category, rotation_strategy, description, enabled)
-                  VALUES (?, ?, ?, ?, ?)
-              """, (name, category, rotation_strategy, description, int(enabled)))
-              return cursor.lastrowid
-
-      def update_pool_usage(self, pool_id: int, enabled: Optional[bool] = None):
-          """Update pool properties"""
-          if enabled is None:
-              return
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  UPDATE pools
-                  SET enabled = ?, created_at = created_at
-                  WHERE id = ?
-              """, (int(enabled), pool_id))
-
-      def delete_pool(self, pool_id: int):
-          """Delete pool and cascade members/history"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("DELETE FROM pools WHERE id = ?", (pool_id,))
-
-      def add_pool_member(
-          self,
-          pool_id: int,
-          provider_id: str,
-          provider_name: str,
-          priority: int = 1,
-          weight: int = 1,
-          success_rate: float = 0.0,
-          rate_limit_usage: int = 0,
-          rate_limit_limit: int = 0,
-          rate_limit_percentage: float = 0.0
-      ) -> int:
-          """Add a provider to a pool"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  INSERT INTO pool_members
-                  (pool_id, provider_id, provider_name, priority, weight,
-                   success_rate, rate_limit_usage, rate_limit_limit, rate_limit_percentage)
-                  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-              """, (
-                  pool_id,
-                  provider_id,
-                  provider_name,
-                  priority,
-                  weight,
-                  success_rate,
-                  rate_limit_usage,
-                  rate_limit_limit,
-                  rate_limit_percentage
-              ))
-              return cursor.lastrowid
-
-      def remove_pool_member(self, pool_id: int, provider_id: str):
-          """Remove provider from pool"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  DELETE FROM pool_members
-                  WHERE pool_id = ? AND provider_id = ?
-              """, (pool_id, provider_id))
-
-      def increment_member_use(self, pool_id: int, provider_id: str):
-          """Increment use count for pool member"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  UPDATE pool_members
-                  SET use_count = use_count + 1
-                  WHERE pool_id = ? AND provider_id = ?
-              """, (pool_id, provider_id))
-
-      def update_member_stats(
-          self,
-          pool_id: int,
-          provider_id: str,
-          success_rate: Optional[float] = None,
-          rate_limit_usage: Optional[int] = None,
-          rate_limit_limit: Optional[int] = None,
-          rate_limit_percentage: Optional[float] = None
-      ):
-          """Update success/rate limit stats"""
-          updates = []
-          params = []
-
-          if success_rate is not None:
-              updates.append("success_rate = ?")
-              params.append(success_rate)
-          if rate_limit_usage is not None:
-              updates.append("rate_limit_usage = ?")
-              params.append(rate_limit_usage)
-          if rate_limit_limit is not None:
-              updates.append("rate_limit_limit = ?")
-              params.append(rate_limit_limit)
-          if rate_limit_percentage is not None:
-              updates.append("rate_limit_percentage = ?")
-              params.append(rate_limit_percentage)
-
-          if not updates:
-              return
-
-          params.extend([pool_id, provider_id])
-
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute(f"""
-                  UPDATE pool_members
-                  SET {', '.join(updates)}
-                  WHERE pool_id = ? AND provider_id = ?
-              """, params)
-
-      def log_pool_rotation(
-          self,
-          pool_id: int,
-          provider_id: str,
-          provider_name: str,
-          reason: str
-      ):
-          """Log rotation event"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  INSERT INTO pool_rotations
-                  (pool_id, provider_id, provider_name, reason)
-                  VALUES (?, ?, ?, ?)
-              """, (pool_id, provider_id, provider_name, reason))
-
-      def get_pools(self) -> List[Dict]:
-          """Get all pools with members and stats"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  SELECT p.*,
-                         COALESCE((SELECT COUNT(*) FROM pool_rotations pr WHERE pr.pool_id = p.id), 0) as rotation_count
-                  FROM pools p
-                  ORDER BY p.created_at DESC
-              """)
-              pools = [dict(row) for row in cursor.fetchall()]
-
-              for pool in pools:
-                  cursor.execute("""
-                      SELECT * FROM pool_members
-                      WHERE pool_id = ?
-                      ORDER BY priority DESC, weight DESC, provider_name
-                  """, (pool['id'],))
-                  pool['members'] = [dict(row) for row in cursor.fetchall()]
-
-              return pools
-
-      def get_pool(self, pool_id: int) -> Optional[Dict]:
-          """Get single pool"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  SELECT p.*,
-                         COALESCE((SELECT COUNT(*) FROM pool_rotations pr WHERE pr.pool_id = p.id), 0) as rotation_count
-                  FROM pools p
-                  WHERE p.id = ?
-              """, (pool_id,))
-              row = cursor.fetchone()
-              if not row:
-                  return None
-              pool = dict(row)
-              cursor.execute("""
-                  SELECT * FROM pool_members
-                  WHERE pool_id = ?
-                  ORDER BY priority DESC, weight DESC, provider_name
-              """, (pool_id,))
-              pool['members'] = [dict(r) for r in cursor.fetchall()]
-              return pool
-
-      def get_pool_rotation_history(self, pool_id: Optional[int] = None, limit: int = 50) -> List[Dict]:
-          """Get rotation history (optionally filtered by pool)"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              if pool_id is not None:
-                  cursor.execute("""
-                      SELECT * FROM pool_rotations
-                      WHERE pool_id = ?
-                      ORDER BY created_at DESC
-                      LIMIT ?
-                  """, (pool_id, limit))
-              else:
-                  cursor.execute("""
-                      SELECT * FROM pool_rotations
-                      ORDER BY created_at DESC
-                      LIMIT ?
-                  """, (limit,))
-              return [dict(row) for row in cursor.fetchall()]
-
-      # ------------------------------------------------------------------
-      # Provider health logging
-      # ------------------------------------------------------------------
-
-      def log_provider_status(
-          self,
-          provider_name: str,
-          category: str,
-          status: str,
-          response_time: Optional[float] = None,
-          status_code: Optional[int] = None,
-          endpoint_tested: Optional[str] = None,
-          error_message: Optional[str] = None
-      ):
-          """Log provider status in status_log table"""
-          with self.get_connection() as conn:
-              cursor = conn.cursor()
-              cursor.execute("""
-                  INSERT INTO status_log
-                  (provider_name, category, status, response_time, status_code,
-                   error_message, endpoint_tested, timestamp)
-                  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-              """, (
-                  provider_name,
-                  category,
-                  status,
-                  response_time,
-                  status_code,
-                  error_message,
-                  endpoint_tested,
-                  time.time()
-              ))
+    # ------------------------------------------------------------------
+    # Pool management helpers
+    # ------------------------------------------------------------------
+
+    def create_pool(
+        self,
+        name: str,
+        category: str,
+        rotation_strategy: str,
+        description: Optional[str] = None,
+        enabled: bool = True
+    ) -> int:
+        """Create a new pool and return its ID"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO pools (name, category, rotation_strategy, description, enabled)
+                VALUES (?, ?, ?, ?, ?)
+            """, (name, category, rotation_strategy, description, int(enabled)))
+            return cursor.lastrowid
+
+    def update_pool_usage(self, pool_id: int, enabled: Optional[bool] = None):
+        """Update pool properties"""
+        if enabled is None:
+            return
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                UPDATE pools
+                SET enabled = ?, created_at = created_at
+                WHERE id = ?
+            """, (int(enabled), pool_id))
+
+    def delete_pool(self, pool_id: int):
+        """Delete pool and cascade members/history"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM pools WHERE id = ?", (pool_id,))
+
+    def add_pool_member(
+        self,
+        pool_id: int,
+        provider_id: str,
+        provider_name: str,
+        priority: int = 1,
+        weight: int = 1,
+        success_rate: float = 0.0,
+        rate_limit_usage: int = 0,
+        rate_limit_limit: int = 0,
+        rate_limit_percentage: float = 0.0
+    ) -> int:
+        """Add a provider to a pool"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO pool_members
+                (pool_id, provider_id, provider_name, priority, weight,
+                 success_rate, rate_limit_usage, rate_limit_limit, rate_limit_percentage)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                pool_id,
+                provider_id,
+                provider_name,
+                priority,
+                weight,
+                success_rate,
+                rate_limit_usage,
+                rate_limit_limit,
+                rate_limit_percentage
+            ))
+            return cursor.lastrowid
+
+    def remove_pool_member(self, pool_id: int, provider_id: str):
+        """Remove provider from pool"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                DELETE FROM pool_members
+                WHERE pool_id = ? AND provider_id = ?
+            """, (pool_id, provider_id))
+
+    def increment_member_use(self, pool_id: int, provider_id: str):
+        """Increment use count for pool member"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                UPDATE pool_members
+                SET use_count = use_count + 1
+                WHERE pool_id = ? AND provider_id = ?
+            """, (pool_id, provider_id))
+
+    def update_member_stats(
+        self,
+        pool_id: int,
+        provider_id: str,
+        success_rate: Optional[float] = None,
+        rate_limit_usage: Optional[int] = None,
+        rate_limit_limit: Optional[int] = None,
+        rate_limit_percentage: Optional[float] = None
+    ):
+        """Update success/rate limit stats"""
+        updates = []
+        params = []
+
+        if success_rate is not None:
+            updates.append("success_rate = ?")
+            params.append(success_rate)
+        if rate_limit_usage is not None:
+            updates.append("rate_limit_usage = ?")
+            params.append(rate_limit_usage)
+        if rate_limit_limit is not None:
+            updates.append("rate_limit_limit = ?")
+            params.append(rate_limit_limit)
+        if rate_limit_percentage is not None:
+            updates.append("rate_limit_percentage = ?")
+            params.append(rate_limit_percentage)
+
+        if not updates:
+            return
+
+        params.extend([pool_id, provider_id])
+
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(f"""
+                UPDATE pool_members
+                SET {', '.join(updates)}
+                WHERE pool_id = ? AND provider_id = ?
+            """, params)
+
+    def log_pool_rotation(
+        self,
+        pool_id: int,
+        provider_id: str,
+        provider_name: str,
+        reason: str
+    ):
+        """Log rotation event"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO pool_rotations
+                (pool_id, provider_id, provider_name, reason)
+                VALUES (?, ?, ?, ?)
+            """, (pool_id, provider_id, provider_name, reason))
+
+    def get_pools(self) -> List[Dict]:
+        """Get all pools with members and stats"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT p.*,
+                       COALESCE((SELECT COUNT(*) FROM pool_rotations pr WHERE pr.pool_id = p.id), 0) as rotation_count
+                FROM pools p
+                ORDER BY p.created_at DESC
+            """)
+            pools = [dict(row) for row in cursor.fetchall()]
+
+            for pool in pools:
+                cursor.execute("""
+                    SELECT * FROM pool_members
+                    WHERE pool_id = ?
+                    ORDER BY priority DESC, weight DESC, provider_name
+                """, (pool['id'],))
+                pool['members'] = [dict(row) for row in cursor.fetchall()]
+
+            return pools
+
+    def get_pool(self, pool_id: int) -> Optional[Dict]:
+        """Get single pool"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT p.*,
+                       COALESCE((SELECT COUNT(*) FROM pool_rotations pr WHERE pr.pool_id = p.id), 0) as rotation_count
+                FROM pools p
+                WHERE p.id = ?
+            """, (pool_id,))
+            row = cursor.fetchone()
+            if not row:
+                return None
+            pool = dict(row)
+            cursor.execute("""
+                SELECT * FROM pool_members
+                WHERE pool_id = ?
+                ORDER BY priority DESC, weight DESC, provider_name
+            """, (pool_id,))
+            pool['members'] = [dict(r) for r in cursor.fetchall()]
+            return pool
+
+    def get_pool_rotation_history(self, pool_id: Optional[int] = None, limit: int = 50) -> List[Dict]:
+        """Get rotation history (optionally filtered by pool)"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            if pool_id is not None:
+                cursor.execute("""
+                    SELECT * FROM pool_rotations
+                    WHERE pool_id = ?
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                """, (pool_id, limit))
+            else:
+                cursor.execute("""
+                    SELECT * FROM pool_rotations
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                """, (limit,))
+            return [dict(row) for row in cursor.fetchall()]
+
+    # ------------------------------------------------------------------
+    # Provider health logging
+    # ------------------------------------------------------------------
+
+    def log_provider_status(
+        self,
+        provider_name: str,
+        category: str,
+        status: str,
+        response_time: Optional[float] = None,
+        status_code: Optional[int] = None,
+        endpoint_tested: Optional[str] = None,
+        error_message: Optional[str] = None
+    ):
+        """Log provider status in status_log table"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO status_log
+                (provider_name, category, status, response_time, status_code,
+                 error_message, endpoint_tested, timestamp)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                provider_name,
+                category,
+                status,
+                response_time,
+                status_code,
+                error_message,
+                endpoint_tested,
+                time.time()
+            ))

database/__init__.py

@@ -1,8 +1,44 @@
-"""Database module for crypto API monitoring"""
+"""Database package exports.
 
-from database.db_manager import DatabaseManager
+This package exposes both the new SQLAlchemy-based ``DatabaseManager`` and the
+legacy SQLite-backed ``Database`` class that the existing application modules
+still import via ``from database import Database``. During the transition phase
+we dynamically load the legacy implementation from the root ``database.py``
+module (renamed here as ``legacy_database`` when importing) and fall back to the
+new manager if that module is unavailable.
+"""
 
-# For backward compatibility
-Database = DatabaseManager
+from importlib import util as _importlib_util
+from pathlib import Path as _Path
+from typing import Optional as _Optional
 
-__all__ = ['DatabaseManager', 'Database']
+from .db_manager import DatabaseManager
+
+def _load_legacy_database() -> _Optional[type]:
+    """Load the legacy Database class from the root-level ``database.py`` if it exists."""
+    legacy_path = _Path(__file__).resolve().parent.parent / "database.py"
+    if not legacy_path.exists():
+        return None
+
+    spec = _importlib_util.spec_from_file_location("legacy_database", legacy_path)
+    if spec is None or spec.loader is None:
+        return None
+
+    module = _importlib_util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(module)
+    except Exception:
+        # If loading the legacy module fails we silently fall back to DatabaseManager
+        return None
+
+    return getattr(module, "Database", None)
+
+
+_LegacyDatabase = _load_legacy_database()
+
+if _LegacyDatabase is not None:
+    Database = _LegacyDatabase
+else:
+    Database = DatabaseManager
+
+__all__ = ["DatabaseManager", "Database"]

database/compat.py

@@ -0,0 +1,196 @@
+"""Compat layer for DatabaseManager to provide methods expected by legacy app code.
+
+This module monkey-patches the DatabaseManager class from database.db_manager
+to add:
+- log_provider_status
+- get_uptime_percentage
+- get_avg_response_time
+
+The implementations are lightweight and defensive: if the underlying engine
+is not available, they fail gracefully instead of raising errors.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Optional
+
+try:
+    from sqlalchemy import text as _sa_text
+except Exception:  # pragma: no cover - extremely defensive
+    _sa_text = None  # type: ignore
+
+try:
+    from .db_manager import DatabaseManager  # type: ignore
+except Exception:  # pragma: no cover
+    DatabaseManager = None  # type: ignore
+
+
+def _get_engine(instance) -> Optional[object]:
+    """Best-effort helper to get an SQLAlchemy engine from the manager."""
+    return getattr(instance, "engine", None)
+
+
+def _ensure_table(conn) -> None:
+    """Create provider_status table if it does not exist yet."""
+    if _sa_text is None:
+        return
+    conn.execute(
+        _sa_text(
+            """
+            CREATE TABLE IF NOT EXISTS provider_status (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                provider_name TEXT NOT NULL,
+                category TEXT NOT NULL,
+                status TEXT NOT NULL,
+                response_time REAL,
+                status_code INTEGER,
+                error_message TEXT,
+                endpoint_tested TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+    )
+
+
+def _log_provider_status(
+    self,
+    provider_name: str,
+    category: str,
+    status: str,
+    response_time: Optional[float] = None,
+    status_code: Optional[int] = None,
+    endpoint_tested: Optional[str] = None,
+    error_message: Optional[str] = None,
+) -> None:
+    """Insert a status row into provider_status.
+
+    This is a best-effort logger; if no engine is available it silently returns.
+    """
+    engine = _get_engine(self)
+    if engine is None or _sa_text is None:
+        return
+
+    now = datetime.utcnow()
+    try:
+        with engine.begin() as conn:  # type: ignore[call-arg]
+            _ensure_table(conn)
+            conn.execute(
+                _sa_text(
+                    """
+                    INSERT INTO provider_status (
+                        provider_name,
+                        category,
+                        status,
+                        response_time,
+                        status_code,
+                        error_message,
+                        endpoint_tested,
+                        created_at
+                    )
+                    VALUES (
+                        :provider_name,
+                        :category,
+                        :status,
+                        :response_time,
+                        :status_code,
+                        :error_message,
+                        :endpoint_tested,
+                        :created_at
+                    )
+                    """
+                ),
+                {
+                    "provider_name": provider_name,
+                    "category": category,
+                    "status": status,
+                    "response_time": response_time,
+                    "status_code": status_code,
+                    "error_message": error_message,
+                    "endpoint_tested": endpoint_tested,
+                    "created_at": now,
+                },
+            )
+    except Exception:  # pragma: no cover - we never want this to crash the app
+        # Swallow DB errors; health endpoints must not bring the whole app down.
+        return
+
+
+def _get_uptime_percentage(self, provider_name: str, hours: int = 24) -> float:
+    """Compute uptime percentage for a provider in the last N hours.
+
+    Uptime is calculated as the ratio of rows with status='online' to total
+    rows in the provider_status table within the given time window.
+    """
+    engine = _get_engine(self)
+    if engine is None or _sa_text is None:
+        return 0.0
+
+    cutoff = datetime.utcnow() - timedelta(hours=hours)
+    try:
+        with engine.begin() as conn:  # type: ignore[call-arg]
+            _ensure_table(conn)
+            result = conn.execute(
+                _sa_text(
+                    """
+                    SELECT
+                        COUNT(*) AS total,
+                        SUM(CASE WHEN status = 'online' THEN 1 ELSE 0 END) AS online
+                    FROM provider_status
+                    WHERE provider_name = :provider_name
+                      AND created_at >= :cutoff
+                    """
+                ),
+                {"provider_name": provider_name, "cutoff": cutoff},
+            ).first()
+    except Exception:
+        return 0.0
+
+    if not result or result[0] in (None, 0):
+        return 0.0
+
+    total = float(result[0] or 0)
+    online = float(result[1] or 0)
+    return round(100.0 * online / total, 2)
+
+
+def _get_avg_response_time(self, provider_name: str, hours: int = 24) -> float:
+    """Average response time (ms) for a provider over the last N hours."""
+    engine = _get_engine(self)
+    if engine is None or _sa_text is None:
+        return 0.0
+
+    cutoff = datetime.utcnow() - timedelta(hours=hours)
+    try:
+        with engine.begin() as conn:  # type: ignore[call-arg]
+            _ensure_table(conn)
+            result = conn.execute(
+                _sa_text(
+                    """
+                    SELECT AVG(response_time) AS avg_response
+                    FROM provider_status
+                    WHERE provider_name = :provider_name
+                      AND response_time IS NOT NULL
+                      AND created_at >= :cutoff
+                    """
+                ),
+                {"provider_name": provider_name, "cutoff": cutoff},
+            ).first()
+    except Exception:
+        return 0.0
+
+    if not result or result[0] is None:
+        return 0.0
+
+    return round(float(result[0]), 2)
+
+
+# Apply monkey-patches when this module is imported.
+if DatabaseManager is not None:  # pragma: no cover
+    if not hasattr(DatabaseManager, "log_provider_status"):
+        DatabaseManager.log_provider_status = _log_provider_status  # type: ignore[attr-defined]
+    if not hasattr(DatabaseManager, "get_uptime_percentage"):
+        DatabaseManager.get_uptime_percentage = _get_uptime_percentage  # type: ignore[attr-defined]
+    if not hasattr(DatabaseManager, "get_avg_response_time"):
+        DatabaseManager.get_avg_response_time = _get_avg_response_time  # type: ignore[attr-defined]

database/db_manager.py

@@ -1537,126 +1537,3 @@ if __name__ == "__main__":
         if table != 'database_size_mb':
             print(f"  {table}: {count}")
     print(f"  Database Size: {stats.get('database_size_mb', 0)} MB")
-
-
-# === Monkey-patch compatibility methods for legacy health logging ===
-# These provide the same interface as the older `Database` class from database.py
-# so that calls like `db.log_provider_status` and `db.get_uptime_percentage`
-# used in app.py continue to work when using DatabaseManager with SQLAlchemy.
-
-from sqlalchemy import text as _sa_text
-from datetime import datetime as _dt, timedelta as _td
-
-def _dm_log_provider_status(
-    self,
-    provider_name: str,
-    category: str,
-    status: str,
-    response_time: Optional[float] = None,
-    status_code: Optional[int] = None,
-    endpoint_tested: Optional[str] = None,
-    error_message: Optional[str] = None,
-):
-    """Log provider status into a simple `status_log` table.
-
-    This mirrors the behavior of the older sqlite-based `Database.log_provider_status`
-    implementation so that existing code paths in app.py keep working.
-    """
-    try:
-        # Ensure table exists (idempotent)
-        create_sql = _sa_text("""
-            CREATE TABLE IF NOT EXISTS status_log (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                provider_name TEXT NOT NULL,
-                category TEXT NOT NULL,
-                status TEXT NOT NULL,
-                response_time REAL,
-                status_code INTEGER,
-                error_message TEXT,
-                endpoint_tested TEXT,
-                timestamp REAL NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        """)
-        insert_sql = _sa_text("""
-            INSERT INTO status_log
-                (provider_name, category, status, response_time, status_code,
-                 error_message, endpoint_tested, timestamp)
-            VALUES (:provider_name, :category, :status, :response_time, :status_code,
-                    :error_message, :endpoint_tested, :timestamp)
-        """)
-        with self.engine.begin() as conn:
-            conn.execute(create_sql)
-            conn.execute(
-                insert_sql,
-                {
-                    "provider_name": provider_name,
-                    "category": category,
-                    "status": status,
-                    "response_time": response_time,
-                    "status_code": status_code,
-                    "error_message": error_message,
-                    "endpoint_tested": endpoint_tested,
-                    "timestamp": _dt.now().timestamp(),
-                },
-            )
-    except Exception as e:  # pragma: no cover - logging safeguard
-        logger.error(f"Failed to log provider status for {provider_name}: {e}", exc_info=True)
-
-
-def _dm_get_uptime_percentage(
-    self,
-    provider_name: str,
-    hours: int = 24,
-) -> float:
-    """Calculate uptime percentage from `status_log` table.
-
-    This approximates the legacy behavior:
-    uptime = (online_rows / total_rows) * 100
-    where `status = 'online'` is treated as healthy.
-    """
-    try:
-        cutoff = _dt.now() - _td(hours=hours)
-        # Ensure table exists before querying
-        create_sql = _sa_text("""
-            CREATE TABLE IF NOT EXISTS status_log (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                provider_name TEXT NOT NULL,
-                category TEXT NOT NULL,
-                status TEXT NOT NULL,
-                response_time REAL,
-                status_code INTEGER,
-                error_message TEXT,
-                endpoint_tested TEXT,
-                timestamp REAL NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        """)
-        query_sql = _sa_text("""
-            SELECT
-                COUNT(*) AS total,
-                SUM(CASE WHEN status = 'online' THEN 1 ELSE 0 END) AS online
-            FROM status_log
-            WHERE provider_name = :provider_name
-              AND created_at >= :cutoff
-        """)
-        with self.engine.begin() as conn:
-            conn.execute(create_sql)
-            result = conn.execute(
-                query_sql,
-                {"provider_name": provider_name, "cutoff": cutoff},
-            ).first()
-        if result and result[0]:
-            total = result[0] or 0
-            online = result[1] or 0
-            if total > 0:
-                return round((online / total) * 100.0, 2)
-        return 0.0
-    except Exception as e:  # pragma: no cover - logging safeguard
-        logger.error(f"Failed to compute uptime for {provider_name}: {e}", exc_info=True)
-        return 0.0
-
-
-# Attach methods to DatabaseManager so existing code can call them.
-DatabaseManager.log_provider_status = _dm_log_provider_status  # type: ignore[attr-defined]
-DatabaseManager.get_uptime_percentage = _dm_get_uptime_percentage  # type: ignore[attr-defined]