1270 lines
62 KiB
Python
1270 lines
62 KiB
Python
import argparse
|
||
import os
|
||
import random
|
||
import re
|
||
import shutil
|
||
import traceback
|
||
from enum import Enum
|
||
from threading import Lock
|
||
from time import sleep
|
||
|
||
import log
|
||
from app.conf import ModuleConf
|
||
from app.helper import DbHelper, ProgressHelper
|
||
from app.helper import ThreadHelper
|
||
from app.media import Media, Category, Scraper
|
||
from app.media.meta import MetaInfo
|
||
from app.message import Message
|
||
from app.plugins import EventManager
|
||
from app.utils import EpisodeFormat, PathUtils, StringUtils, SystemUtils, ExceptionUtils
|
||
from app.utils.types import MediaType, SyncType, RmtMode, EventType
|
||
from config import RMT_SUBEXT, RMT_MEDIAEXT, RMT_FAVTYPE, RMT_MIN_FILESIZE, DEFAULT_MOVIE_FORMAT, \
|
||
DEFAULT_TV_FORMAT, Config
|
||
|
||
lock = Lock()
|
||
|
||
|
||
class FileTransfer:
|
||
media = None
|
||
message = None
|
||
category = None
|
||
mediaserver = None
|
||
scraper = None
|
||
threadhelper = None
|
||
dbhelper = None
|
||
progress = None
|
||
eventmanager = None
|
||
|
||
_default_rmt_mode = None
|
||
_movie_path = None
|
||
_tv_path = None
|
||
_anime_path = None
|
||
_movie_category_flag = None
|
||
_tv_category_flag = None
|
||
_anime_category_flag = None
|
||
_unknown_path = None
|
||
_min_filesize = RMT_MIN_FILESIZE
|
||
_filesize_cover = False
|
||
_movie_dir_rmt_format = ""
|
||
_movie_file_rmt_format = ""
|
||
_tv_dir_rmt_format = ""
|
||
_tv_season_rmt_format = ""
|
||
_tv_file_rmt_format = ""
|
||
_scraper_flag = False
|
||
_scraper_nfo = {}
|
||
_scraper_pic = {}
|
||
_refresh_mediaserver = False
|
||
_ignored_paths = []
|
||
_ignored_files = ''
|
||
|
||
def __init__(self):
|
||
self.media = Media()
|
||
self.message = Message()
|
||
self.category = Category()
|
||
self.scraper = Scraper()
|
||
self.threadhelper = ThreadHelper()
|
||
self.dbhelper = DbHelper()
|
||
self.progress = ProgressHelper()
|
||
self.eventmanager = EventManager()
|
||
self.init_config()
|
||
|
||
def init_config(self):
|
||
media = Config().get_config('media')
|
||
self._scraper_flag = media.get("nfo_poster")
|
||
self._scraper_nfo = Config().get_config('scraper_nfo')
|
||
self._scraper_pic = Config().get_config('scraper_pic')
|
||
if media:
|
||
# 刷新媒体库开关
|
||
self._refresh_mediaserver = media.get("refresh_mediaserver")
|
||
# 电影目录
|
||
self._movie_path = media.get('movie_path')
|
||
if not isinstance(self._movie_path, list):
|
||
if self._movie_path:
|
||
self._movie_path = [self._movie_path]
|
||
else:
|
||
self._movie_path = []
|
||
# 电影分类
|
||
self._movie_category_flag = self.category.get_movie_category_flag()
|
||
# 电视剧目录
|
||
self._tv_path = media.get('tv_path')
|
||
if not isinstance(self._tv_path, list):
|
||
if self._tv_path:
|
||
self._tv_path = [self._tv_path]
|
||
else:
|
||
self._tv_path = []
|
||
# 电视剧分类
|
||
self._tv_category_flag = self.category.get_tv_category_flag()
|
||
# 动漫目录
|
||
self._anime_path = media.get('anime_path')
|
||
if not isinstance(self._anime_path, list):
|
||
if self._anime_path:
|
||
self._anime_path = [self._anime_path]
|
||
else:
|
||
self._anime_path = []
|
||
# 动漫分类
|
||
self._anime_category_flag = self.category.get_anime_category_flag()
|
||
# 没有动漫目漫切换为电视剧目录和分类
|
||
if not self._anime_path:
|
||
self._anime_path = self._tv_path
|
||
self._anime_category_flag = self._tv_category_flag
|
||
# 未识别目录
|
||
self._unknown_path = media.get('unknown_path')
|
||
if not isinstance(self._unknown_path, list):
|
||
if self._unknown_path:
|
||
self._unknown_path = [self._unknown_path]
|
||
else:
|
||
self._unknown_path = []
|
||
# 最小文件大小
|
||
min_filesize = media.get('min_filesize')
|
||
if isinstance(min_filesize, int):
|
||
self._min_filesize = min_filesize * 1024 * 1024
|
||
elif isinstance(min_filesize, str) and min_filesize.isdigit():
|
||
self._min_filesize = int(min_filesize) * 1024 * 1024
|
||
# 文件路径转移忽略词
|
||
ignored_paths = media.get('ignored_paths')
|
||
if ignored_paths:
|
||
if ignored_paths.endswith(";"):
|
||
ignored_paths = ignored_paths[:-1]
|
||
self._ignored_paths = re.compile(r'%s' % re.sub(r';', r'|', ignored_paths))
|
||
# 文件名转移忽略词
|
||
ignored_files = media.get('ignored_files')
|
||
if ignored_files:
|
||
if ignored_files.endswith(";"):
|
||
ignored_files = ignored_files[:-1]
|
||
self._ignored_files = re.compile(r'%s' % re.sub(r';', r'|', ignored_files))
|
||
# 高质量文件覆盖
|
||
self._filesize_cover = media.get('filesize_cover')
|
||
# 电影重命名格式
|
||
movie_name_format = media.get('movie_name_format') or DEFAULT_MOVIE_FORMAT
|
||
movie_formats = movie_name_format.rsplit('/', 1)
|
||
if movie_formats:
|
||
self._movie_dir_rmt_format = movie_formats[0]
|
||
if len(movie_formats) > 1:
|
||
self._movie_file_rmt_format = movie_formats[-1]
|
||
# 电视剧重命名格式
|
||
tv_name_format = media.get('tv_name_format') or DEFAULT_TV_FORMAT
|
||
tv_formats = tv_name_format.rsplit('/', 2)
|
||
if tv_formats:
|
||
self._tv_dir_rmt_format = tv_formats[0]
|
||
if len(tv_formats) > 2:
|
||
self._tv_season_rmt_format = tv_formats[-2]
|
||
self._tv_file_rmt_format = tv_formats[-1]
|
||
self._default_rmt_mode = ModuleConf.RMT_MODES.get(Config().get_config('pt').get('rmt_mode', 'copy'),
|
||
RmtMode.COPY)
|
||
|
||
@staticmethod
|
||
def __transfer_command(file_item, target_file, rmt_mode):
|
||
"""
|
||
使用系统命令处理单个文件
|
||
:param file_item: 文件路径
|
||
:param target_file: 目标文件路径
|
||
:param rmt_mode: RmtMode转移方式
|
||
"""
|
||
with lock:
|
||
if rmt_mode == RmtMode.LINK:
|
||
# 更链接
|
||
retcode, retmsg = SystemUtils.link(file_item, target_file)
|
||
elif rmt_mode == RmtMode.SOFTLINK:
|
||
# 软链接
|
||
retcode, retmsg = SystemUtils.softlink(file_item, target_file)
|
||
elif rmt_mode == RmtMode.MOVE:
|
||
# 移动
|
||
retcode, retmsg = SystemUtils.move(file_item, target_file)
|
||
elif rmt_mode == RmtMode.RCLONE:
|
||
# Rclone移动
|
||
retcode, retmsg = SystemUtils.rclone_move(file_item, target_file)
|
||
elif rmt_mode == RmtMode.RCLONECOPY:
|
||
# Rclone复制
|
||
retcode, retmsg = SystemUtils.rclone_copy(file_item, target_file)
|
||
elif rmt_mode == RmtMode.MINIO:
|
||
# Minio移动
|
||
retcode, retmsg = SystemUtils.minio_move(file_item, target_file)
|
||
elif rmt_mode == RmtMode.MINIOCOPY:
|
||
# Minio复制
|
||
retcode, retmsg = SystemUtils.minio_copy(file_item, target_file)
|
||
else:
|
||
# 复制
|
||
retcode, retmsg = SystemUtils.copy(file_item, target_file)
|
||
if retcode != 0:
|
||
log.error("【Rmt】%s" % retmsg)
|
||
return retcode
|
||
|
||
def __transfer_subtitles(self, org_name, new_name, rmt_mode):
|
||
"""
|
||
根据文件名转移对应字幕文件
|
||
:param org_name: 原文件名
|
||
:param new_name: 新文件名
|
||
:param rmt_mode: RmtMode转移方式
|
||
"""
|
||
# 字幕正则式
|
||
_zhcn_sub_re = r"([.\[(](((zh[-_])?(cn|ch[si]|sg|sc))|zho?" \
|
||
r"|chinese|(cn|ch[si]|sg|zho?|eng)[-_&](cn|ch[si]|sg|zho?|eng)" \
|
||
r"|简[体中]?)[.\])])" \
|
||
r"|([\u4e00-\u9fa5]{0,3}[中双][\u4e00-\u9fa5]{0,2}[字文语][\u4e00-\u9fa5]{0,3})" \
|
||
r"|简体|简中"
|
||
_zhtw_sub_re = r"([.\[(](((zh[-_])?(hk|tw|cht|tc))" \
|
||
r"|繁[体中]?)[.\])])" \
|
||
r"|繁体中[文字]|中[文字]繁体|繁体"
|
||
_eng_sub_re = r"[.\[(]eng[.\])]"
|
||
|
||
# 比对文件名并转移字幕
|
||
dir_name = os.path.dirname(org_name)
|
||
file_name = os.path.basename(org_name)
|
||
file_list = PathUtils.get_dir_level1_files(dir_name, RMT_SUBEXT)
|
||
if len(file_list) == 0:
|
||
log.debug("【Rmt】%s 目录下没有找到字幕文件..." % dir_name)
|
||
else:
|
||
log.debug("【Rmt】字幕文件清单：" + str(file_list))
|
||
metainfo = MetaInfo(title=file_name)
|
||
for file_item in file_list:
|
||
sub_file_name = re.sub(_zhtw_sub_re,
|
||
".",
|
||
re.sub(_zhcn_sub_re,
|
||
".",
|
||
os.path.basename(file_item),
|
||
flags=re.I),
|
||
flags=re.I)
|
||
sub_file_name = re.sub(_eng_sub_re, ".", sub_file_name, flags=re.I)
|
||
sub_metainfo = MetaInfo(title=os.path.basename(file_item))
|
||
if (os.path.splitext(file_name)[0] == os.path.splitext(sub_file_name)[0]) or \
|
||
(sub_metainfo.cn_name and sub_metainfo.cn_name == metainfo.cn_name) \
|
||
or (sub_metainfo.en_name and sub_metainfo.en_name == metainfo.en_name):
|
||
if metainfo.get_season_string() \
|
||
and metainfo.get_season_string() != sub_metainfo.get_season_string():
|
||
continue
|
||
if metainfo.get_episode_string() \
|
||
and metainfo.get_episode_string() != sub_metainfo.get_episode_string():
|
||
continue
|
||
new_file_type = ""
|
||
# 兼容jellyfin字幕识别(多重识别), emby则会识别最后一个后缀
|
||
if re.search(_zhcn_sub_re, file_item, re.I):
|
||
new_file_type = ".chi.zh-cn"
|
||
elif re.search(_zhtw_sub_re, file_item,
|
||
re.I):
|
||
new_file_type = ".zh-tw"
|
||
elif re.search(_eng_sub_re, file_item, re.I):
|
||
new_file_type = ".eng"
|
||
# 通过对比字幕文件大小 尽量转移所有存在的字幕
|
||
file_ext = os.path.splitext(file_item)[-1]
|
||
new_sub_tag_dict = {
|
||
".eng": ".英文",
|
||
".chi.zh-cn": ".简体中文",
|
||
".zh-tw": ".繁体中文"
|
||
}
|
||
new_sub_tag_list = [
|
||
new_file_type if t == 0 else "%s%s(%s)" % (new_file_type,
|
||
new_sub_tag_dict.get(
|
||
new_file_type, ""
|
||
),
|
||
t) for t in range(6)
|
||
]
|
||
for new_sub_tag in new_sub_tag_list:
|
||
new_file = os.path.splitext(new_name)[0] + new_sub_tag + file_ext
|
||
# 如果字幕文件不存在, 直接转移字幕, 并跳出循环
|
||
try:
|
||
if not os.path.exists(new_file):
|
||
log.debug("【Rmt】正在处理字幕：%s" % os.path.basename(file_item))
|
||
retcode = self.__transfer_command(file_item=file_item,
|
||
target_file=new_file,
|
||
rmt_mode=rmt_mode)
|
||
if retcode == 0:
|
||
log.info("【Rmt】字幕 %s %s完成" % (os.path.basename(file_item), rmt_mode.value))
|
||
break
|
||
else:
|
||
log.error(
|
||
"【Rmt】字幕 %s %s失败，错误码 %s" % (file_name, rmt_mode.value, str(retcode)))
|
||
return retcode
|
||
# 如果字幕文件的大小与已存在文件相同, 说明已经转移过了, 则跳出循环
|
||
elif os.path.getsize(new_file) == os.path.getsize(file_item):
|
||
log.info("【Rmt】字幕 %s 已存在" % new_file)
|
||
break
|
||
# 否则 循环继续 > 通过new_sub_tag_list 获取新的tag附加到字幕文件名, 继续检查是否能转移
|
||
except OSError as reason:
|
||
log.info("【Rmt】字幕 %s 出错了,原因: %s" % (new_file, str(reason)))
|
||
return 0
|
||
|
||
def __transfer_bluray_dir(self, file_path, new_path, rmt_mode):
|
||
"""
|
||
转移蓝光文件夹
|
||
:param file_path: 原路径
|
||
:param new_path: 新路径
|
||
:param rmt_mode: RmtMode转移方式
|
||
"""
|
||
log.info("【Rmt】正在%s目录：%s 到 %s" % (rmt_mode.value, file_path, new_path))
|
||
# 复制
|
||
retcode = self.__transfer_dir_files(src_dir=file_path,
|
||
target_dir=new_path,
|
||
rmt_mode=rmt_mode,
|
||
bludir=True)
|
||
if retcode == 0:
|
||
log.info("【Rmt】文件 %s %s完成" % (file_path, rmt_mode.value))
|
||
else:
|
||
log.error("【Rmt】文件%s %s失败，错误码 %s" % (file_path, rmt_mode.value, str(retcode)))
|
||
return retcode
|
||
|
||
def is_target_dir_path(self, path):
|
||
"""
|
||
判断是否为目的路径下的路径
|
||
:param path: 路径
|
||
:return: True/False
|
||
"""
|
||
if not path:
|
||
return False
|
||
for tv_path in self._tv_path:
|
||
if PathUtils.is_path_in_path(tv_path, path):
|
||
return True
|
||
for movie_path in self._movie_path:
|
||
if PathUtils.is_path_in_path(movie_path, path):
|
||
return True
|
||
for anime_path in self._anime_path:
|
||
if PathUtils.is_path_in_path(anime_path, path):
|
||
return True
|
||
for unknown_path in self._unknown_path:
|
||
if PathUtils.is_path_in_path(unknown_path, path):
|
||
return True
|
||
return False
|
||
|
||
def __transfer_dir_files(self, src_dir, target_dir, rmt_mode, bludir=False):
|
||
"""
|
||
按目录结构转移所有文件
|
||
:param src_dir: 原路径
|
||
:param target_dir: 新路径
|
||
:param rmt_mode: RmtMode转移方式
|
||
:param bludir: 是否蓝光目录
|
||
"""
|
||
file_list = PathUtils.get_dir_files(src_dir)
|
||
retcode = 0
|
||
for file in file_list:
|
||
new_file = file.replace(src_dir, target_dir)
|
||
if os.path.exists(new_file):
|
||
log.warn("【Rmt】%s 文件已存在" % new_file)
|
||
continue
|
||
new_dir = os.path.dirname(new_file)
|
||
if not os.path.exists(new_dir):
|
||
os.makedirs(new_dir)
|
||
retcode = self.__transfer_command(file_item=file,
|
||
target_file=new_file,
|
||
rmt_mode=rmt_mode)
|
||
if retcode != 0:
|
||
break
|
||
else:
|
||
if not bludir:
|
||
self.dbhelper.insert_transfer_blacklist(file)
|
||
if retcode == 0 and bludir:
|
||
self.dbhelper.insert_transfer_blacklist(src_dir)
|
||
return retcode
|
||
|
||
def __transfer_origin_file(self, file_item, target_dir, rmt_mode):
|
||
"""
|
||
按原文件名link文件到目的目录
|
||
:param file_item: 原文件路径
|
||
:param target_dir: 目的目录
|
||
:param rmt_mode: RmtMode转移方式
|
||
"""
|
||
if not file_item or not target_dir:
|
||
return -1
|
||
if not os.path.exists(file_item):
|
||
log.warn("【Rmt】%s 不存在" % file_item)
|
||
return -1
|
||
# 计算目录目录
|
||
parent_name = os.path.basename(os.path.dirname(file_item))
|
||
target_dir = os.path.join(target_dir, parent_name)
|
||
if not os.path.exists(target_dir):
|
||
log.debug("【Rmt】正在创建目录：%s" % target_dir)
|
||
os.makedirs(target_dir)
|
||
# 目录
|
||
if os.path.isdir(file_item):
|
||
log.info("【Rmt】正在%s目录：%s 到 %s" % (rmt_mode.value, file_item, target_dir))
|
||
retcode = self.__transfer_dir_files(src_dir=file_item,
|
||
target_dir=target_dir,
|
||
rmt_mode=rmt_mode)
|
||
# 文件
|
||
else:
|
||
target_file = os.path.join(target_dir, os.path.basename(file_item))
|
||
if os.path.exists(target_file):
|
||
log.warn("【Rmt】%s 文件已存在" % target_file)
|
||
return 0
|
||
retcode = self.__transfer_command(file_item=file_item,
|
||
target_file=target_file,
|
||
rmt_mode=rmt_mode)
|
||
if retcode == 0:
|
||
self.dbhelper.insert_transfer_blacklist(file_item)
|
||
if retcode == 0:
|
||
log.info("【Rmt】%s %s到unknown完成" % (file_item, rmt_mode.value))
|
||
else:
|
||
log.error("【Rmt】%s %s到unknown失败，错误码 %s" % (file_item, rmt_mode.value, retcode))
|
||
return retcode
|
||
|
||
def __transfer_file(self, file_item, new_file, rmt_mode, over_flag=False, old_file=None):
|
||
"""
|
||
转移一个文件，同时处理字幕
|
||
:param file_item: 原文件路径
|
||
:param new_file: 新文件路径
|
||
:param rmt_mode: RmtMode转移方式
|
||
:param over_flag: 是否覆盖，为True时会先删除再转移
|
||
"""
|
||
file_name = os.path.basename(file_item)
|
||
if not over_flag and os.path.exists(new_file):
|
||
log.warn("【Rmt】文件已存在：%s" % new_file)
|
||
return 0
|
||
if over_flag and old_file and os.path.isfile(old_file):
|
||
log.info("【Rmt】正在删除已存在的文件：%s" % old_file)
|
||
os.remove(old_file)
|
||
log.info("【Rmt】正在转移文件：%s 到 %s" % (file_name, new_file))
|
||
retcode = self.__transfer_command(file_item=file_item,
|
||
target_file=new_file,
|
||
rmt_mode=rmt_mode)
|
||
if retcode == 0:
|
||
log.info("【Rmt】文件 %s %s完成" % (file_name, rmt_mode.value))
|
||
self.dbhelper.insert_transfer_blacklist(file_item)
|
||
else:
|
||
log.error("【Rmt】文件 %s %s失败，错误码 %s" % (file_name, rmt_mode.value, str(retcode)))
|
||
return retcode
|
||
# 处理字幕
|
||
return self.__transfer_subtitles(org_name=file_item,
|
||
new_name=new_file,
|
||
rmt_mode=rmt_mode)
|
||
|
||
def transfer_media(self,
|
||
in_from: Enum,
|
||
in_path,
|
||
rmt_mode: RmtMode = None,
|
||
files: list = None,
|
||
target_dir=None,
|
||
unknown_dir=None,
|
||
tmdb_info=None,
|
||
media_type: MediaType = None,
|
||
season=None,
|
||
episode: (EpisodeFormat, bool) = None,
|
||
min_filesize=None,
|
||
udf_flag=False,
|
||
root_path=False):
|
||
"""
|
||
识别并转移一个文件、多个文件或者目录
|
||
:param in_from: 来源，即调用该功能的渠道
|
||
:param in_path: 转移的路径，可能是一个文件也可以是一个目录
|
||
:param files: 文件清单，非空时以该文件清单为准，为空时从in_path中按后缀和大小限制检索需要处理的文件清单
|
||
:param target_dir: 目的文件夹，非空的转移到该文件夹，为空时则按类型转移到配置文件中的媒体库文件夹
|
||
:param unknown_dir: 未识别文件夹，非空时未识别的媒体文件转移到该文件夹，为空时则使用配置文件中的未识别文件夹
|
||
:param rmt_mode: 文件转移方式
|
||
:param tmdb_info: 手动识别转移时传入的TMDB信息对象，如未输入，则按名称笔TMDB实时查询
|
||
:param media_type: 手动识别转移时传入的文件类型，如未输入，则自动识别
|
||
:param season: 手动识别目录或文件时传入的的字号，如未输入，则自动识别
|
||
:param episode: (EpisodeFormat，是否批处理匹配)
|
||
:param min_filesize: 过滤小文件大小的上限值
|
||
:param udf_flag: 自定义转移标志，为True时代表是自定义转移，此时很多处理不一样
|
||
:param root_path: 是否根目录下的文件
|
||
:return: 处理状态，错误信息
|
||
"""
|
||
|
||
def __finish_transfer(status, message):
|
||
if status:
|
||
self.progress.update(ptype="filetransfer",
|
||
value=100,
|
||
text=f"{in_path} 转移成功！")
|
||
else:
|
||
self.progress.update(ptype="filetransfer",
|
||
value=100,
|
||
text=f"{in_path} 转移失败：{message}！")
|
||
self.progress.end('filetransfer')
|
||
return status, message
|
||
|
||
# 开始进度
|
||
self.progress.start('filetransfer')
|
||
|
||
episode = (None, False) if not episode else episode
|
||
if not in_path:
|
||
log.error("【Rmt】输入路径错误!")
|
||
return __finish_transfer(False, "输入路径错误")
|
||
|
||
if not rmt_mode:
|
||
rmt_mode = self._default_rmt_mode
|
||
|
||
log.info("【Rmt】开始处理：%s，转移方式：%s" % (in_path, rmt_mode.value))
|
||
|
||
success_flag = True
|
||
error_message = ""
|
||
bluray_disk_dir = None
|
||
if not files:
|
||
# 如果传入的是个目录
|
||
if os.path.isdir(in_path):
|
||
if not os.path.exists(in_path):
|
||
log.error("【Rmt】文件转移失败，目录不存在 %s" % in_path)
|
||
return __finish_transfer(False, "目录不存在")
|
||
# 回收站及隐藏的文件不处理
|
||
if PathUtils.is_invalid_path(in_path):
|
||
return __finish_transfer(False, "回收站或者隐藏文件夹")
|
||
# 判断是不是原盘文件夹
|
||
bluray_disk_dir = PathUtils.get_bluray_dir(in_path)
|
||
if bluray_disk_dir:
|
||
file_list = [bluray_disk_dir]
|
||
log.info("【Rmt】当前为蓝光原盘文件夹：%s" % str(in_path))
|
||
else:
|
||
if str(min_filesize) == "0":
|
||
# 不限制大小
|
||
now_filesize = 0
|
||
else:
|
||
# 未输入大小限制默认为配置大小限制
|
||
now_filesize = self._min_filesize if not str(min_filesize).isdigit() else int(
|
||
min_filesize) * 1024 * 1024
|
||
# 查找目录下的文件
|
||
file_list = PathUtils.get_dir_files(in_path=in_path,
|
||
episode_format=episode[0],
|
||
exts=RMT_MEDIAEXT,
|
||
filesize=now_filesize)
|
||
log.debug("【Rmt】文件清单：" + str(file_list))
|
||
if len(file_list) == 0:
|
||
log.warn("【Rmt】%s 目录下未找到媒体文件，当前最小文件大小限制为 %s"
|
||
% (in_path, StringUtils.str_filesize(now_filesize)))
|
||
return __finish_transfer(False,
|
||
"目录下未找到媒体文件，当前最小文件大小限制为 %s"
|
||
% StringUtils.str_filesize(now_filesize))
|
||
# 传入的是个文件
|
||
else:
|
||
if not os.path.exists(in_path):
|
||
log.error("【Rmt】文件转移失败，文件不存在：%s" % in_path)
|
||
return __finish_transfer(False, "文件不存在")
|
||
if os.path.splitext(in_path)[-1].lower() not in RMT_MEDIAEXT:
|
||
log.warn("【Rmt】不支持的媒体文件格式，不处理：%s" % in_path)
|
||
return __finish_transfer(False, "不支持的媒体文件格式")
|
||
# 判断是不是原盘文件夹
|
||
bluray_disk_dir = PathUtils.get_bluray_dir(in_path)
|
||
if bluray_disk_dir:
|
||
file_list = [bluray_disk_dir]
|
||
log.info("【Rmt】当前为蓝光原盘文件夹：%s" % bluray_disk_dir)
|
||
else:
|
||
file_list = [in_path]
|
||
else:
|
||
# 传入的是个文件列表，这些文失件是in_path下面的文件
|
||
file_list = files
|
||
|
||
# 过滤掉文件列表
|
||
file_list, msg = self.check_ignore(file_list=file_list)
|
||
if not file_list:
|
||
return __finish_transfer(True, msg)
|
||
|
||
# 目录同步模式下，过滤掉文件列表中已处理过的
|
||
if in_from == SyncType.MON:
|
||
file_list = list(filter(self.dbhelper.is_transfer_notin_blacklist, file_list))
|
||
if not file_list:
|
||
log.info("【Rmt】所有文件均已成功转移过，没有需要处理的文件！如需重新处理，请清理缓存（服务->清理转移缓存）")
|
||
return __finish_transfer(True, "没有新文件需要处理")
|
||
# API检索出媒体信息，传入一个文件列表，得出每一个文件的名称，这里是当前目录下所有的文件了
|
||
Medias = self.media.get_media_info_on_files(file_list, tmdb_info, media_type, season, episode[0])
|
||
if not Medias:
|
||
log.error("【Rmt】检索媒体信息出错！")
|
||
return __finish_transfer(False, "检索媒体信息出错")
|
||
|
||
# 更新进度
|
||
self.progress.update(ptype="filetransfer", text=f"共 {len(Medias)} 个文件需要处理...")
|
||
|
||
# 统计总的文件数、失败文件数、需要提醒的失败数
|
||
failed_count = 0
|
||
alert_count = 0
|
||
alert_messages = []
|
||
total_count = 0
|
||
# 电视剧可能有多集，如果在循环里发消息就太多了，要在外面发消息
|
||
message_medias = {}
|
||
# 需要刷新媒体库的清单
|
||
refresh_library_items = []
|
||
# 处理识别后的每一个文件或单个文件夹
|
||
for file_item, media in Medias.items():
|
||
try:
|
||
# 总数量
|
||
total_count = total_count + 1
|
||
|
||
if not udf_flag:
|
||
if re.search(r'[./\s\[]+Sample[/.\s\]]+', file_item, re.IGNORECASE):
|
||
log.warn("【Rmt】%s 可能是预告片，跳过..." % file_item)
|
||
continue
|
||
|
||
# 文件名
|
||
file_name = os.path.basename(file_item)
|
||
# 更新进度
|
||
self.progress.update(ptype="filetransfer",
|
||
value=round(total_count/len(Medias) * 100) - (0.5/len(Medias) * 100),
|
||
text="正在处理：%s ..." % file_name)
|
||
|
||
# 数据库记录的路径
|
||
if bluray_disk_dir:
|
||
reg_path = bluray_disk_dir
|
||
else:
|
||
reg_path = file_item
|
||
# 未识别
|
||
if not media or not media.tmdb_info or not media.get_title_string():
|
||
log.warn("【Rmt】%s 无法识别媒体信息！" % file_name)
|
||
success_flag = False
|
||
error_message = "无法识别媒体信息"
|
||
self.progress.update(ptype="filetransfer", text=error_message)
|
||
if udf_flag:
|
||
return __finish_transfer(success_flag, error_message)
|
||
# 记录未识别
|
||
is_need_insert_unknown = self.dbhelper.is_need_insert_transfer_unknown(reg_path)
|
||
if is_need_insert_unknown:
|
||
self.dbhelper.insert_transfer_unknown(reg_path, target_dir, rmt_mode)
|
||
alert_count += 1
|
||
failed_count += 1
|
||
if error_message not in alert_messages and is_need_insert_unknown:
|
||
alert_messages.append(error_message)
|
||
# 原样转移过去
|
||
if unknown_dir:
|
||
log.warn("【Rmt】%s 按原文件名转移到未识别目录：%s" % (file_name, unknown_dir))
|
||
self.__transfer_origin_file(file_item=file_item, target_dir=unknown_dir, rmt_mode=rmt_mode)
|
||
elif self._unknown_path:
|
||
unknown_path = self.__get_best_unknown_path(in_path)
|
||
if not unknown_path:
|
||
continue
|
||
log.warn("【Rmt】%s 按原文件名转移到未识别目录：%s" % (file_name, unknown_path))
|
||
self.__transfer_origin_file(file_item=file_item, target_dir=unknown_path, rmt_mode=rmt_mode)
|
||
else:
|
||
log.error("【Rmt】%s 无法识别媒体信息！" % file_name)
|
||
continue
|
||
# 当前文件大小
|
||
media.size = os.path.getsize(file_item)
|
||
# 目的目录，有输入target_dir时，往这个目录放
|
||
if target_dir:
|
||
dist_path = target_dir
|
||
else:
|
||
dist_path = self.__get_best_target_path(mtype=media.type, in_path=in_path, size=media.size)
|
||
if not dist_path:
|
||
log.error("【Rmt】文件转移失败，目的路径不存在！")
|
||
success_flag = False
|
||
error_message = "目的路径不存在"
|
||
failed_count += 1
|
||
alert_count += 1
|
||
if error_message not in alert_messages:
|
||
alert_messages.append(error_message)
|
||
continue
|
||
if dist_path and not os.path.exists(dist_path):
|
||
return __finish_transfer(False, "目录不存在：%s" % dist_path)
|
||
|
||
# 判断文件是否已存在，返回：目录存在标志、目录名、文件存在标志、文件名
|
||
dir_exist_flag, ret_dir_path, file_exist_flag, ret_file_path = self.__is_media_exists(dist_path, media)
|
||
# 新文件后缀
|
||
file_ext = os.path.splitext(file_item)[-1]
|
||
new_file = ret_file_path
|
||
# 已存在的文件数量
|
||
exist_filenum = 0
|
||
handler_flag = False
|
||
# 路径存在
|
||
if dir_exist_flag:
|
||
# 蓝光原盘
|
||
if bluray_disk_dir:
|
||
log.warn("【Rmt】蓝光原盘目录已存在：%s" % ret_dir_path)
|
||
if udf_flag:
|
||
return __finish_transfer(False, "蓝光原盘目录已存在：%s" % ret_dir_path)
|
||
failed_count += 1
|
||
continue
|
||
# 文件存在
|
||
if file_exist_flag:
|
||
exist_filenum = exist_filenum + 1
|
||
if rmt_mode != RmtMode.SOFTLINK:
|
||
if media.size > os.path.getsize(ret_file_path) and self._filesize_cover or udf_flag:
|
||
ret_file_path, ret_file_ext = os.path.splitext(ret_file_path)
|
||
new_file = "%s%s" % (ret_file_path, file_ext)
|
||
old_file = "%s%s" % (ret_file_path, ret_file_ext)
|
||
log.info("【Rmt】文件 %s 已存在，覆盖为 %s" % (old_file, new_file))
|
||
ret = self.__transfer_file(file_item=file_item,
|
||
new_file=new_file,
|
||
rmt_mode=rmt_mode,
|
||
over_flag=True, old_file=old_file)
|
||
if ret != 0:
|
||
success_flag = False
|
||
error_message = "文件转移失败，错误码 %s" % ret
|
||
self.progress.update(ptype="filetransfer", text=error_message)
|
||
if udf_flag:
|
||
return __finish_transfer(success_flag, error_message)
|
||
failed_count += 1
|
||
alert_count += 1
|
||
if error_message not in alert_messages:
|
||
alert_messages.append(error_message)
|
||
continue
|
||
handler_flag = True
|
||
else:
|
||
log.warn("【Rmt】文件 %s 已存在" % ret_file_path)
|
||
failed_count += 1
|
||
continue
|
||
else:
|
||
log.warn("【Rmt】文件 %s 已存在" % ret_file_path)
|
||
failed_count += 1
|
||
continue
|
||
# 路径不存在
|
||
else:
|
||
if not ret_dir_path:
|
||
log.error("【Rmt】拼装目录路径错误，无法从文件名中识别出季集信息：%s" % file_item)
|
||
success_flag = False
|
||
error_message = "识别失败，无法从文件名中识别出季集信息"
|
||
self.progress.update(ptype="filetransfer", text=error_message)
|
||
if udf_flag:
|
||
return __finish_transfer(success_flag, error_message)
|
||
# 记录未识别
|
||
is_need_insert_unknown = self.dbhelper.is_need_insert_transfer_unknown(reg_path)
|
||
if is_need_insert_unknown:
|
||
self.dbhelper.insert_transfer_unknown(reg_path, target_dir, rmt_mode)
|
||
alert_count += 1
|
||
failed_count += 1
|
||
if error_message not in alert_messages and is_need_insert_unknown:
|
||
alert_messages.append(error_message)
|
||
continue
|
||
else:
|
||
# 创建电录
|
||
log.debug("【Rmt】正在创建目录：%s" % ret_dir_path)
|
||
os.makedirs(ret_dir_path)
|
||
# 转移蓝光原盘
|
||
if bluray_disk_dir:
|
||
ret = self.__transfer_bluray_dir(file_item, ret_dir_path, rmt_mode)
|
||
if ret != 0:
|
||
success_flag = False
|
||
error_message = "蓝光目录转移失败，错误码：%s" % ret
|
||
self.progress.update(ptype="filetransfer", text=error_message)
|
||
if udf_flag:
|
||
return __finish_transfer(success_flag, error_message)
|
||
failed_count += 1
|
||
alert_count += 1
|
||
if error_message not in alert_messages:
|
||
alert_messages.append(error_message)
|
||
continue
|
||
else:
|
||
# 开始转移文件
|
||
if not handler_flag:
|
||
if not ret_file_path:
|
||
log.error("【Rmt】拼装文件路径错误，无法从文件名中识别出集数：%s" % file_item)
|
||
success_flag = False
|
||
error_message = "识别失败，无法从文件名中识别出集数"
|
||
self.progress.update(ptype="filetransfer", text=error_message)
|
||
if udf_flag:
|
||
return __finish_transfer(success_flag, error_message)
|
||
# 记录未识别
|
||
is_need_insert_unknown = self.dbhelper.is_need_insert_transfer_unknown(reg_path)
|
||
if is_need_insert_unknown:
|
||
self.dbhelper.insert_transfer_unknown(reg_path, target_dir, rmt_mode)
|
||
alert_count += 1
|
||
failed_count += 1
|
||
if error_message not in alert_messages and is_need_insert_unknown:
|
||
alert_messages.append(error_message)
|
||
continue
|
||
new_file = "%s%s" % (ret_file_path, file_ext)
|
||
ret = self.__transfer_file(file_item=file_item,
|
||
new_file=new_file,
|
||
rmt_mode=rmt_mode,
|
||
over_flag=False)
|
||
if ret != 0:
|
||
success_flag = False
|
||
error_message = "文件转移失败，错误码 %s" % ret
|
||
self.progress.update(ptype="filetransfer", text=error_message)
|
||
if udf_flag:
|
||
return __finish_transfer(success_flag, error_message)
|
||
failed_count += 1
|
||
alert_count += 1
|
||
if error_message not in alert_messages:
|
||
alert_messages.append(error_message)
|
||
continue
|
||
# 媒体库刷新条目：类型-类别-标题-年份
|
||
refresh_item = {"type": media.type, "category": media.category, "title": media.title,
|
||
"year": media.year, "target_path": dist_path}
|
||
# 登记媒体库刷新
|
||
if refresh_item not in refresh_library_items:
|
||
refresh_library_items.append(refresh_item)
|
||
# 查询TMDB详情，需要全部数据
|
||
media.set_tmdb_info(self.media.get_tmdb_info(mtype=media.type,
|
||
tmdbid=media.tmdb_id,
|
||
append_to_response="all"))
|
||
# 下载字幕条目
|
||
subtitle_item = media.to_dict()
|
||
subtitle_item.update({
|
||
"file": ret_file_path,
|
||
"file_ext": os.path.splitext(file_item)[-1],
|
||
"bluray": True if bluray_disk_dir else False
|
||
})
|
||
# 登记字幕下载事件
|
||
self.eventmanager.send_event(EventType.SubtitleDownload, subtitle_item)
|
||
# 转移历史记录
|
||
self.dbhelper.insert_transfer_history(
|
||
in_from=in_from,
|
||
rmt_mode=rmt_mode,
|
||
in_path=reg_path,
|
||
out_path=new_file if not bluray_disk_dir else ret_dir_path,
|
||
dest=dist_path,
|
||
media_info=media)
|
||
# 未识别手动识别或历史记录重新识别的批处理模式
|
||
if isinstance(episode[1], bool) and episode[1]:
|
||
# 未识别手动识别，更改未识别记录为已处理
|
||
self.dbhelper.update_transfer_unknown_state(file_item)
|
||
# 电影立即发送消息
|
||
if media.type == MediaType.MOVIE:
|
||
self.message.send_transfer_movie_message(in_from,
|
||
media,
|
||
exist_filenum,
|
||
self._movie_category_flag)
|
||
# 否则登记汇总发消息
|
||
else:
|
||
# 按季汇总
|
||
message_key = "%s-%s" % (media.get_title_string(), media.get_season_string())
|
||
if not message_medias.get(message_key):
|
||
message_medias[message_key] = media
|
||
# 汇总集数、大小
|
||
if not message_medias[message_key].is_in_episode(media.get_episode_list()):
|
||
message_medias[message_key].total_episodes += media.total_episodes
|
||
message_medias[message_key].size += media.size
|
||
# 生成nfo及poster
|
||
if self._scraper_flag:
|
||
# 生成刮削文件
|
||
self.scraper.gen_scraper_files(media=media,
|
||
scraper_nfo=self._scraper_nfo,
|
||
scraper_pic=self._scraper_pic,
|
||
dir_path=ret_dir_path,
|
||
file_name=os.path.basename(ret_file_path),
|
||
file_ext=file_ext)
|
||
# 更新进度
|
||
self.progress.update(ptype="filetransfer",
|
||
value=round(total_count / len(Medias) * 100),
|
||
text="%s 转移完成" % file_name)
|
||
# 移动模式随机休眠（兼容一些网盘挂载目录）
|
||
if rmt_mode == RmtMode.MOVE:
|
||
sleep(round(random.uniform(0, 1), 1))
|
||
|
||
except Exception as err:
|
||
ExceptionUtils.exception_traceback(err)
|
||
log.error("【Rmt】文件转移时发生错误：%s - %s" % (str(err), traceback.format_exc()))
|
||
# 循环结束
|
||
# 统计完成情况，发送通知
|
||
if message_medias:
|
||
self.message.send_transfer_tv_message(message_medias, in_from)
|
||
# 刷新媒体库
|
||
if refresh_library_items and self._refresh_mediaserver:
|
||
self.mediaserver.refresh_library_by_items(refresh_library_items)
|
||
# 总结
|
||
log.info("【Rmt】%s 处理完成，总数：%s，失败：%s" % (in_path, total_count, failed_count))
|
||
if alert_count > 0:
|
||
self.message.send_transfer_fail_message(in_path, alert_count, "、".join(alert_messages))
|
||
elif failed_count == 0:
|
||
# 删除空目录
|
||
if rmt_mode == RmtMode.MOVE \
|
||
and os.path.exists(in_path) \
|
||
and os.path.isdir(in_path) \
|
||
and not root_path \
|
||
and not PathUtils.get_dir_files(in_path=in_path, exts=RMT_MEDIAEXT) \
|
||
and not PathUtils.get_dir_files(in_path=in_path, exts=['.!qb', '.part']):
|
||
log.info("【Rmt】目录下已无媒体文件及正在下载的文件，移动模式下删除目录：%s" % in_path)
|
||
shutil.rmtree(in_path)
|
||
return __finish_transfer(success_flag, error_message)
|
||
|
||
def transfer_manually(self, s_path, t_path, mode):
|
||
"""
|
||
全量转移，用于使用命令调用
|
||
:param s_path: 源目录
|
||
:param t_path: 目的目录
|
||
:param mode: 转移方式
|
||
"""
|
||
if not s_path:
|
||
return
|
||
if not os.path.exists(s_path):
|
||
print("【Rmt】源目录不存在：%s" % s_path)
|
||
return
|
||
if t_path:
|
||
if not os.path.exists(t_path):
|
||
print("【Rmt】目的目录不存在：%s" % t_path)
|
||
return
|
||
rmt_mode = ModuleConf.RMT_MODES.get(mode)
|
||
if not rmt_mode:
|
||
print("【Rmt】转移模式错误！")
|
||
return
|
||
print("【Rmt】转移模式为：%s" % rmt_mode.value)
|
||
print("【Rmt】正在转移以下目录中的全量文件：%s" % s_path)
|
||
for path in PathUtils.get_dir_level1_medias(s_path, RMT_MEDIAEXT):
|
||
if PathUtils.is_invalid_path(path):
|
||
continue
|
||
ret, ret_msg = self.transfer_media(in_from=SyncType.MAN,
|
||
in_path=path,
|
||
target_dir=t_path,
|
||
rmt_mode=rmt_mode)
|
||
if not ret:
|
||
print("【Rmt】%s 处理失败：%s" % (path, ret_msg))
|
||
|
||
def __is_media_exists(self,
|
||
media_dest,
|
||
media):
|
||
"""
|
||
判断媒体文件是否忆存在
|
||
:param media_dest: 媒体文件所在目录
|
||
:param media: 已识别的媒体信息
|
||
:return: 目录是否存在，目录路径，文件是否存在，文件路径
|
||
"""
|
||
# 返回变量
|
||
dir_exist_flag = False
|
||
file_exist_flag = False
|
||
ret_dir_path = None
|
||
ret_file_path = None
|
||
# 电影
|
||
if media.type == MediaType.MOVIE:
|
||
# 目录名称
|
||
dir_name, file_name = self.get_moive_dest_path(media)
|
||
# 默认目录路径
|
||
file_path = os.path.join(media_dest, dir_name)
|
||
# 开启分类时目录路径
|
||
if self._movie_category_flag:
|
||
file_path = os.path.join(media_dest, media.category, dir_name)
|
||
for m_type in [RMT_FAVTYPE, media.category]:
|
||
type_path = os.path.join(media_dest, m_type, dir_name)
|
||
# 目录是否存在
|
||
if os.path.exists(type_path):
|
||
file_path = type_path
|
||
break
|
||
# 返回路径
|
||
ret_dir_path = file_path
|
||
# 路径存在标志
|
||
if os.path.exists(file_path):
|
||
dir_exist_flag = True
|
||
# 文件路径
|
||
file_dest = os.path.join(file_path, file_name)
|
||
# 返回文件路径
|
||
ret_file_path = file_dest
|
||
# 文件是否存在
|
||
for ext in RMT_MEDIAEXT:
|
||
ext_dest = "%s%s" % (file_dest, ext)
|
||
if os.path.exists(ext_dest):
|
||
file_exist_flag = True
|
||
ret_file_path = ext_dest
|
||
break
|
||
# 电视剧或者动漫
|
||
else:
|
||
# 目录名称
|
||
dir_name, season_name, file_name = self.get_tv_dest_path(media)
|
||
# 剧集目录
|
||
if (media.type == MediaType.TV and self._tv_category_flag) or (
|
||
media.type == MediaType.ANIME and self._anime_category_flag):
|
||
media_path = os.path.join(media_dest, media.category, dir_name)
|
||
else:
|
||
media_path = os.path.join(media_dest, dir_name)
|
||
# 季
|
||
if media.get_season_list():
|
||
# 季路径
|
||
season_dir = os.path.join(media_path, season_name)
|
||
# 返回目录路径
|
||
ret_dir_path = season_dir
|
||
# 目录是否存在
|
||
if os.path.exists(season_dir):
|
||
dir_exist_flag = True
|
||
# 处理集
|
||
episodes = media.get_episode_list()
|
||
if episodes:
|
||
# 集文件路径
|
||
file_path = os.path.join(season_dir, file_name)
|
||
# 返回文件路径
|
||
ret_file_path = file_path
|
||
# 文件存在标志
|
||
for ext in RMT_MEDIAEXT:
|
||
ext_dest = "%s%s" % (file_path, ext)
|
||
if os.path.exists(ext_dest):
|
||
file_exist_flag = True
|
||
ret_file_path = ext_dest
|
||
break
|
||
return dir_exist_flag, ret_dir_path, file_exist_flag, ret_file_path
|
||
|
||
def transfer_embyfav(self, item_path):
|
||
"""
|
||
Emby/Jellyfin点红星后转移电影文件到精选分类
|
||
:param item_path: 文件路径
|
||
"""
|
||
if not item_path:
|
||
return False
|
||
if not self._movie_category_flag or not self._movie_path:
|
||
return False
|
||
if os.path.isdir(item_path):
|
||
movie_dir = item_path
|
||
else:
|
||
movie_dir = os.path.dirname(item_path)
|
||
# 已经是精选下的不处理
|
||
movie_type = os.path.basename(os.path.dirname(movie_dir))
|
||
if movie_type == RMT_FAVTYPE \
|
||
or movie_type not in self.category.get_movie_categorys():
|
||
return False
|
||
movie_name = os.path.basename(movie_dir)
|
||
movie_path = self.__get_best_target_path(mtype=MediaType.MOVIE, in_path=movie_dir)
|
||
# 开始转移文件，转移到同目录下的精选目录
|
||
org_path = os.path.join(movie_path, movie_type, movie_name)
|
||
new_path = os.path.join(movie_path, RMT_FAVTYPE, movie_name)
|
||
if os.path.exists(org_path):
|
||
log.info("【Rmt】开始转移文件 %s 到 %s ..." % (org_path, new_path))
|
||
if os.path.exists(new_path):
|
||
log.info("【Rmt】目录 %s 已存在" % new_path)
|
||
return False
|
||
ret, retmsg = SystemUtils.move(org_path, new_path)
|
||
if ret == 0:
|
||
return True
|
||
else:
|
||
log.error("【Rmt】%s" % retmsg)
|
||
else:
|
||
log.error("【Rmt】%s 目录不存在" % org_path)
|
||
return False
|
||
|
||
def get_dest_path_by_info(self, dest, meta_info):
|
||
"""
|
||
拼装转移重命名后的新文件地址
|
||
:param dest: 目的目录
|
||
:param meta_info: 媒体信息
|
||
"""
|
||
if not dest or not meta_info:
|
||
return None
|
||
if meta_info.type == MediaType.MOVIE:
|
||
dir_name, _ = self.get_moive_dest_path(meta_info)
|
||
if self._movie_category_flag:
|
||
return os.path.join(dest, meta_info.category, dir_name)
|
||
else:
|
||
return os.path.join(dest, dir_name)
|
||
else:
|
||
dir_name, season_name, _ = self.get_tv_dest_path(meta_info)
|
||
if self._tv_category_flag:
|
||
return os.path.join(dest, meta_info.category, dir_name, season_name)
|
||
else:
|
||
return os.path.join(dest, dir_name, season_name)
|
||
|
||
def get_no_exists_medias(self, meta_info, season=None, total_num=None):
|
||
"""
|
||
根据媒体库目录结构，判断媒体是否存在
|
||
:param meta_info: 已识别的媒体信息
|
||
:param season: 季号，数字，剧集时需要
|
||
:param total_num: 该季总集数，剧集时需要
|
||
:return: 如果是电影返回已存在的电影清单：title、year，如果是剧集，则返回不存在的集的清单
|
||
"""
|
||
# 电影
|
||
if meta_info.type == MediaType.MOVIE:
|
||
dir_name, _ = self.get_moive_dest_path(meta_info)
|
||
for dest_path in self._movie_path:
|
||
# 判断精选
|
||
fav_path = os.path.join(dest_path, RMT_FAVTYPE, dir_name)
|
||
fav_files = PathUtils.get_dir_files(fav_path, RMT_MEDIAEXT)
|
||
# 其它分类
|
||
if self._movie_category_flag:
|
||
dest_path = os.path.join(dest_path, meta_info.category, dir_name)
|
||
else:
|
||
dest_path = os.path.join(dest_path, dir_name)
|
||
files = PathUtils.get_dir_files(dest_path, RMT_MEDIAEXT)
|
||
if len(files) > 0 or len(fav_files) > 0:
|
||
return [{'title': meta_info.title, 'year': meta_info.year}]
|
||
return []
|
||
# 电视剧
|
||
else:
|
||
dir_name, season_name, _ = self.get_tv_dest_path(meta_info)
|
||
if not season or not total_num:
|
||
return []
|
||
if meta_info.type == MediaType.ANIME:
|
||
dest_paths = self._anime_path
|
||
category_flag = self._anime_category_flag
|
||
else:
|
||
dest_paths = self._tv_path
|
||
category_flag = self._tv_category_flag
|
||
# 总需要的集
|
||
total_episodes = [episode for episode in range(1, total_num + 1)]
|
||
# 已存在的集
|
||
exists_episodes = []
|
||
for dest_path in dest_paths:
|
||
if category_flag:
|
||
dest_path = os.path.join(dest_path, meta_info.category, dir_name, season_name)
|
||
else:
|
||
dest_path = os.path.join(dest_path, dir_name, season_name)
|
||
# 目录不存在
|
||
if not os.path.exists(dest_path):
|
||
continue
|
||
files = PathUtils.get_dir_files(dest_path, RMT_MEDIAEXT)
|
||
for file in files:
|
||
file_meta_info = MetaInfo(os.path.basename(file))
|
||
if not file_meta_info.get_season_list() or not file_meta_info.get_episode_list():
|
||
continue
|
||
if file_meta_info.get_name() != meta_info.title:
|
||
continue
|
||
if not file_meta_info.is_in_season(season):
|
||
continue
|
||
exists_episodes = list(set(exists_episodes).union(set(file_meta_info.get_episode_list())))
|
||
return list(set(total_episodes).difference(set(exists_episodes)))
|
||
|
||
def __get_best_target_path(self, mtype, in_path=None, size=0):
|
||
"""
|
||
查询一个最好的目录返回，有in_path时找与in_path同路径的，没有in_path时，顺序查找1个符合大小要求的，没有in_path和size时，返回第1个
|
||
:param mtype: 媒体类型：电影、电视剧、动漫
|
||
:param in_path: 源目录
|
||
:param size: 文件大小
|
||
"""
|
||
if not mtype:
|
||
return None
|
||
if mtype == MediaType.MOVIE:
|
||
dest_paths = self._movie_path
|
||
elif mtype == MediaType.TV:
|
||
dest_paths = self._tv_path
|
||
else:
|
||
dest_paths = self._anime_path
|
||
if not dest_paths:
|
||
return None
|
||
if not isinstance(dest_paths, list):
|
||
return dest_paths
|
||
if isinstance(dest_paths, list) and len(dest_paths) == 1:
|
||
return dest_paths[0]
|
||
# 有输入路径的，匹配有共同上级路径的
|
||
if in_path:
|
||
# 先用自定义规则匹配 找同级目录最多的路径
|
||
max_return_path = None
|
||
max_path_len = 0
|
||
for dest_path in dest_paths:
|
||
try:
|
||
path_len = len(os.path.commonpath([in_path, dest_path]))
|
||
if path_len > max_path_len:
|
||
max_path_len = path_len
|
||
max_return_path = dest_path
|
||
except Exception as err:
|
||
ExceptionUtils.exception_traceback(err)
|
||
continue
|
||
if max_return_path:
|
||
return max_return_path
|
||
# 有输入大小的，匹配第1个满足空间存储要求的
|
||
if size:
|
||
for path in dest_paths:
|
||
disk_free_size = SystemUtils.get_free_space_gb(path)
|
||
if float(disk_free_size) > float(size / 1024 / 1024 / 1024):
|
||
return path
|
||
# 默认返回第1个
|
||
return dest_paths[0]
|
||
|
||
def __get_best_unknown_path(self, in_path):
|
||
"""
|
||
查找最合适的unknown目录
|
||
:param in_path: 源目录
|
||
"""
|
||
if not self._unknown_path:
|
||
return None
|
||
for unknown_path in self._unknown_path:
|
||
if os.path.commonpath([in_path, unknown_path]) not in ["/", "\\"]:
|
||
return unknown_path
|
||
return self._unknown_path[0]
|
||
|
||
def link_sync_file(self, src_path, in_file, target_dir, sync_transfer_mode):
|
||
"""
|
||
对文件做纯链接处理，不做识别重命名，则监控模块调用
|
||
:param : 来源渠道
|
||
:param src_path: 源目录
|
||
:param in_file: 源文件
|
||
:param target_dir: 目的目录
|
||
:param sync_transfer_mode: 明确的转移方式
|
||
"""
|
||
new_file = in_file.replace(src_path, target_dir)
|
||
new_file_list, msg = self.check_ignore(file_list=[new_file])
|
||
if not new_file_list:
|
||
return 0, msg
|
||
else:
|
||
new_file = new_file_list[0]
|
||
new_dir = os.path.dirname(new_file)
|
||
if not os.path.exists(new_dir):
|
||
os.makedirs(new_dir)
|
||
return self.__transfer_command(file_item=in_file,
|
||
target_file=new_file,
|
||
rmt_mode=sync_transfer_mode), ""
|
||
|
||
def get_format_dict(self, media):
|
||
"""
|
||
根据媒体信息，返回Format字典
|
||
"""
|
||
if not media:
|
||
return {}
|
||
episode_title = self.media.get_episode_title(media)
|
||
# 此处使用独立对象，避免影响语言
|
||
en_title = Media().get_tmdb_en_title(media)
|
||
return {
|
||
"title": StringUtils.clear_file_name(media.title),
|
||
"en_title": StringUtils.clear_file_name(en_title),
|
||
"original_name": StringUtils.clear_file_name(os.path.splitext(media.org_string or "")[0]),
|
||
"original_title": StringUtils.clear_file_name(media.original_title),
|
||
"name": StringUtils.clear_file_name(media.get_name()),
|
||
"year": media.year,
|
||
"edition": media.get_edtion_string() or None,
|
||
"videoFormat": media.resource_pix,
|
||
"releaseGroup": media.resource_team,
|
||
"effect": media.resource_effect,
|
||
"videoCodec": media.video_encode,
|
||
"audioCodec": media.audio_encode,
|
||
"tmdbid": media.tmdb_id,
|
||
"season": media.get_season_seq(),
|
||
"episode": media.get_episode_seqs(),
|
||
"episode_title": StringUtils.clear_file_name(episode_title),
|
||
"season_episode": "%s%s" % (media.get_season_item(), media.get_episode_items()),
|
||
"part": media.part
|
||
}
|
||
|
||
def get_moive_dest_path(self, media_info):
|
||
"""
|
||
计算电影文件路径
|
||
:return: 电影目录、电影名称
|
||
"""
|
||
format_dict = self.get_format_dict(media_info)
|
||
dir_name = re.sub(r"[-_\s.]*None", "", self._movie_dir_rmt_format.format(**format_dict))
|
||
file_name = re.sub(r"[-_\s.]*None", "", self._movie_file_rmt_format.format(**format_dict))
|
||
return dir_name, file_name
|
||
|
||
def get_tv_dest_path(self, media_info):
|
||
"""
|
||
计算电视剧文件路径
|
||
:return: 电视剧目录、季目录、集名称
|
||
"""
|
||
format_dict = self.get_format_dict(media_info)
|
||
dir_name = re.sub(r"[-_\s.]*None", "", self._tv_dir_rmt_format.format(**format_dict))
|
||
season_name = re.sub(r"[-_\s.]*None", "", self._tv_season_rmt_format.format(**format_dict))
|
||
file_name = re.sub(r"[-_\s.]*None", "", self._tv_file_rmt_format.format(**format_dict))
|
||
return dir_name, season_name, file_name
|
||
|
||
def check_ignore(self, file_list):
|
||
"""
|
||
检查过滤文件列表中忽略项目
|
||
:param file_list: 文件路径列表
|
||
"""
|
||
if not file_list:
|
||
return [], ""
|
||
# 过滤掉文件列表中文件路径包含文件路径转移忽略词的
|
||
if self._ignored_paths:
|
||
try:
|
||
for file in file_list[:]:
|
||
if re.findall(self._ignored_paths, os.path.dirname(file)):
|
||
log.info(f"【Rmt】{file} 文件路径含转移忽略词，已忽略转移")
|
||
file_list.remove(file)
|
||
if not file_list:
|
||
return [], "排除文件路径转移忽略词后，没有新文件需要处理"
|
||
except Exception as err:
|
||
ExceptionUtils.exception_traceback(err)
|
||
log.error("【Rmt】文件路径转移忽略词设置有误：%s" % str(err))
|
||
|
||
# 过滤掉文件列表中文件名包含文件名转移忽略词的
|
||
if self._ignored_files:
|
||
try:
|
||
for file in file_list[:]:
|
||
if re.findall(self._ignored_files, os.path.basename(file)):
|
||
log.info(f"【Rmt】{file} 文件名包含转移忽略词，已忽略转移")
|
||
file_list.remove(file)
|
||
if not file_list:
|
||
return [], "排除文件名转移忽略词后，没有新文件需要处理"
|
||
except Exception as err:
|
||
ExceptionUtils.exception_traceback(err)
|
||
log.error("【Rmt】文件名转移忽略词设置有误：%s" % str(err))
|
||
|
||
return file_list, ""
|
||
|
||
|
||
if __name__ == "__main__":
|
||
"""
|
||
手工转移时，使用命名行调用
|
||
"""
|
||
Config().init_syspath()
|
||
|
||
parser = argparse.ArgumentParser(description='文件转移工具')
|
||
parser.add_argument('-m', '--mode', dest='mode', required=True,
|
||
help='转移模式：link copy softlink move rclone rclonecopy minio miniocopy')
|
||
parser.add_argument('-s', '--source', dest='s_path', required=True, help='硬链接源目录路径')
|
||
parser.add_argument('-d', '--target', dest='t_path', required=False, help='硬链接目的目录路径')
|
||
args = parser.parse_args()
|
||
if os.environ.get('NASTOOL_CONFIG'):
|
||
print("【Rmt】配置文件地址：%s" % os.environ.get('NASTOOL_CONFIG'))
|
||
print("【Rmt】源目录路径：%s" % args.s_path)
|
||
if args.t_path:
|
||
print("【Rmt】目的目录路径：%s" % args.t_path)
|
||
else:
|
||
print("【Rmt】目的目录为配置文件中的电影、电视剧媒体库目录")
|
||
FileTransfer().transfer_manually(args.s_path, args.t_path, args.mode)
|
||
else:
|
||
print("【Rmt】未设置环境变量，请先设置 NASTOOL_CONFIG 环境变量为配置文件地址")
|