diff --git a/bin/ffx.py b/bin/ffx.py index 17a1639..ef0a85c 100755 --- a/bin/ffx.py +++ b/bin/ffx.py @@ -428,11 +428,6 @@ def convert(ctx, fc = FfxController(context, sourceMediaDescriptor) - # dispositionTokens = fc.generateDispositionTokens() - # click.echo(f"Disposition Tokens: {dispositionTokens}") - - # audioTokens = fc.generateAudioEncodingTokens() - # click.echo(f"Audio Tokens: {audioTokens}") else: @@ -480,14 +475,6 @@ def convert(ctx, fc = FfxController(context, targetMediaDescriptor, sourceMediaDescriptor) - # mappingTokens = fc.generateMetadataTokens() - # click.echo(f"Metadata Tokens: {mappingTokens}") - - # dispositionTokens = fc.generateDispositionTokens() - # click.echo(f"Disposition Tokens: {dispositionTokens}") - - # audioTokens = fc.generateAudioEncodingTokens() - # click.echo(f"Audio Tokens: {audioTokens}") if ctx.obj['verbosity'] > 0: click.echo(f"Season={mediaFileProperties.getSeason()} Episode={mediaFileProperties.getEpisode()}") @@ -495,6 +482,7 @@ def convert(ctx, if ctx.obj['verbosity'] > 0: click.echo(f"fileBasename={sourceFileBasename}") + for q in q_list: if ctx.obj['verbosity'] > 0: diff --git a/bin/ffx/ffx_controller.py b/bin/ffx/ffx_controller.py index 70fb886..c5f290b 100644 --- a/bin/ffx/ffx_controller.py +++ b/bin/ffx/ffx_controller.py @@ -53,6 +53,8 @@ class FfxController(): self.__sourceMediaDescriptor = sourceMediaDescriptor self.__targetMediaDescriptor = targetMediaDescriptor + self.__logger = context['logger'] + def generateAV1Tokens(self, quality, preset, subIndex : int = 0): @@ -173,21 +175,20 @@ class FfxController(): # sourceTrackDescriptors = [] if self.__sourceMediaDescriptor is None else self.__sourceMediaDescriptor.getAllTrackDescriptors() targetTrackDescriptors = self.__targetMediaDescriptor.getAllTrackDescriptors() + dispositionTokens = [] - - # raise click.ClickException(f"ttd subindices: {[t.getSubIndex() for t in targetTrackDescriptors]}") - #TODO: Sorting here is for the sole purpose to let the tokens appear with ascending subindices. Why necessary? Jellyfin order? - # for trackDescriptor in sorted(targetTrackDescriptors.copy(), key=lambda d: d.getSubIndex()): - for trackDescriptor in targetTrackDescriptors: + for trackIndex in range(len(targetTrackDescriptors)): + + td = targetTrackDescriptors[trackIndex] #HINT: No dispositions for pgs subtitle tracks that have no external file source - if (trackDescriptor.getExternalSourceFilePath() - or trackDescriptor.getCodec() != TrackDescriptor.CODEC_PGS): + if (td.getExternalSourceFilePath() + or td.getCodec() != TrackDescriptor.CODEC_PGS): - subIndex = trackDescriptor.getSubIndex() - streamIndicator = trackDescriptor.getType().indicator() - dispositionSet = trackDescriptor.getDispositionSet() + subIndex = td.getSubIndex() + streamIndicator = td.getType().indicator() + dispositionSet = td.getDispositionSet() if dispositionSet: dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '+'.join([d.label() for d in dispositionSet])] @@ -197,159 +198,6 @@ class FfxController(): return dispositionTokens -# def generateMetadataTokens(self): -# """Source media descriptor is mandatory""" -# -# metadataTokens = [] -# -# # click.echo(f"source media descriptor: track indices={[d.getIndex() for d in sourceMediaDescriptor.getAllTrackDescriptors()]}") -# # click.echo(f"target media descriptor: track indices={[d.getIndex() for d in targetMediaDescriptor.getAllTrackDescriptors()]}") -# -# # +jellyfin -jellyfin -# mediaDifferences = self.__targetMediaDescriptor.compare(self.__sourceMediaDescriptor) -# -# # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}} -# -# click.echo(f"media diff {mediaDifferences}") -# -# if MediaDescriptor.TAGS_KEY in mediaDifferences.keys(): -# -# sourceTags = self.__sourceMediaDescriptor.getTags() -# targetTags = self.__targetMediaDescriptor.getTags() -# -# #TODO: Warum erscheint nur -1 im output? -# if DIFF_REMOVED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys(): -# # for removedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]: -# # row = (f"removed media tag: key='{removedTagKey}' value='{sourceTags[removedTagKey]}'",) -# # self.differencesTable.add_row(*map(str, row)) -# pass -# #metadataTokens += [f"-map_metadata:g", "-1"] -# -# #for targetMediaTagKey in targetTags: -# #metadataTokens += [f"-metadata:g", f"{targetMediaTagKey}={targetTags[targetMediaTagKey]}"] -# -# else: -# -# if DIFF_ADDED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys(): -# for addedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]: -# # row = (f"added media tag: key='{addedTagKey}' value='{targetTags[addedTagKey]}'",) -# click.echo(f"added metadata key='{addedTagKey}' value='{targetTags[addedTagKey]}'->'{targetTags[addedTagKey]}'") -# # self.differencesTable.add_row(*map(str, row)) -# #pass -# metadataTokens += [f"-metadata:g", f"{addedTagKey}={targetTags[addedTagKey]}"] -# -# -# -# if DIFF_CHANGED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys(): -# for changedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]: -# #row = (f"changed media tag: key='{changedTagKey}' value='{sourceTags[changedTagKey]}'->'{targetTags[changedTagKey]}'",) -# click.echo(f"changed metadata key='{changedTagKey}' value='{sourceTags[changedTagKey]}'->'{targetTags[changedTagKey]}'") -# # self.differencesTable.add_row(*map(str, row)) -# #pass -# metadataTokens += [f"-metadata:g", f"{changedTagKey}={targetTags[changedTagKey]}"] -# -# if MediaDescriptor.TRACKS_KEY in mediaDifferences.keys(): -# -# sourceTrackDescriptors = self.__sourceMediaDescriptor.getAllTrackDescriptors() -# targetTrackDescriptors = self.__targetMediaDescriptor.getReorderedTrackDescriptors() -# -# if DIFF_ADDED_KEY in mediaDifferences[MediaDescriptor.TRACKS_KEY].keys(): -# addedTracksIndices = mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY] -# raise click.ClickException(f"FfxController.generateMetadataTokens(): Adding tracks is not supported. Track indices {addedTracksIndices}") -# -# #raise click.ClickException(f"add track {mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]}") -# #for addedTrackIndex in mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]: -# #addedTrack : Track = targetTrackDescriptors[addedTrackIndex] -# # row = (f"added {addedTrack.getType().label()} track: index={addedTrackIndex} lang={addedTrack.getLanguage().threeLetter()}",) -# # self.differencesTable.add_row(*map(str, row)) -# -# if DIFF_REMOVED_KEY in mediaDifferences[MediaDescriptor.TRACKS_KEY].keys(): -# removedTracksIndices = mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY].keys() -# raise click.ClickException(f"FfxController.generateMetadataTokens(): Removing tracks is not supported. Track indices {removedTracksIndices}") -# #for removedTrackIndex in mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY]: -# # row = (f"removed track: index={removedTrackIndex}",) -# # self.differencesTable.add_row(*map(str, row)) -# -# # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}} -# if DIFF_CHANGED_KEY in mediaDifferences[MediaDescriptor.TRACKS_KEY].keys(): -# for changedTrackIndex in mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].keys(): -# -# changedTargetTrackDescriptor : TrackDescriptor = targetTrackDescriptors[changedTrackIndex] -# changedTargetTrackSourceIndex = changedTargetTrackDescriptor.getSourceIndex() -# changedTargetSourceSubIndex = sourceTrackDescriptors[changedTargetTrackSourceIndex].getSubIndex() -# # changedSourceTrackDescriptor : TrackDescriptor = sourceTrackDescriptors[changedTargetTrackSourceIndex] -# # changedSourceTrackSubIndex = changedSourceTrackDescriptor.getSubIndex() -# -# changedTrackDiff : dict = mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY][changedTrackIndex] -# -# if MediaDescriptor.TAGS_KEY in changedTrackDiff.keys(): -# -# -# if DIFF_REMOVED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]: -# #for removedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]: -# # row = (f"changed {changedTargetTrackDescriptor.getType().label()} track index={changedTrackIndex} removed key={removedTagKey}",) -# # self.differencesTable.add_row(*map(str, row)) -# -# #addedTagValue = targetTrackDescriptors[changedTargetTrackSourceIndex].getTags()[addedTagKey] -# -# metadataTokens += [f"-map_metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}", "-1"] -# -# for targetTrackTagKey, targetTrackTagValue in changedTargetTrackDescriptor.getTags(): -# metadataTokens += [f"-metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}", -# f"{targetTrackTagKey}={targetTrackTagValue}"] -# -# else: -# -# # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}} -# if DIFF_ADDED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]: -# for addedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]: -# -# addedTagValue = targetTrackDescriptors[changedTargetTrackSourceIndex].getTags()[addedTagKey] -# -# # addedTagValue = changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY][addedTagKey] -# -# # click.echo(f"addedTagValue={addedTagValue}") -# # click.echo(f"sourceTrackDescriptors: subindex={[s.getSubIndex() for s in sourceTrackDescriptors]} sourceindex={[s.getSourceIndex() for s in sourceTrackDescriptors]} tags={[s.getTags() for s in sourceTrackDescriptors]}") -# # click.echo(f"targetTrackDescriptors: subindex={[t.getSubIndex() for t in targetTrackDescriptors]} sourceindex={[t.getSourceIndex() for t in targetTrackDescriptors]} tags={[t.getTags() for t in targetTrackDescriptors]}") -# # click.echo(f"changed track_index={changedTrackIndex} indicator={changedTargetTrackDescriptor.getType().indicator()} key={addedTagKey} value={addedTagValue} source_index={changedSourceTrackIndex}") -# -# metadataTokens += [f"-metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}", -# f"{addedTagKey}={addedTagValue}"] -# -# # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}} -# if DIFF_CHANGED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]: -# for changedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]: -# -# changedTagValue = targetTrackDescriptors[changedTargetTrackSourceIndex].getTags()[changedTagKey] -# # sourceSubIndex = sourceTrackDescriptors[changedTargetTrackSourceIndex].getSubIndex() -# # addedTagValue = changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY][addedTagKey] -# -# # click.echo(f"addedTagValue={addedTagValue}") -# # click.echo(f"sourceTrackDescriptors: subindex={[s.getSubIndex() for s in sourceTrackDescriptors]} sourceindex={[s.getSourceIndex() for s in sourceTrackDescriptors]} tags={[s.getTags() for s in sourceTrackDescriptors]}") -# # click.echo(f"targetTrackDescriptors: subindex={[t.getSubIndex() for t in targetTrackDescriptors]} sourceindex={[t.getSourceIndex() for t in targetTrackDescriptors]} tags={[t.getTags() for t in targetTrackDescriptors]}") -# # click.echo(f"changed track_index={changedTrackIndex} indicator={changedTargetTrackDescriptor.getType().indicator()} key={addedTagKey} value={addedTagValue} source_index={changedSourceTrackIndex}") -# -# metadataTokens += [f"-metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}", -# f"{changedTagKey}={changedTagValue}"] -# -# # if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys(): -# -# # if DIFF_ADDED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]: -# # for addedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_ADDED_KEY]: -# # # row = (f"changed {changedTargetTrackDescriptor.getType().label()} track index={changedTrackIndex} added disposition={addedDisposition.label()}",) -# # # self.differencesTable.add_row(*map(str, row)) -# # pass -# -# # if DIFF_REMOVED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]: -# # for removedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_REMOVED_KEY]: -# # # row = (f"changed {changedTargetTrackDescriptor.getType().label()} track index={changedTrackIndex} removed disposition={removedDisposition.label()}",) -# # # self.differencesTable.add_row(*map(str, row)) -# # pass - -# return metadataTokens - - - def generateMetadataTokens(self): metadataTokens = [] @@ -377,6 +225,7 @@ class FfxController(): preset: int = DEFAULT_AV1_PRESET, denoise: bool = False): + # self.__targetMediaDescriptor order OK commandTokens = FfxController.COMMAND_TOKENS + ['-i', sourcePath] @@ -404,7 +253,7 @@ class FfxController(): FfxController.DEFAULT_FILE_FORMAT, FfxController.DEFAULT_FILE_EXTENSION) - # click.echo(f"Command: {' '.join(commandSequence)}") + self.__logger.debug(f"FfxController.runJon() commandSequence:{' '.join(commandSequence)}") if not self.__context['dry_run']: executeProcess(commandSequence) @@ -421,7 +270,7 @@ class FfxController(): commandSequence1 += FfxController.NULL_TOKENS - # click.echo(f"Command 1: {' '.join(commandSequence1)}") + self.__logger.debug(f"FfxController.runJon() commandSequence1:{' '.join(commandSequence1)}") if os.path.exists(FfxController.TEMP_FILE_NAME): os.remove(FfxController.TEMP_FILE_NAME) @@ -449,7 +298,7 @@ class FfxController(): FfxController.DEFAULT_FILE_FORMAT, FfxController.DEFAULT_FILE_EXTENSION) - # click.echo(f"Command 2: {' '.join(commandSequence2)}") + self.__logger.debug(f"FfxController.runJon() commandSequence2:{' '.join(commandSequence2)}") if not self.__context['dry_run']: out, err, rc = executeProcess(commandSequence2) diff --git a/bin/ffx/media_descriptor.py b/bin/ffx/media_descriptor.py index 7dcf9c9..4d1af78 100644 --- a/bin/ffx/media_descriptor.py +++ b/bin/ffx/media_descriptor.py @@ -25,7 +25,7 @@ class MediaDescriptor: FFPROBE_TAGS_KEY = "tags" FFPROBE_CODEC_TYPE_KEY = "codec_type" - JELLYFIN_ORDER_FLAG_KEY = "jellyfin_order" + # JELLYFIN_ORDER_FLAG_KEY = "jellyfin_order" EXCLUDED_MEDIA_TAGS = ["creation_time"] @@ -70,14 +70,15 @@ class MediaDescriptor: else: self.__trackDescriptors = [] - if MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY in kwargs.keys(): - if type(kwargs[MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY]) is not bool: - raise TypeError( - f"MediaDescriptor.__init__(): Argument {MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY} is required to be of type bool" - ) - self.__jellyfinOrder = kwargs[MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY] - else: - self.__jellyfinOrder = False + # if MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY in kwargs.keys(): + # if type(kwargs[MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY]) is not bool: + # raise TypeError( + # f"MediaDescriptor.__init__(): Argument {MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY} is required to be of type bool" + # ) + # self.__jellyfinOrder = kwargs[MediaDescriptor.JELLYFIN_ORDER_FLAG_KEY] + # else: + # self.__jellyfinOrder = False + self.__jellyfinOrder = self.__context['use_jellyfin'] if 'use_jellyfin' in self.__context.keys() else False def setDefaultSubTrack(self, trackType: TrackType, subIndex: int): @@ -94,7 +95,6 @@ class MediaDescriptor: TrackDisposition.FORCED, t.getSubIndex() == int(subIndex) ) - def checkConfiguration(self): videoTracks = self.getVideoTracks() @@ -123,6 +123,18 @@ class MediaDescriptor: raise ValueError('Multiple streams originating from the same source stream') + def applySourceIndices(self, sourceMediaDescriptor: Self): + sourceTrackDescriptors = sourceMediaDescriptor.getAllTrackDescriptors() + + numTrackDescriptors = len(self.__trackDescriptors) + if len(sourceTrackDescriptors) != numTrackDescriptors: + raise ValueError('MediaDescriptor.applySourceIndices (): Number of track descriptors does not match') + + for trackIndex in range(numTrackDescriptors): + # click.echo(f"{trackIndex} -> {sourceTrackDescriptors[trackIndex].getSourceIndex()}") + self.__trackDescriptors[trackIndex].setSourceIndex(sourceTrackDescriptors[trackIndex].getSourceIndex()) + + def applyJellyfinOrder(self): """Reorder subtracks in types with default the last, then make subindices flat again""" @@ -144,13 +156,24 @@ class MediaDescriptor: if defaultVideoTracks: videoTracks.append(videoTracks.pop(videoTracks.index(defaultVideoTracks[0]))) #self.sortSubIndices(videoTracks) + numVideoTracks = len(videoTracks) + for vIndex in range(numVideoTracks): + videoTracks[vIndex].setDispositionFlag(TrackDisposition.DEFAULT, + vIndex == numVideoTracks - 1) if defaultAudioTracks: audioTracks.append(audioTracks.pop(audioTracks.index(defaultAudioTracks[0]))) #self.sortSubIndices(audioTracks) + numAudioTracks = len(audioTracks) + for aIndex in range(numAudioTracks): + audioTracks[aIndex].setDispositionFlag(TrackDisposition.DEFAULT, + aIndex == numAudioTracks - 1) if defaultSubtitleTracks: subtitleTracks.append(subtitleTracks.pop(subtitleTracks.index(defaultSubtitleTracks[0]))) #self.sortSubIndices(subtitleTracks) - + numSubtitleTracks = len(subtitleTracks) + for sIndex in range(numSubtitleTracks): + subtitleTracks[sIndex].setDispositionFlag(TrackDisposition.DEFAULT, + sIndex == numSubtitleTracks - 1) self.__trackDescriptors = videoTracks + audioTracks + subtitleTracks #self.sortIndices(self.__trackDescriptors) self.reindexSubIndices() @@ -206,9 +229,10 @@ class MediaDescriptor: subIndex += 1 return descriptors - def reindexSubIndices(self): + def reindexSubIndices(self, trackDescriptors: list = []): + tdList = trackDescriptors if trackDescriptors else self.__trackDescriptors subIndexCounter = {} - for td in self.__trackDescriptors: + for td in tdList: trackType = td.getType() if trackType not in subIndexCounter.keys(): subIndexCounter[trackType] = 0 @@ -224,9 +248,10 @@ class MediaDescriptor: index += 1 return descriptors - def reindexIndices(self): - for trackIndex in range(len(self.__trackDescriptors)): - self.__trackDescriptors[trackIndex].setIndex(trackIndex) + def reindexIndices(self, trackDescriptors: list = []): + tdList = trackDescriptors if trackDescriptors else self.__trackDescriptors + for trackIndex in range(len(tdList)): + tdList[trackIndex].setIndex(trackIndex) def getAllTrackDescriptors(self) -> List[TrackDescriptor]: @@ -352,18 +377,35 @@ class MediaDescriptor: def getInputMappingTokens(self, use_sub_index: bool = True, only_video: bool = False): """Tracks must be reordered for source index order""" - # reorderedTrackDescriptors = self.getReorderedTrackDescriptors() + # sourceTrackDescriptorSubIndices = [self.__trackDescriptors[std.getSourceIndex()].getSubIndex() + # for std in self.__trackDescriptors] + + # self.reindexSubIndices(trackDescriptors = sourceOrderTrackDescriptors) + # self.reindexIndices(trackDescriptors = sourceOrderTrackDescriptors) + + # click.echo(sourceTrackDescriptorIndices) + inputMappingTokens = [] filePointer = 1 - #for rtd in reorderedTrackDescriptors: - for rtd in sorted(self.__trackDescriptors.copy(), key=lambda d: d.getSourceIndex()): + for trackIndex in range(len(self.__trackDescriptors)): - trackType = rtd.getType() + td = self.__trackDescriptors[trackIndex] + + stdi = self.__trackDescriptors[td.getSourceIndex()].getIndex() + stdsi = self.__trackDescriptors[td.getSourceIndex()].getSubIndex() + + # sti = self.__trackDescriptors[trackIndex].getSourceIndex() + # sotd = sourceOrderTrackDescriptors[sti] + + # appearently this negates applyJellyfinOrder + #for rtd in sorted(self.__trackDescriptors.copy(), key=lambda d: d.getSourceIndex()): + + trackType = td.getType() if (trackType == TrackType.VIDEO or not only_video): - importedFilePath = rtd.getExternalSourceFilePath() + importedFilePath = td.getExternalSourceFilePath() if use_sub_index: @@ -377,15 +419,15 @@ class MediaDescriptor: else: - if rtd.getCodec() != TrackDescriptor.CODEC_PGS: + if td.getCodec() != TrackDescriptor.CODEC_PGS: inputMappingTokens += [ "-map", - f"0:{trackType.indicator()}:{rtd.getSubIndex()}", + f"0:{trackType.indicator()}:{stdsi}", ] else: - if rtd.getCodec() != TrackDescriptor.CODEC_PGS: - inputMappingTokens += ["-map", f"0:{rtd.getIndex()}"] + if td.getCodec() != TrackDescriptor.CODEC_PGS: + inputMappingTokens += ["-map", f"0:{stdi}"] return inputMappingTokens @@ -451,7 +493,7 @@ class MediaDescriptor: # click.echo(f"matchingSubtitleFileDescriptors: {matchingSubtitleFileDescriptors}") self.__logger.debug(f"importSubtitles(): matchingSubtitleFileDescriptors: {matchingSubtitleFileDescriptors}") - click.echo(f"importSubtitles(): matchingSubtitleFileDescriptors: {matchingSubtitleFileDescriptors}") + # click.echo(f"importSubtitles(): matchingSubtitleFileDescriptors: {matchingSubtitleFileDescriptors}") for msfd in matchingSubtitleFileDescriptors: matchingSubtitleTrackDescriptor = [s for s in subtitleTracks if s.getIndex() == msfd["index"]] diff --git a/bin/ffx/test/helper.py b/bin/ffx/test/helper.py index 2111148..f9135c3 100644 --- a/bin/ffx/test/helper.py +++ b/bin/ffx/test/helper.py @@ -230,9 +230,8 @@ def createMediaTestFile(mediaDescriptor: MediaDescriptor, f"{mediaTagKey}={mediaTagValue}"] subIndexCounter[trackType] += 1 - - #HINT: No context required for creating disposition tokens - fc = FfxController({}, mediaDescriptor) + ffxContext = {'logger': logger} + fc = FfxController(ffxContext, mediaDescriptor) commandTokens += (generatorTokens + importTokens diff --git a/bin/ffx/test/jellyfin_combinator_0.py b/bin/ffx/test/jellyfin_combinator_0.py index 035585e..733b0f8 100644 --- a/bin/ffx/test/jellyfin_combinator_0.py +++ b/bin/ffx/test/jellyfin_combinator_0.py @@ -10,7 +10,7 @@ from .jellyfin_combinator import JellyfinCombinator class JellyfinCombinator0(JellyfinCombinator): - VARIANT = 'j' + VARIANT = 'J0' # def __init__(self, SubCombinators: dict = {}, context = None): def __init__(self, context = None): diff --git a/bin/ffx/test/jellyfin_combinator_1.py b/bin/ffx/test/jellyfin_combinator_1.py index 3119d39..988754d 100644 --- a/bin/ffx/test/jellyfin_combinator_1.py +++ b/bin/ffx/test/jellyfin_combinator_1.py @@ -9,7 +9,7 @@ from .jellyfin_combinator import JellyfinCombinator class JellyfinCombinator1(JellyfinCombinator): - VARIANT = 'J' + VARIANT = 'J1' # def __init__(self, SubCombinators: dict = {}, context = None): def __init__(self, context = None): diff --git a/bin/ffx/test/media_combinator_0.py b/bin/ffx/test/media_combinator_0.py index b16642b..b66ea2f 100644 --- a/bin/ffx/test/media_combinator_0.py +++ b/bin/ffx/test/media_combinator_0.py @@ -31,12 +31,18 @@ class MediaCombinator0(MediaCombinator): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} diff --git a/bin/ffx/test/media_combinator_1.py b/bin/ffx/test/media_combinator_1.py index 7c7ccd0..fa9ca7a 100644 --- a/bin/ffx/test/media_combinator_1.py +++ b/bin/ffx/test/media_combinator_1.py @@ -31,17 +31,26 @@ class MediaCombinator1(MediaCombinator): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} diff --git a/bin/ffx/test/media_combinator_2.py b/bin/ffx/test/media_combinator_2.py index 4d0778c..5220fa5 100644 --- a/bin/ffx/test/media_combinator_2.py +++ b/bin/ffx/test/media_combinator_2.py @@ -30,28 +30,42 @@ class MediaCombinator2(MediaCombinator): return MediaCombinator2.VARIANT - def getPayload(self, subtitleDispositionTuple = (set(), set()), subtitleTagTuple = ({}, {})): + def getPayload(self, + subtitleDispositionTuple = (set(), set()), + subtitleTagTuple = ({}, {})): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0] trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 3 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[1] trackDescriptor3 = TrackDescriptor(**kwargs) diff --git a/bin/ffx/test/media_combinator_3.py b/bin/ffx/test/media_combinator_3.py index bd8936e..51d4c9c 100644 --- a/bin/ffx/test/media_combinator_3.py +++ b/bin/ffx/test/media_combinator_3.py @@ -30,35 +30,52 @@ class MediaCombinator3(MediaCombinator): return MediaCombinator3.VARIANT - def getPayload(self, subtitleDispositionTuple = (set(), set(), set()), subtitleTagTuple = ({}, {}, {})): - + def getPayload(self, + subtitleDispositionTuple = (set(), set(), set()), + subtitleTagTuple = ({}, {}, {})): + kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0] trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 3 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[1] trackDescriptor3 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 4 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 4 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 2 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[2] trackDescriptor4 = TrackDescriptor(**kwargs) diff --git a/bin/ffx/test/media_combinator_4.py b/bin/ffx/test/media_combinator_4.py index 548bc68..ceb2f7f 100644 --- a/bin/ffx/test/media_combinator_4.py +++ b/bin/ffx/test/media_combinator_4.py @@ -30,23 +30,34 @@ class MediaCombinator4(MediaCombinator): return MediaCombinator4.VARIANT - def getPayload(self, audioDispositionTuple = (set(), set()), audioTagTuple = ({}, {})): + def getPayload(self, + audioDispositionTuple = (set(), set()), + audioTagTuple = ({}, {})): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0] trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1] trackDescriptor2 = TrackDescriptor(**kwargs) diff --git a/bin/ffx/test/media_combinator_5.py b/bin/ffx/test/media_combinator_5.py index 88e39fb..1caff92 100644 --- a/bin/ffx/test/media_combinator_5.py +++ b/bin/ffx/test/media_combinator_5.py @@ -30,30 +30,44 @@ class MediaCombinator5(MediaCombinator): return MediaCombinator5.VARIANT - def getPayload(self, audioDispositionTuple = (set(), set()), audioTagTuple = ({}, {})): + def getPayload(self, + audioDispositionTuple = (set(), set()), + audioTagTuple = ({}, {})): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0] trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1] trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 3 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor3 = TrackDescriptor(**kwargs) diff --git a/bin/ffx/test/media_combinator_6.py b/bin/ffx/test/media_combinator_6.py index 729201a..4cfc355 100644 --- a/bin/ffx/test/media_combinator_6.py +++ b/bin/ffx/test/media_combinator_6.py @@ -30,37 +30,56 @@ class MediaCombinator6(MediaCombinator): return MediaCombinator6.VARIANT - def getPayload(self, audioDispositionTuple = (set(), set()), audioTagTuple = ({}, {}), subtitleDispositionTuple = (set(), set()), subtitleTagTuple = ({}, {})): + def getPayload(self, + audioDispositionTuple = (set(), set()), + audioTagTuple = ({}, {}), + subtitleDispositionTuple = (set(), set()), + subtitleTagTuple = ({}, {})): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0] trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1] trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 3 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0] trackDescriptor3 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 4 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 4 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[1] trackDescriptor4 = TrackDescriptor(**kwargs) diff --git a/bin/ffx/test/media_combinator_7.py b/bin/ffx/test/media_combinator_7.py index 070a4b7..888518e 100644 --- a/bin/ffx/test/media_combinator_7.py +++ b/bin/ffx/test/media_combinator_7.py @@ -8,6 +8,8 @@ from ffx.media_descriptor import MediaDescriptor from .media_combinator import MediaCombinator from .disposition_combinator_2 import DispositionCombinator2 +from .disposition_combinator_3 import DispositionCombinator3 +from .track_tag_combinator_2 import TrackTagCombinator2 from .track_tag_combinator_3 import TrackTagCombinator3 from .jellyfin_combinator import JellyfinCombinator from .media_tag_combinator import MediaTagCombinator @@ -29,41 +31,68 @@ class MediaCombinator7(MediaCombinator): return MediaCombinator7.VARIANT - def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set(), set())): + def getPayload(self, + audioDispositionTuple = (set(), set()), + audioTagTuple = ({}, {}), + subtitleDispositionTuple = (set(), set(), set()), + subtitleTagTuple = ({}, {}, {})): kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 0 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 trackDescriptor0 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 1 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] + kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0] trackDescriptor1 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 2 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] + kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1] trackDescriptor2 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 3 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] + kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0] trackDescriptor3 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 4 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 4 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] + kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[1] trackDescriptor4 = TrackDescriptor(**kwargs) kwargs = {} kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.INDEX_KEY] = 5 + kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 5 kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.SUB_INDEX_KEY] = 2 kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2] + kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[2] trackDescriptor5 = TrackDescriptor(**kwargs) kwargs = {} @@ -91,8 +120,8 @@ class MediaCombinator7(MediaCombinator): for MTC in MediaTagCombinator.getAllClassReferences(): for DC2_A in DispositionCombinator2.getAllClassReferences(): - for TC3_A in TrackTagCombinator3.getAllClassReferences(): - for DC2_S in DispositionCombinator2.getAllClassReferences(): + for TC2_A in TrackTagCombinator2.getAllClassReferences(): + for DC3_S in DispositionCombinator3.getAllClassReferences(): for TC3_S in TrackTagCombinator3.getAllClassReferences(): for J in JellyfinCombinator.getAllClassReferences(): @@ -100,8 +129,8 @@ class MediaCombinator7(MediaCombinator): self._context['use_jellyfin'] = j.getPayload() dc2a = DC2_A(self._context) - tc3a = TC3_A(self._context) - dc2s = DC2_S(self._context) + tc2a = TC2_A(self._context) + dc3s = DC3_S(self._context) tc3s = TC3_S(self._context) mtc = MTC(self._context) @@ -110,28 +139,28 @@ class MediaCombinator7(MediaCombinator): yieldObj['identifier'] = self.getIdentifier() yieldObj['variants'] = [self.getVariant(), f"A:{dc2a.getVariant()}", - f"A:{tc3a.getVariant()}", - f"S:{dc2s.getVariant()}", + f"A:{tc2a.getVariant()}", + f"S:{dc3s.getVariant()}", f"S:{tc3s.getVariant()}", mtc.getVariant(), j.getVariant()] - yieldObj['payload'] = self.getPayload(dc2a.getPayload(), tc3a.getPayload(), dc2s.getPayload(), tc3s.getPayload()) + yieldObj['payload'] = self.getPayload(dc2a.getPayload(), tc2a.getPayload(), dc3s.getPayload(), tc3s.getPayload()) yieldObj['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT', 'J'] yieldObj['assertFuncs'] = [self.assertFunc, dc2a.assertFunc, - tc3a.assertFunc, - dc2s.assertFunc, + tc2a.assertFunc, + dc3s.assertFunc, tc3s.assertFunc, mtc.assertFunc, j.assertFunc] yieldObj['shouldFail'] = (self.shouldFail() | dc2a.shouldFail() - | tc3a.shouldFail() - | dc2s.shouldFail() + | tc2a.shouldFail() + | dc3s.shouldFail() | tc3s.shouldFail() | mtc.shouldFail() | j.shouldFail()) diff --git a/bin/ffx/test/scenario_1.py b/bin/ffx/test/scenario_1.py index 9e73861..075e7f4 100644 --- a/bin/ffx/test/scenario_1.py +++ b/bin/ffx/test/scenario_1.py @@ -42,7 +42,7 @@ class Scenario1(Scenario): variantIdentifier = '-'.join(variantList) variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}" - sourceMediaDescriptor = yieldObj['payload'] + sourceMediaDescriptor: MediaDescriptor = yieldObj['payload'] assertSelectorList: list = yieldObj['assertSelectors'] assertFuncList = yieldObj['assertFuncs'] shouldFail = yieldObj['shouldFail'] @@ -50,19 +50,20 @@ class Scenario1(Scenario): try: jellyfinSelectorIndex = assertSelectorList.index('J') jellyfinVariant = variantList[jellyfinSelectorIndex] - testContext['use_jellyfin'] = jellyfinVariant == 'J' + testContext['use_jellyfin'] = jellyfinVariant == 'J1' except ValueError: jellyfinSelectorIndex = -1 - # if variantIdentifier != 'VAASS-A:D01-S:D00': - # return + + if self._context['test_variant'] and variantIdentifier != self._context['test_variant']: + return self._logger.debug(f"Running Job: {variantLabel}") # Phase 1: Setup source files self.clearTestDirectory() - mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory, logger=self._logger) + mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory, logger=self._logger, length = 2) # # Phase 2: Prepare database # @@ -104,6 +105,10 @@ class Scenario1(Scenario): resultFileProperties = FileProperties(testContext, resultFile) resultMediaDescriptor = resultFileProperties.getMediaDescriptor() + if testContext['use_jellyfin']: + sourceMediaDescriptor.applyJellyfinOrder() + resultMediaDescriptor.applySourceIndices(sourceMediaDescriptor) + resultMediaTracks = resultMediaDescriptor.getAllTrackDescriptors() for assertIndex in range(len(assertSelectorList)): diff --git a/bin/ffx/test/scenario_2.py b/bin/ffx/test/scenario_2.py index 41f3046..06e639b 100644 --- a/bin/ffx/test/scenario_2.py +++ b/bin/ffx/test/scenario_2.py @@ -1,12 +1,151 @@ +import os, sys, click + from .scenario import Scenario +from ffx.test.helper import createMediaTestFile +from ffx.process import executeProcess + +from ffx.file_properties import FileProperties + +from ffx.media_descriptor import MediaDescriptor +from ffx.track_descriptor import TrackDescriptor + +from ffx.track_type import TrackType +from ffx.track_disposition import TrackDisposition + +from ffx.test.media_combinator import MediaCombinator + + class Scenario2(Scenario): + """Creating file VAa, h264/aac/aac + Converting to VaA, vp9/opus/opus + No tmdb, default parameters""" def __init__(self, context): + + context['use_jellyfin'] = True + context['use_tmdb'] = False + context['use_pattern'] = False + #context['no_prompt'] = False + super().__init__(context) + + + +# def job(self, yieldObj: dict): +# +# testContext = self._context.copy() +# +# identifier = yieldObj['identifier'] +# variantList = yieldObj['variants'] +# +# variantIdentifier = '-'.join(variantList) +# variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}" +# +# sourceMediaDescriptor: MediaDescriptor = yieldObj['payload'] +# assertSelectorList: list = yieldObj['assertSelectors'] +# assertFuncList = yieldObj['assertFuncs'] +# shouldFail = yieldObj['shouldFail'] +# +# try: +# jellyfinSelectorIndex = assertSelectorList.index('J') +# jellyfinVariant = variantList[jellyfinSelectorIndex] +# testContext['use_jellyfin'] = jellyfinVariant == 'J1' +# except ValueError: +# jellyfinSelectorIndex = -1 +# +# +# if self._context['test_variant'] and variantIdentifier != self._context['test_variant']: +# return +# +# +# self._logger.debug(f"Running Job: {variantLabel}") +# +# # Phase 1: Setup source files +# self.clearTestDirectory() +# mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory, logger=self._logger, length = 2) +# +# # # Phase 2: Prepare database +# # +# # Phase 3: Run ffx +# commandSequence = [sys.executable, +# self._ffxExecutablePath, +# 'convert', +# mediaFilePath, +# '--no-prompt'] +# +# if not testContext['use_jellyfin']: +# commandSequence += ['--no-jellyfin'] +# +# self._logger.debug(f"{variantLabel}: Test sequence: {commandSequence}") +# +# out, err, rc = executeProcess(commandSequence, directory = self._testDirectory) +# +# if out: +# self._logger.debug(f"{variantLabel}: Process output: {out}") +# if rc: +# self._logger.debug(f"{variantLabel}: Process returned ERROR {rc} ({err})") +# +# # Phase 4: Evaluate results +# +# try: +# +# jobFailed = bool(rc) +# +# self._logger.debug(f"{variantLabel}: Should fail: {shouldFail} / actually failed: {jobFailed}") +# +# assert jobFailed == shouldFail, f"Process {'failed' if jobFailed else 'did not fail'}" +# +# if not jobFailed: +# +# resultFile = os.path.join(self._testDirectory, 'media.webm') +# +# assert os.path.isfile(resultFile), f"Result file 'media.webm' in path '{self._testDirectory}' wasn't created" +# +# resultFileProperties = FileProperties(testContext, resultFile) +# resultMediaDescriptor = resultFileProperties.getMediaDescriptor() +# +# if testContext['use_jellyfin']: +# sourceMediaDescriptor.applyJellyfinOrder() +# resultMediaDescriptor.applySourceIndices(sourceMediaDescriptor) +# +# resultMediaTracks = resultMediaDescriptor.getAllTrackDescriptors() +# +# for assertIndex in range(len(assertSelectorList)): +# +# assertSelector = assertSelectorList[assertIndex] +# assertFunc = assertFuncList[assertIndex] +# assertVariant = variantList[assertIndex] +# +# if assertSelector == 'M': +# assertFunc() +# for variantIndex in range(len(assertVariant)): +# assert assertVariant[variantIndex].lower() == resultMediaTracks[variantIndex].getType().indicator(), f"Stream #{variantIndex} is not of type {resultMediaTracks[variantIndex].getType().label()}" +# +# elif assertSelector == 'AD' or assertSelector == 'AT': +# assertFunc(resultMediaDescriptor.getAudioTracks()) +# +# elif assertSelector == 'SD' or assertSelector == 'ST': +# assertFunc(resultMediaDescriptor.getSubtitleTracks()) +# +# elif type(assertSelector) is str: +# if assertSelector == 'J': +# assertFunc() +# +# +# self._reportLogger.info(f"{variantLabel}: Test passed") +# +# except AssertionError as ae: +# +# self._reportLogger.error(f"{variantLabel}: Test FAILED ({ae})") + def run(self): pass - # self._testDirectory - #createMediaTestFile() +# MC_list = MediaCombinator.getAllClassReferences() +# for MC in MC_list: +# self._logger.debug(f"MC={MC.__name__}") +# mc = MC(context = self._context) +# for y in mc.getYield(): +# self.job(y) diff --git a/bin/ffx/test/track_tag_combinator_2_2.py b/bin/ffx/test/track_tag_combinator_2_2.py index 5779307..f6629d5 100644 --- a/bin/ffx/test/track_tag_combinator_2_2.py +++ b/bin/ffx/test/track_tag_combinator_2_2.py @@ -25,10 +25,10 @@ class TrackTagCombinator21(TrackTagCombinator2): assert not 'language' in resortedTrackDescriptors[0].getTags().keys(), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag" assert not 'title' in resortedTrackDescriptors[0].getTags().keys(), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag" - assert 'language' in resortedTrackDescriptors[1].getTags().keys(), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag" - assert resortedTrackDescriptors[1].getTags()['language'] == 'bas', f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'bas'" - assert 'title' in resortedTrackDescriptors[1].getTags().keys(), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag" - assert resortedTrackDescriptors[1].getTags()['title'] == 'Baskisch', f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Baskisch'" + assert 'language' in resortedTrackDescriptors[1].getTags().keys(), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag" + assert resortedTrackDescriptors[1].getTags()['language'] == 'bas', f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag 'bas'" + assert 'title' in resortedTrackDescriptors[1].getTags().keys(), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set title tag" + assert resortedTrackDescriptors[1].getTags()['title'] == 'Baskisch', f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set title 'Baskisch'" def shouldFail(self): return False diff --git a/bin/ffx/test/track_tag_combinator_2_3.py b/bin/ffx/test/track_tag_combinator_2_3.py index 86b0ba0..ba56324 100644 --- a/bin/ffx/test/track_tag_combinator_2_3.py +++ b/bin/ffx/test/track_tag_combinator_2_3.py @@ -34,4 +34,4 @@ class TrackTagCombinator23(TrackTagCombinator2): def shouldFail(self): - return True + return False diff --git a/bin/ffx/test/track_tag_combinator_3_4.py b/bin/ffx/test/track_tag_combinator_3_4.py index 24cb976..fe78ee1 100644 --- a/bin/ffx/test/track_tag_combinator_3_4.py +++ b/bin/ffx/test/track_tag_combinator_3_4.py @@ -39,4 +39,4 @@ class TrackTagCombinator34(TrackTagCombinator3): assert resortedTrackDescriptors[2].getTags()['title'] == 'English', f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'English'" def shouldFail(self): - return True + return False diff --git a/bin/ffx/track_descriptor.py b/bin/ffx/track_descriptor.py index 6d4e6b4..2e0b758 100644 --- a/bin/ffx/track_descriptor.py +++ b/bin/ffx/track_descriptor.py @@ -260,6 +260,9 @@ class TrackDescriptor: def getSourceIndex(self): return self.__sourceIndex + def setSourceIndex(self, sourceIndex: int): + self.__sourceIndex = int(sourceIndex) + def getSubIndex(self): return self.__subIndex diff --git a/bin/ffx_tests.py b/bin/ffx_tests.py index e440814..e8ed06d 100755 --- a/bin/ffx_tests.py +++ b/bin/ffx_tests.py @@ -74,11 +74,14 @@ def ffx(ctx, verbose, dry_run): # Another subcommand @ffx.command() @click.pass_context -def run(ctx): +@click.option('--variant', type=str, default='', help='Only run this test variant') +def run(ctx, variant): """Run ffx test sequences""" ctx.obj['logger'].info('Starting FFX test runs') + ctx.obj['test_variant'] = variant + for scenarioIdentifier in Scenario.list(): scenario = Scenario.getClassReference(scenarioIdentifier)(ctx.obj)