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)