|
|
|
@@ -0,0 +1,877 @@
|
|
|
|
|
#!/usr/bin/env python3
|
|
|
|
|
# webhook_server.py - FastAPI webhook server for media date cache
|
|
|
|
|
|
|
|
|
|
import os
|
|
|
|
|
import json
|
|
|
|
|
import asyncio
|
|
|
|
|
import glob
|
|
|
|
|
import re
|
|
|
|
|
from pathlib import Path
|
|
|
|
|
from datetime import datetime, timezone
|
|
|
|
|
from fastapi import FastAPI, HTTPException, BackgroundTasks, Request
|
|
|
|
|
from pydantic import BaseModel
|
|
|
|
|
from typing import Optional, Dict, Any, List, Set
|
|
|
|
|
import sqlite3
|
|
|
|
|
import uvicorn
|
|
|
|
|
import threading
|
|
|
|
|
import time
|
|
|
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
|
|
|
|
|
|
|
|
# Import our existing logic
|
|
|
|
|
from media_date_cache import (
|
|
|
|
|
db_connect, apply_series, parse_imdb_from_path,
|
|
|
|
|
_log, _iso_now, SonarrClient
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Pydantic models for webhook payloads
|
|
|
|
|
class SonarrWebhook(BaseModel):
|
|
|
|
|
eventType: str
|
|
|
|
|
series: Optional[Dict[str, Any]] = None
|
|
|
|
|
episodes: Optional[list] = []
|
|
|
|
|
episodeFile: Optional[Dict[str, Any]] = None
|
|
|
|
|
isUpgrade: Optional[bool] = False
|
|
|
|
|
movie: Optional[Dict[str, Any]] = None
|
|
|
|
|
remoteMovie: Optional[Dict[str, Any]] = None
|
|
|
|
|
deletedFiles: Optional[list] = []
|
|
|
|
|
|
|
|
|
|
class Config:
|
|
|
|
|
extra = "allow" # Allow extra fields not defined in the model
|
|
|
|
|
|
|
|
|
|
class RadarrWebhook(BaseModel):
|
|
|
|
|
eventType: str
|
|
|
|
|
movie: Optional[Dict[str, Any]] = None
|
|
|
|
|
movieFile: Optional[Dict[str, Any]] = None
|
|
|
|
|
isUpgrade: Optional[bool] = False
|
|
|
|
|
deletedFiles: Optional[list] = []
|
|
|
|
|
remoteMovie: Optional[Dict[str, Any]] = None
|
|
|
|
|
renamedMovieFiles: Optional[List[Dict[str, Any]]] = [] # present on Rename
|
|
|
|
|
|
|
|
|
|
class Config:
|
|
|
|
|
extra = "allow"
|
|
|
|
|
|
|
|
|
|
class HealthResponse(BaseModel):
|
|
|
|
|
status: str
|
|
|
|
|
version: str
|
|
|
|
|
uptime: str
|
|
|
|
|
database_status: str
|
|
|
|
|
|
|
|
|
|
app = FastAPI(
|
|
|
|
|
title="Media Date Cache Webhook Server",
|
|
|
|
|
description="Webhook server for managing TV show and movie import dates and NFO files",
|
|
|
|
|
version="1.0.0"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Global state
|
|
|
|
|
start_time = datetime.now(timezone.utc)
|
|
|
|
|
db_path = Path(os.environ.get("DB_PATH", "/app/data/media_dates.db"))
|
|
|
|
|
|
|
|
|
|
class WebhookConfig:
|
|
|
|
|
def __init__(self):
|
|
|
|
|
# TV paths
|
|
|
|
|
tv_paths_str = os.environ.get("TV_PATHS", os.environ.get("MEDIA_PATH", "/media/tv,/media/tv6"))
|
|
|
|
|
self.tv_paths = [Path(p.strip()) for p in tv_paths_str.split(",")]
|
|
|
|
|
|
|
|
|
|
# Movie paths
|
|
|
|
|
movie_paths_str = os.environ.get("MOVIE_PATHS", "/media/movies,/media/movies6")
|
|
|
|
|
self.movie_paths = [Path(p.strip()) for p in movie_paths_str.split(",")]
|
|
|
|
|
|
|
|
|
|
self.manage_nfo = os.environ.get("MANAGE_NFO", "true").lower() == "true"
|
|
|
|
|
self.fix_dir_mtimes = os.environ.get("FIX_DIR_MTIMES", "true").lower() == "true"
|
|
|
|
|
self.lock_metadata = os.environ.get("LOCK_METADATA", "true").lower() == "true"
|
|
|
|
|
self.debug = os.environ.get("DEBUG", "false").lower() == "true"
|
|
|
|
|
# Batching configuration
|
|
|
|
|
self.batch_delay = float(os.environ.get("BATCH_DELAY", "5.0")) # seconds
|
|
|
|
|
self.max_concurrent_series = int(os.environ.get("MAX_CONCURRENT_SERIES", "3"))
|
|
|
|
|
|
|
|
|
|
config = WebhookConfig()
|
|
|
|
|
|
|
|
|
|
# Movie database schema additions
|
|
|
|
|
MOVIE_SCHEMA = """
|
|
|
|
|
CREATE TABLE IF NOT EXISTS movies (
|
|
|
|
|
imdb_id TEXT PRIMARY KEY,
|
|
|
|
|
movie_path TEXT NOT NULL,
|
|
|
|
|
last_applied TEXT
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
CREATE TABLE IF NOT EXISTS movie_dates (
|
|
|
|
|
imdb_id TEXT PRIMARY KEY,
|
|
|
|
|
released TEXT,
|
|
|
|
|
dateadded TEXT,
|
|
|
|
|
source TEXT,
|
|
|
|
|
has_video_file INTEGER DEFAULT 0
|
|
|
|
|
);
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def ensure_movie_tables(conn: sqlite3.Connection):
|
|
|
|
|
"""Ensure movie tables exist in the database"""
|
|
|
|
|
try:
|
|
|
|
|
result = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='movies'").fetchone()
|
|
|
|
|
if not result:
|
|
|
|
|
_log("INFO", "Creating movie tables in database")
|
|
|
|
|
conn.executescript(MOVIE_SCHEMA)
|
|
|
|
|
conn.commit()
|
|
|
|
|
except sqlite3.Error as e:
|
|
|
|
|
_log("ERROR", f"Failed to create movie tables: {e}")
|
|
|
|
|
|
|
|
|
|
# Movie processing functions
|
|
|
|
|
def parse_imdb_from_movie_path(p: Path):
|
|
|
|
|
"""Extract IMDb ID from movie directory name"""
|
|
|
|
|
# Look for patterns like: Movie Name (2023) [imdb-tt1234567]
|
|
|
|
|
m = re.search(r'\[imdb-(tt\d+)\]', p.name, re.IGNORECASE)
|
|
|
|
|
return m.group(1).lower() if m else None
|
|
|
|
|
|
|
|
|
|
def is_movie_dir(p: Path) -> bool:
|
|
|
|
|
"""Check if path is a movie directory with IMDb ID"""
|
|
|
|
|
return p.is_dir() and parse_imdb_from_movie_path(p) is not None
|
|
|
|
|
|
|
|
|
|
def write_movie_nfo(movie_dir: Path, imdb_id: str, released: str, dateadded: str, source: str, lock_metadata: bool = True):
|
|
|
|
|
"""Write movie NFO file"""
|
|
|
|
|
try:
|
|
|
|
|
movie_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Failed creating movie directory {movie_dir}: {e}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
nfo_file = movie_dir / f"{movie_dir.name}.nfo"
|
|
|
|
|
xml = [
|
|
|
|
|
'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
|
|
|
|
|
"<movie>",
|
|
|
|
|
f" <id>{imdb_id}</id>",
|
|
|
|
|
f" <uniqueid type=\"imdb\" default=\"true\">{imdb_id}</uniqueid>",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
if released:
|
|
|
|
|
xml.append(f" <premiered>{released.split('T')[0]}</premiered>")
|
|
|
|
|
xml.append(f" <year>{released.split('-')[0]}</year>")
|
|
|
|
|
|
|
|
|
|
if dateadded:
|
|
|
|
|
xml.append(f" <dateadded>{dateadded}</dateadded>")
|
|
|
|
|
|
|
|
|
|
if lock_metadata:
|
|
|
|
|
xml.append(" <lockdata>true</lockdata>")
|
|
|
|
|
|
|
|
|
|
if source:
|
|
|
|
|
xml.append(f" <!-- source: {source} -->")
|
|
|
|
|
xml.append(f" <!-- managed by media-date-cache -->")
|
|
|
|
|
|
|
|
|
|
xml.append("</movie>\n")
|
|
|
|
|
content = "\n".join(xml)
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
|
nfo_file.write_text(content, encoding="utf-8")
|
|
|
|
|
_log("DEBUG", f"Created movie NFO: {nfo_file}")
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Failed writing {nfo_file}: {e}")
|
|
|
|
|
|
|
|
|
|
def set_movie_file_mtime(movie_dir: Path, dateadded_iso: str):
|
|
|
|
|
"""Set movie file modification time to match dateadded"""
|
|
|
|
|
if not dateadded_iso:
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
|
ts = datetime.fromisoformat(dateadded_iso.replace("Z", "+00:00")).timestamp()
|
|
|
|
|
|
|
|
|
|
# Find video files
|
|
|
|
|
video_exts = (".mkv", ".mp4", ".avi", ".mov", ".m4v")
|
|
|
|
|
for f in movie_dir.iterdir():
|
|
|
|
|
if f.is_file() and f.suffix.lower() in video_exts:
|
|
|
|
|
try:
|
|
|
|
|
os.utime(f, (ts, ts), follow_symlinks=False)
|
|
|
|
|
_log("DEBUG", f"Updated movie file mtime: {f} -> {dateadded_iso}")
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("WARNING", f"Failed to update mtime on {f}: {e}")
|
|
|
|
|
|
|
|
|
|
# Set directory mtime too
|
|
|
|
|
try:
|
|
|
|
|
os.utime(movie_dir, (ts, ts), follow_symlinks=False)
|
|
|
|
|
_log("DEBUG", f"Updated movie dir mtime: {movie_dir} -> {dateadded_iso}")
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("WARNING", f"Failed to update mtime on {movie_dir}: {e}")
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("WARNING", f"Bad timestamp for movie mtimes: {dateadded_iso}: {e}")
|
|
|
|
|
|
|
|
|
|
def apply_movie(movie_dir: Path, conn: sqlite3.Connection):
|
|
|
|
|
"""Apply date caching to a movie directory"""
|
|
|
|
|
imdb_id = parse_imdb_from_movie_path(movie_dir)
|
|
|
|
|
if not imdb_id:
|
|
|
|
|
_log("ERROR", f"Movie path does not contain an IMDb id [imdb-tt...]: {movie_dir}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
ensure_movie_tables(conn)
|
|
|
|
|
|
|
|
|
|
# Store/refresh movie row
|
|
|
|
|
conn.execute(
|
|
|
|
|
"INSERT INTO movies(imdb_id, movie_path, last_applied) VALUES(?,?,?) "
|
|
|
|
|
"ON CONFLICT(imdb_id) DO UPDATE SET movie_path=excluded.movie_path, last_applied=excluded.last_applied",
|
|
|
|
|
(imdb_id, str(movie_dir), _iso_now()),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Check if movie has video files
|
|
|
|
|
video_exts = (".mkv", ".mp4", ".avi", ".mov", ".m4v")
|
|
|
|
|
has_video_files = any(f.is_file() and f.suffix.lower() in video_exts for f in movie_dir.iterdir())
|
|
|
|
|
|
|
|
|
|
if not has_video_files:
|
|
|
|
|
_log("WARNING", f"No video files found in movie directory: {movie_dir}")
|
|
|
|
|
conn.execute(
|
|
|
|
|
"INSERT INTO movie_dates(imdb_id, released, dateadded, source, has_video_file) VALUES(?,?,?,?,?) "
|
|
|
|
|
"ON CONFLICT(imdb_id) DO UPDATE SET has_video_file=excluded.has_video_file",
|
|
|
|
|
(imdb_id, None, None, None, 0),
|
|
|
|
|
)
|
|
|
|
|
conn.commit()
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
# For movies, we'll use simpler logic - primarily file mtime as dateadded
|
|
|
|
|
# Get the newest video file mtime as our dateadded
|
|
|
|
|
newest_mtime = None
|
|
|
|
|
for f in movie_dir.iterdir():
|
|
|
|
|
if f.is_file() and f.suffix.lower() in video_exts:
|
|
|
|
|
try:
|
|
|
|
|
mtime = f.stat().st_mtime
|
|
|
|
|
if newest_mtime is None or mtime > newest_mtime:
|
|
|
|
|
newest_mtime = mtime
|
|
|
|
|
except Exception:
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
|
|
dateadded_iso = None
|
|
|
|
|
if newest_mtime:
|
|
|
|
|
try:
|
|
|
|
|
dateadded_iso = datetime.fromtimestamp(newest_mtime, tz=timezone.utc).isoformat(timespec="seconds")
|
|
|
|
|
except Exception:
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
released_iso = None
|
|
|
|
|
source = "file:mtime"
|
|
|
|
|
|
|
|
|
|
# Store in database
|
|
|
|
|
conn.execute(
|
|
|
|
|
"INSERT INTO movie_dates(imdb_id, released, dateadded, source, has_video_file) VALUES(?,?,?,?,?) "
|
|
|
|
|
"ON CONFLICT(imdb_id) DO UPDATE SET released=excluded.released, dateadded=excluded.dateadded, source=excluded.source, has_video_file=excluded.has_video_file",
|
|
|
|
|
(imdb_id, released_iso, dateadded_iso, source, 1),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Create NFO if requested
|
|
|
|
|
if config.manage_nfo:
|
|
|
|
|
write_movie_nfo(movie_dir, imdb_id, released_iso, dateadded_iso, source, config.lock_metadata)
|
|
|
|
|
|
|
|
|
|
# Update file times if requested
|
|
|
|
|
if config.fix_dir_mtimes and dateadded_iso:
|
|
|
|
|
set_movie_file_mtime(movie_dir, dateadded_iso)
|
|
|
|
|
|
|
|
|
|
conn.commit()
|
|
|
|
|
_log("INFO", f"Processed movie: {movie_dir.name}")
|
|
|
|
|
|
|
|
|
|
# Thread-safe batching mechanism (updated for both TV and movies)
|
|
|
|
|
class WebhookBatcher:
|
|
|
|
|
def __init__(self):
|
|
|
|
|
self.pending_items: Dict[str, Dict] = {} # key -> latest webhook data
|
|
|
|
|
self.timers: Dict[str, threading.Timer] = {} # key -> timer
|
|
|
|
|
self.processing: Set[str] = set() # Currently processing items
|
|
|
|
|
self.lock = threading.Lock()
|
|
|
|
|
self.executor = ThreadPoolExecutor(max_workers=config.max_concurrent_series, thread_name_prefix="media-processor")
|
|
|
|
|
|
|
|
|
|
def add_webhook(self, key: str, webhook_data: Dict, media_type: str):
|
|
|
|
|
"""Add webhook to batch, resetting timer if needed"""
|
|
|
|
|
with self.lock:
|
|
|
|
|
# Cancel existing timer if present
|
|
|
|
|
if key in self.timers:
|
|
|
|
|
self.timers[key].cancel()
|
|
|
|
|
_log("DEBUG", f"Cancelled existing timer for {key}")
|
|
|
|
|
|
|
|
|
|
# Store/update webhook data
|
|
|
|
|
webhook_data['media_type'] = media_type # Add media type to data
|
|
|
|
|
self.pending_items[key] = webhook_data
|
|
|
|
|
_log("INFO", f"Batched {media_type} webhook for {key} (delay: {config.batch_delay}s)")
|
|
|
|
|
|
|
|
|
|
# Create new timer
|
|
|
|
|
timer = threading.Timer(config.batch_delay, self._process_item, args=[key])
|
|
|
|
|
self.timers[key] = timer
|
|
|
|
|
timer.start()
|
|
|
|
|
|
|
|
|
|
def _process_item(self, key: str):
|
|
|
|
|
"""Process an item after batch delay"""
|
|
|
|
|
with self.lock:
|
|
|
|
|
if key in self.processing or key not in self.pending_items:
|
|
|
|
|
return
|
|
|
|
|
self.processing.add(key)
|
|
|
|
|
webhook_data = self.pending_items.pop(key)
|
|
|
|
|
self.timers.pop(key, None)
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
|
media_type = webhook_data.get('media_type', 'unknown')
|
|
|
|
|
_log("INFO", f"Processing batched {media_type}: {key}")
|
|
|
|
|
self.executor.submit(self._process_item_sync, key, webhook_data)
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error submitting {media_type} processing for {key}: {e}")
|
|
|
|
|
with self.lock:
|
|
|
|
|
self.processing.discard(key)
|
|
|
|
|
|
|
|
|
|
def _process_item_sync(self, key: str, webhook_data: Dict):
|
|
|
|
|
"""Synchronous item processing with dedicated DB connection"""
|
|
|
|
|
try:
|
|
|
|
|
media_type = webhook_data.get('media_type', 'unknown')
|
|
|
|
|
if media_type == 'tv':
|
|
|
|
|
self._process_tv_sync(key, webhook_data)
|
|
|
|
|
elif media_type == 'movie':
|
|
|
|
|
self._process_movie_sync(key, webhook_data)
|
|
|
|
|
else:
|
|
|
|
|
_log("ERROR", f"Unknown media type: {media_type}")
|
|
|
|
|
finally:
|
|
|
|
|
with self.lock:
|
|
|
|
|
self.processing.discard(key)
|
|
|
|
|
|
|
|
|
|
def _process_tv_sync(self, imdb_id: str, webhook_data: Dict):
|
|
|
|
|
"""Process TV series"""
|
|
|
|
|
try:
|
|
|
|
|
series_info = webhook_data.get('series', {})
|
|
|
|
|
series_title = series_info.get("title", "Unknown")
|
|
|
|
|
series_path_str = webhook_data.get('series_path')
|
|
|
|
|
|
|
|
|
|
if not series_path_str:
|
|
|
|
|
_log("ERROR", f"No series path found for {imdb_id}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
series_path = Path(series_path_str)
|
|
|
|
|
if not series_path.exists():
|
|
|
|
|
_log("ERROR", f"Series path does not exist: {series_path}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
conn = None
|
|
|
|
|
try:
|
|
|
|
|
conn = db_connect(db_path)
|
|
|
|
|
conn.execute("PRAGMA busy_timeout = 30000")
|
|
|
|
|
conn.execute("PRAGMA journal_mode = WAL")
|
|
|
|
|
|
|
|
|
|
class MockArgs:
|
|
|
|
|
def __init__(self):
|
|
|
|
|
self.manage_nfo = config.manage_nfo
|
|
|
|
|
self.fix_dir_mtimes = config.fix_dir_mtimes
|
|
|
|
|
self.lock_metadata = config.lock_metadata
|
|
|
|
|
self.use_cache = True
|
|
|
|
|
self.force_refresh = False
|
|
|
|
|
self.skip_if_current = False
|
|
|
|
|
self.debug = config.debug
|
|
|
|
|
self.update_video_mtimes = True
|
|
|
|
|
|
|
|
|
|
_log("INFO", f"Processing TV series: {series_title} at {series_path}")
|
|
|
|
|
apply_series(series_path, MockArgs(), conn)
|
|
|
|
|
_log("INFO", f"Successfully processed batched TV series: {series_title}")
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error processing TV series {series_title}: {e}")
|
|
|
|
|
finally:
|
|
|
|
|
if conn:
|
|
|
|
|
try:
|
|
|
|
|
conn.close()
|
|
|
|
|
except:
|
|
|
|
|
pass
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error in TV processing: {e}")
|
|
|
|
|
|
|
|
|
|
def _process_movie_sync(self, imdb_id: str, webhook_data: Dict):
|
|
|
|
|
"""Process movie"""
|
|
|
|
|
try:
|
|
|
|
|
movie_info = webhook_data.get('movie', {})
|
|
|
|
|
movie_title = movie_info.get("title", "Unknown")
|
|
|
|
|
movie_path_str = webhook_data.get('movie_path')
|
|
|
|
|
|
|
|
|
|
if not movie_path_str:
|
|
|
|
|
_log("ERROR", f"No movie path found for {imdb_id}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
movie_path = Path(movie_path_str)
|
|
|
|
|
if not movie_path.exists():
|
|
|
|
|
_log("ERROR", f"Movie path does not exist: {movie_path}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
conn = None
|
|
|
|
|
try:
|
|
|
|
|
conn = db_connect(db_path)
|
|
|
|
|
conn.execute("PRAGMA busy_timeout = 30000")
|
|
|
|
|
conn.execute("PRAGMA journal_mode = WAL")
|
|
|
|
|
|
|
|
|
|
_log("INFO", f"Processing movie: {movie_title} at {movie_path}")
|
|
|
|
|
apply_movie(movie_path, conn)
|
|
|
|
|
_log("INFO", f"Successfully processed batched movie: {movie_title}")
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error processing movie {movie_title}: {e}")
|
|
|
|
|
finally:
|
|
|
|
|
if conn:
|
|
|
|
|
try:
|
|
|
|
|
conn.close()
|
|
|
|
|
except:
|
|
|
|
|
pass
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error in movie processing: {e}")
|
|
|
|
|
|
|
|
|
|
def get_status(self) -> Dict:
|
|
|
|
|
"""Get current batching status"""
|
|
|
|
|
with self.lock:
|
|
|
|
|
return {
|
|
|
|
|
"pending_items": list(self.pending_items.keys()),
|
|
|
|
|
"processing_items": list(self.processing),
|
|
|
|
|
"pending_count": len(self.pending_items),
|
|
|
|
|
"processing_count": len(self.processing),
|
|
|
|
|
"executor_active_threads": getattr(self.executor, '_threads', 0)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# Global batcher instance
|
|
|
|
|
batcher = WebhookBatcher()
|
|
|
|
|
|
|
|
|
|
def find_series_path_from_sonarr_path(sonarr_path: str) -> Optional[Path]:
|
|
|
|
|
"""Convert Sonarr's full path to container path"""
|
|
|
|
|
if not sonarr_path:
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
|
if sonarr_path.startswith("/mnt/unionfs/Media/TV/"):
|
|
|
|
|
container_path = sonarr_path.replace("/mnt/unionfs/Media/TV/", "/media/")
|
|
|
|
|
path = Path(container_path)
|
|
|
|
|
if path.exists():
|
|
|
|
|
_log("INFO", f"Found series path via Sonarr path: {path}")
|
|
|
|
|
return path
|
|
|
|
|
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
|
def find_movie_path_from_radarr_path(radarr_path: str) -> Optional[Path]:
|
|
|
|
|
"""Convert Radarr's full path (folderPath or path) to container path"""
|
|
|
|
|
if not radarr_path:
|
|
|
|
|
return None
|
|
|
|
|
if radarr_path.startswith("/mnt/unionfs/Media/Movies/"):
|
|
|
|
|
container_path = radarr_path.replace("/mnt/unionfs/Media/Movies/", "/media/")
|
|
|
|
|
path = Path(container_path)
|
|
|
|
|
if path.exists():
|
|
|
|
|
_log("INFO", f"Found movie path via Radarr path: {path}")
|
|
|
|
|
return path
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
|
def find_series_path(series_title: str, imdb_id: str, sonarr_path: str = None) -> Optional[Path]:
|
|
|
|
|
"""Find the series directory based on title, IMDb ID, and optional Sonarr path"""
|
|
|
|
|
|
|
|
|
|
if sonarr_path:
|
|
|
|
|
series_path = find_series_path_from_sonarr_path(sonarr_path)
|
|
|
|
|
if series_path:
|
|
|
|
|
return series_path
|
|
|
|
|
|
|
|
|
|
if imdb_id and not imdb_id.startswith("tt"):
|
|
|
|
|
imdb_id = f"tt{imdb_id}"
|
|
|
|
|
|
|
|
|
|
_log("DEBUG", f"Searching for series: {series_title} with IMDb ID: {imdb_id}")
|
|
|
|
|
|
|
|
|
|
for media_path in config.tv_paths:
|
|
|
|
|
if not media_path.exists():
|
|
|
|
|
_log("WARNING", f"TV path does not exist: {media_path}")
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
|
|
if imdb_id:
|
|
|
|
|
pattern = str(media_path / f"*[imdb-{imdb_id}]*")
|
|
|
|
|
matches = glob.glob(pattern)
|
|
|
|
|
if matches:
|
|
|
|
|
found_path = Path(matches[0])
|
|
|
|
|
_log("INFO", f"Found series directory by IMDb ID: {found_path}")
|
|
|
|
|
return found_path
|
|
|
|
|
|
|
|
|
|
if series_title:
|
|
|
|
|
series_title_clean = series_title.lower().replace(" ", "").replace("-", "").replace(":", "")
|
|
|
|
|
for item in media_path.iterdir():
|
|
|
|
|
if item.is_dir() and "[imdb-" in item.name.lower():
|
|
|
|
|
item_clean = item.name.lower().replace(" ", "").replace("-", "").replace(":", "")
|
|
|
|
|
if series_title_clean in item_clean:
|
|
|
|
|
_log("INFO", f"Found series directory by title: {item}")
|
|
|
|
|
return item
|
|
|
|
|
|
|
|
|
|
_log("WARNING", f"Could not find directory for series: {series_title} ({imdb_id})")
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
|
def find_movie_path(movie_title: str, imdb_id: str, radarr_path: str = None) -> Optional[Path]:
|
|
|
|
|
"""Find the movie directory based on title, IMDb ID, and optional Radarr path"""
|
|
|
|
|
|
|
|
|
|
if radarr_path:
|
|
|
|
|
movie_path = find_movie_path_from_radarr_path(radarr_path)
|
|
|
|
|
if movie_path:
|
|
|
|
|
return movie_path
|
|
|
|
|
|
|
|
|
|
if imdb_id and not imdb_id.startswith("tt"):
|
|
|
|
|
imdb_id = f"tt{imdb_id}"
|
|
|
|
|
|
|
|
|
|
_log("DEBUG", f"Searching for movie: {movie_title} with IMDb ID: {imdb_id}")
|
|
|
|
|
|
|
|
|
|
for media_path in config.movie_paths:
|
|
|
|
|
if not media_path.exists():
|
|
|
|
|
_log("WARNING", f"Movie path does not exist: {media_path}")
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
|
|
if imdb_id:
|
|
|
|
|
pattern = str(media_path / f"*[imdb-{imdb_id}]*")
|
|
|
|
|
matches = glob.glob(pattern)
|
|
|
|
|
if matches:
|
|
|
|
|
found_path = Path(matches[0])
|
|
|
|
|
_log("INFO", f"Found movie directory by IMDb ID: {found_path}")
|
|
|
|
|
return found_path
|
|
|
|
|
|
|
|
|
|
if movie_title:
|
|
|
|
|
movie_title_clean = movie_title.lower().replace(" ", "").replace("-", "").replace(":", "")
|
|
|
|
|
for item in media_path.iterdir():
|
|
|
|
|
if item.is_dir() and "[imdb-" in item.name.lower():
|
|
|
|
|
item_clean = item.name.lower().replace(" ", "").replace("-", "").replace(":", "")
|
|
|
|
|
if movie_title_clean in item_clean:
|
|
|
|
|
_log("INFO", f"Found movie directory by title: {item}")
|
|
|
|
|
return item
|
|
|
|
|
|
|
|
|
|
_log("WARNING", f"Could not find directory for movie: {movie_title} ({imdb_id})")
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
|
async def process_sonarr_import(webhook_data: SonarrWebhook):
|
|
|
|
|
"""Process a Sonarr import webhook by adding to batch"""
|
|
|
|
|
try:
|
|
|
|
|
if not webhook_data.series:
|
|
|
|
|
_log("WARNING", f"No series data in {webhook_data.eventType} webhook")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
series_info = webhook_data.series
|
|
|
|
|
series_title = series_info.get("title", "Unknown")
|
|
|
|
|
imdb_id = series_info.get("imdbId", "")
|
|
|
|
|
sonarr_path = series_info.get("path", "")
|
|
|
|
|
|
|
|
|
|
if imdb_id:
|
|
|
|
|
imdb_id = imdb_id.replace("tt", "").strip()
|
|
|
|
|
if imdb_id:
|
|
|
|
|
imdb_id = f"tt{imdb_id}"
|
|
|
|
|
|
|
|
|
|
if not imdb_id:
|
|
|
|
|
_log("ERROR", f"No IMDb ID found for series: {series_title}")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
_log("INFO", f"Received webhook for series: {series_title} (IMDb: {imdb_id})")
|
|
|
|
|
|
|
|
|
|
series_path = find_series_path(series_title, imdb_id, sonarr_path)
|
|
|
|
|
if not series_path:
|
|
|
|
|
_log("ERROR", f"Could not find series directory for: {series_title} ({imdb_id})")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
webhook_dict = {
|
|
|
|
|
'series': series_info,
|
|
|
|
|
'series_path': str(series_path),
|
|
|
|
|
'event_type': webhook_data.eventType
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
batcher.add_webhook(imdb_id, webhook_dict, 'tv')
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error processing Sonarr webhook: {e}")
|
|
|
|
|
raise
|
|
|
|
|
|
|
|
|
|
async def process_radarr_import(webhook_data: RadarrWebhook):
|
|
|
|
|
"""Process a Radarr import webhook by adding to batch"""
|
|
|
|
|
try:
|
|
|
|
|
if not webhook_data.movie:
|
|
|
|
|
_log("WARNING", f"No movie data in {webhook_data.eventType} webhook")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
movie_info = webhook_data.movie
|
|
|
|
|
movie_title = movie_info.get("title", "Unknown")
|
|
|
|
|
|
|
|
|
|
# Prefer folderPath for Rename payloads; fall back to path
|
|
|
|
|
radarr_path = movie_info.get("folderPath") or movie_info.get("path", "")
|
|
|
|
|
|
|
|
|
|
# imdbId may be missing on Rename; fall back to remoteMovie or parse from folder
|
|
|
|
|
imdb_id = (movie_info.get("imdbId") or (webhook_data.remoteMovie or {}).get("imdbId") or "").strip()
|
|
|
|
|
if imdb_id:
|
|
|
|
|
imdb_id = f"tt{imdb_id.replace('tt','')}"
|
|
|
|
|
|
|
|
|
|
movie_path = find_movie_path(movie_title, imdb_id, radarr_path)
|
|
|
|
|
if not imdb_id and movie_path:
|
|
|
|
|
# Try to parse from the resolved folder name
|
|
|
|
|
parsed = parse_imdb_from_movie_path(movie_path)
|
|
|
|
|
if parsed:
|
|
|
|
|
imdb_id = parsed
|
|
|
|
|
|
|
|
|
|
if not imdb_id:
|
|
|
|
|
_log("WARNING", f"No IMDb ID available for movie '{movie_title}'. Proceeding by path only.")
|
|
|
|
|
|
|
|
|
|
_log("INFO", f"Received webhook for movie: {movie_title} (IMDb: {imdb_id or 'unknown'})")
|
|
|
|
|
if getattr(webhook_data, "renamedMovieFiles", None):
|
|
|
|
|
_log("INFO", f"Renamed {len(webhook_data.renamedMovieFiles)} file(s) for {movie_title}")
|
|
|
|
|
|
|
|
|
|
if not movie_path:
|
|
|
|
|
_log("ERROR", f"Could not find movie directory for: {movie_title} ({imdb_id or 'unknown'})")
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
webhook_dict = {
|
|
|
|
|
'movie': movie_info,
|
|
|
|
|
'movie_path': str(movie_path),
|
|
|
|
|
'event_type': webhook_data.eventType
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
batcher.add_webhook(imdb_id or str(movie_path), webhook_dict, 'movie')
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Error processing Radarr webhook: {e}")
|
|
|
|
|
raise
|
|
|
|
|
|
|
|
|
|
@app.post("/webhook/sonarr")
|
|
|
|
|
async def sonarr_webhook(request: Request, background_tasks: BackgroundTasks):
|
|
|
|
|
"""Handle Sonarr webhooks"""
|
|
|
|
|
try:
|
|
|
|
|
webhook_data = await request.json()
|
|
|
|
|
_log("DEBUG", f"Raw Sonarr webhook payload: {webhook_data}")
|
|
|
|
|
|
|
|
|
|
webhook = SonarrWebhook(**webhook_data)
|
|
|
|
|
_log("INFO", f"Received Sonarr webhook: {webhook.eventType}")
|
|
|
|
|
|
|
|
|
|
if webhook.eventType not in ["Download", "Upgrade", "Rename"]:
|
|
|
|
|
return {"status": "ignored", "reason": f"Event type {webhook.eventType} not processed"}
|
|
|
|
|
|
|
|
|
|
await process_sonarr_import(webhook)
|
|
|
|
|
return {"status": "accepted", "message": "Sonarr webhook queued for batched processing"}
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Failed to parse Sonarr webhook: {e}")
|
|
|
|
|
raise HTTPException(status_code=422, detail=f"Invalid Sonarr webhook format: {e}")
|
|
|
|
|
|
|
|
|
|
@app.post("/webhook/radarr")
|
|
|
|
|
async def radarr_webhook(request: Request, background_tasks: BackgroundTasks):
|
|
|
|
|
"""Handle Radarr webhooks"""
|
|
|
|
|
try:
|
|
|
|
|
webhook_data = await request.json()
|
|
|
|
|
_log("DEBUG", f"Raw Radarr webhook payload: {webhook_data}")
|
|
|
|
|
|
|
|
|
|
webhook = RadarrWebhook(**webhook_data)
|
|
|
|
|
_log("INFO", f"Received Radarr webhook: {webhook.eventType}")
|
|
|
|
|
|
|
|
|
|
# Allow common movie-file events; Rename payload has folderPath/renamedMovieFiles
|
|
|
|
|
if webhook.eventType not in ["Download", "Upgrade", "Rename", "MovieFileDelete", "MovieDelete"]:
|
|
|
|
|
return {"status": "ignored", "reason": f"Event type {webhook.eventType} not processed"}
|
|
|
|
|
|
|
|
|
|
await process_radarr_import(webhook)
|
|
|
|
|
return {"status": "accepted", "message": "Radarr webhook queued for batched processing"}
|
|
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Failed to parse Radarr webhook: {e}")
|
|
|
|
|
raise HTTPException(status_code=422, detail=f"Invalid Radarr webhook format: {e}")
|
|
|
|
|
|
|
|
|
|
@app.get("/health")
|
|
|
|
|
async def health_check() -> HealthResponse:
|
|
|
|
|
"""Health check endpoint"""
|
|
|
|
|
uptime = datetime.now(timezone.utc) - start_time
|
|
|
|
|
|
|
|
|
|
# Check database connectivity
|
|
|
|
|
try:
|
|
|
|
|
conn = db_connect(db_path)
|
|
|
|
|
conn.execute("PRAGMA busy_timeout = 5000")
|
|
|
|
|
conn.execute("SELECT 1").fetchone()
|
|
|
|
|
conn.close()
|
|
|
|
|
db_status = "healthy"
|
|
|
|
|
except Exception as e:
|
|
|
|
|
db_status = f"error: {e}"
|
|
|
|
|
|
|
|
|
|
return HealthResponse(
|
|
|
|
|
status="healthy" if db_status == "healthy" else "degraded",
|
|
|
|
|
version="1.0.0",
|
|
|
|
|
uptime=str(uptime),
|
|
|
|
|
database_status=db_status
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
@app.get("/stats")
|
|
|
|
|
async def get_stats():
|
|
|
|
|
"""Get database statistics"""
|
|
|
|
|
try:
|
|
|
|
|
conn = db_connect(db_path)
|
|
|
|
|
conn.execute("PRAGMA busy_timeout = 5000")
|
|
|
|
|
|
|
|
|
|
# Ensure movie tables exist
|
|
|
|
|
ensure_movie_tables(conn)
|
|
|
|
|
|
|
|
|
|
# Get TV series count
|
|
|
|
|
tv_series_count = conn.execute("SELECT COUNT(*) FROM series").fetchone()[0]
|
|
|
|
|
|
|
|
|
|
# Get TV episode count
|
|
|
|
|
tv_episode_count = conn.execute("SELECT COUNT(*) FROM episode_dates").fetchone()[0]
|
|
|
|
|
|
|
|
|
|
# Get TV episodes with video files
|
|
|
|
|
tv_with_files = conn.execute("SELECT COUNT(*) FROM episode_dates WHERE has_video_file = 1").fetchone()[0]
|
|
|
|
|
|
|
|
|
|
# Get movie count
|
|
|
|
|
movie_count = conn.execute("SELECT COUNT(*) FROM movies").fetchone()[0]
|
|
|
|
|
|
|
|
|
|
# Get movies with video files
|
|
|
|
|
movies_with_files = conn.execute("SELECT COUNT(*) FROM movie_dates WHERE has_video_file = 1").fetchone()[0]
|
|
|
|
|
|
|
|
|
|
# Get TV source breakdown
|
|
|
|
|
tv_sources = conn.execute("""
|
|
|
|
|
SELECT source, COUNT(*) as count
|
|
|
|
|
FROM episode_dates
|
|
|
|
|
WHERE has_video_file = 1
|
|
|
|
|
GROUP BY source
|
|
|
|
|
ORDER BY count DESC
|
|
|
|
|
""").fetchall()
|
|
|
|
|
|
|
|
|
|
# Get movie source breakdown
|
|
|
|
|
movie_sources = conn.execute("""
|
|
|
|
|
SELECT source, COUNT(*) as count
|
|
|
|
|
FROM movie_dates
|
|
|
|
|
WHERE has_video_file = 1
|
|
|
|
|
GROUP BY source
|
|
|
|
|
ORDER BY count DESC
|
|
|
|
|
""").fetchall()
|
|
|
|
|
|
|
|
|
|
conn.close()
|
|
|
|
|
|
|
|
|
|
return {
|
|
|
|
|
"tv_series_count": tv_series_count,
|
|
|
|
|
"tv_episode_count": tv_episode_count,
|
|
|
|
|
"tv_episodes_with_files": tv_with_files,
|
|
|
|
|
"movie_count": movie_count,
|
|
|
|
|
"movies_with_files": movies_with_files,
|
|
|
|
|
"tv_sources": dict(tv_sources),
|
|
|
|
|
"movie_sources": dict(movie_sources)
|
|
|
|
|
}
|
|
|
|
|
except Exception as e:
|
|
|
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
|
|
|
|
@app.get("/batch/status")
|
|
|
|
|
async def get_batch_status():
|
|
|
|
|
"""Get current batching status"""
|
|
|
|
|
return batcher.get_status()
|
|
|
|
|
|
|
|
|
|
def iterate_movie_paths():
|
|
|
|
|
"""Find all movie directories in configured paths"""
|
|
|
|
|
movies = []
|
|
|
|
|
for movie_path in config.movie_paths:
|
|
|
|
|
if not movie_path.exists():
|
|
|
|
|
continue
|
|
|
|
|
for item in movie_path.iterdir():
|
|
|
|
|
if is_movie_dir(item):
|
|
|
|
|
movies.append(item)
|
|
|
|
|
return sorted(movies)
|
|
|
|
|
|
|
|
|
|
def run_manual_scan_sync(scan_paths: List[Path], scan_type: str = "both"):
|
|
|
|
|
"""Synchronous function for manual scan - runs in executor"""
|
|
|
|
|
from media_date_cache import iterate_target_path
|
|
|
|
|
|
|
|
|
|
class MockArgs:
|
|
|
|
|
def __init__(self):
|
|
|
|
|
self.manage_nfo = config.manage_nfo
|
|
|
|
|
self.fix_dir_mtimes = config.fix_dir_mtimes
|
|
|
|
|
self.lock_metadata = config.lock_metadata
|
|
|
|
|
self.use_cache = True
|
|
|
|
|
self.force_refresh = False
|
|
|
|
|
self.skip_if_current = True # Skip current files in manual scan
|
|
|
|
|
self.debug = config.debug
|
|
|
|
|
self.update_video_mtimes = True
|
|
|
|
|
|
|
|
|
|
conn = None
|
|
|
|
|
try:
|
|
|
|
|
conn = db_connect(db_path)
|
|
|
|
|
conn.execute("PRAGMA busy_timeout = 30000")
|
|
|
|
|
conn.execute("PRAGMA journal_mode = WAL")
|
|
|
|
|
ensure_movie_tables(conn)
|
|
|
|
|
|
|
|
|
|
for scan_path in scan_paths:
|
|
|
|
|
_log("INFO", f"Starting manual scan of: {scan_path}")
|
|
|
|
|
|
|
|
|
|
if scan_type in ["both", "tv"]:
|
|
|
|
|
# Scan TV series
|
|
|
|
|
tv_targets = iterate_target_path(scan_path)
|
|
|
|
|
for series_dir in tv_targets:
|
|
|
|
|
try:
|
|
|
|
|
apply_series(series_dir, MockArgs(), conn)
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Failed processing TV series {series_dir}: {e}")
|
|
|
|
|
|
|
|
|
|
if scan_type in ["both", "movies"]:
|
|
|
|
|
# Scan movies
|
|
|
|
|
if scan_path in config.movie_paths:
|
|
|
|
|
for item in scan_path.iterdir():
|
|
|
|
|
if is_movie_dir(item):
|
|
|
|
|
try:
|
|
|
|
|
apply_movie(item, conn)
|
|
|
|
|
except Exception as e:
|
|
|
|
|
_log("ERROR", f"Failed processing movie {item}: {e}")
|
|
|
|
|
|
|
|
|
|
_log("INFO", f"Completed manual scan of: {scan_path}")
|
|
|
|
|
finally:
|
|
|
|
|
if conn:
|
|
|
|
|
try:
|
|
|
|
|
conn.close()
|
|
|
|
|
except:
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
@app.post("/manual/scan")
|
|
|
|
|
async def manual_scan(background_tasks: BackgroundTasks, path: Optional[str] = None, scan_type: str = "both"):
|
|
|
|
|
"""Trigger a manual library scan"""
|
|
|
|
|
if path:
|
|
|
|
|
scan_paths = [Path(path)]
|
|
|
|
|
else:
|
|
|
|
|
# Scan both TV and movie paths
|
|
|
|
|
scan_paths = list(config.tv_paths) + list(config.movie_paths)
|
|
|
|
|
|
|
|
|
|
# Validate scan_type
|
|
|
|
|
if scan_type not in ["both", "tv", "movies"]:
|
|
|
|
|
raise HTTPException(status_code=400, detail="scan_type must be 'both', 'tv', or 'movies'")
|
|
|
|
|
|
|
|
|
|
# Run in executor
|
|
|
|
|
async def run_scan():
|
|
|
|
|
await asyncio.get_event_loop().run_in_executor(None, run_manual_scan_sync, scan_paths, scan_type)
|
|
|
|
|
|
|
|
|
|
background_tasks.add_task(run_scan)
|
|
|
|
|
|
|
|
|
|
return {"status": "started", "message": f"Manual {scan_type} scan started for {len(scan_paths)} paths"}
|
|
|
|
|
|
|
|
|
|
@app.post("/manual/scan/tv")
|
|
|
|
|
async def manual_scan_tv(background_tasks: BackgroundTasks, path: Optional[str] = None):
|
|
|
|
|
"""Trigger a manual TV library scan"""
|
|
|
|
|
return await manual_scan(background_tasks, path, "tv")
|
|
|
|
|
|
|
|
|
|
@app.post("/manual/scan/movies")
|
|
|
|
|
async def manual_scan_movies(background_tasks: BackgroundTasks, path: Optional[str] = None):
|
|
|
|
|
"""Trigger a manual movie library scan"""
|
|
|
|
|
return await manual_scan(background_tasks, path, "movies")
|
|
|
|
|
|
|
|
|
|
@app.get("/test/path/{media_title}")
|
|
|
|
|
async def test_path_matching(media_title: str, imdb_id: Optional[str] = None,
|
|
|
|
|
media_type: str = "tv", app_path: Optional[str] = None):
|
|
|
|
|
"""Test endpoint to debug path matching"""
|
|
|
|
|
if media_type == "tv":
|
|
|
|
|
result = find_series_path(media_title, imdb_id or "", app_path or "")
|
|
|
|
|
paths = config.tv_paths
|
|
|
|
|
elif media_type == "movie":
|
|
|
|
|
result = find_movie_path(media_title, imdb_id or "", app_path or "")
|
|
|
|
|
paths = config.movie_paths
|
|
|
|
|
else:
|
|
|
|
|
raise HTTPException(status_code=400, detail="media_type must be 'tv' or 'movie'")
|
|
|
|
|
|
|
|
|
|
return {
|
|
|
|
|
"media_title": media_title,
|
|
|
|
|
"media_type": media_type,
|
|
|
|
|
"imdb_id": imdb_id,
|
|
|
|
|
"app_path": app_path,
|
|
|
|
|
"search_paths": [str(p) for p in paths],
|
|
|
|
|
"found_path": str(result) if result else None,
|
|
|
|
|
"exists": result.exists() if result else False
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
|
# Enable debug logging if requested
|
|
|
|
|
if config.debug:
|
|
|
|
|
import logging
|
|
|
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
|
|
|
os.environ["DEBUG"] = "true"
|
|
|
|
|
|
|
|
|
|
_log("INFO", "Starting Media Date Cache Webhook Server with TV and Movie support")
|
|
|
|
|
_log("INFO", f"TV paths: {[str(p) for p in config.tv_paths]}")
|
|
|
|
|
_log("INFO", f"Movie paths: {[str(p) for p in config.movie_paths]}")
|
|
|
|
|
_log("INFO", f"Database path: {db_path}")
|
|
|
|
|
_log("INFO", f"Manage NFO: {config.manage_nfo}")
|
|
|
|
|
_log("INFO", f"Fix dir mtimes: {config.fix_dir_mtimes}")
|
|
|
|
|
_log("INFO", f"Lock metadata: {config.lock_metadata}")
|
|
|
|
|
_log("INFO", f"Batch delay: {config.batch_delay}s")
|
|
|
|
|
_log("INFO", f"Max concurrent items: {config.max_concurrent_series}")
|
|
|
|
|
|
|
|
|
|
uvicorn.run(
|
|
|
|
|
"webhook_server:app",
|
|
|
|
|
host="0.0.0.0",
|
|
|
|
|
port=int(os.environ.get("PORT", "8080")),
|
|
|
|
|
reload=False
|
|
|
|
|
)
|
|
|
|
|
|
sbcrumb