def test_no_candidates(self, tvdb_mock):
tvdb_mock.find_episode.return_value = []
tvdb_mock.season_number = lambda e: (e['airedSeason'], e['airedEpisodeNumber'])
tvdb_mock.get_series_id.return_value = 54321
meta = {
'Title': 'TheSeries',
'WM/SubTitle': 'Test Episode Name',
'WM/SubTitleDescription': 'TheSubTitleDescription',
'WM/MediaOriginalBroadcastDateTime': '2011-01-01T00:00:00Z'
}
input_file = os.path.join(self.tv_in.name, 'test.wtv')
create_test_video(length=10, video_def=WTV_VIDEO_DEF, output_file=input_file, metadata=meta)
os.utime(input_file, (0, 0))
config = Configuration(self.config_file.name, tvdb_mock)
config.run()
self.assertEqual(1, config.count)
expected_file = os.path.join(self.out_dir.name,
'TheSeries/Season 2/TheSeries - S02E03 - Test Episode NameTVDB.mp4')
self.assertFalse(os.path.isfile(expected_file))
config.wtvdb.begin()
wtv = config.wtvdb.get_wtv('test.wtv')
self.assertIsNotNone(wtv)
self.assertEqual(0, len(wtv.candidate_episodes))
config.wtvdb.end()
def test_multiple(self):
movie_count = 3
tv_count = 3
expected_files = []
for i in range(movie_count):
movie_name = 'Move Name (200{}) - 1080p.mkv'.format(i)
input_file = os.path.join(self.movie_in.name, movie_name)
create_test_video(length=3, output_file=input_file)
os.utime(input_file, (0, 0))
expected_files.append(os.path.join(self.movie_out.name,
movie_name))
for i in range(tv_count):
tv_name = 'Show Name/Season 02/Show Name - S02E0{} - Episode Title.mkv'.format(
i)
input_file = os.path.join(self.tv_in.name, tv_name)
os.makedirs(os.path.dirname(input_file), exist_ok=True)
create_test_video(length=3, output_file=input_file)
os.utime(input_file, (0, 0))
expected_files.append(os.path.join(self.tv_out.name, tv_name))
result = self.convert_dvds.run()
self.assertEqual(movie_count + tv_count, self.backup_count)
for f in expected_files:
self.assertTrue(os.path.isfile(f))
self.assertFalse(0, os.path.getsize(f))
self.assertEquals(movie_count, result.movie_processed_count)
self.assertEquals(movie_count, result.movie_total_count)
self.assertEquals(0, result.movie_error_count)
self.assertEquals(0, result.tv_error_count)
self.assertEquals(tv_count, result.tv_processed_count)
self.assertEquals(tv_count, result.tv_total_count)
def test_basic(self, tvdb_mock):
tvdb_mock.find_episode.return_value = [{
'id': 1001,
'episodeName': 'Test Episode NameTVDB',
'overview': 'TheOverview',
'firstAired': '2011-01-01',
'airedSeason': 2,
'airedEpisodeNumber': 3
}]
tvdb_mock.season_number = lambda e: (e['airedSeason'], e['airedEpisodeNumber'])
meta = {
'Title': 'TheSeries',
'WM/SubTitle': 'Test Episode Name',
'WM/SubTitleDescription': 'TheSubTitleDescription',
'WM/MediaOriginalBroadcastDateTime': '2011-01-01T00:00:00Z'
}
input_file = os.path.join(self.tv_in.name, 'test.wtv')
create_test_video(length=10, video_def=WTV_VIDEO_DEF, output_file=input_file, metadata=meta)
os.utime(input_file, (0, 0))
config = Configuration(self.config_file.name, tvdb_mock)
config.run()
self.assertEqual(1, config.count)
expected_file = os.path.join(self.out_dir.name,
'TheSeries/Season 2/TheSeries - S02E03 - Test Episode NameTVDB.mp4')
self.assertTrue(os.path.isfile(expected_file))
def create(self, video_def, audio_def):
self.count += 1
create_test_video(1,
video_def=video_def,
audio_defs=[audio_def],
output_file=os.path.join(
self.tmpdir.name, '{}.mp4'.format(self.count)))
return self.count
def test_not_aac(self):
with create_test_video(length=5, video_def=MP4_VIDEO_DEF,
audio_defs=[AudioDefition(codec=AudioCodec.AC3)]) as first, \
create_test_video(length=5, video_def=MP4_VIDEO_DEF) as second:
with NamedTemporaryFile(suffix='.mp4') as output:
with self.assertRaises(expected_exception=Exception):
concat_mp4(output.name,
files=[first.name, second.name],
overwrite=True)
def test_not_h264(self):
with create_test_video(length=5, video_def=VideoDefinition(Resolution.LOW_DEF, VideoCodec.MPEG2,
VideoFileContainer.MP4)) as first, \
create_test_video(length=5, video_def=MP4_VIDEO_DEF) as second:
with NamedTemporaryFile(suffix='.mp4') as output:
with self.assertRaises(expected_exception=Exception):
concat_mp4(output.name,
files=[first.name, second.name],
overwrite=True)
def test_2_files(self):
with create_test_video(length=5, video_def=MP4_VIDEO_DEF) as first, \
create_test_video(length=5, video_def=MP4_VIDEO_DEF) as second:
with NamedTemporaryFile(suffix='.mp4') as output:
concat_mp4(output.name,
files=[first.name, second.name],
overwrite=True)
metadata = create_metadata_extractor().extract(output.name)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(10, int(metadata.video_streams[0].duration))
self.assertEqual(1, len(metadata.audio_streams))
self.assertEqual('aac', metadata.audio_streams[0].codec)
self.assertEqual(2, metadata.audio_streams[0].channels)
assertAudioLength(10, metadata.audio_streams[0].duration)
def test_audio_remux(self):
config = convert_config_from_ns({'audio_codec': 'copy'})
with create_test_video(length=3, audio_defs=[AudioDefition(codec=AudioCodec.AC3)]) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.audio_streams[0].codec, AudioCodec.AC3.ffmpeg_codec_name)
def test_video_remux(self):
config = convert_config_from_ns({'video_codec': 'copy'})
with create_test_video(length=3, video_def=VideoDefinition(codec=VideoCodec.MPEG2)) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.video_streams[0].codec, VideoCodec.MPEG2.ffmpeg_codec_name)
def test_meta(self):
create_test_video(1,
video_def=H264_VIDEO_DEF,
audio_defs=[AAC_STEREO_AUDIO_DEF],
output_file=os.path.join(self.tmpdir.name,
'test.mp4'),
metadata={'title': 'whatever'})
self.run_test(1, 'meta.title = whatever')
self.run_test(1, 'meta.tags.title = whatever')
create_test_video(1,
video_def=H264_VIDEO_DEF,
audio_defs=[AAC_STEREO_AUDIO_DEF],
output_file=os.path.join(self.tmpdir.name,
'test2.mp4'),
metadata={'title': 'whatever two'})
self.run_test(1, 'meta.title = "whatever two"')
def test_h265_1080p_5_1(self):
length = 3
with create_test_video(length=length,
video_def=VideoDefinition(
Resolution.HIGH_DEF, VideoCodec.H265,
VideoFileContainer.MKV),
audio_defs=[
AudioDefition(AudioCodec.AAC,
AudioChannelName.SURROUND_5_1)
]) as file:
metadata = create_metadata_extractor().extract(file.name)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(1, len(metadata.audio_streams))
v = metadata.video_streams[0]
a = metadata.audio_streams[0]
self.assertEqual(VideoCodec.H265.ffmpeg_codec_name, v.codec)
self.assertEqual(length, v.duration)
self.assertEqual(Resolution.HIGH_DEF.width, v.width)
self.assertEqual(Resolution.HIGH_DEF.height, v.height)
self.assertEqual(AudioCodec.AAC.ffmpeg_codec_name, a.codec)
assertAudioLength(length, a.duration)
self.assertEqual(6, a.channels)
def test_scale_convert(self):
config = ConvertConfig(scale=480)
with create_test_video(length=4, video_def=VideoDefinition(resolution=Resolution.HIGH_DEF)) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.resolution, Resolution.STANDARD_DEF)
def test_cut_convert(self):
config = convert_config_from_ns({'start': 3.0, 'end': 6.0})
with create_test_video(length=10) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertAlmostEqual(3.0, metadata.estimated_duration, delta=.03)
def test_mpeg2_convert(self):
config = convert_config_from_ns(
{'video_codec': VideoCodec.MPEG2.ffmpeg_encoder_name})
with create_test_video(length=3) as file, NamedTemporaryFile(
suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.video_streams[0].codec.lower(),
VideoCodec.MPEG2.ffmpeg_codec_name)
def test_movie_run(self):
movie_name = 'Move Name (2000) - 1080p.mkv'
input_file = os.path.join(self.movie_in.name, movie_name)
create_test_video(length=10, output_file=input_file)
os.utime(input_file, (0, 0))
expected_output_file = os.path.join(self.movie_out.name, movie_name)
result = self.convert_dvds.run()
self.assertEqual(1, self.backup_count)
self.assertTrue(os.path.isfile(expected_output_file))
self.assertFalse(0, os.path.getsize(expected_output_file))
self.assertEquals(1, result.movie_processed_count)
self.assertEquals(1, result.movie_total_count)
self.assertEquals(0, result.movie_error_count)
self.assertEquals(0, result.tv_error_count)
self.assertEquals(0, result.tv_processed_count)
self.assertEquals(0, result.tv_total_count)
def test_tv_run(self):
tv_name = 'Show Name/Season 02/Show Name - S02E01 - Episode Title.mkv'
input_file = os.path.join(self.tv_in.name, tv_name)
os.makedirs(os.path.dirname(input_file), exist_ok=True)
create_test_video(length=10, output_file=input_file)
os.utime(input_file, (0, 0))
expected_output_file = os.path.join(self.tv_out.name, tv_name)
result = self.convert_dvds.run()
print(result)
self.assertEqual(1, self.backup_count)
self.assertTrue(os.path.isfile(expected_output_file))
self.assertFalse(0, os.path.getsize(expected_output_file))
self.assertEquals(0, result.movie_processed_count)
self.assertEquals(0, result.movie_total_count)
self.assertEquals(0, result.movie_error_count)
self.assertEquals(0, result.tv_error_count)
self.assertEquals(1, result.tv_processed_count)
self.assertEquals(1, result.tv_total_count)
def test_defaults_convert(self):
config = convert_config_from_ns({})
with create_test_video(length=3, video_def=VideoDefinition(resolution=Resolution.LOW_DEF,
codec=VideoCodec.MPEG2),
audio_defs=[AudioDefition(codec=AudioCodec.AC3)]) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
metadata = extract_metadata(output.name)
self.assertEqual(metadata.resolution, Resolution.LOW_DEF)
self.assertEqual(metadata.video_streams[0].codec, VideoCodec.H264.ffmpeg_codec_name)
self.assertEqual(metadata.audio_streams[0].codec, AudioCodec.AAC.ffmpeg_codec_name)
def test_movie_exists(self):
movie_name = 'Move Name (2000) - 1080p.mkv'
input_file = os.path.join(self.movie_in.name, movie_name)
create_test_video(length=10, output_file=input_file)
os.utime(input_file, (0, 0))
output_file = os.path.join(self.movie_out.name, movie_name)
with open(output_file, 'w'):
pass
result = self.convert_dvds.run()
self.assertEqual(1, self.backup_count)
self.assertEquals(0, os.path.getsize(output_file))
self.assertEquals(1, result.movie_processed_count)
self.assertEquals(1, result.movie_total_count)
self.assertEquals(0, result.movie_error_count)
self.assertEquals(0, result.tv_error_count)
self.assertEquals(0, result.tv_processed_count)
self.assertEquals(0, result.tv_total_count)
def test_get_combinable_files(self):
with TemporaryDirectory() as input_dir, TemporaryDirectory(
) as output_dir:
file1 = os.path.join(input_dir, 'file1.mkv')
file2 = os.path.join(input_dir, 'file2.mkv')
file3 = os.path.join(input_dir, 'file3.mkv')
file1_srt = os.path.join(input_dir, 'file1.eng.srt')
file2_srt = os.path.join(input_dir, 'file2.spa.srt')
create_test_video(length=3, output_file=file1)
create_test_video(length=3, output_file=file2)
create_test_video(length=3, output_file=file3)
with open(file1_srt, 'w') as f:
f.write(SRT_TEXT)
with open(file2_srt, 'w') as f:
f.write(SRT_TEXT)
files = list(get_combinable_files(input_dir, output_dir))
self.assertEqual(
(file1, file1_srt, 'eng', os.path.join(output_dir,
'file1.mkv')), files[0])
self.assertEqual(
(file2, file2_srt, 'spa', os.path.join(output_dir,
'file2.mkv')), files[1])
self.assertEqual(
(file3, None, None, os.path.join(output_dir, 'file3.mkv')),
files[2])
def test_basic_combine(self):
with create_test_video(length=3) as file, \
NamedTemporaryFile(suffix='.srt', mode='w') as srt_file, \
NamedTemporaryFile(suffix='.mkv') as out:
srt_file.file.write(SRT_TEXT)
srt_file.file.flush()
ret = combine(file.name,
srt_file.name,
output=out.name,
lang='eng',
overwrite=True)
self.assertEqual(0, ret)
self._validate_file(out.name)
def test_metadata_in_file(self):
meta = {'TestKey': 'test_value'}
length = 2
with create_test_video(length=length,
video_def=VideoDefinition(
Resolution.HIGH_DEF, VideoCodec.H264,
VideoFileContainer.WTV),
metadata=meta) as file:
metadata = create_metadata_extractor().extract(file.name)
print(metadata.tags)
self.assertTrue('TestKey' in metadata.tags)
self.assertEqual('test_value', metadata.tags['TestKey'])
with create_test_video(length=length,
video_def=VideoDefinition(
Resolution.HIGH_DEF, VideoCodec.H264,
VideoFileContainer.MKV),
metadata=meta) as file:
metadata = create_metadata_extractor().extract(file.name)
print(metadata.tags)
# MKV stores as uppercase
self.assertTrue('TESTKEY' in metadata.tags)
self.assertEqual('test_value', metadata.tags['TESTKEY'])
def test_h264_stereo(self):
length = 5
with create_test_video(length=length) as file:
metadata = create_metadata_extractor().extract(file.name)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(1, len(metadata.audio_streams))
v = metadata.video_streams[0]
a = metadata.audio_streams[0]
self.assertEqual(VideoCodec.H264.ffmpeg_codec_name, v.codec)
self.assertEqual(length, v.duration)
self.assertEqual(Resolution.LOW_DEF.width, v.width)
self.assertEqual(Resolution.LOW_DEF.height, v.height)
self.assertEqual(AudioCodec.AAC.ffmpeg_codec_name, a.codec)
assertAudioLength(length, a.duration)
self.assertEqual(2, a.channels)
def test_mpeg2(self):
length = 5
with create_test_video(
length=length,
video_def=VideoDefinition(codec=VideoCodec.MPEG2)) as file:
metadata = create_metadata_extractor().extract(file.name, True)
self.assertEqual(1, len(metadata.video_streams))
self.assertEqual(1, len(metadata.audio_streams))
self.assertFalse(metadata.interlace_report.is_interlaced())
v = metadata.video_streams[0]
a = metadata.audio_streams[0]
self.assertEqual(VideoCodec.MPEG2.ffmpeg_codec_name, v.codec)
self.assertEqual(length, v.duration)
self.assertEqual(Resolution.LOW_DEF.width, v.width)
self.assertEqual(Resolution.LOW_DEF.height, v.height)
self.assertEqual(AudioCodec.AAC.ffmpeg_codec_name, a.codec)
assertAudioLength(length, a.duration)
self.assertEqual(2, a.channels)
def test_combine_all(self):
with TemporaryDirectory() as input_dir, TemporaryDirectory(
) as output_dir:
create_test_video(length=3,
output_file=os.path.join(input_dir, 'file1.mkv'))
create_test_video(length=3,
output_file=os.path.join(input_dir, 'file2.mkv'))
create_test_video(length=3,
output_file=os.path.join(input_dir, 'file3.mkv'))
with open(os.path.join(input_dir, 'file1.eng.srt'), 'w') as f:
f.write(SRT_TEXT)
with open(os.path.join(input_dir, 'file2.spa.srt'), 'w') as f:
f.write(SRT_TEXT)
combine_all(get_combinable_files(input_dir, output_dir))
out1 = os.path.join(output_dir, 'file1.mkv')
out2 = os.path.join(output_dir, 'file2.mkv')
self.assertTrue(os.path.isfile(out1))
self.assertTrue(os.path.isfile(out2))
self.assertFalse(
os.path.isfile(os.path.join(output_dir, 'file3.mkv')))
self._validate_file(out1)
self._validate_file(out2, 'spa')
def test_basic_convert(self):
config = convert_config_from_ns({})
with create_test_video(length=10) as file, NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
def test(self):
with create_test_video(length=5) as file:
self.assertTrue(os.path.isfile(file.name))
def test_metadata_print(self):
from media_management_scripts.commands.metadata import print_metadata
with create_test_video(length=2) as file:
print_metadata(file.name)
def test_auto_bitrate_custom_convert(self):
config = ConvertConfig(bitrate='auto', auto_bitrate_240=300)
with create_test_video(length=10) as file, NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
def test_deinterlace_detect_convert(self):
config = ConvertConfig(deinterlace=True)
with create_test_video(length=10) as file, NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
def test_deinterlace_convert(self):
config = ConvertConfig(deinterlace=True)
with create_test_video(length=10, video_def=VideoDefinition(codec=VideoCodec.MPEG2,
interlaced=True)) as file, \
NamedTemporaryFile(suffix='.mkv') as output:
convert_with_config(file.name, output.name, config, overwrite=True)
