srcalchemy 0.2.0__py3-none-any.whl

srcalchemy/process/process.py

@@ -0,0 +1,346 @@
+#################################################################################
+# MIT License
+#
+# Copyright (c) 2025 Duncan Fraser
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#################################################################################
+#
+# File          : process.py
+#
+# Author        : Duncan Fraser <dfraser@thedrunkencoder.uk>
+#
+# Description   :
+#
+#################################################################################
+
+import os
+import shutil
+from dataclasses import dataclass
+from typing import Literal
+
+from srcalchemy.collector import EpisodeInfo, MovieInfo, TVInfo, fileInfo, parseFileInfo
+from srcalchemy.config import ConfigSpec, movieConfig, tvConfig
+
+
+def formatMovieParent(movie_info: MovieInfo, movie_config: movieConfig) -> str:
+    """Generate the Parent Path for storing Movie
+
+    :param movie_info: Movie Information
+    :param movie_config: Configuration Options for Movies from Base Configuration
+
+    :returns: Directory Name
+    """
+    format_map = {
+        "TITLE": movie_info.title,
+        "YEAR": movie_info.year,
+        "FORMAT": movie_info.formatString,
+    }
+
+    movie_parent = movie_config.parentFormat.format_map(format_map)
+
+    return movie_parent
+
+
+def formatMovieFile(movie_info: MovieInfo, movie_config: movieConfig) -> str:
+    """Generate the file name for storing Movie
+
+    :param movie_info: Movie Information
+    :param movie_config: Configuration Options for Movies from Base Configuration
+
+    :returns: Filename
+    """
+    format_map = {
+        "TITLE": movie_info.title,
+        "YEAR": movie_info.year,
+        "FORMAT": movie_info.formatString,
+    }
+
+    movie_file = movie_config.fileFormat.format_map(format_map)
+
+    return movie_file
+
+
+def formatTvParent(
+    tv_info: TVInfo, episode_info: EpisodeInfo, tv_config: tvConfig
+) -> str:
+    """Generate the Parent Path for storing Episodes
+
+    :param tv_info: TV Show Information
+    :param episode_info: Episode Information
+    :param tv_config: Configuration Options for TV Shows from Base Configuration
+
+    :returns: Directory Name
+    """
+    format_map = {
+        "TITLE": tv_info.title,
+        "YEAR": tv_info.year,
+    }
+
+    tv_parent = tv_config.parentFormat.format_map(format_map)
+
+    return tv_parent
+
+
+def formatTvSeason(
+    tv_info: TVInfo, episode_info: EpisodeInfo, tv_config: tvConfig
+) -> str:
+    """Generate the Season Path for storing Episodes
+
+    :param tv_info: TV Show Information
+    :param episode_info: Episode Information
+    :param tv_config: Configuration Options for TV Shows from Base Configuration
+
+    :returns: Directory Name
+    """
+    format_map = {
+        "TITLE": tv_info.title,
+        "YEAR": tv_info.year,
+        "SEASON": episode_info.season,
+    }
+
+    tv_season = tv_config.seasonFormat.format_map(format_map)
+
+    return tv_season
+
+
+def formatTvEpisode(
+    tv_info: TVInfo, episode_info: EpisodeInfo, tv_config: tvConfig
+) -> str:
+    """Generate the file name for storing Episodes
+
+    :param tv_info: TV Show Information
+    :param episode_info: Episode Information
+    :param tv_config: Configuration Options for TV Shows from Base Configuration
+
+    :returns: Filename
+    """
+    format_map = {
+        "SHOW_TITLE": tv_info.title,
+        "TITLE": episode_info.title,
+        "YEAR": tv_info.year,
+        "SEASON": episode_info.season,
+        "EPISODE": episode_info.episode,
+    }
+
+    tv_episode = tv_config.fileFormat.format_map(format_map)
+
+    return tv_episode
+
+
+@dataclass
+class renameOperation:
+    """Rename Operation
+
+    Stores the source and destination and provides a status string
+    """
+
+    src: fileInfo
+    """Source file information"""
+    dest: fileInfo
+    """Destination file information"""
+    status: Literal["ok", "warning", "fail", "skip"] | None = None
+    """Status of operation"""
+
+
+def performRenameOperation(
+    config: ConfigSpec, data: renameOperation, dry_run: bool = False
+) -> renameOperation:
+    """Perform Rename Operation
+
+    Will rename the source file path to the destination file path and create the path if it does not exist.
+    The rename will not be performed if the source and destination file path are the same.
+    If the mode is "copy" will copy the file before renaming. If the mode is "move" will move and rename.
+
+    :param config: Configuration object
+    :param data: Rename operation to perform
+
+    :returns: Rename Operation
+    """
+    if data.src == data.dest:
+        data.status = "skip"
+        config.log.debug(
+            f"Source and Destination are the same path : {data.src.filename}"
+        )
+        return data
+
+    if not os.path.exists(data.src.path):
+        config.log.debug(f"Source does not exist : {data.src.path}")
+        data.status = "fail"
+        return data
+
+    if not os.path.isdir(data.dest.parentPath):
+        os.makedirs(data.dest.parentPath, exist_ok=True)
+
+    if not dry_run:
+        if config.general.mode == "move":
+            shutil.move(src=data.src.path, dst=data.dest.path)
+        elif config.general.mode == "copy":
+            shutil.copy(src=data.src.path, dst=data.dest.path)
+
+    data.status = "ok"
+    return data
+
+
+def performCleanDirectory(
+    config: ConfigSpec, data: renameOperation, dry_run: bool = False
+) -> bool:
+    """Clean Source Directory
+
+    Delete parent path of source file information.
+    Will not be performed if the destination parent path is the same as the source parent path
+
+    :param config: Configuration object
+    :param data: Rename Operation to delete src parent path
+    """
+    if not os.path.isdir(data.src.parentPath):
+        config.log.debug(f"Parent Path does not exit: {data.src.parentPath}")
+        return False
+
+    if data.src.parentPath == data.src.basePath:
+        config.log.debug(f"Parent Path and Base Path are the same: {data.src.basePath}")
+        return False
+
+    if data.src.parentPath == data.dest.parentPath:
+        config.log.debug(
+            f"Source and Destination Parent Path are the same: {data.src.parentPath}"
+        )
+        return False
+
+    if not dry_run:
+        shutil.rmtree(path=data.src.parentPath)
+    else:
+        config.log.debug(f"Dry Run Would remove: {data.src.parentPath}")
+
+    return True
+
+
+def processMovieRename(config: ConfigSpec, movie_info: MovieInfo) -> fileInfo:
+    """Process Movie Information into Output File Information
+
+    :param config: Configuration object
+    :param movie_info: Movie Information
+
+    :returns: File information for output file
+    """
+    new_parent_path = formatMovieParent(
+        movie_info=movie_info, movie_config=config.movie_config
+    )
+    new_filename = formatMovieFile(
+        movie_info=movie_info, movie_config=config.movie_config
+    )
+
+    if config.movie_config.outputDirectory is not None:
+        new_path = os.path.join(
+            config.movie_config.outputDirectory,
+            new_parent_path,
+            new_filename + movie_info.file.extension,
+        )
+        base_path = config.movie_config.outputDirectory
+    else:
+        new_path = os.path.join(
+            config.movie_config.basePath,
+            new_parent_path,
+            new_filename + movie_info.file.extension,
+        )
+        base_path = config.movie_config.basePath
+
+    file_info = parseFileInfo(path=new_path, base_path=base_path)
+
+    return file_info
+
+
+def processTvRename(
+    config: ConfigSpec, tv_info: TVInfo, episode_info: EpisodeInfo
+) -> fileInfo:
+    """Process Episodes Information into Output File Information
+
+    :param config: Configuration object
+    :param tv_info: TV information
+    :param episode_info: Episode information
+
+    :returns: File information for output file
+    """
+    new_parent_path = formatTvParent(
+        tv_info=tv_info, episode_info=episode_info, tv_config=config.tv_config
+    )
+    new_season_path = formatTvSeason(
+        tv_info=tv_info, episode_info=episode_info, tv_config=config.tv_config
+    )
+    new_filename = formatTvEpisode(
+        tv_info=tv_info, episode_info=episode_info, tv_config=config.tv_config
+    )
+
+    if config.tv_config.outputDirectory is not None:
+        new_path = os.path.join(
+            config.tv_config.outputDirectory,
+            new_parent_path,
+            new_season_path,
+            new_filename + episode_info.file.extension,
+        )
+        base_path = config.tv_config.outputDirectory
+    else:
+        new_path = os.path.join(
+            config.tv_config.basePath,
+            new_parent_path,
+            new_season_path,
+            new_filename + episode_info.file.extension,
+        )
+        base_path = config.tv_config.basePath
+
+    file_info = parseFileInfo(path=new_path, base_path=base_path)
+
+    return file_info
+
+
+def collectMovieRename(
+    config: ConfigSpec, movie_list: list[MovieInfo]
+) -> list[renameOperation]:
+    """Collect Movie Rename Operations from Movie Information
+
+    :param config: Configuration object
+    :param movie_list: List of Movie Info
+
+    :returns: List of rename operations to be performed
+    """
+    file_list: list[renameOperation] = []
+    for movie in movie_list:
+        new_file_info = processMovieRename(config=config, movie_info=movie)
+        file_list.append(renameOperation(src=movie.file, dest=new_file_info))
+
+    return file_list
+
+
+def collectTvRename(config: ConfigSpec, tv_info: list[TVInfo]) -> list[renameOperation]:
+    """Collect TV Rename Operations from Movie Information
+
+    :param config: Configuration object
+    :param tv_info: List of TV info
+
+    :returns: List of rename operations to be performed
+    """
+    file_list: list[renameOperation] = []
+    for tv in tv_info:
+        for episode in tv.episodes:
+            new_file_info = processTvRename(
+                config=config, tv_info=tv, episode_info=episode
+            )
+            file_list.append(renameOperation(src=episode.file, dest=new_file_info))
+
+    return file_list

srcalchemy/srcalchemy.py

@@ -0,0 +1,358 @@
+#################################################################################
+# MIT License
+#
+# Copyright (c) 2025 Duncan Fraser
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#################################################################################
+#
+# File          : srcalchemy.py
+#
+# Author        : Duncan Fraser <dfraser@thedrunkencoder.uk>
+#
+# Description   :
+#
+#################################################################################
+import logging
+import os
+import sys
+from argparse import ArgumentParser, Namespace
+from typing import Final
+
+from alive_progress import alive_bar
+
+from . import _version, collector, config, process
+
+DEFAULT_CONFIG_FILE: Final = "config.ini"
+OUTPUT_MOVIES: Final = "movie.bin"
+OUTPUT_TV: Final = "tv.bin"
+
+
+def collectConfig(config_path: str = DEFAULT_CONFIG_FILE) -> config.ConfigSpec:
+    """Parse Configuration from file. If file does not exist returns default configuration
+
+    :param config_path: Path to configuration file
+
+    :returns: Populated configuration
+    """
+    config_data = config.ConfigSpec()
+
+    if not os.path.exists(config_path):
+        return config_data
+
+    with open(config_path, "rb") as conf_file:
+        config_data = config.parseConfig(configIO=conf_file)
+
+    return config_data
+
+
+def configLogger(
+    level: str, log_file: str | None = None, log_std: bool = False
+) -> logging.Logger:
+    """Configure logging object
+
+    :param level: String representation of log level
+    :param log_file: Path to log file
+    :param log_std: If True output log to standard output
+
+    :returns: Logging Object
+    """
+    logger = logging.getLogger(__name__)
+    form = logging.Formatter(
+        "%(asctime)s %(levelname)s [%(module)s:%(funcName)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    log_levels = {
+        "debug": logging.DEBUG,
+        "info": logging.INFO,
+        "warning": logging.WARNING,
+        "error": logging.ERROR,
+        "critical": logging.CRITICAL,
+    }
+
+    if level not in log_levels:
+        raise ValueError(f"Undefined Level {level}")
+
+    logger.setLevel(log_levels[level])
+
+    if log_file:
+        fh = logging.FileHandler(filename=log_file, mode="a")
+        fh.setFormatter(form)
+        logger.addHandler(fh)
+
+    if log_std:
+        sh = logging.StreamHandler(sys.stdout)
+        sh.setFormatter(form)
+        logger.addHandler(sh)
+
+    return logger
+
+
+def parseArgs(config_data: config.ConfigSpec) -> tuple[Namespace, config.ConfigSpec]:
+    """Parse command line arguments
+
+    :params config_data: Configuration data, will be modified and returned
+
+    :returns: Tuple containing parsed arguments and modified configuration information
+    """
+    desc_str = f"srcalchemy v{_version.__version__}: Utility for renaming video files from a kodi library"
+    parser = ArgumentParser(prog="srcalchemy", description=desc_str)
+
+    parser.add_argument("--config", "-c", required=False, default=DEFAULT_CONFIG_FILE)
+    parser.add_argument(
+        "--debug",
+        "-d",
+        action="store",
+        default="info",
+        choices=["debug", "info", "warning", "error", "critical"],
+        required=False,
+    )
+    parser.add_argument("--logfile", action="store", required=False, metavar="xxx.log")
+    parser.add_argument(
+        "--quiet", "-q", action="store_true", required=False, default=False
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init = subparsers.add_parser("init", help="Initialize config file")  # noqa: F841
+    collection = subparsers.add_parser(  # noqa: F841
+        "collect", help="Collect Information"
+    )
+    rename = subparsers.add_parser("rename", help="Use Information")
+    clean = subparsers.add_parser("clean", help="Print Information")
+
+    stats = subparsers.add_parser("stats", help="Shows collections statistics")  # noqa: F841
+
+    rename.add_argument("--dryRun", required=False, action="store_true")
+    clean.add_argument("--dryRun", required=False, action="store_true")
+
+    args = parser.parse_args()
+
+    if args.config:
+        config_data = collectConfig(args.config)
+
+    if args.logfile:
+        config_data.general.logFile = args.logfile
+
+    return (args, config_data)
+
+
+def init(config_path: str = DEFAULT_CONFIG_FILE) -> int:
+    """Write default configuration to file
+
+    :param config_path: Path to configuration file
+
+    :returns: Status Code
+    """
+    with open(config_path, "w") as conf_file:
+        config.writeDefaultConfig(configIO=conf_file)
+    return 0
+
+
+def collect(config_data: config.ConfigSpec) -> int:
+    """Collect Move and TV information and serialize
+
+    :param config: Configuration object
+
+    :returns: Status Code
+    """
+    movie_info = collector.getMovieInfo(config=config_data)
+    tv_info = collector.getTvInfo(config=config_data)
+
+    if not os.path.isdir(config_data.general.dataDirectory):
+        os.makedirs(config_data.general.dataDirectory, exist_ok=True)
+
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_MOVIES), "wb"
+    ) as movie_file:
+        collector.serializeMovieInfo(pickleIO=movie_file, movieInfo=movie_info)
+
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_TV), "wb"
+    ) as tv_file:
+        collector.serializeTVInfo(pickleIO=tv_file, tvInfo=tv_info)
+
+    movie_stats = collector.movieInfoStatistics(data=movie_info)
+    tv_stats = collector.tvInfoStatistics(data=tv_info)
+
+    config_data.log.info(
+        "Collection complete. Found %s Movies and %s Episodes over %s Tv Shows",
+        movie_stats.count,
+        tv_stats.episodeCount,
+        tv_stats.count,
+    )
+    return 0
+
+
+def rename(config_data: config.ConfigSpec, dry_run: bool = False) -> int:
+    """Perform rename operations from serialized data
+
+    :param config: Configuration object
+    :param dry_run: If True, will perform as dry run of rename operation
+
+    :returns: Status Code
+    """
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_MOVIES), "rb"
+    ) as movie_file:
+        movie_info = collector.deserializeMovieInfo(pickleIO=movie_file)
+
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_TV), "rb"
+    ) as tv_file:
+        tv_info = collector.deserializeTVInfo(pickleIO=tv_file)
+
+    movie_rename = process.collectMovieRename(config=config_data, movie_list=movie_info)
+    tv_rename = process.collectTvRename(config=config_data, tv_info=tv_info)
+
+    with alive_bar(len(movie_rename), title="Movie Rename") as progress:
+        for movie in movie_rename:
+            config_data.log.info(
+                "{} Movie   : {} --> {}".format(
+                    "Moving" if config_data.general.mode == "move" else "Copying",
+                    movie.src.path,
+                    movie.dest.path,
+                )
+            )
+            process.performRenameOperation(
+                config=config_data, data=movie, dry_run=dry_run
+            )
+            progress()
+
+    with alive_bar(len(tv_rename), title="TV Rename   ") as progress:
+        for tv in tv_rename:
+            config_data.log.info(
+                "{} Episode : {} --> {}".format(
+                    "Moving" if config_data.general.mode == "move" else "Copying",
+                    tv.src.path,
+                    tv.dest.path,
+                )
+            )
+
+            process.performRenameOperation(config=config_data, data=tv, dry_run=dry_run)
+            progress()
+
+    return 0
+
+
+def clean(config_data: config.ConfigSpec, dry_run: bool = False) -> int:
+    """Perform clean operation
+
+    :param config: Configuration object
+    :param dry_run: If True, will perform as dry run of clean operation
+
+    :returns: Status Code
+    """
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_MOVIES), "rb"
+    ) as movie_file:
+        movie_info = collector.deserializeMovieInfo(pickleIO=movie_file)
+
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_TV), "rb"
+    ) as tv_file:
+        tv_info = collector.deserializeTVInfo(pickleIO=tv_file)
+
+    movie_rename = process.collectMovieRename(config=config_data, movie_list=movie_info)
+    tv_rename = process.collectTvRename(config=config_data, tv_info=tv_info)
+
+    with alive_bar(len(movie_rename), title="Movie Clean") as progress:
+        for movie in movie_rename:
+            config_data.log.info(f"Deleting Movie Directory : {movie.src.parentPath}")
+            process.performCleanDirectory(
+                config=config_data, data=movie, dry_run=dry_run
+            )
+            progress()
+
+    with alive_bar(len(tv_rename), title="TV Clean   ") as progress:
+        for tv in tv_rename:
+            config_data.log.info(f"Deleting TV Directory    : {tv.src.parentPath}")
+            process.performCleanDirectory(config=config_data, data=tv, dry_run=dry_run)
+            progress()
+    return 0
+
+
+def stats(config_data: config.ConfigSpec) -> int:
+    """Perform clean operation
+
+    :param config: Configuration object
+
+    :returns: Status Code
+    """
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_MOVIES), "rb"
+    ) as movie_file:
+        movie_info = collector.deserializeMovieInfo(pickleIO=movie_file)
+
+    with open(
+        os.path.join(config_data.general.dataDirectory, OUTPUT_TV), "rb"
+    ) as tv_file:
+        tv_info = collector.deserializeTVInfo(pickleIO=tv_file)
+
+    movie_stats = collector.movieInfoStatistics(data=movie_info)
+    tv_stats = collector.tvInfoStatistics(data=tv_info)
+
+    config_data.log.info(
+        "%s Movies and %s Episodes over %s Tv Shows",
+        movie_stats.count,
+        tv_stats.episodeCount,
+        tv_stats.count,
+    )
+    return 0
+
+
+def main() -> int:
+    """Main process"""
+    config_data = collectConfig(DEFAULT_CONFIG_FILE)
+
+    args, config_data = parseArgs(config_data=config_data)
+
+    if not os.path.isdir(config_data.general.dataDirectory):
+        os.makedirs(config_data.general.dataDirectory, exist_ok=True)
+
+    if (
+        not os.path.isdir(os.path.dirname(config_data.general.logFile))
+        and os.path.dirname(config_data.general.logFile) != ""
+    ):
+        os.makedirs(os.path.dirname(config_data.general.logFile), exist_ok=True)
+
+    logger = configLogger(
+        level=args.debug, log_file=config_data.general.logFile, log_std=(not args.quiet)
+    )
+    config_data.log = logger
+
+    status = 0
+
+    if args.command == "init":
+        status = init(args.config)
+    elif args.command == "collect":
+        status = collect(config_data=config_data)
+    elif args.command == "rename":
+        status = rename(config_data=config_data, dry_run=args.dryRun)
+    elif args.command == "clean":
+        status = clean(config_data=config_data, dry_run=args.dryRun)
+    elif args.command == "stats":
+        status = stats(config_data=config_data)
+
+    return status
+
+
+if __name__ == "__main__":
+    sys.exit(main())