602 lines
21 KiB
Python
602 lines
21 KiB
Python
"""Hydrus API health check and initialization.
|
||
|
||
Provides startup health checks for Hydrus API availability and gracefully
|
||
disables Hydrus features if the API is unavailable.
|
||
"""
|
||
|
||
import logging
|
||
import sys
|
||
|
||
from helper.logger import log, debug
|
||
from typing import Tuple, Optional, Dict, Any
|
||
from pathlib import Path
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# Global state for Hydrus availability
|
||
_HYDRUS_AVAILABLE: Optional[bool] = None
|
||
_HYDRUS_UNAVAILABLE_REASON: Optional[str] = None
|
||
_HYDRUS_CHECK_COMPLETE = False
|
||
|
||
# Global state for Debrid availability
|
||
_DEBRID_AVAILABLE: Optional[bool] = None
|
||
_DEBRID_UNAVAILABLE_REASON: Optional[str] = None
|
||
_DEBRID_CHECK_COMPLETE = False
|
||
|
||
# Global state for MPV availability
|
||
_MPV_AVAILABLE: Optional[bool] = None
|
||
_MPV_UNAVAILABLE_REASON: Optional[str] = None
|
||
_MPV_CHECK_COMPLETE = False
|
||
|
||
# Global state for Matrix availability
|
||
_MATRIX_AVAILABLE: Optional[bool] = None
|
||
_MATRIX_UNAVAILABLE_REASON: Optional[str] = None
|
||
_MATRIX_CHECK_COMPLETE = False
|
||
|
||
# Global state for Cookies availability
|
||
_COOKIES_FILE_PATH: Optional[str] = None
|
||
|
||
|
||
def check_hydrus_availability(config: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
|
||
"""Check if Hydrus API is available by pinging it.
|
||
|
||
Args:
|
||
config: Application configuration dictionary
|
||
|
||
Returns:
|
||
Tuple of (is_available: bool, reason: Optional[str])
|
||
- (True, None) if Hydrus is available
|
||
- (False, reason) if Hydrus is unavailable with reason
|
||
"""
|
||
try:
|
||
from helper.hydrus import is_available as _is_hydrus_available
|
||
|
||
logger.info("[Hydrus Health Check] Pinging Hydrus API...")
|
||
is_available, reason = _is_hydrus_available(config, use_cache=False)
|
||
|
||
if is_available:
|
||
logger.info("[Hydrus Health Check] Hydrus API is AVAILABLE")
|
||
return True, None
|
||
else:
|
||
reason_str = f": {reason}" if reason else ""
|
||
logger.warning(f"[Hydrus Health Check] Hydrus API is UNAVAILABLE{reason_str}")
|
||
return False, reason
|
||
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
logger.error(f"[Hydrus Health Check] Error checking Hydrus availability: {error_msg}")
|
||
return False, error_msg
|
||
|
||
|
||
def initialize_hydrus_health_check(config: Dict[str, Any]) -> None:
|
||
"""Initialize Hydrus health check at startup.
|
||
|
||
This should be called once at application startup to determine if Hydrus
|
||
features should be enabled or disabled.
|
||
|
||
Args:
|
||
config: Application configuration dictionary
|
||
"""
|
||
global _HYDRUS_AVAILABLE, _HYDRUS_UNAVAILABLE_REASON, _HYDRUS_CHECK_COMPLETE
|
||
|
||
logger.info("[Startup] Starting Hydrus health check...")
|
||
|
||
try:
|
||
is_available, reason = check_hydrus_availability(config)
|
||
_HYDRUS_AVAILABLE = is_available
|
||
_HYDRUS_UNAVAILABLE_REASON = reason
|
||
_HYDRUS_CHECK_COMPLETE = True
|
||
|
||
if is_available:
|
||
debug("Hydrus: ENABLED - All Hydrus features available", file=sys.stderr)
|
||
else:
|
||
debug(f"Hydrus: DISABLED - {reason or 'Connection failed'}", file=sys.stderr)
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Startup] Failed to initialize Hydrus health check: {e}", exc_info=True)
|
||
_HYDRUS_AVAILABLE = False
|
||
_HYDRUS_UNAVAILABLE_REASON = str(e)
|
||
_HYDRUS_CHECK_COMPLETE = True
|
||
debug(f"Hydrus: DISABLED - Error during health check: {e}", file=sys.stderr)
|
||
|
||
|
||
def check_debrid_availability(config: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
|
||
"""Check if Debrid API is available.
|
||
|
||
Args:
|
||
config: Application configuration dictionary
|
||
|
||
Returns:
|
||
Tuple of (is_available: bool, reason: Optional[str])
|
||
- (True, None) if Debrid API is available
|
||
- (False, reason) if Debrid API is unavailable with reason
|
||
"""
|
||
try:
|
||
from helper.http_client import HTTPClient
|
||
|
||
logger.info("[Debrid Health Check] Pinging Debrid API at https://api.alldebrid.com/v4/ping...")
|
||
|
||
try:
|
||
# Use the public ping endpoint to check API availability
|
||
# This endpoint doesn't require authentication
|
||
with HTTPClient(timeout=10.0, verify_ssl=True) as client:
|
||
response = client.get('https://api.alldebrid.com/v4/ping')
|
||
logger.debug(f"[Debrid Health Check] Response status: {response.status_code}")
|
||
|
||
# Read response text first (handles gzip decompression)
|
||
try:
|
||
response_text = response.text
|
||
logger.debug(f"[Debrid Health Check] Response text: {response_text}")
|
||
except Exception as e:
|
||
logger.error(f"[Debrid Health Check] ❌ Failed to read response text: {e}")
|
||
return False, f"Failed to read response: {e}"
|
||
|
||
# Parse JSON
|
||
try:
|
||
result = response.json()
|
||
logger.debug(f"[Debrid Health Check] Response JSON: {result}")
|
||
except Exception as e:
|
||
logger.error(f"[Debrid Health Check] ❌ Failed to parse JSON: {e}")
|
||
logger.error(f"[Debrid Health Check] Response was: {response_text}")
|
||
return False, f"Failed to parse response: {e}"
|
||
|
||
# Validate response format
|
||
if result.get('status') == 'success' and result.get('data', {}).get('ping') == 'pong':
|
||
logger.info("[Debrid Health Check] ✅ Debrid API is AVAILABLE")
|
||
return True, None
|
||
else:
|
||
logger.warning(f"[Debrid Health Check] ❌ Debrid API returned unexpected response: {result}")
|
||
return False, "Invalid API response"
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
logger.warning(f"[Debrid Health Check] ❌ Debrid API error: {error_msg}")
|
||
import traceback
|
||
logger.debug(f"[Debrid Health Check] Traceback: {traceback.format_exc()}")
|
||
return False, error_msg
|
||
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
logger.error(f"[Debrid Health Check] ❌ Error checking Debrid availability: {error_msg}")
|
||
return False, error_msg
|
||
|
||
|
||
def initialize_debrid_health_check(config: Dict[str, Any]) -> None:
|
||
"""Initialize Debrid health check at startup.
|
||
|
||
This should be called once at application startup to determine if Debrid
|
||
features should be enabled or disabled.
|
||
|
||
Args:
|
||
config: Application configuration dictionary
|
||
"""
|
||
global _DEBRID_AVAILABLE, _DEBRID_UNAVAILABLE_REASON, _DEBRID_CHECK_COMPLETE
|
||
|
||
logger.info("[Startup] Starting Debrid health check...")
|
||
|
||
try:
|
||
is_available, reason = check_debrid_availability(config)
|
||
_DEBRID_AVAILABLE = is_available
|
||
_DEBRID_UNAVAILABLE_REASON = reason
|
||
_DEBRID_CHECK_COMPLETE = True
|
||
|
||
if is_available:
|
||
debug("✅ Debrid: ENABLED - All Debrid features available", file=sys.stderr)
|
||
logger.info("[Startup] Debrid health check PASSED")
|
||
else:
|
||
debug(f"⚠️ Debrid: DISABLED - {reason or 'Connection failed'}", file=sys.stderr)
|
||
logger.warning(f"[Startup] Debrid health check FAILED: {reason}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Startup] Failed to initialize Debrid health check: {e}", exc_info=True)
|
||
_DEBRID_AVAILABLE = False
|
||
_DEBRID_UNAVAILABLE_REASON = str(e)
|
||
_DEBRID_CHECK_COMPLETE = True
|
||
debug(f"⚠️ Debrid: DISABLED - Error during health check: {e}", file=sys.stderr)
|
||
|
||
|
||
def check_mpv_availability() -> Tuple[bool, Optional[str]]:
|
||
"""Check if MPV is available (installed and runnable).
|
||
|
||
Returns:
|
||
Tuple of (is_available: bool, reason: Optional[str])
|
||
"""
|
||
global _MPV_AVAILABLE, _MPV_UNAVAILABLE_REASON, _MPV_CHECK_COMPLETE
|
||
|
||
if _MPV_CHECK_COMPLETE and _MPV_AVAILABLE is not None:
|
||
return _MPV_AVAILABLE, _MPV_UNAVAILABLE_REASON
|
||
|
||
import shutil
|
||
import subprocess
|
||
|
||
logger.info("[MPV Health Check] Checking for MPV executable...")
|
||
|
||
mpv_path = shutil.which("mpv")
|
||
if not mpv_path:
|
||
_MPV_AVAILABLE = False
|
||
_MPV_UNAVAILABLE_REASON = "Executable 'mpv' not found in PATH"
|
||
_MPV_CHECK_COMPLETE = True
|
||
logger.warning(f"[MPV Health Check] ❌ MPV is UNAVAILABLE: {_MPV_UNAVAILABLE_REASON}")
|
||
return False, _MPV_UNAVAILABLE_REASON
|
||
|
||
# Try to get version to confirm it works
|
||
try:
|
||
result = subprocess.run(
|
||
[mpv_path, "--version"],
|
||
capture_output=True,
|
||
text=True,
|
||
timeout=2
|
||
)
|
||
if result.returncode == 0:
|
||
version_line = result.stdout.split('\n')[0]
|
||
_MPV_AVAILABLE = True
|
||
_MPV_UNAVAILABLE_REASON = None
|
||
_MPV_CHECK_COMPLETE = True
|
||
logger.info(f"[MPV Health Check] ✅ MPV is AVAILABLE ({version_line})")
|
||
return True, None
|
||
else:
|
||
_MPV_AVAILABLE = False
|
||
_MPV_UNAVAILABLE_REASON = f"MPV returned non-zero exit code: {result.returncode}"
|
||
_MPV_CHECK_COMPLETE = True
|
||
logger.warning(f"[MPV Health Check] ❌ MPV is UNAVAILABLE: {_MPV_UNAVAILABLE_REASON}")
|
||
return False, _MPV_UNAVAILABLE_REASON
|
||
except Exception as e:
|
||
_MPV_AVAILABLE = False
|
||
_MPV_UNAVAILABLE_REASON = f"Error running MPV: {e}"
|
||
_MPV_CHECK_COMPLETE = True
|
||
logger.warning(f"[MPV Health Check] ❌ MPV is UNAVAILABLE: {_MPV_UNAVAILABLE_REASON}")
|
||
return False, _MPV_UNAVAILABLE_REASON
|
||
|
||
|
||
def initialize_mpv_health_check() -> None:
|
||
"""Initialize MPV health check at startup.
|
||
|
||
This should be called once at application startup to determine if MPV
|
||
features should be enabled or disabled.
|
||
"""
|
||
global _MPV_AVAILABLE, _MPV_UNAVAILABLE_REASON, _MPV_CHECK_COMPLETE
|
||
|
||
logger.info("[Startup] Starting MPV health check...")
|
||
|
||
try:
|
||
is_available, reason = check_mpv_availability()
|
||
_MPV_AVAILABLE = is_available
|
||
_MPV_UNAVAILABLE_REASON = reason
|
||
_MPV_CHECK_COMPLETE = True
|
||
|
||
if is_available:
|
||
debug("✅ MPV: ENABLED - All MPV features available", file=sys.stderr)
|
||
logger.info("[Startup] MPV health check PASSED")
|
||
else:
|
||
debug(f"⚠️ MPV: DISABLED - {reason or 'Connection failed'}", file=sys.stderr)
|
||
debug("→ Hydrus features still available", file=sys.stderr)
|
||
logger.warning(f"[Startup] MPV health check FAILED: {reason}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Startup] Failed to initialize MPV health check: {e}", exc_info=True)
|
||
_MPV_AVAILABLE = False
|
||
_MPV_UNAVAILABLE_REASON = str(e)
|
||
_MPV_CHECK_COMPLETE = True
|
||
debug(f"⚠️ MPV: DISABLED - Error during health check: {e}", file=sys.stderr)
|
||
|
||
|
||
def check_matrix_availability(config: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
|
||
"""Check if Matrix homeserver is reachable and credentials are valid.
|
||
|
||
Args:
|
||
config: Application configuration dictionary
|
||
|
||
Returns:
|
||
Tuple of (is_available: bool, reason: Optional[str])
|
||
"""
|
||
try:
|
||
import requests
|
||
matrix_conf = config.get('storage', {}).get('matrix', {})
|
||
homeserver = matrix_conf.get('homeserver')
|
||
access_token = matrix_conf.get('access_token')
|
||
|
||
if not homeserver:
|
||
return False, "Not configured"
|
||
|
||
if not homeserver.startswith('http'):
|
||
homeserver = f"https://{homeserver}"
|
||
|
||
# Check versions endpoint (no auth required)
|
||
try:
|
||
resp = requests.get(f"{homeserver}/_matrix/client/versions", timeout=5)
|
||
if resp.status_code != 200:
|
||
return False, f"Homeserver returned {resp.status_code}"
|
||
except Exception as e:
|
||
return False, f"Homeserver unreachable: {e}"
|
||
|
||
# Check auth if token provided (whoami)
|
||
if access_token:
|
||
try:
|
||
headers = {"Authorization": f"Bearer {access_token}"}
|
||
resp = requests.get(f"{homeserver}/_matrix/client/v3/account/whoami", headers=headers, timeout=5)
|
||
if resp.status_code != 200:
|
||
return False, f"Authentication failed: {resp.status_code}"
|
||
except Exception as e:
|
||
return False, f"Auth check failed: {e}"
|
||
|
||
return True, None
|
||
|
||
except Exception as e:
|
||
return False, str(e)
|
||
|
||
|
||
def initialize_matrix_health_check(config: Dict[str, Any]) -> None:
|
||
"""Initialize Matrix health check at startup."""
|
||
global _MATRIX_AVAILABLE, _MATRIX_UNAVAILABLE_REASON, _MATRIX_CHECK_COMPLETE
|
||
|
||
logger.info("[Startup] Starting Matrix health check...")
|
||
|
||
try:
|
||
is_available, reason = check_matrix_availability(config)
|
||
_MATRIX_AVAILABLE = is_available
|
||
_MATRIX_UNAVAILABLE_REASON = reason
|
||
_MATRIX_CHECK_COMPLETE = True
|
||
|
||
if is_available:
|
||
debug("Matrix: ENABLED - Homeserver reachable", file=sys.stderr)
|
||
else:
|
||
if reason != "Not configured":
|
||
debug(f"Matrix: DISABLED - {reason}", file=sys.stderr)
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Startup] Failed to initialize Matrix health check: {e}", exc_info=True)
|
||
_MATRIX_AVAILABLE = False
|
||
_MATRIX_UNAVAILABLE_REASON = str(e)
|
||
_MATRIX_CHECK_COMPLETE = True
|
||
|
||
|
||
def is_hydrus_available() -> bool:
|
||
"""Check if Hydrus is available (from cached health check).
|
||
|
||
Returns:
|
||
True if Hydrus API is available, False otherwise
|
||
"""
|
||
return _HYDRUS_AVAILABLE is True
|
||
|
||
|
||
def get_hydrus_unavailable_reason() -> Optional[str]:
|
||
"""Get the reason why Hydrus is unavailable.
|
||
|
||
Returns:
|
||
String explaining why Hydrus is unavailable, or None if available
|
||
"""
|
||
return _HYDRUS_UNAVAILABLE_REASON if not is_hydrus_available() else None
|
||
|
||
|
||
def is_hydrus_check_complete() -> bool:
|
||
"""Check if the Hydrus health check has been completed.
|
||
|
||
Returns:
|
||
True if health check has run, False if still pending
|
||
"""
|
||
return _HYDRUS_CHECK_COMPLETE
|
||
|
||
|
||
def disable_hydrus_features() -> None:
|
||
"""Manually disable all Hydrus features (for testing/fallback).
|
||
|
||
This can be called if Hydrus connectivity is lost after startup.
|
||
"""
|
||
global _HYDRUS_AVAILABLE, _HYDRUS_UNAVAILABLE_REASON
|
||
_HYDRUS_AVAILABLE = False
|
||
_HYDRUS_UNAVAILABLE_REASON = "Manually disabled or lost connection"
|
||
logger.warning("[Hydrus] Features manually disabled")
|
||
|
||
|
||
def enable_hydrus_features() -> None:
|
||
"""Manually enable Hydrus features (for testing/fallback).
|
||
|
||
This can be called if Hydrus connectivity is restored after startup.
|
||
"""
|
||
global _HYDRUS_AVAILABLE, _HYDRUS_UNAVAILABLE_REASON
|
||
_HYDRUS_AVAILABLE = True
|
||
_HYDRUS_UNAVAILABLE_REASON = None
|
||
logger.info("[Hydrus] Features manually enabled")
|
||
|
||
|
||
def is_debrid_available() -> bool:
|
||
"""Check if Debrid is available (from cached health check).
|
||
|
||
Returns:
|
||
True if Debrid API is available, False otherwise
|
||
"""
|
||
return _DEBRID_AVAILABLE is True
|
||
|
||
|
||
def get_debrid_unavailable_reason() -> Optional[str]:
|
||
"""Get the reason why Debrid is unavailable.
|
||
|
||
Returns:
|
||
String explaining why Debrid is unavailable, or None if available
|
||
"""
|
||
return _DEBRID_UNAVAILABLE_REASON if not is_debrid_available() else None
|
||
|
||
|
||
def is_debrid_check_complete() -> bool:
|
||
"""Check if the Debrid health check has been completed.
|
||
|
||
Returns:
|
||
True if health check has run, False if still pending
|
||
"""
|
||
return _DEBRID_CHECK_COMPLETE
|
||
|
||
|
||
def disable_debrid_features() -> None:
|
||
"""Manually disable all Debrid features (for testing/fallback).
|
||
|
||
This can be called if Debrid connectivity is lost after startup.
|
||
"""
|
||
global _DEBRID_AVAILABLE, _DEBRID_UNAVAILABLE_REASON
|
||
_DEBRID_AVAILABLE = False
|
||
_DEBRID_UNAVAILABLE_REASON = "Manually disabled or lost connection"
|
||
logger.warning("[Debrid] Features manually disabled")
|
||
|
||
|
||
def enable_debrid_features() -> None:
|
||
"""Manually enable Debrid features (for testing/fallback).
|
||
|
||
This can be called if Debrid connectivity is restored after startup.
|
||
"""
|
||
global _DEBRID_AVAILABLE, _DEBRID_UNAVAILABLE_REASON
|
||
_DEBRID_AVAILABLE = True
|
||
_DEBRID_UNAVAILABLE_REASON = None
|
||
logger.info("[Debrid] Features manually enabled")
|
||
|
||
|
||
def is_mpv_available() -> bool:
|
||
"""Check if MPV is available (from cached health check).
|
||
|
||
Returns:
|
||
True if MPV is available, False otherwise
|
||
"""
|
||
return _MPV_AVAILABLE is True
|
||
|
||
|
||
def get_mpv_unavailable_reason() -> Optional[str]:
|
||
"""Get the reason why MPV is unavailable.
|
||
|
||
Returns:
|
||
String explaining why MPV is unavailable, or None if available
|
||
"""
|
||
return _MPV_UNAVAILABLE_REASON if not is_mpv_available() else None
|
||
|
||
|
||
def is_mpv_check_complete() -> bool:
|
||
"""Check if the MPV health check has been completed.
|
||
|
||
Returns:
|
||
True if health check has run, False if still pending
|
||
"""
|
||
return _MPV_CHECK_COMPLETE
|
||
|
||
|
||
def disable_mpv_features() -> None:
|
||
"""Manually disable all MPV features (for testing/fallback).
|
||
|
||
This can be called if MPV connectivity is lost after startup.
|
||
"""
|
||
global _MPV_AVAILABLE, _MPV_UNAVAILABLE_REASON
|
||
_MPV_AVAILABLE = False
|
||
_MPV_UNAVAILABLE_REASON = "Manually disabled or lost connection"
|
||
logger.warning("[MPV] Features manually disabled")
|
||
|
||
|
||
def enable_mpv_features() -> None:
|
||
"""Manually enable MPV features (for testing/fallback).
|
||
|
||
This can be called if MPV connectivity is restored after startup.
|
||
"""
|
||
global _MPV_AVAILABLE, _MPV_UNAVAILABLE_REASON
|
||
_MPV_AVAILABLE = True
|
||
_MPV_UNAVAILABLE_REASON = None
|
||
logger.info("[MPV] Features manually enabled")
|
||
|
||
|
||
def is_matrix_available() -> bool:
|
||
"""Check if Matrix is available (from cached health check).
|
||
|
||
Returns:
|
||
True if Matrix is available, False otherwise
|
||
"""
|
||
return _MATRIX_AVAILABLE is True
|
||
|
||
|
||
def get_matrix_unavailable_reason() -> Optional[str]:
|
||
"""Get the reason why Matrix is unavailable.
|
||
|
||
Returns:
|
||
String explaining why Matrix is unavailable, or None if available
|
||
"""
|
||
return _MATRIX_UNAVAILABLE_REASON if not is_matrix_available() else None
|
||
|
||
|
||
def is_matrix_check_complete() -> bool:
|
||
"""Check if the Matrix health check has been completed.
|
||
|
||
Returns:
|
||
True if health check has run, False if still pending
|
||
"""
|
||
return _MATRIX_CHECK_COMPLETE
|
||
|
||
|
||
def disable_matrix_features() -> None:
|
||
"""Manually disable all Matrix features (for testing/fallback).
|
||
|
||
This can be called if Matrix connectivity is lost after startup.
|
||
"""
|
||
global _MATRIX_AVAILABLE, _MATRIX_UNAVAILABLE_REASON
|
||
_MATRIX_AVAILABLE = False
|
||
_MATRIX_UNAVAILABLE_REASON = "Manually disabled or lost connection"
|
||
logger.warning("[Matrix] Features manually disabled")
|
||
|
||
|
||
def enable_matrix_features() -> None:
|
||
"""Manually enable Matrix features (for testing/fallback).
|
||
|
||
This can be called if Matrix connectivity is restored after startup.
|
||
"""
|
||
global _MATRIX_AVAILABLE, _MATRIX_UNAVAILABLE_REASON
|
||
_MATRIX_AVAILABLE = True
|
||
_MATRIX_UNAVAILABLE_REASON = None
|
||
logger.info("[Matrix] Features manually enabled")
|
||
|
||
|
||
def initialize_local_library_scan(config: Dict[str, Any]) -> None:
|
||
"""Initialize and scan local library at startup.
|
||
|
||
This ensures that any new files in the local library folder are indexed
|
||
and their sidecar files are imported and cleaned up.
|
||
"""
|
||
from config import get_local_storage_path
|
||
from helper.local_library import LocalLibraryInitializer
|
||
|
||
logger.info("[Startup] Starting Local Library scan...")
|
||
|
||
try:
|
||
storage_path = get_local_storage_path(config)
|
||
if not storage_path:
|
||
debug("⚠️ Local Library: SKIPPED - No storage path configured", file=sys.stderr)
|
||
return
|
||
|
||
debug(f"Scanning local library at: {storage_path}", file=sys.stderr)
|
||
initializer = LocalLibraryInitializer(storage_path)
|
||
stats = initializer.scan_and_index()
|
||
|
||
# Log summary
|
||
new_files = stats.get('files_new', 0)
|
||
sidecars = stats.get('sidecars_imported', 0)
|
||
|
||
if new_files > 0 or sidecars > 0:
|
||
debug(f"✅ Local Library: Scanned - New files: {new_files}, Sidecars imported: {sidecars}", file=sys.stderr)
|
||
else:
|
||
debug("✅ Local Library: Up to date", file=sys.stderr)
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Startup] Failed to scan local library: {e}", exc_info=True)
|
||
debug(f"⚠️ Local Library: ERROR - Scan failed: {e}", file=sys.stderr)
|
||
|
||
|
||
def initialize_cookies_check() -> None:
|
||
"""Check for cookies.txt in the application root directory."""
|
||
global _COOKIES_FILE_PATH
|
||
|
||
# Assume CLI.py is in the root
|
||
root_dir = Path(__file__).parent
|
||
cookies_path = root_dir / "cookies.txt"
|
||
|
||
if cookies_path.exists():
|
||
_COOKIES_FILE_PATH = str(cookies_path)
|
||
debug(f"✅ Cookies: ENABLED - Found cookies.txt", file=sys.stderr)
|
||
else:
|
||
_COOKIES_FILE_PATH = None
|
||
# debug("ℹ️ Cookies: Using browser cookies (fallback)", file=sys.stderr)
|
||
|
||
|
||
def get_cookies_file_path() -> Optional[str]:
|
||
"""Get the path to the cookies.txt file if it exists."""
|
||
return _COOKIES_FILE_PATH
|