jfmo 3.0.0__py3-none-any.whl

jfmo/__init__.py

@@ -0,0 +1,124 @@
+import os
+import signal
+import sys
+
+from loguru import logger
+
+from .cli import CLI
+from .config import config
+from .daemon import FileWatcher
+from .di import Container
+from .exceptions import DirectoryNotFoundError, TransliterationModelError
+from .utils.cli_output import print_dry_run_banner, print_entry_header, print_header, print_result, print_summary
+from .utils.fs.file_ops import is_video_file
+
+EXIT_SUCCESS = 0
+EXIT_CONFIG_ERROR = 1
+EXIT_DIRECTORY_ERROR = 2
+EXIT_SYSTEM_ERROR = 5
+EXIT_MODEL_ERROR = 6
+
+
+def _run(apply: bool) -> None:
+    config.DRY_RUN = not apply
+    container = Container()
+
+    show_output = not config.DAEMON_MODE
+
+    video_entries = [
+        name
+        for name in os.listdir(config.DOWNLOADS_DIR)
+        if os.path.isdir(os.path.join(config.DOWNLOADS_DIR, name))
+        or (os.path.isfile(os.path.join(config.DOWNLOADS_DIR, name)) and is_video_file(name))
+    ]
+
+    if show_output and config.DRY_RUN:
+        print_dry_run_banner()
+    if show_output:
+        print_header(len(video_entries))
+
+    all_results = []
+    skipped_count = 0
+
+    for name in video_entries:
+        path = os.path.join(config.DOWNLOADS_DIR, name)
+
+        if show_output:
+            print_entry_header(name, is_dir=os.path.isdir(path))
+
+        if os.path.isdir(path):
+            results = container.formatter.format_directory(path)
+            all_results.extend(results)
+            if show_output:
+                for r in results:
+                    print_result(r)
+        else:
+            result = container.formatter.format_file(path)
+            if result is None:
+                skipped_count += 1
+            else:
+                all_results.append(result)
+                if show_output:
+                    print_result(result)
+
+    if show_output:
+        print_summary(all_results, skipped_count, config.DRY_RUN)
+        if config.DRY_RUN:
+            print_dry_run_banner()
+
+
+def _run_daemon() -> None:
+    container = Container()
+    watcher = FileWatcher(config.DOWNLOADS_DIR, config.DAEMON_INTERVAL_SEC, container.formatter)
+
+    def _stop(signum, _frame):
+        logger.info(f"Signal {signum}. Stopping...")
+        watcher.stop()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, _stop)
+    signal.signal(signal.SIGTERM, _stop)
+
+    logger.info("Daemon starting...")
+    logger.info(config)
+    watcher.start()
+
+
+def main():
+    cli = CLI()
+    command = cli.read_command()
+
+    if command is None:
+        cli.print_help()
+        sys.exit(EXIT_SUCCESS)
+
+    try:
+        config.DAEMON_MODE = command == "daemon"
+        config.load(cli.read_config_path())
+
+        if command == "daemon":
+            _run_daemon()
+        else:
+            _run(cli.read_run_apply())
+
+    except FileNotFoundError as e:
+        logger.error(str(e))
+        sys.exit(EXIT_CONFIG_ERROR)
+
+    except ValueError as e:
+        logger.error(str(e))
+        sys.exit(EXIT_CONFIG_ERROR)
+
+    except DirectoryNotFoundError as e:
+        logger.error(str(e))
+        sys.exit(EXIT_DIRECTORY_ERROR)
+
+    except TransliterationModelError as e:
+        logger.error(str(e))
+        sys.exit(EXIT_MODEL_ERROR)
+
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        sys.exit(EXIT_SYSTEM_ERROR)
+
+    sys.exit(EXIT_SUCCESS)

jfmo/cli.py

@@ -0,0 +1,59 @@
+from argparse import ArgumentParser, RawDescriptionHelpFormatter
+from importlib.metadata import version
+
+
+class CLI:
+    def __init__(self) -> None:
+        self._parser = self._create_parser()
+        self._args = self._parser.parse_args()
+
+    def _create_parser(self) -> ArgumentParser:
+        parser = ArgumentParser(
+            prog="jfmo",
+            description="Jellyfin Format Media Organizer",
+            usage="%(prog)s <command> [options]",
+            formatter_class=RawDescriptionHelpFormatter,
+            add_help=True,
+        )
+        parser.add_argument(
+            "-v",
+            "--version",
+            action="version",
+            version=f"{parser.prog} {version('jfmo')}",
+        )
+
+        parser.add_argument(
+            "-c",
+            "--config",
+            metavar="FILE",
+            default="/etc/jfmo/config.yaml",
+            help="Path to configuration file (default: /etc/jfmo/config.yaml)",
+        )
+
+        subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+        # Run command
+        run_parser = subparsers.add_parser("run", help="Process downloads directory (default: dry-run)")
+        run_parser.add_argument(
+            "-a",
+            "--apply",
+            action="store_true",
+            help="Apply changes (move files). Without this flag runs as dry-run.",
+        )
+
+        # Daemon command
+        subparsers.add_parser("daemon", help="Watch downloads directory for new files")
+
+        return parser
+
+    def read_command(self) -> str:
+        return self._args.command
+
+    def read_config_path(self) -> str:
+        return self._args.config
+
+    def read_run_apply(self) -> bool:
+        return getattr(self._args, "apply", False)
+
+    def print_help(self) -> None:
+        self._parser.print_help()

jfmo/config.py

@@ -0,0 +1,206 @@
+import os
+import re
+import sys
+from pathlib import Path
+
+import yaml
+from loguru import logger
+
+from .parser.tokens import Token
+
+# Valid tokens per naming pattern
+_VALID_TOKENS: dict[str, set[Token]] = {
+    "naming.movie.file": {
+        Token.TITLE,
+        Token.YEAR,
+        Token.QUALITY,
+        Token.TMDB_ID,
+        Token.SOURCE,
+        Token.CODEC,
+        Token.HDR,
+        Token.SERVICE,
+        Token.RELEASE_GROUP,
+    },
+    "naming.tv.folder": {Token.TITLE, Token.YEAR, Token.TMDB_ID},
+    "naming.tv.season": {Token.SEASON},
+    "naming.tv.file": {
+        Token.TITLE,
+        Token.SEASON,
+        Token.EPISODE,
+        Token.QUALITY,
+        Token.SOURCE,
+        Token.CODEC,
+        Token.HDR,
+        Token.SERVICE,
+        Token.RELEASE_GROUP,
+    },
+}
+
+
+class Config:
+    def __init__(self) -> None:
+        self.LOG_LEVEL: str = "INFO"
+
+        self.DAEMON_INTERVAL_SEC: int = 30
+
+        self.DOWNLOADS_DIR: str
+        self.MOVIES_DIR: str
+        self.TV_DIR: str
+
+        # Naming format tokens
+        self.FORMAT_MOVIE_FILE: str = "{title} ({year}) [tmdbid-{tmdb_id}] - {quality}"
+        self.FORMAT_TV_FOLDER: str = "{title} ({year}) [tmdbid-{tmdb_id}]"
+        self.FORMAT_TV_SEASON_FOLDER: str = "Season {season}"
+        self.FORMAT_TV_FILE: str = "{title} S{season}E{episode} - {quality}"
+
+        # TMDB configuration
+        self.TMDB_API_KEY: str | None = None
+
+        self.DRY_RUN: bool = False
+        self.DAEMON_MODE: bool = False
+
+    def _setup_logger(self) -> None:
+        logger.remove()
+
+        if self.DAEMON_MODE:
+            logger.add(
+                sys.stderr,
+                colorize=True,
+                level=self.LOG_LEVEL,
+                format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan> - <level>{message}</level>",
+            )
+
+        log_dir = Path("/var/log/jfmo")
+        try:
+            log_dir.mkdir(parents=True, exist_ok=True)
+            logger.add(
+                str(log_dir / ("jfmo_{time:YYYY-MM-DD}.log")),
+                rotation="10 MB",
+                retention="30 days",
+                compression="zip",
+                level=self.LOG_LEVEL,
+                format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}",
+            )
+        except PermissionError:
+            pass  # No file logging if lacking permissions
+
+    def load(self, path: str) -> None:
+        """Load configuration from a YAML file.
+
+        Raises:
+            FileNotFoundError: If the config file does not exist.
+            ValueError: If the YAML is invalid or cannot be applied.
+        """
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Config file not found: {path}")
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in config file: {e}") from e
+
+        if not data:
+            self._setup_logger()
+            return
+
+        # Logging
+        if "logging" in data:
+            log = data["logging"]
+            if "log_level" in log:
+                self.LOG_LEVEL = log["log_level"].upper()
+
+        # Daemon
+        if "daemon" in data and "interval" in data["daemon"]:
+            self.DAEMON_INTERVAL_SEC = data["daemon"]["interval"]
+
+        # Directories
+        if "directories" in data:
+            dirs = data["directories"]
+            if "downloads" in dirs:
+                dl = dirs["downloads"]
+                if isinstance(dl, dict) and "path" in dl:
+                    self.DOWNLOADS_DIR = dl["path"]
+            if "media" in dirs:
+                media = dirs["media"]
+                if "movies" in media:
+                    self.MOVIES_DIR = media["movies"]
+                if "tv" in media:
+                    self.TV_DIR = media["tv"]
+
+        # Naming tokens
+        if "naming" in data:
+            naming = data["naming"]
+            if "movie" in naming and isinstance(naming["movie"], dict) and "file" in naming["movie"]:
+                self.FORMAT_MOVIE_FILE = naming["movie"]["file"]
+            if "tv" in naming and isinstance(naming["tv"], dict):
+                tv = naming["tv"]
+                if "folder" in tv:
+                    self.FORMAT_TV_FOLDER = tv["folder"]
+                if "season" in tv:
+                    self.FORMAT_TV_SEASON_FOLDER = tv["season"]
+                if "file" in tv:
+                    self.FORMAT_TV_FILE = tv["file"]
+
+        # TMDB
+        if "tmdb" in data and (api_key := data["tmdb"].get("api_key")):
+            self.TMDB_API_KEY = api_key
+
+        self._setup_logger()
+        self._validate()
+
+    def _validate(self) -> None:
+        """Validate configuration values after loading.
+
+        Raises:
+            ValueError: If required directories are missing or paths do not exist.
+        """
+        errors: list[str] = []
+
+        # Required directory attributes must be set
+        for attr in ("DOWNLOADS_DIR", "MOVIES_DIR", "TV_DIR"):
+            if not hasattr(self, attr):
+                errors.append(f"Required directory not configured: '{attr.lower()}'")
+            else:
+                path = getattr(self, attr)
+                if not os.path.exists(path):
+                    errors.append(f"Directory does not exist: {attr}={path!r}")
+                elif not os.path.isdir(path):
+                    errors.append(f"Path is not a directory: {attr}={path!r}")
+
+        if self.DAEMON_INTERVAL_SEC < 30:
+            errors.append(f"daemon.interval must be >= 30, got {self.DAEMON_INTERVAL_SEC}")
+
+        errors.extend(self._validate_naming_patterns())
+
+        if errors:
+            raise ValueError("Configuration errors:\n" + "\n".join(f"  - {e}" for e in errors))
+
+    def _validate_naming_patterns(self) -> list[str]:
+        errors = []
+        token_pattern = re.compile(r"\{(\w+)\}")
+
+        for label, pattern in [
+            ("naming.movie.file", self.FORMAT_MOVIE_FILE),
+            ("naming.tv.folder", self.FORMAT_TV_FOLDER),
+            ("naming.tv.season", self.FORMAT_TV_SEASON_FOLDER),
+            ("naming.tv.file", self.FORMAT_TV_FILE),
+        ]:
+            used_tokens = set(token_pattern.findall(pattern))
+            unknown = used_tokens - _VALID_TOKENS[label]
+            if unknown:
+                errors.append(f"{label}: invalid tokens {unknown} (allowed: {_VALID_TOKENS[label]})")
+
+        return errors
+
+    def __str__(self) -> str:
+        return (
+            f"Current configuration:\n"
+            f"  Download: {self.DOWNLOADS_DIR}\n"
+            f"  Movies: {self.MOVIES_DIR} - TV: {self.TV_DIR}\n"
+            f"  Daemon Interval: {self.DAEMON_INTERVAL_SEC} sec\n"
+            f"  TMDB Integration: {'enable' if self.TMDB_API_KEY else 'disable'}"
+        )
+
+
+config = Config()

jfmo/daemon.py

@@ -0,0 +1,105 @@
+import os
+from datetime import datetime
+from threading import Event
+
+from loguru import logger
+
+from .formatter import Formatter
+from .utils.fs.file_ops import is_video_file
+from .utils.fs.file_stability_tracker import FileStabilityTracker
+
+
+class FileWatcher:
+    def __init__(self, watch_dir: str, check_interval: int, formatter: Formatter) -> None:
+        self.watch_dir = watch_dir
+        self.check_interval = check_interval
+        self.formatter = formatter
+        self.known_entries: set[str] = set()
+        self.stability_tracker = FileStabilityTracker(stability_cycles=2)
+        self.stop_event = Event()
+        self._cycle = 0
+
+    def _scan_entries(self) -> set[str]:
+        """Return direct children of watch_dir (dirs and video files)."""
+        found: set[str] = set()
+        try:
+            for name in os.listdir(self.watch_dir):
+                path = os.path.join(self.watch_dir, name)
+                if os.path.isdir(path) or (os.path.isfile(path) and is_video_file(name)):
+                    found.add(path)
+        except Exception as e:
+            logger.error(f"Error scanning directory: {e}")
+        return found
+
+    def _is_stable(self, path: str) -> bool:
+        """Check stability: for dirs, check all video files inside are stable."""
+        if os.path.isfile(path):
+            return self.stability_tracker.is_stable(path)
+        for root, _, filenames in os.walk(path):
+            for filename in filenames:
+                if is_video_file(filename) and not self.stability_tracker.is_stable(os.path.join(root, filename)):
+                    return False
+        return True
+
+    def _mark_processed(self, path: str) -> None:
+        if os.path.isfile(path):
+            self.stability_tracker.mark_processed(path)
+        else:
+            for root, _, filenames in os.walk(path):
+                for filename in filenames:
+                    if is_video_file(filename):
+                        self.stability_tracker.mark_processed(os.path.join(root, filename))
+
+    def _ts(self) -> str:
+        return datetime.now().strftime("%H:%M:%S")
+
+    def _process_new_entry(self, path: str) -> None:
+        name = os.path.basename(path)
+
+        if not self._is_stable(path):
+            return
+
+        self._mark_processed(path)
+        logger.info(f"New entry: {name}")
+
+        try:
+            result = self.formatter.format_directory(path) if os.path.isdir(path) else self.formatter.format_file(path)
+
+            if result is None:
+                logger.info(f"Skipped: {name}")
+            elif result:
+                logger.info(f"Processed: {name}")
+            else:
+                logger.error(f"Failed: {name}")
+        except Exception as e:
+            logger.error(f"Error processing {name}: {e}")
+
+    def start(self) -> None:
+        self.known_entries = self._scan_entries()
+        logger.info(f"Watching {len(self.known_entries)} existing entries")
+
+        while not self.stop_event.is_set():
+            try:
+                current_entries = self._scan_entries()
+                new_entries = current_entries - self.known_entries
+
+                for path in new_entries:
+                    self._process_new_entry(path)
+
+                self.known_entries = current_entries
+                self._cycle += 1
+
+                if self._cycle % 10 == 0:
+                    logger.info(f"[{self._ts()}] watching {len(current_entries)} entries")
+
+                self.stop_event.wait(self.check_interval)
+
+            except KeyboardInterrupt:
+                logger.info("Interrupted")
+                break
+            except Exception as e:
+                logger.error(f"Watch loop error: {e}")
+                self.stop_event.wait(self.check_interval)
+
+    def stop(self) -> None:
+        self.stop_event.set()

jfmo/di.py

@@ -0,0 +1,44 @@
+from .config import config
+from .formatter import Formatter
+from .metadata import TMDBClient
+from .parser import Parser
+from .parser.steps import (
+    CodecStep,
+    EpisodeStep,
+    ExtensionStep,
+    HdrStep,
+    MediaTypeStep,
+    QualityStep,
+    ReleaseGroupStep,
+    SeasonStep,
+    ServiceStep,
+    SourceStep,
+    TitleStep,
+    YearStep,
+)
+from .processors import MovieProcessor, TvProcessor
+
+
+class Container:
+    def __init__(self) -> None:
+        self.tmdb_client = TMDBClient(config.TMDB_API_KEY)
+
+        self.parser = Parser(
+            ExtensionStep(),
+            SeasonStep(),
+            EpisodeStep(),
+            YearStep(),
+            SourceStep(),
+            CodecStep(),
+            HdrStep(),
+            ServiceStep(),
+            ReleaseGroupStep(),
+            QualityStep(),
+            MediaTypeStep(),
+            TitleStep(),
+        )
+
+        self.movie_processor = MovieProcessor(self.tmdb_client)
+        self.tv_processor = TvProcessor(self.tmdb_client)
+
+        self.formatter = Formatter(self.parser, self.movie_processor, self.tv_processor)

jfmo/exceptions.py

@@ -0,0 +1,10 @@
+class DirectoryNotFoundError(Exception):
+    """Raised when a required media directory does not exist."""
+
+
+class DaemonError(Exception):
+    """Raised when the daemon fails to start."""
+
+
+class TransliterationModelError(Exception):
+    """Raised when language models cannot be loaded."""

jfmo/formatter.py

@@ -0,0 +1,59 @@
+import os
+
+from loguru import logger
+
+from .parser import MediaType, ParseContext, Parser
+from .parser.tokens import Token
+from .processors.movie_processor import MovieProcessor
+from .processors.result import ProcessResult
+from .processors.tv_processor import TvProcessor
+from .transliteration import Transliterator
+from .utils.fs.file_ops import is_video_file
+
+
+class Formatter:
+    def __init__(self, parser: Parser, movie_processor: MovieProcessor, tv_processor: TvProcessor) -> None:
+        self._parser = parser
+        self._movie = movie_processor
+        self._tv = tv_processor
+
+    def format_file(self, filepath: str) -> ProcessResult | None:
+        ctx = self._parser.parse(filepath)
+        if ctx.skip_reason:
+            logger.info(f"Skipped {os.path.basename(filepath)}: {ctx.skip_reason}")
+            return None
+        ctx.tokens[Token.TITLE] = Transliterator.transliterate_text(ctx.tokens.get(Token.TITLE, ""))
+        if ctx.media_type == MediaType.TV:
+            return self._tv.process(ctx)
+        return self._movie.process(ctx)
+
+    def format_directory(self, dirpath: str) -> list[ProcessResult]:
+        root_ctx = self._parser.parse(os.path.basename(dirpath))
+        root_season = root_ctx.tokens.get(Token.SEASON)
+        root_title = root_ctx.tokens.get(Token.TITLE, "")
+
+        results: list[ProcessResult] = []
+        for current_dir, _, files in os.walk(dirpath):
+            # Determine season: filename > subdirectory > root dir > None
+            if current_dir == dirpath:
+                effective_season = root_season
+            else:
+                sub_ctx = self._parser.parse(os.path.basename(current_dir))
+                effective_season = sub_ctx.tokens.get(Token.SEASON) or root_season
+
+            for file in files:
+                if is_video_file(file):
+                    filepath = os.path.join(current_dir, file)
+                    tokens = {Token.SEASON: effective_season} if effective_season else {}
+                    seed = ParseContext(filepath=filepath, tokens=tokens)
+                    ctx = self._parser.parse(filepath, seed=seed)
+                    if ctx.skip_reason:
+                        logger.info(f"Skipped {file}: {ctx.skip_reason}")
+                        continue
+                    if not ctx.tokens.get(Token.TITLE) and root_title:
+                        ctx.tokens[Token.TITLE] = Transliterator.transliterate_text(root_title)
+                    else:
+                        ctx.tokens[Token.TITLE] = Transliterator.transliterate_text(ctx.tokens.get(Token.TITLE, ""))
+                    results.append(self._tv.process(ctx))
+
+        return results

jfmo/metadata/__init__.py

@@ -0,0 +1 @@
+from .tmdb import TMDBClient as TMDBClient