Tests passed, Config-File

.gitignore

@@ -1,2 +1,4 @@
 __pycache__
 junk/
+.vscode/launch.json
+.ipynb_checkpoints/

bin/check.py

@@ -1,32 +0,0 @@
-import os
-
-from ffx.pattern_controller import PatternController
-
-from ffx.model.show import Base
-from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
-from sqlalchemy.orm import relationship, sessionmaker, Mapped, backref
-
-filename = 'Boruto.Naruto.Next.Generations.S01E256.GerEngSub.AAC.1080p.WebDL.x264-Tanuki.mkv'
-
-
-
-# Data 'input' variable
-context = {}
-
-# Initialize DB
-homeDir = os.path.expanduser("~")
-ffxVarDir = os.path.join(homeDir, '.local', 'var', 'ffx')
-if not os.path.exists(ffxVarDir):
-    os.makedirs(ffxVarDir)
-
-context['database_url'] = f"sqlite:///{os.path.join(ffxVarDir, 'ffx.db')}"
-context['database_engine'] = create_engine(context['database_url'])
-context['database_session'] = sessionmaker(bind=context['database_engine'])
-
-Base.metadata.create_all(context['database_engine'])
-
-
-pc = PatternController(context)
-
-
-print(pc.matchFilename(filename))

bin/ffx/audio_layout.py

@@ -0,0 +1,64 @@
+import click 
+from enum import Enum
+from .track_type import TrackType
+
+class AudioLayout(Enum):
+
+    LAYOUT_STEREO   = {"label": "stereo", "index": 1}
+    LAYOUT_5_1      = {"label": "5.1(side)", "index": 2}
+    LAYOUT_6_1      = {"label": "6.1", "index": 3}
+    LAYOUT_7_1      = {"label": "7.1", "index": 4} #TODO: Does this exist?
+
+    LAYOUT_6CH      = {"label": "6ch", "index": 5}
+
+    LAYOUT_UNDEFINED  = {"label": "undefined", "index": 0}
+
+
+    def label(self):
+        """Returns the audio layout as string"""
+        return str(self.value['label'])
+
+    def index(self):
+        """Returns the audio layout as integer"""
+        return int(self.value['index'])
+
+    @staticmethod
+    def fromLabel(label : str):
+        try:
+            
+            return [a for a in AudioLayout if a.value['label'] == str(label)][0]
+        except:
+            raise click.ClickException('fromLabel failed')
+            return AudioLayout.LAYOUT_UNDEFINED
+
+    @staticmethod
+    def fromIndex(index : int):
+        try:
+            return [a for a in AudioLayout if a.value['index'] == int(index)][0]
+        except:
+            raise click.ClickException('fromIndex failed')
+            return AudioLayout.LAYOUT_UNDEFINED
+
+    @staticmethod
+    def identify(streamObj):
+
+        FFPROBE_LAYOUT_KEY = 'channel_layout'
+        FFPROBE_CHANNELS_KEY = 'channels'
+        FFPROBE_CODEC_TYPE_KEY = 'codec_type'
+
+        if (type(streamObj) is not dict
+                or FFPROBE_CODEC_TYPE_KEY not in streamObj.keys()
+                or streamObj[FFPROBE_CODEC_TYPE_KEY] != TrackType.AUDIO.label()):
+            raise Exception('Not an ffprobe audio stream object')
+
+        if FFPROBE_LAYOUT_KEY in streamObj.keys():
+            matchingLayouts = [l for l in AudioLayout if l.label() == streamObj[FFPROBE_LAYOUT_KEY]]
+            if matchingLayouts:
+                return matchingLayouts[0]
+
+        if (FFPROBE_CHANNELS_KEY in streamObj.keys()
+                and int(streamObj[FFPROBE_CHANNELS_KEY]) == 6):
+
+            return AudioLayout.LAYOUT_6CH
+  
+        return AudioLayout.LAYOUT_UNDEFINED

bin/ffx/configuration_controller.py

@@ -0,0 +1,48 @@
+import os, json
+
+class ConfigurationController():
+
+    CONFIG_FILENAME = 'ffx.json'
+    DATABASE_FILENAME = 'ffx.db'
+    LOG_FILENAME = 'ffx.log'
+
+    DATABASE_PATH_CONFIG_KEY = 'databasePath'
+    LOG_DIRECTORY_CONFIG_KEY = 'logDirectory'
+
+    def __init__(self):
+
+        self.__homeDir = os.path.expanduser("~")
+        self.__localVarDir = os.path.join(self.__homeDir, '.local', 'var')
+        self.__localEtcDir = os.path.join(self.__homeDir, '.local', 'etc')
+
+        self.__configurationData = {}
+
+        # .local/etc/ffx.json
+        self.__configFilePath = os.path.join(self.__localEtcDir, ConfigurationController.CONFIG_FILENAME)
+        if os.path.isfile(self.__configFilePath):
+            with open(self.__configFilePath, 'r') as configurationFile:
+                self.__configurationData = json.load(configurationFile)
+
+        if ConfigurationController.DATABASE_PATH_CONFIG_KEY in self.__configurationData.keys():
+            self.__databaseFilePath = self.__configurationData[ConfigurationController.DATABASE_PATH_CONFIG_KEY]
+            os.makedirs(os.path.dirname(self.__databaseFilePath), exist_ok=True)
+        else:
+            ffxVarDir = os.path.join(self.__localVarDir, 'ffx')
+            os.makedirs(ffxVarDir, exist_ok=True)
+            self.__databaseFilePath = os.path.join(ffxVarDir, ConfigurationController.DATABASE_FILENAME)
+
+        if ConfigurationController.LOG_DIRECTORY_CONFIG_KEY in self.__configurationData.keys():
+            self.__logDir = self.__configurationData[ConfigurationController.LOG_DIRECTORY_CONFIG_KEY]
+        else:
+            self.__logDir = os.path.join(self.__localVarDir, 'log')
+            os.makedirs(self.__logDir, exist_ok=True)
+
+
+    def getHomeDirectory(self):
+        return self.__homeDir
+
+    def getLogFilePath(self):
+        return os.path.join(self.__logDir, ConfigurationController.LOG_FILENAME)
+
+    def getDatabaseFilePath(self):
+        return self.__databaseFilePath

bin/ffx/dashboard_screen.py

@@ -1,16 +0,0 @@
-from textual.app import App, ComposeResult
-from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label
-
-class DashboardScreen(Screen):
-
-    def __init__(self):
-        super().__init__()
-
-        context = self.app.getContext()
-        context['dashboard'] = 'dashboard'
-
-    def compose(self) -> ComposeResult:
-        yield Header(show_clock=True)
-        yield Placeholder("Dashboard Screen")
-        yield Footer()

bin/ffx/database.py

@@ -0,0 +1,45 @@
+import os
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from ffx.model.show import Base, Show
+from ffx.model.pattern import Pattern
+from ffx.model.track import Track
+
+from ffx.model.media_tag import MediaTag
+from ffx.model.track_tag import TrackTag
+
+
+def databaseContext(databasePath: str = ''):
+
+    databaseContext = {}
+
+    if databasePath is None:
+        # sqlite:///:memory:
+        databasePath = ':memory:'
+    elif not databasePath:
+        homeDir = os.path.expanduser("~")
+        ffxVarDir = os.path.join(homeDir, '.local', 'var', 'ffx')
+        if not os.path.exists(ffxVarDir):
+            os.makedirs(ffxVarDir)
+        databasePath = os.path.join(ffxVarDir, 'ffx.db')
+
+    databaseContext['url'] = f"sqlite:///{databasePath}"
+    databaseContext['engine'] = create_engine(databaseContext['url'])
+    databaseContext['session'] = sessionmaker(bind=databaseContext['engine'])
+
+    Base.metadata.create_all(databaseContext['engine'])
+
+    # isSyncronuous = False
+    # while not isSyncronuous:
+    # while True:
+    #     try:
+    #         with databaseContext['database_engine'].connect() as connection:
+    #             connection.execute(sqlalchemy.text('PRAGMA foreign_keys=ON;'))
+    #             #isSyncronuous = True
+    #             break
+    #     except sqlite3.OperationalError:
+    #         time.sleep(0.1)
+
+    return databaseContext

bin/ffx/ffx_app.py

@@ -1,20 +1,8 @@
-import os, time, sqlite3, sqlalchemy
+from textual.app import App
-
-from textual.app import App, ComposeResult
-from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label
-
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from ffx.model.show import Base, Show
-from ffx.model.pattern import Pattern
-from ffx.model.track import Track
 
 from .shows_screen import ShowsScreen
-from .warning_screen import WarningScreen
+from .media_details_screen import MediaDetailsScreen
-from .dashboard_screen import DashboardScreen
+
-from .settings_screen import SettingsScreen
-from .help_screen import HelpScreen
 
 class FfxApp(App):
 
@@ -32,34 +20,19 @@ class FfxApp(App):
         # Data 'input' variable
         self.context = context
 
-        # Initialize DB
-        homeDir = os.path.expanduser("~")
-        ffxVarDir = os.path.join(homeDir, '.local', 'var', 'ffx')
-        if not os.path.exists(ffxVarDir):
-            os.makedirs(ffxVarDir)
-
-        self.context['database_url'] = f"sqlite:///{os.path.join(ffxVarDir, 'ffx.db')}"
-        self.context['database_engine'] = create_engine(self.context['database_url'])
-        self.context['database_session'] = sessionmaker(bind=self.context['database_engine'])
-
-        Base.metadata.create_all(self.context['database_engine'])
-
-        # isSyncronuous = False
-        # while not isSyncronuous:
-        # while True:
-        #     try:
-        #         with self.context['database_engine'].connect() as connection:
-        #             connection.execute(sqlalchemy.text('PRAGMA foreign_keys=ON;'))
-        #             #isSyncronuous = True
-        #             break
-        #     except sqlite3.OperationalError:
-        #         time.sleep(0.1)
-
 
     def on_mount(self) -> None:
+
+        if 'command' in self.context.keys():
+
+            if self.context['command'] == 'shows':
                 self.push_screen(ShowsScreen())
 
+            if self.context['command'] == 'inspect':                
+                self.push_screen(MediaDetailsScreen())
+
 
     def getContext(self):
         """Data 'output' method"""
         return self.context
+

bin/ffx/ffx_controller.py

@@ -1,2 +1,343 @@
+import os, click, re
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.helper import DIFF_ADDED_KEY, DIFF_REMOVED_KEY, DIFF_CHANGED_KEY
+from ffx.track_descriptor import TrackDescriptor
+from ffx.model.track import Track
+from ffx.audio_layout import AudioLayout
+from ffx.track_type import TrackType
+from ffx.video_encoder import VideoEncoder
+from ffx.process import executeProcess
+from ffx.track_disposition import TrackDisposition
+
 class FfxController():
-    pass
+
+    COMMAND_TOKENS = ['ffmpeg', '-y']
+    NULL_TOKENS = ['-f', 'null', '/dev/null'] # -f null /dev/null
+
+    TEMP_FILE_NAME = "ffmpeg2pass-0.log"
+
+    DEFAULT_VIDEO_ENCODER = VideoEncoder.VP9.label()
+
+    DEFAULT_QUALITY = 23
+    DEFAULT_AV1_PRESET = 5
+
+    DEFAULT_FILE_FORMAT = 'webm'
+    DEFAULT_FILE_EXTENSION = 'webm'
+
+    DEFAULT_STEREO_BANDWIDTH = "128"
+    DEFAULT_AC3_BANDWIDTH = "256"
+    DEFAULT_DTS_BANDWIDTH = "320"
+
+    DEFAULT_CROP_START = 60
+    DEFAULT_CROP_LENGTH = 180
+
+    MKVMERGE_METADATA_KEYS = ['BPS',
+                                'NUMBER_OF_FRAMES',
+                                'NUMBER_OF_BYTES',
+                                '_STATISTICS_WRITING_APP',
+                                '_STATISTICS_WRITING_DATE_UTC',
+                                '_STATISTICS_TAGS']
+
+    INPUT_FILE_EXTENSIONS = ['mkv', 'mp4', 'avi', 'flv', 'webm']
+    
+    CHANNEL_MAP_5_1 = 'FL-FL|FR-FR|FC-FC|LFE-LFE|SL-BL|SR-BR:5.1'
+
+
+    def __init__(self,
+                    context : dict,
+                    targetMediaDescriptor : MediaDescriptor,
+                    sourceMediaDescriptor : MediaDescriptor = None):
+
+        self.__context = context
+        self.__sourceMediaDescriptor = sourceMediaDescriptor
+        self.__targetMediaDescriptor = targetMediaDescriptor
+
+        self.__logger = context['logger']
+
+
+    def generateAV1Tokens(self, quality, preset, subIndex : int = 0):
+
+        return [f"-c:v:{int(subIndex)}", 'libsvtav1',
+                '-svtav1-params', f"crf={quality}:preset={preset}:tune=0:enable-overlays=1:scd=1:scm=0",
+                '-pix_fmt', 'yuv420p10le']
+
+
+    # -c:v:0 libvpx-vp9 -row-mt 1 -crf 32 -pass 1 -speed 4 -frame-parallel 0 -g 9999 -aq-mode 0
+    def generateVP9Pass1Tokens(self, quality, subIndex : int = 0):
+
+        return [f"-c:v:{int(subIndex)}",
+                'libvpx-vp9',
+                '-row-mt', '1',
+                '-crf', str(quality),
+                '-pass', '1',
+                '-speed', '4',
+                '-frame-parallel', '0',
+                '-g', '9999',
+                '-aq-mode', '0']
+
+    # -c:v:0 libvpx-vp9 -row-mt 1 -crf 32 -pass 2 -frame-parallel 0 -g 9999 -aq-mode 0 -auto-alt-ref 1 -lag-in-frames 25
+    def generateVP9Pass2Tokens(self, quality, subIndex : int = 0):
+
+        return [f"-c:v:{int(subIndex)}",
+                'libvpx-vp9',
+                '-row-mt', '1',
+                '-crf', str(quality),
+                '-pass', '2',
+                '-frame-parallel', '0',
+                '-g', '9999',
+                '-aq-mode', '0',
+                '-auto-alt-ref', '1',
+                '-lag-in-frames', '25']
+
+
+    def generateCropTokens(self):
+
+        if 'crop_start' in self.__context.keys() and 'crop_length' in self.__context.keys():
+            cropStart = int(self.__context['crop_start'])
+            cropLength = int(self.__context['crop_length'])
+        else:
+            cropStart = FfxController.DEFAULT_CROP_START
+            cropLength = FfxController.DEFAULT_CROP_LENGTH
+
+        return ['-ss', str(cropStart), '-t', str(cropLength)]
+
+
+    def generateDenoiseTokens(self, spatial=5, patch=7, research=7, hw=False):
+        filterName = 'nlmeans_opencl' if hw else 'nlmeans'
+        return ['-vf', f"{filterName}=s={spatial}:p={patch}:r={research}"]
+
+
+    def generateOutputTokens(self, filepath, format, ext):
+        outputFilePath = f"{filepath}.{ext}"
+        return ['-f', format, outputFilePath]
+
+
+    def generateAudioEncodingTokens(self):
+        """Generates ffmpeg options audio streams including channel remapping, codec and bitrate"""
+
+        audioTokens = []
+
+        #sourceAudioTrackDescriptors = [smd for smd in self.__sourceMediaDescriptor.getAllTrackDescriptors() if smd.getType() == TrackType.AUDIO]
+        # targetAudioTrackDescriptors = [rtd for rtd in self.__targetMediaDescriptor.getReorderedTrackDescriptors() if rtd.getType() == TrackType.AUDIO]
+        targetAudioTrackDescriptors = [td for td in self.__targetMediaDescriptor.getAllTrackDescriptors() if td.getType() == TrackType.AUDIO]
+
+        trackSubIndex = 0
+        for trackDescriptor in targetAudioTrackDescriptors:
+
+            # Calculate source sub index
+            #changedTargetTrackDescriptor : TrackDescriptor = targetAudioTrackDescriptors[trackDescriptor.getIndex()]
+            #changedTargetTrackSourceIndex = changedTargetTrackDescriptor.getSourceIndex()
+            #sourceSubIndex = sourceAudioTrackDescriptors[changedTargetTrackSourceIndex].getSubIndex()
+
+            trackAudioLayout = trackDescriptor.getAudioLayout()
+            
+            #TODO: Sollte nicht die sub index unverändert bleiben wenn jellyfin reordering angewendet wurde?
+            # siehe auch: MediaDescriptor.getInputMappingTokens()
+            #trackSubIndex = trackDescriptor.getSubIndex()
+
+            if trackAudioLayout == AudioLayout.LAYOUT_6_1:
+                audioTokens += [f"-c:a:{trackSubIndex}",
+                                'libopus',
+                                f"-filter:a:{trackSubIndex}",
+                                'channelmap=channel_layout=6.1',
+                                f"-b:a:{trackSubIndex}",
+                                self.__context['bitrates']['dts']]
+        
+            if trackAudioLayout == AudioLayout.LAYOUT_5_1:
+                audioTokens += [f"-c:a:{trackSubIndex}",
+                                'libopus',
+                                f"-filter:a:{trackSubIndex}",
+                                f"channelmap={FfxController.CHANNEL_MAP_5_1}",
+                                f"-b:a:{trackSubIndex}",
+                                self.__context['bitrates']['ac3']]
+        
+            if trackAudioLayout == AudioLayout.LAYOUT_STEREO:
+                audioTokens += [f"-c:a:{trackSubIndex}",
+                                'libopus',
+                                f"-b:a:{trackSubIndex}",
+                                self.__context['bitrates']['stereo']]
+        
+            if trackAudioLayout == AudioLayout.LAYOUT_6CH:
+                audioTokens += [f"-c:a:{trackSubIndex}",
+                                'libopus',
+                                f"-filter:a:{trackSubIndex}",
+                                f"channelmap={FfxController.CHANNEL_MAP_5_1}",
+                                f"-b:a:{trackSubIndex}",
+                                self.__context['bitrates']['ac3']]
+            trackSubIndex += 1
+        return audioTokens
+
+
+    # -disposition:s:0 default -disposition:s:1 0
+    def generateDispositionTokens(self):
+
+        targetTrackDescriptors = self.__targetMediaDescriptor.getAllTrackDescriptors()
+
+        sourceTrackDescriptors = ([] if self.__sourceMediaDescriptor is None
+                                    else self.__sourceMediaDescriptor.getAllTrackDescriptors())
+        # if not self.__sourceMediaDescriptor is None:
+        #     sourceTrackDescriptors = self.__sourceMediaDescriptor.getAllTrackDescriptors()
+        # else:
+        #     sourceTrackDescriptors = []
+
+        dispositionTokens = []
+
+        for trackIndex in range(len(targetTrackDescriptors)):
+
+            td = targetTrackDescriptors[trackIndex]
+
+            #HINT: No dispositions for pgs subtitle tracks that have no external file source
+            if (td.getExternalSourceFilePath()
+                        or td.getCodec() != TrackDescriptor.CODEC_PGS):
+
+                subIndex = td.getSubIndex()
+                streamIndicator = td.getType().indicator()
+                
+
+                sourceDispositionSet = sourceTrackDescriptors[td.getSourceIndex()].getDispositionSet() if sourceTrackDescriptors else set()
+
+                #TODO: Alles discarden was im targetDescriptor vorhanden ist (?)
+                sourceDispositionSet.discard(TrackDisposition.DEFAULT)
+
+                dispositionSet = td.getDispositionSet() | sourceDispositionSet
+
+                if dispositionSet:
+                    dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '+'.join([d.label() for d in dispositionSet])]
+                else:
+                    dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '0']
+
+        return dispositionTokens
+
+
+    def generateMetadataTokens(self):
+
+        metadataTokens = []
+
+        for tagKey, tagValue in self.__targetMediaDescriptor.getTags().items():
+            metadataTokens += [f"-metadata:g",
+                                f"{tagKey}={tagValue}"]
+
+        #HINT: With current ffmpeg version track metadata tags are not passed to the outfile
+        for td in self.__targetMediaDescriptor.getAllTrackDescriptors():
+
+            for tagKey, tagValue in td.getTags().items():
+            
+                metadataTokens += [f"-metadata:s:{td.getType().indicator()}:{td.getSubIndex()}",
+                                    f"{tagKey}={tagValue}"]
+
+        return metadataTokens
+
+
+    def runJob(self,
+                sourcePath,
+                targetPath,
+                videoEncoder: VideoEncoder = VideoEncoder.VP9,
+                quality: int = DEFAULT_QUALITY,
+                preset: int = DEFAULT_AV1_PRESET,
+                denoise: bool = False):
+
+        # self.__targetMediaDescriptor order OK
+
+        commandTokens = FfxController.COMMAND_TOKENS + ['-i', sourcePath]
+
+        if videoEncoder == VideoEncoder.AV1:
+
+            commandSequence = (commandTokens
+                                + self.__targetMediaDescriptor.getImportFileTokens()
+                                + self.__targetMediaDescriptor.getInputMappingTokens()
+                                + self.generateDispositionTokens())
+
+            if not self.__sourceMediaDescriptor is None:
+                commandSequence += self.generateMetadataTokens()
+
+            if denoise:
+                commandSequence += self.generateDenoiseTokens()
+
+            commandSequence += (self.generateAudioEncodingTokens()
+                                + self.generateAV1Tokens(int(quality), int(preset))
+                                + self.generateAudioEncodingTokens())
+
+            if self.__context['perform_crop']:
+                commandSequence += FfxController.generateCropTokens()
+
+            commandSequence += self.generateOutputTokens(targetPath,
+                                                            FfxController.DEFAULT_FILE_FORMAT,
+                                                            FfxController.DEFAULT_FILE_EXTENSION)
+
+            self.__logger.debug(f"FfxController.runJon() commandSequence:{' '.join(commandSequence)}")
+
+            if not self.__context['dry_run']:
+                executeProcess(commandSequence)
+
+
+        if videoEncoder == VideoEncoder.VP9:
+
+            commandSequence1 = (commandTokens
+                                    + self.__targetMediaDescriptor.getInputMappingTokens(only_video=True)
+                                    + self.generateVP9Pass1Tokens(int(quality)))
+
+            if self.__context['perform_crop']:
+                commandSequence1 += self.generateCropTokens()
+
+            commandSequence1 += FfxController.NULL_TOKENS
+
+            self.__logger.debug(f"FfxController.runJon() commandSequence1:{' '.join(commandSequence1)}")
+
+            if os.path.exists(FfxController.TEMP_FILE_NAME):
+                os.remove(FfxController.TEMP_FILE_NAME)
+
+            if not self.__context['dry_run']:
+                executeProcess(commandSequence1)
+
+            commandSequence2 = (commandTokens
+                                + self.__targetMediaDescriptor.getImportFileTokens()
+                                + self.__targetMediaDescriptor.getInputMappingTokens()
+                                + self.generateDispositionTokens())
+
+            if not self.__sourceMediaDescriptor is None:
+                commandSequence2 += self.generateMetadataTokens()
+
+            if denoise:
+                commandSequence2 += self.generateDenoiseTokens()
+
+            commandSequence2 += self.generateVP9Pass2Tokens(int(quality)) + self.generateAudioEncodingTokens()
+
+            if self.__context['perform_crop']:
+                commandSequence2 += self.generateCropTokens()
+
+            commandSequence2 += self.generateOutputTokens(targetPath,
+                                                            FfxController.DEFAULT_FILE_FORMAT,
+                                                            FfxController.DEFAULT_FILE_EXTENSION)
+
+            self.__logger.debug(f"FfxController.runJon() commandSequence2:{' '.join(commandSequence2)}")
+
+            if not self.__context['dry_run']:            
+                out, err, rc = executeProcess(commandSequence2)
+                if rc:
+                    raise click.ClickException(f"Command resulted in error: rc={rc} error={err}")
+
+
+
+    def createEmptyFile(self,
+                        path: str = 'output.mp4',
+                        sizeX: int = 1280,
+                        sizeY: int = 720,
+                        rate: int = 25,
+                        length: int = 10):
+
+        commandTokens = FfxController.COMMAND_TOKENS
+
+        commandTokens += ['-f',
+                            'lavfi',
+                            '-i',
+                            f"color=size={sizeX}x{sizeY}:rate={rate}:color=black",
+                            '-f',
+                            'lavfi',
+                            '-i',
+                            'anullsrc=channel_layout=stereo:sample_rate=44100',
+                            '-t',
+                            str(length),
+                            path]
+
+        out, err, rc = executeProcess(commandTokens)

bin/ffx/file_properties.py

@@ -1,4 +1,14 @@
-import os, re, click
+import os, re, click, json
+
+from .media_descriptor import MediaDescriptor
+from .pattern_controller import PatternController
+
+from .process import executeProcess
+
+from ffx.model.pattern import Pattern
+from ffx.ffx_controller import FfxController
+from ffx.show_descriptor import ShowDescriptor
+
 
 class FileProperties():
 
@@ -7,15 +17,23 @@ class FileProperties():
     SEASON_EPISODE_INDICATOR_MATCH = '[sS]([0-9]+)[eE]([0-9]+)' 
     EPISODE_INDICATOR_MATCH = '[eE]([0-9]+)'
 
-    def ___init__(self, sourcePath, ):
+    DEFAULT_INDEX_DIGITS = 3
 
+    def __init__(self, context, sourcePath):
+
+        self.context = context
+
+        self.__logger = context['logger']
 
         # Separate basedir, basename and extension for current source file
-        self.__sourceDirectory = os.path.dirname(sourcePath)
+        self.__sourcePath = sourcePath
-        self.__sourceFilename = os.path.basename(sourcePath)
+
+        self.__sourceDirectory = os.path.dirname(self.__sourcePath)
+        self.__sourceFilename = os.path.basename(self.__sourcePath)
+
         sourcePathTokens = self.__sourceFilename.split('.')
 
-        if sourcePathTokens[-1] in FilenameController.FILE_EXTENSIONS:
+        if sourcePathTokens[-1] in FileProperties.FILE_EXTENSIONS:
             self.__sourceFileBasename = '.'.join(sourcePathTokens[:-1])
             self.__sourceFilenameExtension = sourcePathTokens[-1]
         else:
@@ -23,44 +41,217 @@ class FileProperties():
             self.__sourceFilenameExtension = ''
 
 
-        se_match = re.compile(FilenameController.SEASON_EPISODE_INDICATOR_MATCH)
+        self.__pc = PatternController(context)
-        e_match = re.compile(FilenameController.EPISODE_INDICATOR_MATCH)
 
-        se_result = se_match.search(self.__sourceFilename)
+        # db pattern boruto_[sS]([0-9]+)[eE]([0-9]+).mkv
-        e_result = e_match.search(self.__sourceFilename)
 
+        # Checking if database contains matching pattern
+        matchResult = self.__pc.matchFilename(self.__sourceFilename)
+
+        self.__logger.debug(f"FileProperties.__init__(): Match result {matchResult}")
+        
+        self.__pattern: Pattern = matchResult['pattern'] if matchResult else None
+
+        if matchResult:
+            databaseMatchedGroups = matchResult['match'].groups()
+            self.__season = databaseMatchedGroups[0]
+            self.__episode = databaseMatchedGroups[1]
+ 
+        else:
+            self.__logger.debug(f"FileProperties.__init__(): Checking file name for indicator {self.__sourceFilename}")
+
+            se_match = re.search(FileProperties.SEASON_EPISODE_INDICATOR_MATCH, self.__sourceFilename)
+            e_match = re.search(FileProperties.EPISODE_INDICATOR_MATCH, self.__sourceFilename)
+
+            if se_match is not None:
+                self.__season = int(se_match.group(1))
+                self.__episode = int(se_match.group(2))
+            elif e_match is not None:
+                self.__season = -1
+                self.__episode = int(e_match.group(1))
+            else:
                 self.__season = -1
                 self.__episode = -1
-        file_index = 0
 
-        if se_result is not None:
+
-            self.__season = int(se_result.group(1))
+    def getFormatData(self):
-            self.__episode = int(se_result.group(2))
+        """
-        elif e_result is not None:
+        "format": {
-            self.__episode = int(e_result.group(1))
+            "filename": "Downloads/nagatoro_s02/nagatoro_s01e02.mkv",
+            "nb_streams": 18,
+            "nb_programs": 0,
+            "nb_stream_groups": 0,
+            "format_name": "matroska,webm",
+            "format_long_name": "Matroska / WebM",
+            "start_time": "0.000000",
+            "duration": "1420.063000",
+            "size": "1489169824",
+            "bit_rate": "8389316",
+            "probe_score": 100,
+            "tags": {
+                "PUBLISHER": "Crunchyroll",
+                "ENCODER": "Lavf58.29.100"
+            }
+        }       
+        """
+
+        ffprobeOutput, ffprobeError, returnCode = executeProcess(["ffprobe",
+                                                        "-hide_banner",
+                                                        "-show_format",
+                                                        "-of", "json",
+                                                        self.__sourcePath])
+
+
+        if 'Invalid data found when processing input' in ffprobeError:
+            raise Exception(f"File {self.__sourcePath} does not contain valid stream data")
+
+
+        if returnCode != 0:
+            raise Exception(f"ffprobe returned with error {returnCode}")
+
+
+        return json.loads(ffprobeOutput)['format']
+
+    #[{'index': 0, 'codec_name': 'vp9', 'codec_long_name': 'Google VP9', 'profile': 'Profile 0', 'codec_type': 'video', 'codec_tag_string': '[0][0][0][0]', 'codec_tag': '0x0000', 'width': 1920, 'height': 1080, 'coded_width': 1920, 'coded_height': 1080, 'closed_captions': 0, 'film_grain': 0, 'has_b_frames': 0, 'sample_aspect_ratio': '1:1', 'display_aspect_ratio': '16:9', 'pix_fmt': 'yuv420p', 'level': -99, 'color_range': 'tv', 'chroma_location': 'left', 'field_order': 'progressive', 'refs': 1, 'r_frame_rate': '24000/1001', 'avg_frame_rate': '24000/1001', 'time_base': '1/1000', 'start_pts': 0, 'start_time': '0.000000', 'disposition': {'default': 1, 'dub': 0, 'original': 0, 'comment': 0, 'lyrics': 0, 'karaoke': 0, 'forced': 0, 'hearing_impaired': 0, 'visual_impaired': 0, 'clean_effects': 0, 'attached_pic': 0, 'timed_thumbnails': 0, 'non_diegetic': 0, 'captions': 0, 'descriptions': 0, 'metadata': 0, 'dependent': 0, 'still_image': 0}, 'tags': {'BPS': '7974017', 'NUMBER_OF_FRAMES': '34382', 'NUMBER_OF_BYTES': '1429358655', '_STATISTICS_WRITING_APP': "mkvmerge v63.0.0 ('Everything') 64-bit", '_STATISTICS_WRITING_DATE_UTC': '2023-10-07 13:59:46', '_STATISTICS_TAGS': 'BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES', 'ENCODER': 'Lavc61.3.100 libvpx-vp9', 'DURATION': '00:23:54.016000000'}}]
+    #[{'index': 1, 'codec_name': 'opus', 'codec_long_name': 'Opus (Opus Interactive Audio Codec)', 'codec_type': 'audio', 'codec_tag_string': '[0][0][0][0]', 'codec_tag': '0x0000', 'sample_fmt': 'fltp', 'sample_rate': '48000', 'channels': 2, 'channel_layout': 'stereo', 'bits_per_sample': 0, 'initial_padding': 312, 'r_frame_rate': '0/0', 'avg_frame_rate': '0/0', 'time_base': '1/1000', 'start_pts': -7, 'start_time': '-0.007000', 'extradata_size': 19, 'disposition': {'default': 1, 'dub': 0, 'original': 0, 'comment': 0, 'lyrics': 0, 'karaoke': 0, 'forced': 0, 'hearing_impaired': 0, 'visual_impaired': 0, 'clean_effects': 0, 'attached_pic': 0, 'timed_thumbnails': 0, 'non_diegetic': 0, 'captions': 0, 'descriptions': 0, 'metadata': 0, 'dependent': 0, 'still_image': 0}, 'tags': {'language': 'jpn', 'title': 'Japanisch', 'BPS': '128000', 'NUMBER_OF_FRAMES': '61763', 'NUMBER_OF_BYTES': '22946145', '_STATISTICS_WRITING_APP': "mkvmerge v63.0.0 ('Everything') 64-bit", '_STATISTICS_WRITING_DATE_UTC': '2023-10-07 13:59:46', '_STATISTICS_TAGS': 'BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES', 'ENCODER': 'Lavc61.3.100 libopus', 'DURATION': '00:23:54.141000000'}}]
+
+    #[{'index': 2, 'codec_name': 'webvtt', 'codec_long_name': 'WebVTT subtitle', 'codec_type': 'subtitle', 'codec_tag_string': '[0][0][0][0]', 'codec_tag': '0x0000', 'r_frame_rate': '0/0', 'avg_frame_rate': '0/0', 'time_base': '1/1000', 'start_pts': -7, 'start_time': '-0.007000', 'duration_ts': 1434141, 'duration': '1434.141000', 'disposition': {'default': 1, 'dub': 0, 'original': 0, 'comment': 0, 'lyrics': 0, 'karaoke': 0, 'forced': 0, 'hearing_impaired': 0, 'visual_impaired': 0, 'clean_effects': 0, 'attached_pic': 0, 'timed_thumbnails': 0, 'non_diegetic': 0, 'captions': 0, 'descriptions': 0, 'metadata': 0, 'dependent': 0, 'still_image': 0}, 'tags': {'language': 'ger', 'title': 'Deutsch [Full]', 'BPS': '118', 'NUMBER_OF_FRAMES': '300', 'NUMBER_OF_BYTES': '21128', '_STATISTICS_WRITING_APP': "mkvmerge v63.0.0 ('Everything') 64-bit", '_STATISTICS_WRITING_DATE_UTC': '2023-10-07 13:59:46', '_STATISTICS_TAGS': 'BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES', 'ENCODER': 'Lavc61.3.100 webvtt', 'DURATION': '00:23:54.010000000'}}, {'index': 3, 'codec_name': 'webvtt', 'codec_long_name': 'WebVTT subtitle', 'codec_type': 'subtitle', 'codec_tag_string': '[0][0][0][0]', 'codec_tag': '0x0000', 'r_frame_rate': '0/0', 'avg_frame_rate': '0/0', 'time_base': '1/1000', 'start_pts': -7, 'start_time': '-0.007000', 'duration_ts': 1434141, 'duration': '1434.141000', 'disposition': {'default': 0, 'dub': 0, 'original': 0, 'comment': 0, 'lyrics': 0, 'karaoke': 0, 'forced': 0, 'hearing_impaired': 0, 'visual_impaired': 0, 'clean_effects': 0, 'attached_pic': 0, 'timed_thumbnails': 0, 'non_diegetic': 0, 'captions': 0, 'descriptions': 0, 'metadata': 0, 'dependent': 0, 'still_image': 0}, 'tags': {'language': 'eng', 'title': 'Englisch [Full]', 'BPS': '101', 'NUMBER_OF_FRAMES': '276', 'NUMBER_OF_BYTES': '16980', '_STATISTICS_WRITING_APP': "mkvmerge v63.0.0 ('Everything') 64-bit", '_STATISTICS_WRITING_DATE_UTC': '2023-10-07 13:59:46', '_STATISTICS_TAGS': 'BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES', 'ENCODER': 'Lavc61.3.100 webvtt', 'DURATION': '00:23:53.230000000'}}]
+
+
+    def getStreamData(self):
+        """Returns ffprobe stream data as array with elements according to the following example      
+        {
+            "index": 4,
+            "codec_name": "hdmv_pgs_subtitle",
+            "codec_long_name": "HDMV Presentation Graphic Stream subtitles",
+            "codec_type": "subtitle",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/1000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration_ts": 1421035,
+            "duration": "1421.035000",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0,
+                "non_diegetic": 0,
+                "captions": 0,
+                "descriptions": 0,
+                "metadata": 0,
+                "dependent": 0,
+                "still_image": 0
+            },
+            "tags": {
+                "language": "ger",
+                "title": "German Full"
+            }
+        }
+        """
+
+
+        ffprobeOutput, ffprobeError, returnCode = executeProcess(["ffprobe",
+                                                        "-hide_banner",
+                                                        "-show_streams",
+                                                        "-of", "json",
+                                                        self.__sourcePath])
+
+        if 'Invalid data found when processing input' in ffprobeError:
+            raise Exception(f"File {self.__sourcePath} does not contain valid stream data")
+
+
+        if returnCode != 0:
+            raise Exception(f"ffprobe returned with error {returnCode}")
+
+
+        return json.loads(ffprobeOutput)['streams']
+
+
+    def getMediaDescriptor(self):
+        return MediaDescriptor.fromFfprobe(self.context, self.getFormatData(), self.getStreamData())
+
+
+    def getShowId(self) -> int:
+        """Result is -1 if the filename did not match anything in database"""
+        return self.__pattern.getShowId() if self.__pattern is not None else -1
+
+    def getPattern(self) -> Pattern:
+        """Result is None if the filename did not match anything in database"""
+        return self.__pattern
+
+
+    def getSeason(self):
+        return int(self.__season)
+
+    def getEpisode(self):
+        return int(self.__episode)
+
+
+    def getFilename(self):
+        return self.__sourceFilename
+
+    def getFileBasename(self):
+        return self.__sourceFileBasename
+
+
+    def assembleTargetFileBasename(self,
+                                label: str = "",
+                                quality: int = -1,
+                                fileIndex: int = -1,
+                                indexDigits: int = DEFAULT_INDEX_DIGITS,
+                                extraTokens: list = []):
+
+        if 'show_descriptor' in self.context.keys():
+            season_digits = self.context['show_descriptor'][ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY]
+            episode_digits = self.context['show_descriptor'][ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY]
         else:
-            file_index += 1
+            season_digits = ShowDescriptor.DEFAULT_INDICATOR_SEASON_DIGITS
+            episode_digits = ShowDescriptor.DEFAULT_INDICATOR_EPISODE_DIGITS
 
-
-
-        matchingFileSubtitleDescriptors = sorted([d for d in availableFileSubtitleDescriptors if d['season'] == season and d['episode'] == episode], key=lambda d: d['stream'])  if availableFileSubtitleDescriptors else []
-
-        print(f"season={season} episode={episode} file={file_index}")
-
-
-        # Assemble target filename tokens
         targetFilenameTokens = []
-        targetFilenameExtension = DEFAULT_FILE_EXTENSION
+
+        # targetFilenameExtension = FfxController.DEFAULT_FILE_EXTENSION if extension is None else str(extension)
+
+        click.echo(f"assembleTargetFileBasename(): label={label} is {'truthy' if label else 'falsy'}")
 
         if label:
+
             targetFilenameTokens = [label]
 
-            if season > -1 and episode > -1:
+            if fileIndex > -1:
-                targetFilenameTokens += [f"S{season:0{season_digits}d}E{episode:0{episode_digits}d}"]
+                targetFilenameTokens += [f"{fileIndex:0{indexDigits}d}"]
-            elif episode > -1:
+            elif self.__season > -1 and self.__episode > -1:
-                targetFilenameTokens += [f"E{episode:0{episode_digits}d}"]
+                targetFilenameTokens += [f"S{self.__season:0{season_digits}d}E{self.__episode:0{episode_digits}d}"]
-            else:
+            elif self.__episode > -1:
-                targetFilenameTokens += [f"{file_index:0{index_digits}d}"]
+                targetFilenameTokens += [f"E{self.__episode:0{episode_digits}d}"]
 
         else:                
-            targetFilenameTokens = [sourceFileBasename]
+            targetFilenameTokens = [self.__sourceFileBasename]
+
+
+        if quality != -1:
+            targetFilenameTokens += [f"q{quality}"]
+
+        # In case source and target filenames are the same add an extension to distinct output from input
+        #if not label and self.__sourceFilenameExtension == targetFilenameExtension:
+        #    targetFilenameTokens += ['ffx']
+        targetFilenameTokens += extraTokens
+
+        targetFilename = '_'.join(targetFilenameTokens)
+
+        #self.__logger.debug(f"assembleTargetFileBasename(): Target filename: {targetFilename}")
+        click.echo(f"assembleTargetFileBasename(): Target filename: {targetFilename}")
+
+        return targetFilename

bin/ffx/helper.py

@@ -0,0 +1,61 @@
+import click
+
+DIFF_ADDED_KEY = 'added'
+DIFF_REMOVED_KEY = 'removed'
+DIFF_CHANGED_KEY = 'changed'
+DIFF_UNCHANGED_KEY = 'unchanged'
+
+def dictDiff(a : dict, b : dict):
+
+    a_keys = set(a.keys())
+    b_keys = set(b.keys())
+
+    a_only = a_keys - b_keys
+    b_only = b_keys - a_keys
+    a_b = a_keys & b_keys
+
+    changed = {k for k in a_b if a[k] != b[k]}
+
+    diffResult = {}
+
+
+    if a_only:
+        diffResult[DIFF_REMOVED_KEY] = a_only
+        diffResult[DIFF_UNCHANGED_KEY] = b_keys
+    if b_only:
+        diffResult[DIFF_ADDED_KEY] = b_only
+    if changed:
+        diffResult[DIFF_CHANGED_KEY] = changed
+
+    return diffResult
+
+def dictCache(element: dict, cache: list = []):
+    for index in range(len(cache)):
+        diff = dictDiff(cache[index], element)
+        if not diff:
+            return index, cache
+    cache.append(element)
+    return -1, cache
+
+
+def setDiff(a : set, b : set) -> set:
+
+    a_only = a - b
+    b_only = b - a
+
+    diffResult = {}
+
+    if a_only:
+        diffResult[DIFF_REMOVED_KEY] = a_only
+    if b_only:
+        diffResult[DIFF_ADDED_KEY] = b_only
+
+    return diffResult
+
+
+def filterFilename(fileName: str) -> str:
+    """This filter replaces charactes from TMDB responses with characters
+    less problemating when using in filenames or removes them"""
+
+    fileName = str(fileName).replace(':', ';')
+    return fileName

bin/ffx/iso_language.py

@@ -73,6 +73,8 @@ class IsoLanguage(Enum):
     VIETNAMESE      = {"name": "Vietnamese", "iso639_1": "vi", "iso639_2": "vie"}
     WELSH           = {"name": "Welsh", "iso639_1": "cy", "iso639_2": "wel"}
 
+    UNDEFINED       = {"name": "undefined", "iso639_1": "xx", "iso639_2": "und"}
+
 
     @staticmethod
     def find(label : str):
@@ -81,25 +83,16 @@ class IsoLanguage(Enum):
 
         if closestMatches:
             foundLangs = [l for l in IsoLanguage if l.value['name'] == closestMatches[0]]
-            return foundLangs[0] if foundLangs else None
+            return foundLangs[0] if foundLangs else IsoLanguage.UNDEFINED
         else:
-            return None
+            return IsoLanguage.UNDEFINED
 
     @staticmethod
     def findThreeLetter(theeLetter : str):
         foundLangs = [l for l in IsoLanguage if l.value['iso639_2'] == str(theeLetter)]
-        return foundLangs[0] if foundLangs else None
+        return foundLangs[0] if foundLangs else IsoLanguage.UNDEFINED
 
 
-# def get(lang : str):
-# 
-#     selectedLangs = [l for l in IsoLanguage if l.value['iso639_2'] == lang]
-# 
-#     if selectedLangs:
-#         return selectedLangs[0]
-#     else:
-#         return None
-
     def label(self):
         return str(self.value['name'])
 

bin/ffx/media_controller.py

@@ -0,0 +1,47 @@
+import click, re
+
+from ffx.model.pattern import Pattern
+from ffx.media_descriptor import MediaDescriptor
+
+from ffx.tag_controller import TagController
+from ffx.track_controller import TrackController
+
+class MediaController():
+    
+    def __init__(self, context):
+        
+        self.context = context
+        self.Session = self.context['database']['session'] # convenience
+
+        self.__logger = context['logger']
+
+        self.__tc = TrackController(context = context)
+        self.__tac = TagController(context = context)
+
+    def setPatternMediaDescriptor(self, mediaDescriptor: MediaDescriptor, patternId: int):
+
+        try:
+
+            pid = int(patternId)
+
+            s = self.Session()
+            q = s.query(Pattern).filter(Pattern.id == pid)
+
+            if q.count():
+                pattern = q.first
+
+                for mediaTagKey, mediaTagValue in mediaDescriptor.getTags():
+                    self.__tac.updateMediaTag(pid, mediaTagKey, mediaTagValue)
+                for trackDescriptor in mediaDescriptor.getAllTrackDescriptors():
+                    self.__tc.addTrack(trackDescriptor, patternId = pid)
+
+                s.commit()
+                return True
+            else:
+                return False
+
+        except Exception as ex:
+            self.__logger.error(f"MediaController.setPatternMediaDescriptor(): {repr(ex)}")
+            raise click.ClickException(f"MediaController.setPatternMediaDescriptor(): {repr(ex)}")
+        finally:
+            s.close()

bin/ffx/media_descriptor.py

@@ -1,2 +1,511 @@
-class MediaDescriptor():
+import os, re, click, logging
-    pass
+
+from typing import List, Self
+
+from ffx.track_type import TrackType
+from ffx.track_disposition import TrackDisposition
+
+from ffx.track_descriptor import TrackDescriptor
+
+from ffx.helper import dictDiff, DIFF_ADDED_KEY, DIFF_CHANGED_KEY, DIFF_REMOVED_KEY
+
+
+class MediaDescriptor:
+    """This class represents the structural content of a media file including streams and metadata"""
+
+    CONTEXT_KEY = "context"
+
+    TAGS_KEY = "tags"
+    TRACKS_KEY = "tracks"
+
+    TRACK_DESCRIPTOR_LIST_KEY = "track_descriptors"
+    CLEAR_TAGS_FLAG_KEY = "clear_tags"
+
+    FFPROBE_DISPOSITION_KEY = "disposition"
+    FFPROBE_TAGS_KEY = "tags"
+    FFPROBE_CODEC_TYPE_KEY = "codec_type"
+
+    # JELLYFIN_ORDER_FLAG_KEY = "jellyfin_order"
+
+    EXCLUDED_MEDIA_TAGS = ["creation_time"]
+
+    SEASON_EPISODE_STREAM_LANGUAGE_MATCH = '[sS]([0-9]+)[eE]([0-9]+)_([0-9]+)_([a-z]{3})'
+    SUBTITLE_FILE_EXTENSION = 'vtt'
+
+    def __init__(self, **kwargs):
+
+        if MediaDescriptor.CONTEXT_KEY in kwargs.keys():
+            if type(kwargs[MediaDescriptor.CONTEXT_KEY]) is not dict:
+                raise TypeError(
+                    f"MediaDescriptor.__init__(): Argument {MediaDescriptor.CONTEXT_KEY} is required to be of type dict"
+                )
+            self.__context = kwargs[MediaDescriptor.CONTEXT_KEY]
+            self.__logger = self.__context['logger']
+        else:
+            self.__context = {}
+            self.__logger = logging.getLogger('FFX').addHandler(logging.NullHandler())
+
+        if MediaDescriptor.TAGS_KEY in kwargs.keys():
+            if type(kwargs[MediaDescriptor.TAGS_KEY]) is not dict:
+                raise TypeError(
+                    f"MediaDescriptor.__init__(): Argument {MediaDescriptor.TAGS_KEY} is required to be of type dict"
+                )
+            self.__mediaTags = kwargs[MediaDescriptor.TAGS_KEY]
+        else:
+            self.__mediaTags = {}
+
+        if MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY in kwargs.keys():
+            if (
+                type(kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY]) is not list
+            ):  # Use List typehint for TrackDescriptor as well if it works
+                raise TypeError(
+                    f"MediaDescriptor.__init__(): Argument {MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY} is required to be of type list"
+                )
+            for d in kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY]:
+                if type(d) is not TrackDescriptor:
+                    raise TypeError(
+                        f"TrackDesciptor.__init__(): All elements of argument list {MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY} are required to be of type TrackDescriptor"
+                    )
+            self.__trackDescriptors = kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY]
+        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
+        self.__jellyfinOrder = self.__context['use_jellyfin'] if 'use_jellyfin' in self.__context.keys() else False
+
+
+    def setDefaultSubTrack(self, trackType: TrackType, subIndex: int):
+        for t in self.getAllTrackDescriptors():
+            if t.getType() == trackType:
+                t.setDispositionFlag(
+                    TrackDisposition.DEFAULT, t.getSubIndex() == int(subIndex)
+                )
+
+    def setForcedSubTrack(self, trackType: TrackType, subIndex: int):
+        for t in self.getAllTrackDescriptors():
+            if t.getType() == trackType:
+                t.setDispositionFlag(
+                    TrackDisposition.FORCED, t.getSubIndex() == int(subIndex)
+                )
+
+    def checkConfiguration(self):
+
+        videoTracks = self.getVideoTracks()
+        audioTracks = self.getAudioTracks()
+        subtitleTracks = self.getSubtitleTracks()
+        
+        if len([v for v in videoTracks if v.getDispositionFlag(TrackDisposition.DEFAULT)]) > 1:
+            raise ValueError('More than one default video track')
+        if len([a for a in audioTracks if a.getDispositionFlag(TrackDisposition.DEFAULT)]) > 1:
+            raise ValueError('More than one default audio track')
+        if len([s for s in subtitleTracks if s.getDispositionFlag(TrackDisposition.DEFAULT)]) > 1:
+            raise ValueError('More than one default subtitle track')
+
+        if len([v for v in videoTracks if v.getDispositionFlag(TrackDisposition.FORCED)]) > 1:
+            raise ValueError('More than one forced video track')
+        if len([a for a in audioTracks if a.getDispositionFlag(TrackDisposition.FORCED)]) > 1:
+            raise ValueError('More than one forced audio track')
+        if len([s for s in subtitleTracks if s.getDispositionFlag(TrackDisposition.FORCED)]) > 1:
+            raise ValueError('More than one forced subtitle track')
+
+        trackDescriptors = videoTracks + audioTracks + subtitleTracks
+        sourceIndices = [
+            t.getSourceIndex() for t in trackDescriptors
+        ]
+        if len(set(sourceIndices)) < len(trackDescriptors):
+            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"""
+
+        # videoTracks = self.sortSubIndices(self.getVideoTracks())
+        # audioTracks = self.sortSubIndices(self.getAudioTracks())
+        # subtitleTracks = self.sortSubIndices(self.getSubtitleTracks())
+
+        self.checkConfiguration()
+
+        # from self.__trackDescriptors
+        videoTracks = self.getVideoTracks()
+        audioTracks = self.getAudioTracks()
+        subtitleTracks = self.getSubtitleTracks()
+
+        defaultVideoTracks = [v for v in videoTracks if v.getDispositionFlag(TrackDisposition.DEFAULT)]
+        defaultAudioTracks = [a for a in audioTracks if a.getDispositionFlag(TrackDisposition.DEFAULT)]
+        defaultSubtitleTracks = [s for s in subtitleTracks if s.getDispositionFlag(TrackDisposition.DEFAULT)]
+
+        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()
+        self.reindexIndices()
+
+
+    @classmethod
+    def fromFfprobe(cls, context, formatData, streamData):
+
+        kwargs = {}
+
+        kwargs[MediaDescriptor.CONTEXT_KEY] = context
+
+        if MediaDescriptor.FFPROBE_TAGS_KEY in formatData.keys():
+            kwargs[MediaDescriptor.TAGS_KEY] = formatData[
+                MediaDescriptor.FFPROBE_TAGS_KEY
+            ]
+
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = []
+
+        # TODO: Evtl obsolet
+        subIndexCounters = {}
+
+        for streamObj in streamData:
+
+            ffprobeCodecType = streamObj[MediaDescriptor.FFPROBE_CODEC_TYPE_KEY]
+            trackType = TrackType.fromLabel(ffprobeCodecType)
+
+            if trackType != TrackType.UNKNOWN:
+
+                if trackType not in subIndexCounters.keys():
+                    subIndexCounters[trackType] = 0
+
+                kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY].append(
+                    TrackDescriptor.fromFfprobe(
+                        streamObj, subIndex=subIndexCounters[trackType]
+                    )
+                )
+                subIndexCounters[trackType] += 1
+
+        return cls(**kwargs)
+
+    def getTags(self):
+        return self.__mediaTags
+
+
+    def sortSubIndices(
+        self, descriptors: List[TrackDescriptor]
+    ) -> List[TrackDescriptor]:
+        subIndex = 0
+        for d in descriptors:
+            d.setSubIndex(subIndex)
+            subIndex += 1
+        return descriptors
+
+    def reindexSubIndices(self, trackDescriptors: list = []):
+        tdList = trackDescriptors if trackDescriptors else self.__trackDescriptors
+        subIndexCounter = {}
+        for td in tdList:
+            trackType = td.getType()
+            if trackType not in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            td.setSubIndex(subIndexCounter[trackType])
+            subIndexCounter[trackType] += 1
+
+    def sortIndices(
+        self, descriptors: List[TrackDescriptor]
+    ) -> List[TrackDescriptor]:
+        index = 0
+        for d in descriptors:
+            d.setIndex(index)
+            index += 1
+        return descriptors
+
+    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]:
+        return self.getVideoTracks() + self.getAudioTracks() + self.getSubtitleTracks()
+
+    def getVideoTracks(self) -> List[TrackDescriptor]:
+        return [
+            v for v in self.__trackDescriptors if v.getType() == TrackType.VIDEO
+        ]
+
+    def getAudioTracks(self) -> List[TrackDescriptor]:
+        return [
+            a for a in self.__trackDescriptors if a.getType() == TrackType.AUDIO
+        ]
+
+    def getSubtitleTracks(self) -> List[TrackDescriptor]:
+        return [
+            s
+            for s in self.__trackDescriptors
+            if s.getType() == TrackType.SUBTITLE
+        ]
+
+
+    def compare(self, vsMediaDescriptor: Self):
+
+        if not isinstance(vsMediaDescriptor, self.__class__):
+            errorMessage = f"MediaDescriptor.compare(): Argument is required to be of type {self.__class__}"
+            self.__logger.error(errorMessage)
+            # raise click.ClickException(errorMessage)
+            click.Abort()
+
+        vsTags = vsMediaDescriptor.getTags()
+        tags = self.getTags()
+
+        # HINT: Some tags differ per file, for example creation_time, so these are removed before diff
+        for emt in MediaDescriptor.EXCLUDED_MEDIA_TAGS:
+            if emt in tags.keys():
+                del tags[emt]
+            if emt in vsTags.keys():
+                del vsTags[emt]
+
+        tagsDiff = dictDiff(vsTags, tags)
+
+        compareResult = {}
+
+        if tagsDiff:
+            compareResult[MediaDescriptor.TAGS_KEY] = tagsDiff
+
+        # Target track configuration (from DB)
+        # tracks = self.getAllTrackDescriptors()
+        tracks = self.getAllTrackDescriptors() # filtern
+        numTracks = len(tracks)
+
+        # Current track configuration (of file)
+        vsTracks = vsMediaDescriptor.getAllTrackDescriptors()
+        numVsTracks = len(vsTracks)
+
+        maxNumOfTracks = max(numVsTracks, numTracks)
+
+        trackCompareResult = {}
+
+        for tp in range(maxNumOfTracks):
+
+            # inspect/update funktionier nur so
+            if self.__jellyfinOrder:
+                vsTrackIndex = tracks[tp].getSourceIndex()
+            else:
+                vsTrackIndex = tp
+            # vsTrackIndex = tracks[tp].getSourceIndex()
+
+            # Will trigger if tracks are missing in file
+            if tp > (numVsTracks - 1):
+                if DIFF_ADDED_KEY not in trackCompareResult.keys():
+                    trackCompareResult[DIFF_ADDED_KEY] = set()
+                trackCompareResult[DIFF_ADDED_KEY].add(tracks[tp].getIndex())
+                continue
+
+            # Will trigger if tracks are missing in DB definition
+            # New tracks will be added per update via this way
+            if tp > (numTracks - 1):
+                if DIFF_REMOVED_KEY not in trackCompareResult.keys():
+                    trackCompareResult[DIFF_REMOVED_KEY] = {}
+                trackCompareResult[DIFF_REMOVED_KEY][
+                    vsTracks[vsTrackIndex].getIndex()
+                ] = vsTracks[vsTrackIndex]
+                continue
+
+            # assumption is made here that the track order will not change for all files of a sequence
+            trackDiff = tracks[tp].compare(vsTracks[vsTrackIndex])
+
+            if trackDiff:
+                if DIFF_CHANGED_KEY not in trackCompareResult.keys():
+                    trackCompareResult[DIFF_CHANGED_KEY] = {}
+                trackCompareResult[DIFF_CHANGED_KEY][
+                    vsTracks[vsTrackIndex].getIndex()
+                ] = trackDiff
+
+        if trackCompareResult:
+            compareResult[MediaDescriptor.TRACKS_KEY] = trackCompareResult
+
+        return compareResult
+
+
+    def getImportFileTokens(self, use_sub_index: bool = True):
+
+        # reorderedTrackDescriptors = self.getReorderedTrackDescriptors()
+        importFileTokens = []
+
+        #for rtd in reorderedTrackDescriptors:
+        for td in self.__trackDescriptors:
+
+            importedFilePath = td.getExternalSourceFilePath()
+
+            if importedFilePath:
+                importFileTokens += [
+                    "-i",
+                    importedFilePath,
+                ]
+
+        return importFileTokens
+
+
+    def getInputMappingTokens(self, use_sub_index: bool = True, only_video: bool = False):
+        """Tracks must be reordered for source index order"""
+
+        # 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 trackIndex in range(len(self.__trackDescriptors)):
+
+            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 = td.getExternalSourceFilePath()
+
+                if use_sub_index:
+
+                    if importedFilePath:
+
+                        inputMappingTokens += [
+                            "-map",
+                            f"{filePointer}:{trackType.indicator()}:0",
+                        ]
+                        filePointer += 1
+
+                    else:
+
+                        if td.getCodec() != TrackDescriptor.CODEC_PGS:
+                            inputMappingTokens += [
+                                "-map",
+                                f"0:{trackType.indicator()}:{stdsi}",
+                            ]
+
+                else:
+                    if td.getCodec() != TrackDescriptor.CODEC_PGS:
+                        inputMappingTokens += ["-map", f"0:{stdi}"]
+
+        return inputMappingTokens
+
+
+    def searchSubtitleFiles(self, searchDirectory, prefix):
+
+        sesl_match = re.compile(MediaDescriptor.SEASON_EPISODE_STREAM_LANGUAGE_MATCH)
+
+        subtitleFileDescriptors = []
+        for subtitleFilename in os.listdir(searchDirectory):
+            if subtitleFilename.startswith(prefix) and subtitleFilename.endswith(
+                "." + MediaDescriptor.SUBTITLE_FILE_EXTENSION
+            ):
+                sesl_result = sesl_match.search(subtitleFilename)
+                if sesl_result is not None:
+                    subtitleFilePath = os.path.join(searchDirectory, subtitleFilename)
+                    if os.path.isfile(subtitleFilePath):
+
+                        subtitleFileDescriptor = {}
+                        subtitleFileDescriptor["path"] = subtitleFilePath
+                        subtitleFileDescriptor["season"] = int(sesl_result.group(1))
+                        subtitleFileDescriptor["episode"] = int(sesl_result.group(2))
+                        subtitleFileDescriptor["index"] = int(sesl_result.group(3))
+                        subtitleFileDescriptor["language"] = sesl_result.group(4)
+
+                        subtitleFileDescriptors.append(subtitleFileDescriptor)
+
+        self.__logger.debug(f"searchSubtitleFiles(): Available subtitle files {subtitleFileDescriptors}")
+
+        return subtitleFileDescriptors
+
+
+    def importSubtitles(self, searchDirectory, prefix, season: int = -1, episode: int = -1):
+        
+        # click.echo(f"Season: {season} Episode: {episode}")
+        self.__logger.debug(f"importSubtitles(): Season: {season} Episode: {episode}")
+
+        availableFileSubtitleDescriptors = self.searchSubtitleFiles(searchDirectory, prefix)
+        
+        # click.echo(f"availableFileSubtitleDescriptors: {availableFileSubtitleDescriptors}")
+        self.__logger.debug(f"importSubtitles(): availableFileSubtitleDescriptors: {availableFileSubtitleDescriptors}")
+
+        subtitleTracks = self.getSubtitleTracks()
+        
+        # click.echo(f"subtitleTracks: {[s.getIndex() for s in subtitleTracks]}")
+        self.__logger.debug(f"importSubtitles(): subtitleTracks: {[s.getIndex() for s in subtitleTracks]}")
+
+        # if len(availableFileSubtitleDescriptors) != len(subtitleTracks):
+        #     raise click.ClickException(f"MediaDescriptor.importSubtitles(): Number if subtitle files not matching number of subtitle tracks")
+
+        matchingSubtitleFileDescriptors = (
+            sorted(
+                [
+                    d
+                    for d in availableFileSubtitleDescriptors
+                    if d["season"] == int(season) and d["episode"] == int(episode)
+                ],
+                key=lambda d: d["index"],
+            )
+            if availableFileSubtitleDescriptors
+            else []
+        )
+
+        # click.echo(f"matchingSubtitleFileDescriptors: {matchingSubtitleFileDescriptors}")
+        self.__logger.debug(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"]]
+            if matchingSubtitleTrackDescriptor:
+                # click.echo(f"Found matching subtitle file {msfd["path"]}\n")
+                self.__logger.debug(f"importSubtitles(): Found matching subtitle file {msfd["path"]}")
+                matchingSubtitleTrackDescriptor[0].setExternalSourceFilePath(msfd["path"])
+
+
+    def getConfiguration(self, label: str = ''):
+        yield f"--- {label if label else 'MediaDescriptor '+str(id(self))} {' '.join([str(k)+'='+str(v) for k,v in self.__mediaTags.items()])}"
+        for td in self.getAllTrackDescriptors():
+            yield (f"{td.getIndex()}:{td.getType().indicator()}:{td.getSubIndex()} "
+                   + '|'.join([d.indicator() for d in td.getDispositionSet()])
+                   + ' ' + ' '.join([str(k)+'='+str(v) for k,v in td.getTags().items()]))

bin/ffx/media_details_screen.py

@@ -0,0 +1,644 @@
+import os, click, re
+
+from textual import events
+from textual.app import App, ComposeResult
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static, Button, Input, DataTable
+from textual.containers import Grid
+
+from ffx.model.show import Show
+from ffx.model.pattern import Pattern
+
+from .pattern_controller import PatternController
+from .show_controller import ShowController
+from .track_controller import TrackController
+from .tag_controller import TagController
+
+from .track_details_screen import TrackDetailsScreen
+from .track_delete_screen import TrackDeleteScreen
+from .show_details_screen import ShowDetailsScreen
+from .pattern_details_screen import PatternDetailsScreen
+
+from ffx.track_type import TrackType
+from ffx.model.track import Track
+
+from ffx.track_disposition import TrackDisposition
+from ffx.track_descriptor import TrackDescriptor
+from ffx.show_descriptor import ShowDescriptor
+
+from textual.widgets._data_table import CellDoesNotExist
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.file_properties import FileProperties
+
+from ffx.helper import DIFF_ADDED_KEY, DIFF_CHANGED_KEY, DIFF_REMOVED_KEY
+
+
+# Screen[dict[int, str, int]]
+class MediaDetailsScreen(Screen):
+
+    CSS = """
+
+    Grid {
+        grid-size: 5 8;
+        grid-rows: 8 2 2 2 8 2 2 8;
+        grid-columns: 25 25 100 10 75;
+        height: 100%;
+        width: 100%;
+        padding: 1;
+    }
+
+    Input {
+        border: none;
+    }
+    Button {
+        border: none;
+    }
+
+    DataTable {
+        min-height: 40;
+    }
+
+    #toplabel {
+        height: 1;
+    }
+    .two {
+        column-span: 2;
+    }   
+    .three {
+        column-span: 3;
+    }
+    
+    .four {
+        column-span: 4;
+    }
+    .five {
+        column-span: 5;
+    }
+
+    .triple {
+        row-span: 3;
+    }
+
+    .box {
+        height: 100%;
+        border: solid green;
+    }
+
+    .yellow {
+        tint: yellow 40%;
+    }
+
+    #differences-table {
+        row-span: 8;
+        /* tint: magenta 40%; */
+    }
+
+    /* #pattern_input {
+        tint: red 40%;
+    }*/
+    """
+
+
+    BINDINGS = [
+        ("n", "new_pattern", "New Pattern"),
+        ("u", "update_pattern", "Update Pattern"),
+        ("e", "edit_pattern", "Edit Pattern"),
+    ]
+
+
+    def __init__(self):
+        super().__init__()
+
+        self.context = self.app.getContext()
+        self.Session = self.context['database']['session'] # convenience
+
+        self.__pc = PatternController(context = self.context)
+        self.__sc = ShowController(context = self.context)
+        self.__tc = TrackController(context = self.context)
+        self.__tac = TagController(context = self.context)
+
+        if not 'command' in self.context.keys() or self.context['command'] != 'inspect':
+            raise click.ClickException(f"MediaDetailsScreen.__init__(): Can only perform command 'inspect'")
+        
+        if not 'arguments' in self.context.keys() or not 'filename' in self.context['arguments'].keys() or not self.context['arguments']['filename']:
+            raise click.ClickException(f"MediaDetailsScreen.__init__(): Argument 'filename' is required to be provided for command 'inspect'")
+
+        self.__mediaFilename = self.context['arguments']['filename']
+
+        if not os.path.isfile(self.__mediaFilename):
+            raise click.ClickException(f"MediaDetailsScreen.__init__(): Media file {self.__mediaFilename} does not exist")
+
+        self.loadProperties()
+
+
+    def getRowIndexFromShowId(self, showId : int) -> int:
+        """Find the index of the row where the value in the specified column matches the target_value."""
+
+        for rowKey, row in self.showsTable.rows.items(): # dict[RowKey, Row]
+        
+            rowData = self.showsTable.get_row(rowKey)
+
+            try:
+                if showId == int(rowData[0]):
+                    return int(self.showsTable.get_row_index(rowKey))
+            except:
+                continue
+
+        return None
+
+
+    def loadProperties(self):
+
+        self.__mediaFileProperties = FileProperties(self.context, self.__mediaFilename)
+        self.__currentMediaDescriptor = self.__mediaFileProperties.getMediaDescriptor()
+
+        #HINT: This is None if the filename did not match anything in database
+        self.__currentPattern = self.__mediaFileProperties.getPattern()
+
+        # keine tags vorhanden
+        self.__targetMediaDescriptor = self.__currentPattern.getMediaDescriptor(self.context) if self.__currentPattern is not None else None
+
+        # Enumerating differences between media descriptors
+        # from file (=current) vs from stored in database (=target)
+        try:
+            self.__mediaDifferences = self.__targetMediaDescriptor.compare(self.__currentMediaDescriptor) if self.__currentPattern is not None else {}
+        except ValueError:
+            self.__mediaDifferences = {}
+
+
+    def updateDifferences(self):
+
+        self.loadProperties()
+
+        self.differencesTable.clear()
+
+        if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():
+
+            currentTags = self.__currentMediaDescriptor.getTags()
+            targetTags = self.__targetMediaDescriptor.getTags()
+
+            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for addedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
+                    row = (f"added media tag: key='{addedTagKey}' value='{targetTags[addedTagKey]}'",)
+                    self.differencesTable.add_row(*map(str, row))  
+
+            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for removedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
+                    row = (f"removed media tag: key='{removedTagKey}' value='{currentTags[removedTagKey]}'",)
+                    self.differencesTable.add_row(*map(str, row))
+
+            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for changedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
+                    row = (f"changed media tag: key='{changedTagKey}' value='{currentTags[changedTagKey]}'->'{targetTags[changedTagKey]}'",)
+                    self.differencesTable.add_row(*map(str, row))  
+
+        if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():
+
+            currentTracks = self.__currentMediaDescriptor.getAllTrackDescriptors() # 0,1,2,3
+            targetTracks = self.__targetMediaDescriptor.getAllTrackDescriptors() # 0 <- from DB
+
+            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
+
+                #raise click.ClickException(f"add track {self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]}")
+                for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
+                    addedTrack : Track = targetTracks[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 self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
+                for removedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY]:
+                    row = (f"removed track: index={removedTrackIndex}",)
+                    self.differencesTable.add_row(*map(str, row))  
+
+            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
+                for changedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].keys():
+
+                    changedTrack : Track = targetTracks[changedTrackIndex]
+                    changedTrackDiff : dict = self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY][changedTrackIndex]                        
+
+                    if MediaDescriptor.TAGS_KEY in changedTrackDiff.keys():
+
+                        if DIFF_ADDED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
+                            for addedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
+                                addedTagValue = changedTrack.getTags()[addedTagKey]
+                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added key={addedTagKey} value={addedTagValue}",)
+                                self.differencesTable.add_row(*map(str, row))  
+
+                        if DIFF_REMOVED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
+                            for removedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
+                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed key={removedTagKey}",)
+                                self.differencesTable.add_row(*map(str, row))  
+
+                    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 {changedTrack.getType().label()} track index={changedTrackIndex} added disposition={addedDisposition.label()}",)
+                                self.differencesTable.add_row(*map(str, row))  
+
+                        if DIFF_REMOVED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
+                            for removedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_REMOVED_KEY]:
+                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed disposition={removedDisposition.label()}",)
+                                self.differencesTable.add_row(*map(str, row))  
+
+
+    def on_mount(self):
+
+        if self.__currentPattern is None:
+            row = (' ', '<New show>', ' ') # Convert each element to a string before adding
+            self.showsTable.add_row(*map(str, row))
+    
+        for show in self.__sc.getAllShows():
+            row = (int(show.id), show.name, show.year) # Convert each element to a string before adding
+            self.showsTable.add_row(*map(str, row))
+
+        for mediaTagKey, mediaTagValue in self.__currentMediaDescriptor.getTags().items():
+            row = (mediaTagKey, mediaTagValue) # Convert each element to a string before adding
+            self.mediaTagsTable.add_row(*map(str, row))
+
+        self.updateTracks()
+
+
+        if self.__currentPattern is not None:
+
+            showIdentifier = self.__currentPattern.getShowId()
+            showRowIndex = self.getRowIndexFromShowId(showIdentifier)
+            if showRowIndex is not None:
+                self.showsTable.move_cursor(row=showRowIndex)
+
+            self.query_one("#pattern_input", Input).value = self.__currentPattern.getPattern()
+
+            self.updateDifferences()
+
+        else:
+
+            self.query_one("#pattern_input", Input).value = self.__mediaFilename
+            self.highlightPattern(True)
+
+
+    def highlightPattern(self, state : bool):
+        if state:
+            self.query_one("#pattern_input", Input).styles.background = 'red'
+        else:
+            self.query_one("#pattern_input", Input).styles.background = None
+
+
+    def updateTracks(self):
+
+        self.tracksTable.clear()
+
+        trackDescriptorList = self.__currentMediaDescriptor.getAllTrackDescriptors()
+
+        typeCounter = {}
+
+        for td in trackDescriptorList:
+
+            trackType = td.getType()
+            if not trackType in typeCounter.keys():
+                typeCounter[trackType] = 0
+
+            dispoSet = td.getDispositionSet()
+
+            row = (td.getIndex(),
+                    trackType.label(),
+                    typeCounter[trackType],
+                    td.getAudioLayout().label() if trackType == TrackType.AUDIO else ' ',
+                    td.getLanguage().label(),
+                    td.getTitle(),
+                    'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
+                    'Yes' if TrackDisposition.FORCED in dispoSet else 'No')
+
+            self.tracksTable.add_row(*map(str, row))
+
+            typeCounter[trackType] += 1
+
+
+    def compose(self):
+
+        # Create the DataTable widget
+        self.showsTable = DataTable(classes="two")
+
+        # Define the columns with headers
+        self.column_key_show_id = self.showsTable.add_column("ID", width=10)
+        self.column_key_show_name = self.showsTable.add_column("Name", width=50)
+        self.column_key_show_year = self.showsTable.add_column("Year", width=10)
+
+        self.showsTable.cursor_type = 'row'
+
+
+        self.mediaTagsTable = DataTable(classes="two")
+
+        # Define the columns with headers
+        self.column_key_track_tag_key = self.mediaTagsTable.add_column("Key", width=20)
+        self.column_key_track_tag_value = self.mediaTagsTable.add_column("Value", width=100)
+
+        self.mediaTagsTable.cursor_type = 'row'
+
+
+        self.tracksTable = DataTable(classes="two")
+
+        # Define the columns with headers
+        self.column_key_track_index = self.tracksTable.add_column("Index", width=5)
+        self.column_key_track_type = self.tracksTable.add_column("Type", width=10)
+        self.column_key_track_sub_index = self.tracksTable.add_column("Subindex", width=5)
+        self.column_key_track_layout = self.tracksTable.add_column("Layout", width=10)
+        self.column_key_track_language = self.tracksTable.add_column("Language", width=15)
+        self.column_key_track_title = self.tracksTable.add_column("Title", width=48)
+        self.column_key_track_default = self.tracksTable.add_column("Default", width=8)
+        self.column_key_track_forced = self.tracksTable.add_column("Forced", width=8)
+
+        self.tracksTable.cursor_type = 'row'
+
+
+        # Create the DataTable widget
+        self.differencesTable = DataTable(id='differences-table') # classes="triple"
+
+        # Define the columns with headers
+        self.column_key_differences = self.differencesTable.add_column("Differences (file->db)", width=70)
+
+        self.differencesTable.cursor_type = 'row'
+
+        yield Header()
+
+        with Grid():
+
+            # 1
+            yield Static("Show")
+            yield self.showsTable
+            yield Static(" ")
+            yield self.differencesTable
+
+            # 2
+            yield Static(" ")
+            yield Button("Substitute", id="pattern_button")
+            yield Static(" ", classes="two")
+
+            # 3
+            yield Static("Pattern")
+            yield Input(type="text", id='pattern_input', classes="two")
+
+            yield Static(" ")
+            
+            # 4
+            yield Static(" ", classes="four")
+
+            # 5
+            yield Static("Media Tags")
+            yield self.mediaTagsTable
+            yield Static(" ")
+
+            # 6
+            yield Static(" ", classes="four")
+
+            # 7
+            yield Static(" ")
+            yield Button("Set Default", id="select_default_button")
+            yield Button("Set Forced", id="select_forced_button")
+            yield Static(" ")
+            # 8
+            yield Static("Streams")
+            yield self.tracksTable
+            yield Static(" ")
+
+        yield Footer()
+
+
+    def getPatternDescriptorFromInput(self):
+        """Returns show id and pattern from corresponding inputs"""
+        patternDescriptor = {}
+        try:
+            patternDescriptor['show_id'] = self.getSelectedShowDescriptor().getId()
+            patternDescriptor['pattern'] = str(self.query_one("#pattern_input", Input).value)
+        except:
+            pass
+        return patternDescriptor
+
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+
+        if event.button.id == "pattern_button":
+
+            INDICATOR_PATTERN = '([sS][0-9]+[eE][0-9]+)'
+
+            pattern = self.query_one("#pattern_input", Input).value
+
+            patternMatch = re.search(INDICATOR_PATTERN, pattern)
+
+            if patternMatch:
+                self.query_one("#pattern_input", Input).value = pattern.replace(patternMatch.group(1), INDICATOR_PATTERN)
+
+
+        if event.button.id == "select_default_button":
+            selectedTrackDescriptor = self.getSelectedTrackDescriptor()
+            self.__currentMediaDescriptor.setDefaultSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
+            self.updateTracks()
+
+        if event.button.id == "select_forced_button":
+            selectedTrackDescriptor = self.getSelectedTrackDescriptor()
+            self.__currentMediaDescriptor.setForcedSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
+            self.updateTracks()
+
+
+    def getSelectedTrackDescriptor(self):
+        """Returns a partial track descriptor"""
+        try:
+
+            # Fetch the currently selected row when 'Enter' is pressed
+            #selected_row_index = self.table.cursor_row
+            row_key, col_key = self.tracksTable.coordinate_to_cell_key(self.tracksTable.cursor_coordinate)
+
+            if row_key is not None:
+                selected_track_data = self.tracksTable.get_row(row_key)
+
+                kwargs = {}
+                kwargs[TrackDescriptor.CONTEXT_KEY] = self.context
+                kwargs[TrackDescriptor.INDEX_KEY] = int(selected_track_data[0])
+                kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.fromLabel(selected_track_data[1])
+                kwargs[TrackDescriptor.SUB_INDEX_KEY] = int(selected_track_data[2])
+
+                return TrackDescriptor(**kwargs)
+            else:
+                return None
+
+        except CellDoesNotExist:
+            return None
+
+
+    def getSelectedShowDescriptor(self):
+
+        try:
+            # Fetch the currently selected row when 'Enter' is pressed
+            #selected_row_index = self.table.cursor_row
+            row_key, col_key = self.showsTable.coordinate_to_cell_key(self.showsTable.cursor_coordinate)
+
+            if row_key is not None:
+                selected_row_data = self.showsTable.get_row(row_key)
+
+                try:
+                    kwargs = {}
+
+                    kwargs[ShowDescriptor.ID_KEY] = int(selected_row_data[0])                    
+                    kwargs[ShowDescriptor.NAME_KEY] = str(selected_row_data[1])
+                    kwargs[ShowDescriptor.YEAR_KEY] = int(selected_row_data[2])
+
+                    return ShowDescriptor(**kwargs)   
+
+                except ValueError:
+                    return None
+
+        except CellDoesNotExist:
+            return None
+
+
+    def handle_new_pattern(self, showDescriptor: ShowDescriptor):
+
+        show = (showDescriptor.getId(), showDescriptor.getName(), showDescriptor.getYear())
+        self.showsTable.add_row(*map(str, show))
+
+        showRowIndex = self.getRowIndexFromShowId(showDescriptor.getId())
+        if showRowIndex is not None:
+            self.showsTable.move_cursor(row=showRowIndex)
+
+        patternDescriptor = self.getPatternDescriptorFromInput()
+        
+        if patternDescriptor:
+            patternId = self.__pc.addPattern(patternDescriptor)
+            if patternId:
+                self.highlightPattern(False)
+
+                for tagKey, tagValue in self.__currentMediaDescriptor.getTags().items():
+                    self.__tac.updateMediaTag(patternId, tagKey, tagValue)
+
+                for trackDescriptor in self.__currentMediaDescriptor.getAllTrackDescriptors():
+                    self.__tc.addTrack(trackDescriptor, patternId = patternId)
+
+
+    def action_new_pattern(self):
+
+        try:
+            self.__currentMediaDescriptor.checkConfiguration()
+        except ValueError:
+            return
+
+        selectedShowDescriptor = self.getSelectedShowDescriptor()
+        
+        #HINT: Callback is invoked after this method has exited. As a workaround the callback is executed directly
+        # from here with a mock-up screen result containing the necessary part of keys to perform correctly.
+        if selectedShowDescriptor is None:
+            self.app.push_screen(ShowDetailsScreen(), self.handle_new_pattern)
+        else:
+            self.handle_new_pattern(selectedShowDescriptor)
+
+
+    def action_update_pattern(self):
+        """When updating the database the actions must reverse the difference (eq to diff db->file)"""
+
+        if self.__currentPattern is not None:
+            patternDescriptor = self.getPatternDescriptorFromInput()
+            if (patternDescriptor
+                    and self.__currentPattern.getPattern() != patternDescriptor['pattern']):
+                return self.__pc.updatePattern(self.__currentPattern.getId(), patternDescriptor)
+
+        self.loadProperties()
+
+        if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():
+
+            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for addedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
+                    self.__tac.deleteMediaTagByKey(self.__currentPattern.getId(), addedTagKey)
+
+            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for removedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
+                    currentTags = self.__currentMediaDescriptor.getTags()
+                    self.__tac.updateMediaTag(self.__currentPattern.getId(), removedTagKey, currentTags[removedTagKey])
+
+            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for changedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
+                    currentTags = self.__currentMediaDescriptor.getTags()
+                    self.__tac.updateMediaTag(self.__currentPattern.getId(), changedTagKey, currentTags[changedTagKey])
+
+        if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():
+
+            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
+
+                for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
+                    targetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == addedTrackIndex]
+                    if targetTracks:
+                        self.__tc.deleteTrack(targetTracks[0].getId()) # id
+
+            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
+                for removedTrackIndex, removedTrack in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY].items():
+                    
+                    # Track per inspect/update hinzufügen
+                    self.__tc.addTrack(removedTrack, patternId = self.__currentPattern.getId())
+
+            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
+
+                # [vsTracks[tp].getIndex()] = trackDiff
+                for changedTrackIndex, changedTrackDiff in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].items():
+
+                    changedTargetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
+                    changedTargeTrackId = changedTargetTracks[0].getId() if changedTargetTracks else None
+                    changedTargetTrackIndex = changedTargetTracks[0].getIndex() if changedTargetTracks else None
+
+                    changedCurrentTracks = [t for t in self.__currentMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
+                    # changedCurrentTrackId #HINT: Undefined as track descriptors do not come from file with track_id 
+
+                    if TrackDescriptor.TAGS_KEY in changedTrackDiff.keys():
+                        changedTrackTagsDiff = changedTrackDiff[TrackDescriptor.TAGS_KEY]
+
+                        if DIFF_ADDED_KEY in changedTrackTagsDiff.keys():
+                            for addedTrackTagKey in changedTrackTagsDiff[DIFF_ADDED_KEY]:
+
+                                if changedTargetTracks:
+                                    self.__tac.deleteTrackTagByKey(changedTargeTrackId, addedTrackTagKey)
+
+                        if DIFF_REMOVED_KEY in changedTrackTagsDiff.keys():
+                            for removedTrackTagKey in changedTrackTagsDiff[DIFF_REMOVED_KEY]:
+                                if changedCurrentTracks:
+                                    self.__tac.updateTrackTag(changedTargeTrackId, removedTrackTagKey, changedCurrentTracks[0].getTags()[removedTrackTagKey])
+
+                        if DIFF_CHANGED_KEY in changedTrackTagsDiff.keys():
+                            for changedTrackTagKey in changedTrackTagsDiff[DIFF_CHANGED_KEY]:
+                                if changedCurrentTracks:
+                                    self.__tac.updateTrackTag(changedTargeTrackId, changedTrackTagKey, changedCurrentTracks[0].getTags()[changedTrackTagKey])
+
+                    if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():
+                        changedTrackDispositionDiff = changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]
+
+                        if DIFF_ADDED_KEY in changedTrackDispositionDiff.keys():
+                            for changedTrackAddedDisposition in changedTrackDispositionDiff[DIFF_ADDED_KEY]:
+                                if changedTargetTrackIndex is not None:
+                                    self.__tc.setDispositionState(self.__currentPattern.getId(), changedTargetTrackIndex, changedTrackAddedDisposition, False)
+
+                        if DIFF_REMOVED_KEY in changedTrackDispositionDiff.keys():
+                            for changedTrackRemovedDisposition in changedTrackDispositionDiff[DIFF_REMOVED_KEY]:
+                                if changedTargetTrackIndex is not None:
+                                    self.__tc.setDispositionState(self.__currentPattern.getId(), changedTargetTrackIndex, changedTrackRemovedDisposition, True)
+                    
+
+        self.updateDifferences()
+
+
+
+    def action_edit_pattern(self):
+        
+        patternDescriptor = {}
+        patternDescriptor['show_id'] = self.getSelectedShowDescriptor().getId()
+        patternDescriptor['pattern'] = self.getPatternFromInput()
+
+        if patternDescriptor['pattern']:
+
+            selectedPatternId = self.__pc.findPattern(patternDescriptor)
+            
+            if selectedPatternId is None:
+                raise click.ClickException(f"MediaDetailsScreen.action_edit_pattern(): Pattern to edit has no id")
+
+            self.app.push_screen(PatternDetailsScreen(patternId = selectedPatternId, showId = self.getSelectedShowDescriptor().getId()), self.handle_edit_pattern) # <-
+
+
+    def handle_edit_pattern(self, screenResult):
+        self.query_one("#pattern_input", Input).value = screenResult['pattern']
+        self.updateDifferences()
+

bin/ffx/model/media_tag.py

@@ -0,0 +1,28 @@
+# from typing import List
+from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, Enum
+from sqlalchemy.orm import relationship, declarative_base, sessionmaker
+
+from .show import Base
+
+
+class MediaTag(Base):
+    """
+    relationship(argument, opt1, opt2, ...)
+    argument is string of class or Mapped class of the target entity
+    backref creates a bi-directional corresponding relationship (back_populates preferred)
+    back_populates points to the corresponding relationship (the actual class attribute identifier)
+    
+    See: https://docs.sqlalchemy.org/en/(14|20)/orm/basic_relationships.html
+    """
+
+    __tablename__ = 'media_tags'
+
+    # v1.x
+    id = Column(Integer, primary_key=True)
+
+    key = Column(String)
+    value = Column(String)
+
+    # v1.x
+    pattern_id = Column(Integer, ForeignKey('patterns.id', ondelete="CASCADE"))
+    pattern = relationship('Pattern', back_populates='media_tags')

bin/ffx/model/pattern.py

@@ -1,9 +1,13 @@
+import click
+
 from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
 from sqlalchemy.orm import relationship, sessionmaker, Mapped, backref
 
-from .show import Base
+from .show import Base, Show
 from .track import Track
 
+from ffx.media_descriptor import MediaDescriptor
+from ffx.show_descriptor import ShowDescriptor
 
 class Pattern(Base):
 
@@ -19,10 +23,54 @@ class Pattern(Base):
 
     # v1.x
     show_id = Column(Integer, ForeignKey('shows.id', ondelete="CASCADE"))
-    show = relationship('Show', back_populates='patterns')
+    show = relationship(Show, back_populates='patterns', lazy='joined')
 
     # v2.0
     # show_id: Mapped[int] = mapped_column(ForeignKey("shows.id", ondelete="CASCADE"))
     # show: Mapped["Show"] = relationship(back_populates="patterns")
 
-    tracks = relationship('Track', back_populates='pattern', cascade="all, delete")
+    tracks = relationship('Track', back_populates='pattern', cascade="all, delete", lazy='joined')
+
+
+    media_tags = relationship('MediaTag', back_populates='pattern', cascade="all, delete", lazy='joined')
+
+
+    def getId(self):
+        return int(self.id)
+
+    def getShowId(self):
+        return int(self.show_id)
+
+    def getShowDescriptor(self, context) -> ShowDescriptor:
+        # click.echo(f"self.show {self.show} id={self.show_id}")
+        return self.show.getDescriptor(context)
+
+    def getId(self):
+        return int(self.id)
+
+    def getPattern(self):
+        return str(self.pattern)
+
+    def getTags(self):
+        return {str(t.key):str(t.value) for t in self.media_tags}
+
+
+    def getMediaDescriptor(self, context):
+
+        kwargs = {}
+
+        kwargs[MediaDescriptor.CONTEXT_KEY] = context
+
+        kwargs[MediaDescriptor.TAGS_KEY] = self.getTags()
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = []
+
+        # Set ordered subindices
+        subIndexCounter = {}
+        for track in self.tracks:
+            trackType = track.getType()
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY].append(track.getDescriptor(context, subIndex = subIndexCounter[trackType]))
+            subIndexCounter[trackType] += 1
+
+        return MediaDescriptor(**kwargs)

bin/ffx/model/show.py

@@ -2,6 +2,9 @@
 from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
 from sqlalchemy.orm import relationship, declarative_base, sessionmaker
 
+from ffx.show_descriptor import ShowDescriptor
+
+
 Base = declarative_base()
 
 class Show(Base):
@@ -35,7 +38,22 @@ class Show(Base):
     # v2.0
     # patterns: Mapped[List["Pattern"]] = relationship(back_populates="show", cascade="all, delete")
 
-    index_season_digits = Column(Integer, default=2)
+    index_season_digits = Column(Integer, default=ShowDescriptor.DEFAULT_INDEX_SEASON_DIGITS)
-    index_episode_digits = Column(Integer, default=2)
+    index_episode_digits = Column(Integer, default=ShowDescriptor.DEFAULT_INDEX_EPISODE_DIGITS)
-    indicator_season_digits = Column(Integer, default=2)
+    indicator_season_digits = Column(Integer, default=ShowDescriptor.DEFAULT_INDICATOR_SEASON_DIGITS)
-    indicator_episode_digits = Column(Integer, default=2)
+    indicator_episode_digits = Column(Integer, default=ShowDescriptor.DEFAULT_INDICATOR_EPISODE_DIGITS)
+
+
+    def getDescriptor(self, context):
+        
+        kwargs = {}
+        kwargs[ShowDescriptor.CONTEXT_KEY] = context
+        kwargs[ShowDescriptor.ID_KEY] = int(self.id)
+        kwargs[ShowDescriptor.NAME_KEY] = str(self.name)
+        kwargs[ShowDescriptor.YEAR_KEY] = int(self.year)
+        kwargs[ShowDescriptor.INDEX_SEASON_DIGITS_KEY] = int(self.index_season_digits)
+        kwargs[ShowDescriptor.INDEX_EPISODE_DIGITS_KEY] = int(self.index_episode_digits)
+        kwargs[ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY] = int(self.indicator_season_digits)
+        kwargs[ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY] = int(self.indicator_episode_digits)
+        
+        return ShowDescriptor(**kwargs)

bin/ffx/model/track.py

@@ -8,9 +8,12 @@ from ffx.track_type import TrackType
 
 from ffx.iso_language import IsoLanguage
 
-from ffx.model.tag import Tag
+from ffx.track_disposition import TrackDisposition
+from ffx.track_descriptor import TrackDescriptor
 
+from ffx.audio_layout import AudioLayout
 
+import click
 
 class Track(Base):
     """
@@ -29,21 +32,184 @@ class Track(Base):
 
     # P=pattern_id+sub_index+track_type
     track_type = Column(Integer) # TrackType
-    sub_index = Column(Integer)
+
+    index = Column(Integer)
+    source_index = Column(Integer)
 
     # v1.x
     pattern_id = Column(Integer, ForeignKey('patterns.id', ondelete="CASCADE"))
     pattern = relationship('Pattern', back_populates='tracks')
 
+    track_tags = relationship('TrackTag', back_populates='track', cascade="all, delete", lazy="joined")
+
+    disposition_flags = Column(Integer)
+    
+    codec_name = Column(String)
+    audio_layout = Column(Integer)
+
+
+    def __init__(self, **kwargs):
+
+        trackType = kwargs.pop('track_type', None)
+        if trackType is not None:
+            self.track_type = int(trackType)
+
+        dispositionSet = kwargs.pop(TrackDescriptor.DISPOSITION_SET_KEY, set())
+        self.disposition_flags = int(TrackDisposition.toFlags(dispositionSet))
+
+        super().__init__(**kwargs) 
+
+
+    @classmethod
+    def fromFfprobeStreamObj(cls, streamObj, patternId):
+        """{
+                'index': 4,
+                'codec_name': 'hdmv_pgs_subtitle',
+                'codec_long_name': 'HDMV Presentation Graphic Stream subtitles',
+                'codec_type': 'subtitle',
+                'codec_tag_string': '[0][0][0][0]',
+                'codec_tag': '0x0000',
+                'r_frame_rate': '0/0',
+                'avg_frame_rate': '0/0',
+                'time_base': '1/1000',
+                'start_pts': 0,
+                'start_time': '0.000000',
+                'duration_ts': 1421035,
+                'duration': '1421.035000',
+                'disposition': {
+                    'default': 1,
+                    'dub': 0,
+                    'original': 0,
+                    'comment': 0,
+                    'lyrics': 0,
+                    'karaoke': 0,
+                    'forced': 0,
+                    'hearing_impaired': 0,
+                    'visual_impaired': 0,
+                    'clean_effects': 0,
+                    'attached_pic': 0,
+                    'timed_thumbnails': 0,
+                    'non_diegetic': 0,
+                    'captions': 0,
+                    'descriptions': 0,
+                    'metadata': 0,
+                    'dependent': 0,
+                    'still_image': 0
+                },
+                'tags': {
+                    'language': 'ger',
+                    'title': 'German Full'
+                }
+        }
+        
+
+        # v1.x
+        id = Column(Integer, primary_key=True, autoincrement = True)
+
+        # P=pattern_id+sub_index+track_type
+        track_type = Column(Integer) # TrackType
+        sub_index = Column(Integer)
+
+        # v1.x
+        pattern_id = Column(Integer, ForeignKey('patterns.id', ondelete='CASCADE'))
+        pattern = relationship('Pattern', back_populates='tracks')
+
 
         language = Column(String) # IsoLanguage threeLetter
         title = Column(String)
 
-    tags = relationship('Tag', back_populates='track', cascade="all, delete")
+
+        track_tags = relationship('TrackTag', back_populates='track', cascade='all, delete')
 
 
         disposition_flags = Column(Integer)
 
     
-    def getDescriptor(self):
+        """
-        pass
+
+
+        trackType = streamObj[TrackDescriptor.FFPROBE_CODEC_TYPE_KEY]
+
+        if trackType in [t.label() for t in TrackType]:
+
+            return cls(pattern_id = patternId,
+                        track_type = trackType,
+                        codec_name = streamObj[TrackDescriptor.FFPROBE_CODEC_NAME_KEY],
+                        disposition_flags = sum([2**t.index() for (k,v) in streamObj[TrackDescriptor.FFPROBE_DISPOSITION_KEY].items()
+                                                        if v and (t := TrackDisposition.find(k)) is not None]),
+                        audio_layout = AudioLayout.identify(streamObj))
+
+        else:
+            return None
+
+
+    def getId(self):
+        return int(self.id)
+
+    def getPatternId(self):
+        return int(self.pattern_id)
+    
+    def getType(self):
+        return TrackType.fromIndex(self.track_type)
+    
+    def getCodec(self):
+        return str(self.codec_name)
+
+    def getIndex(self):
+        return int(self.index) if self.index is not None else -1
+
+    def getSourceIndex(self):
+        return int(self.source_index) if self.source_index is not None else -1
+
+    def getLanguage(self):
+        tags = {t.key:t.value for t in self.track_tags}
+        return IsoLanguage.findThreeLetter(tags['language']) if 'language' in tags.keys() else IsoLanguage.UNDEFINED
+    
+    def getTitle(self):
+        tags = {t.key:t.value for t in self.track_tags}
+        return tags['title'] if 'title' in tags.keys() else ''
+
+    def getDispositionSet(self):
+        return TrackDisposition.toSet(self.disposition_flags)
+    
+    def getAudioLayout(self):
+        return AudioLayout.fromIndex(self.audio_layout)
+
+    def getTags(self):
+        return {str(t.key):str(t.value) for t in self.track_tags}
+
+
+    def setDisposition(self, disposition : TrackDisposition):
+            self.disposition_flags = self.disposition_flags | int(2**disposition.index())
+
+    def resetDisposition(self, disposition : TrackDisposition):
+            self.disposition_flags = self.disposition_flags & sum([2**d.index() for d in TrackDisposition if d != disposition])
+
+    def getDisposition(self, disposition : TrackDisposition):
+            return bool(self.disposition_flags & 2**disposition.index())
+
+
+    def getDescriptor(self, context, subIndex : int = -1) -> TrackDescriptor:
+
+        kwargs = {}
+
+        kwargs[TrackDescriptor.CONTEXT_KEY] = context
+
+        kwargs[TrackDescriptor.ID_KEY] = self.getId()
+        kwargs[TrackDescriptor.PATTERN_ID_KEY] = self.getPatternId()
+
+        kwargs[TrackDescriptor.INDEX_KEY] = self.getIndex()
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = self.getSourceIndex()
+
+        if subIndex > -1:
+            kwargs[TrackDescriptor.SUB_INDEX_KEY] = subIndex
+
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = self.getType()
+        kwargs[TrackDescriptor.CODEC_NAME_KEY] = self.getCodec()
+        
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = self.getDispositionSet()
+        kwargs[TrackDescriptor.TAGS_KEY] = self.getTags()
+        
+        kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY] = self.getAudioLayout()
+
+        return TrackDescriptor(**kwargs)

bin/ffx/model/track_tag.py

@@ -4,10 +4,8 @@ from sqlalchemy.orm import relationship, declarative_base, sessionmaker
 
 from .show import Base
 
-from ffx.track_type import TrackType
 
-
+class TrackTag(Base):
-class Tag(Base):
     """
     relationship(argument, opt1, opt2, ...)
     argument is string of class or Mapped class of the target entity
@@ -17,7 +15,7 @@ class Tag(Base):
     See: https://docs.sqlalchemy.org/en/(14|20)/orm/basic_relationships.html
     """
 
-    __tablename__ = 'tags'
+    __tablename__ = 'track_tags'
 
     # v1.x
     id = Column(Integer, primary_key=True)
@@ -27,4 +25,4 @@ class Tag(Base):
 
     # v1.x
     track_id = Column(Integer, ForeignKey('tracks.id', ondelete="CASCADE"))
-    track = relationship('Track', back_populates='tags')
+    track = relationship('Track', back_populates='track_tags')

bin/ffx/pattern_controller.py

@@ -8,7 +8,7 @@ class PatternController():
     def __init__(self, context):
         
         self.context = context
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
 
     def addPattern(self, patternDescriptor):
@@ -16,16 +16,16 @@ class PatternController():
         try:
 
             s = self.Session()
-            q = s.query(Pattern).filter(Pattern.show_id == int(patternDescriptor['show_id']), Pattern.pattern == str(patternDescriptor['pattern']))
+            q = s.query(Pattern).filter(Pattern.show_id == int(patternDescriptor['show_id']))
 
             if not q.count():
                 pattern = Pattern(show_id = int(patternDescriptor['show_id']),
                                     pattern = str(patternDescriptor['pattern']))
                 s.add(pattern)
                 s.commit()
-                return patternDescriptor
+                return pattern.getId()
             else:
-                return {}
+                return 0
 
         except Exception as ex:
             raise click.ClickException(f"PatternController.addPattern(): {repr(ex)}")
@@ -77,26 +77,19 @@ class PatternController():
             s.close()
 
 
-    def getPatternDict(self, pattern):
+    def getPattern(self, patternId : int):
-        patternDescriptor = {}
-        patternDescriptor['id'] = int(pattern.id)
-        patternDescriptor['pattern'] = str(pattern.pattern)
-        patternDescriptor['show_id'] = int(pattern.show_id)
-        return patternDescriptor
 
-
+        if type(patternId) is not int:
-    def getPatternDescriptor(self, patternId):
+            raise ValueError(f"PatternController.getPattern(): Argument patternId is required to be of type int")
 
         try:
             s = self.Session()
             q = s.query(Pattern).filter(Pattern.id == int(patternId))
 
-            if q.count():
+            return q.first() if q.count() else None
-                pattern = q.first()
-                return self.getPatternDict(pattern)
 
         except Exception as ex:
-            raise click.ClickException(f"PatternController.getPatternDescriptor(): {repr(ex)}")
+            raise click.ClickException(f"PatternController.getPattern(): {repr(ex)}")
         finally:
             s.close()
 
@@ -123,41 +116,40 @@ class PatternController():
             s.close()
 
 
-    def matchFilename(self, filename):
+    def matchFilename(self, filename : str) -> dict:
-
+        """Returns dict {'match': <a regex match obj>, 'pattern': <ffx pattern obj>} or empty dict of no pattern was found"""
-        SEASON_PATTERN = '[sS]([0-9]+)'
-        EPISODE_PATTERN = '[eE]([0-9]+)'
-
-        result = {}
 
         try:
             s = self.Session()
             q = s.query(Pattern)
 
+            matchResult = {}
+            
             for pattern in q.all():
+                patternMatch = re.search(str(pattern.pattern), str(filename))
+                if patternMatch is not None:
+                    matchResult['match'] = patternMatch
+                    matchResult['pattern'] = pattern
 
-                match = re.search(pattern.pattern, filename)
+            return matchResult
-                
-                if match:
-
-                    result['pattern_id'] = pattern.id
-                    result['show_id'] = pattern.show_id
-
-                    result['indicator'] = match.group(1)
-
-                    seasonMatch = re.search(SEASON_PATTERN, result['indicator'])
-                    if seasonMatch:
-                        result['season'] = int(seasonMatch.group(1))
-
-                    episodeMatch = re.search(EPISODE_PATTERN, result['indicator'])
-                    if episodeMatch:
-                        result['episode'] = int(episodeMatch.group(1))
-
             
         except Exception as ex:
             raise click.ClickException(f"PatternController.matchFilename(): {repr(ex)}")
         finally:
             s.close()
 
-        return result
+    def getMediaDescriptor(self, context, patternId):
 
+        try:
+            s = self.Session()
+            q = s.query(Pattern).filter(Pattern.id == int(patternId))
+
+            if q.count():
+                return q.first().getMediaDescriptor(context)
+            else:
+                return None
+
+        except Exception as ex:
+            raise click.ClickException(f"PatternController.getPatternDescriptor(): {repr(ex)}")
+        finally:
+            s.close()

bin/ffx/pattern_delete_screen.py

@@ -1,12 +1,8 @@
 import click
 
-from textual import events
-from textual.app import App, ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button, Input
+from textual.widgets import Header, Footer, Static, Button
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
-
-from ffx.model.pattern import Pattern
 
 from .show_controller import ShowController
 from .pattern_controller import PatternController
@@ -50,14 +46,14 @@ class PatternDeleteScreen(Screen):
         super().__init__()
 
         self.context = self.app.getContext()
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
         self.__pc = PatternController(context = self.context)
         self.__sc = ShowController(context = self.context)
 
         self.pattern_id = patternId
         self.pattern_obj = self.__pc.getPatternDescriptor(patternId) if patternId is not None else {}
-        self.show_obj = self.__sc.getShowDesciptor(showId) if showId is not None else {}
+        self.show_obj = self.__sc.getShowDescriptor(showId) if showId is not None else {}
 
 
     def on_mount(self):

bin/ffx/pattern_details_screen.py

@@ -3,22 +3,28 @@ import click, re
 from textual import events
 from textual.app import App, ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button, Input
+from textual.widgets import Header, Footer, Static, Button, Input, DataTable
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
 
 from ffx.model.show import Show
 from ffx.model.pattern import Pattern
+from ffx.model.track import Track
 
 from .pattern_controller import PatternController
 from .show_controller import ShowController
 from .track_controller import TrackController
+from .tag_controller import TagController
 
 from .track_details_screen import TrackDetailsScreen
 from .track_delete_screen import TrackDeleteScreen
 
+from .tag_details_screen import TagDetailsScreen
+from .tag_delete_screen import TagDeleteScreen
+
 from ffx.track_type import TrackType
 
 from ffx.track_disposition import TrackDisposition
+from ffx.track_descriptor import TrackDescriptor
 
 from textual.widgets._data_table import CellDoesNotExist
 
@@ -29,8 +35,8 @@ class PatternDetailsScreen(Screen):
     CSS = """
 
     Grid {
-        grid-size: 5 12;
+        grid-size: 5 13;
-        grid-rows: 2 2 2 2 2 6 2 2 6 2 2 2;
+        grid-rows: 2 2 2 2 2 8 2 2 8 2 2 2 2;
         grid-columns: 25 25 25 25 25;
         height: 100%;
         width: 100%;
@@ -67,23 +73,28 @@ class PatternDetailsScreen(Screen):
         height: 100%;
         border: solid green;
     }
+
+    .yellow {
+        tint: yellow 40%;
+    }
     """
 
     def __init__(self, patternId = None, showId = None):
         super().__init__()
 
         self.context = self.app.getContext()
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
         self.__pc = PatternController(context = self.context)
         self.__sc = ShowController(context = self.context)
         self.__tc = TrackController(context = self.context)
+        self.__tac = TagController(context = self.context)
 
-        self.pattern_obj = self.__pc.getPatternDescriptor(patternId) if patternId is not None else {}
+        self.__pattern : Pattern = self.__pc.getPattern(patternId) if patternId is not None else None
-
+        self.__showDescriptor = self.__sc.getShowDescriptor(showId) if showId is not None else None
-        self.show_obj = self.__sc.getShowDesciptor(showId) if showId is not None else {}
 
 
+    #TODO: per controller
     def loadTracks(self, show_id):
 
         try:
@@ -98,93 +109,97 @@ class PatternDetailsScreen(Screen):
             return [{'id': int(p.id), 'pattern': p.pattern} for p in q.all()]
 
         except Exception as ex:
-            click.ClickException(f"loadPatterns(): {repr(ex)}")
+            raise click.ClickException(f"loadTracks(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def updateAudioTracks(self):
+    def updateTracks(self):
 
-        self.audioStreamsTable.clear()
+        self.tracksTable.clear()
 
-        trackIds = self.__tc.findAllTracks(self.pattern_obj['id'])
+        if self.__pattern is not None:
 
-        for audioTrackId in trackIds[TrackType.AUDIO.label()]:
+            tracks = self.__tc.findTracks(self.__pattern.getId())
 
-            ad = self.__tc.getTrackDescriptor(audioTrackId)
+            typeCounter = {}
-            dispoList = ad['disposition_list']
 
-            row = (ad['sub_index'],
+            for tr in tracks:
-                    " ",
-                    ad['language'].label(),
-                    ad['title'],
-                    'Yes' if TrackDisposition.DEFAULT in dispoList else 'No',
-                    'Yes' if TrackDisposition.FORCED in dispoList else 'No')
 
-            self.audioStreamsTable.add_row(*map(str, row))
+                td : TrackDescriptor = tr.getDescriptor(self.context)
 
-    def updateSubtitleTracks(self):
+                trackType = td.getType()
+                if not trackType in typeCounter.keys():
+                    typeCounter[trackType] = 0
 
-        self.subtitleStreamsTable.clear()
+                dispoSet = td.getDispositionSet()
 
-        trackIds = self.__tc.findAllTracks(self.pattern_obj['id'])
+                row = (td.getIndex(),
+                        trackType.label(),
+                        typeCounter[trackType],
+                        td.getAudioLayout().label() if trackType == TrackType.AUDIO else ' ',
+                        td.getLanguage().label(),
+                        td.getTitle(),
+                        'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
+                        'Yes' if TrackDisposition.FORCED in dispoSet else 'No')
 
-        for subtitleTrackId in trackIds[TrackType.SUBTITLE.label()]:
+                self.tracksTable.add_row(*map(str, row))
 
-            sd = self.__tc.getTrackDescriptor(subtitleTrackId)
+                typeCounter[trackType] += 1
-            dispoList = sd['disposition_list']
 
-            row = (sd['sub_index'],
+    def updateTags(self):
-                    " ",
-                    sd['language'].label(),
-                    sd['title'],
-                    'Yes' if TrackDisposition.DEFAULT in dispoList else 'No',
-                    'Yes' if TrackDisposition.FORCED in dispoList else 'No')
 
-            self.subtitleStreamsTable.add_row(*map(str, row))
+        self.tagsTable.clear()
+
+        if self.__pattern is not None:
+
+            # raise click.ClickException(f"patternid={self.__pattern.getId()}") # 1
+
+            tags = self.__tac.findAllMediaTags(self.__pattern.getId())
+
+            #raise click.ClickException(f"tags={tags}") # encoder:blah
+
+            for tagKey, tagValue in tags.items():
+                row = (tagKey, tagValue)
+                self.tagsTable.add_row(*map(str, row))
 
 
     def on_mount(self):
 
-        if self.pattern_obj:
+        if not self.__showDescriptor is None:
-            self.query_one("#pattern_input", Input).value = str(self.pattern_obj['pattern'])
+            self.query_one("#showlabel", Static).update(f"{self.__showDescriptor.getId()} - {self.__showDescriptor.getName()} ({self.__showDescriptor.getYear()})")
 
-        if self.show_obj:
+        if self.__pattern is not None:
-            self.query_one("#showlabel", Static).update(f"{self.show_obj['id']} - {self.show_obj['name']} ({self.show_obj['year']})")
 
+            self.query_one("#pattern_input", Input).value = str(self.__pattern.getPattern())
 
-        if self.pattern_obj:
+            self.updateTags()
-
+            self.updateTracks()
-            self.updateAudioTracks()
-            self.updateSubtitleTracks()
-
 
     def compose(self):
 
-        self.audioStreamsTable = DataTable(classes="five")
+
+        self.tagsTable = DataTable(classes="five")
 
         # Define the columns with headers
-        self.column_key_audio_subid = self.audioStreamsTable.add_column("Subindex", width=20)
+        self.column_key_tag_key = self.tagsTable.add_column("Key", width=10)
-        self.column_key_audio_layout = self.audioStreamsTable.add_column("Layout", width=20)
+        self.column_key_tag_value = self.tagsTable.add_column("Value", width=100)
-        self.column_key_audio_language = self.audioStreamsTable.add_column("Language", width=20)
-        self.column_key_audio_title = self.audioStreamsTable.add_column("Title", width=30)
-        self.column_key_audio_default = self.audioStreamsTable.add_column("Default", width=10)
-        self.column_key_audio_forced = self.audioStreamsTable.add_column("Forced", width=10)
 
-        self.audioStreamsTable.cursor_type = 'row'
+        self.tagsTable.cursor_type = 'row'
 
 
-        self.subtitleStreamsTable = DataTable(classes="five")
+        self.tracksTable = DataTable(id="tracks_table", classes="five")
 
-        # Define the columns with headers
+        self.column_key_track_index = self.tracksTable.add_column("Index", width=5)
-        self.column_key_subtitle_subid = self.subtitleStreamsTable.add_column("Subindex", width=20)
+        self.column_key_track_type = self.tracksTable.add_column("Type", width=10)
-        self.column_key_subtitle_spacer = self.subtitleStreamsTable.add_column(" ", width=20)
+        self.column_key_track_sub_index = self.tracksTable.add_column("Subindex", width=5)
-        self.column_key_subtitle_language = self.subtitleStreamsTable.add_column("Language", width=20)
+        self.column_key_track_audio_layout = self.tracksTable.add_column("Layout", width=10)
-        self.column_key_subtitle_title = self.subtitleStreamsTable.add_column("Title", width=30)
+        self.column_key_track_language = self.tracksTable.add_column("Language", width=15)
-        self.column_key_subtitle_default = self.subtitleStreamsTable.add_column("Default", width=10)
+        self.column_key_track_title = self.tracksTable.add_column("Title", width=48)
-        self.column_key_subtitle_forced = self.subtitleStreamsTable.add_column("Forced", width=10)
+        self.column_key_track_default = self.tracksTable.add_column("Default", width=8)
+        self.column_key_track_forced = self.tracksTable.add_column("Forced", width=8)
 
-        self.subtitleStreamsTable.cursor_type = 'row'
+        self.tracksTable.cursor_type = 'row'
 
 
         yield Header()
@@ -192,13 +207,13 @@ class PatternDetailsScreen(Screen):
         with Grid():
 
             # 1
-            yield Static("Edit filename pattern" if self.pattern_obj else "New filename pattern", id="toplabel")
+            yield Static("Edit filename pattern" if self.__pattern is not None else "New filename pattern", id="toplabel")
             yield Input(type="text", id="pattern_input", classes="four")
 
             # 2
             yield Static("from show")
             yield Static("", id="showlabel", classes="three")
-            yield Button("Substitute pattern", id="patternbutton")
+            yield Button("Substitute pattern", id="pattern_button")
 
             # 3
             yield Static(" ", classes="five")
@@ -206,44 +221,51 @@ class PatternDetailsScreen(Screen):
             yield Static(" ", classes="five")
 
             # 5
-            yield Static("Audio streams")
+            yield Static("Media Tags")
             yield Static(" ")
 
-            if self.pattern_obj:
+            if self.__pattern is not None:
-                yield Button("Add", id="button_add_audio_stream")
+                yield Button("Add", id="button_add_tag")
-                yield Button("Edit", id="button_edit_audio_stream")
+                yield Button("Edit", id="button_edit_tag")
-                yield Button("Delete", id="button_delete_audio_stream")
+                yield Button("Delete", id="button_delete_tag")
             else:
                 yield Static(" ")
                 yield Static(" ")
                 yield Static(" ")
             # 6
-            yield self.audioStreamsTable
+            yield self.tagsTable
 
             # 7
             yield Static(" ", classes="five")
 
             # 8
-            yield Static("Subtitle streams")
+            yield Static("Streams")
             yield Static(" ")
 
-            if self.pattern_obj:
+            if self.__pattern is not None:
-                yield Button("Add", id="button_add_subtitle_stream")
+                yield Button("Add", id="button_add_track")
-                yield Button("Edit", id="button_edit_subtitle_stream")
+                yield Button("Edit", id="button_edit_track")
-                yield Button("Delete", id="button_delete_subtitle_stream")
+                yield Button("Delete", id="button_delete_track")
             else:
                 yield Static(" ")
                 yield Static(" ")
                 yield Static(" ")
             # 9
-            yield self.subtitleStreamsTable
+            yield self.tracksTable
 
             # 10
             yield Static(" ", classes="five")
 
             # 11
+            yield Static(" ", classes="five")
+
+            # 12
             yield Button("Save", id="save_button")
             yield Button("Cancel", id="cancel_button")
+            yield Static(" ", classes="three")
+
+            # 13
+            yield Static(" ", classes="five")
 
         yield Footer()
 
@@ -253,23 +275,24 @@ class PatternDetailsScreen(Screen):
 
 
 
-    def getSelectedAudioTrackId(self):
+    def getSelectedTrackDescriptor(self):
 
-        if not self.pattern_obj:
+        if not self.__pattern:
             return None
 
         try:
 
             # Fetch the currently selected row when 'Enter' is pressed
             #selected_row_index = self.table.cursor_row
-            row_key, col_key = self.audioStreamsTable.coordinate_to_cell_key(self.audioStreamsTable.cursor_coordinate)
+            row_key, col_key = self.tracksTable.coordinate_to_cell_key(self.tracksTable.cursor_coordinate)
 
             if row_key is not None:
-                selected_track_data = self.audioStreamsTable.get_row(row_key)
+                selected_track_data = self.tracksTable.get_row(row_key)
 
-                subIndex = int(selected_track_data[0])
+                trackIndex = int(selected_track_data[0])
+                trackSubIndex = int(selected_track_data[2])
 
-                return self.__tc.findTrack(self.pattern_obj['id'], TrackType.AUDIO, subIndex)
+                return self.__tc.getTrack(self.__pattern.getId(), trackIndex).getDescriptor(self.context, subIndex=trackSubIndex)
 
             else:
                 return None
@@ -278,23 +301,22 @@ class PatternDetailsScreen(Screen):
             return None
 
 
-    def getSelectedSubtitleTrackId(self):
 
-        if not self.pattern_obj:
+    def getSelectedTag(self):
-            return None
 
         try:
 
             # Fetch the currently selected row when 'Enter' is pressed
             #selected_row_index = self.table.cursor_row
-            row_key, col_key = self.subtitleStreamsTable.coordinate_to_cell_key(self.subtitleStreamsTable.cursor_coordinate)
+            row_key, col_key = self.tagsTable.coordinate_to_cell_key(self.tagsTable.cursor_coordinate)
 
             if row_key is not None:
-                selected_track_data = self.subtitleStreamsTable.get_row(row_key)
+                selected_tag_data = self.tagsTable.get_row(row_key)
 
-                subIndex = int(selected_track_data[0])
+                tagKey = str(selected_tag_data[0])
+                tagValue = str(selected_tag_data[1])
 
-                return self.__tc.findTrack(self.pattern_obj['id'], TrackType.SUBTITLE, subIndex)
+                return tagKey, tagValue
 
             else:
                 return None
@@ -310,56 +332,60 @@ class PatternDetailsScreen(Screen):
         if event.button.id == "save_button":
 
             patternDescriptor = {}
-            patternDescriptor['show_id'] = self.show_obj['id']
+            patternDescriptor['show_id'] = self.__showDescriptor.getId()
             patternDescriptor['pattern'] = self.getPatternFromInput()
 
-            if self.pattern_obj:
+            if self.__pattern is not None:
 
-                if self.__pc.updatePattern(self.pattern_obj['id'], patternDescriptor):
+                if self.__pc.updatePattern(self.__pattern.getId(), patternDescriptor):
                     self.dismiss(patternDescriptor)
                 else:
                     #TODO: Meldung
                     self.app.pop_screen()
 
             else:
-                if self.__pc.addPattern(patternDescriptor):
+                patternId = self.__pc.addPattern(patternDescriptor)
+                if patternId:
                     self.dismiss(patternDescriptor)
                 else:
                     #TODO: Meldung
                     self.app.pop_screen()
 
 
-
         if event.button.id == "cancel_button":
             self.app.pop_screen()
 
 
         # Save pattern when just created before adding streams
-        if self.pattern_obj:
+        if self.__pattern is not None:
 
-            #self.pattern_obj
+            numTracks = len(self.tracksTable.rows)
 
-            if event.button.id == "button_add_audio_stream":
+            if event.button.id == "button_add_track":
-                self.app.push_screen(TrackDetailsScreen(trackType = TrackType.AUDIO, patternId = self.pattern_obj['id'], subIndex = len(self.audioStreamsTable.rows)), self.handle_add_track)
+                self.app.push_screen(TrackDetailsScreen(patternId = self.__pattern.getId(), index = numTracks), self.handle_add_track)
 
-            selectedAudioTrackId = self.getSelectedAudioTrackId()
+            selectedTrack = self.getSelectedTrackDescriptor()
-            if selectedAudioTrackId is not None:
+            if selectedTrack is not None:
-                if event.button.id == "button_edit_audio_stream":
+                if event.button.id == "button_edit_track":
-                    self.app.push_screen(TrackDetailsScreen(trackId = selectedAudioTrackId), self.handle_edit_track)
+                    self.app.push_screen(TrackDetailsScreen(trackDescriptor = selectedTrack), self.handle_edit_track)
-                if event.button.id == "button_delete_audio_stream":
+                if event.button.id == "button_delete_track":
-                    self.app.push_screen(TrackDeleteScreen(trackId = selectedAudioTrackId), self.handle_delete_track)
+                    self.app.push_screen(TrackDeleteScreen(trackDescriptor = selectedTrack), self.handle_delete_track)
 
-            if event.button.id == "button_add_subtitle_stream":
-                self.app.push_screen(TrackDetailsScreen(trackType = TrackType.SUBTITLE, patternId = self.pattern_obj['id'], subIndex = len(self.subtitleStreamsTable.rows)), self.handle_add_track)
 
-            selectedSubtitleTrackId = self.getSelectedSubtitleTrackId()
+        if event.button.id == "button_add_tag":
-            if selectedSubtitleTrackId is not None:
+            if self.__pattern is not None:
-                if event.button.id == "button_edit_subtitle_stream":
+                self.app.push_screen(TagDetailsScreen(), self.handle_update_tag)
-                    self.app.push_screen(TrackDetailsScreen(trackId = selectedSubtitleTrackId), self.handle_edit_track)            
-                if event.button.id == "button_delete_subtitle_stream":
-                    self.app.push_screen(TrackDeleteScreen(trackId = selectedSubtitleTrackId), self.handle_delete_track)
 
-        if event.button.id == "patternbutton":
+        if event.button.id == "button_edit_tag":
+            tagKey, tagValue = self.getSelectedTag()
+            self.app.push_screen(TagDetailsScreen(key=tagKey, value=tagValue), self.handle_update_tag)
+
+        if event.button.id == "button_delete_tag":
+            tagKey, tagValue = self.getSelectedTag()
+            self.app.push_screen(TagDeleteScreen(key=tagKey, value=tagValue), self.handle_delete_tag)
+
+
+        if event.button.id == "pattern_button":
 
             INDICATOR_PATTERN = '([sS][0-9]+[eE][0-9]+)'
 
@@ -371,66 +397,60 @@ class PatternDetailsScreen(Screen):
                 self.query_one("#pattern_input", Input).value = pattern.replace(patternMatch.group(1), INDICATOR_PATTERN)
 
 
-    def handle_add_track(self, trackDescriptor):
+    def handle_add_track(self, trackDescriptor : TrackDescriptor):
 
-        dispoList = trackDescriptor['disposition_list']
+        dispoSet = trackDescriptor.getDispositionSet()
+        trackType = trackDescriptor.getType()
+        index = trackDescriptor.getIndex()
+        subIndex = trackDescriptor.getSubIndex()
+        language = trackDescriptor.getLanguage()
+        title = trackDescriptor.getTitle()
 
-        if trackDescriptor['type'] == TrackType.AUDIO:
+        row = (index,
-
+               trackType.label(),
-            row = (trackDescriptor['sub_index'],
+               subIndex,
                 " ",
-                    trackDescriptor['language'].label(),
+                language.label(),
-                    trackDescriptor['title'],
+                title,
-                    'Yes' if TrackDisposition.DEFAULT in dispoList else 'No',
+                'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
-                    'Yes' if TrackDisposition.FORCED in dispoList else 'No')
+                'Yes' if TrackDisposition.FORCED in dispoSet else 'No')
 
-            self.audioStreamsTable.add_row(*map(str, row))
+        self.tracksTable.add_row(*map(str, row))
-
-        if trackDescriptor['type'] == TrackType.SUBTITLE:
-
-            row = (trackDescriptor['sub_index'],
-                    " ",
-                    trackDescriptor['language'].label(),
-                    trackDescriptor['title'],
-                    'Yes' if TrackDisposition.DEFAULT in dispoList else 'No',
-                    'Yes' if TrackDisposition.FORCED in dispoList else 'No')
-
-            self.subtitleStreamsTable.add_row(*map(str, row))
 
 
-    def handle_edit_track(self, trackDescriptor):
+    def handle_edit_track(self, trackDescriptor : TrackDescriptor):
 
         try:
-            if trackDescriptor['type'] == TrackType.AUDIO:
 
-                row_key, col_key = self.audioStreamsTable.coordinate_to_cell_key(self.audioStreamsTable.cursor_coordinate)
+            row_key, col_key = self.tracksTable.coordinate_to_cell_key(self.tracksTable.cursor_coordinate)
 
-                self.audioStreamsTable.update_cell(row_key, self.column_key_audio_language, trackDescriptor['language'].label())
+            self.tracksTable.update_cell(row_key, self.column_key_track_audio_layout, trackDescriptor.getAudioLayout().label())
-                self.audioStreamsTable.update_cell(row_key, self.column_key_audio_title, trackDescriptor['title'])
+            self.tracksTable.update_cell(row_key, self.column_key_track_language, trackDescriptor.getLanguage().label())
-                self.audioStreamsTable.update_cell(row_key, self.column_key_audio_default, 'Yes' if TrackDisposition.DEFAULT in trackDescriptor['disposition_list'] else 'No')
+            self.tracksTable.update_cell(row_key, self.column_key_track_title, trackDescriptor.getTitle())
-                self.audioStreamsTable.update_cell(row_key, self.column_key_audio_forced, 'Yes' if TrackDisposition.FORCED in trackDescriptor['disposition_list'] else 'No')
+            self.tracksTable.update_cell(row_key, self.column_key_track_default, 'Yes' if TrackDisposition.DEFAULT in trackDescriptor.getDispositionSet() else 'No')
-
+            self.tracksTable.update_cell(row_key, self.column_key_track_forced, 'Yes' if TrackDisposition.FORCED in trackDescriptor.getDispositionSet() else 'No')
-            if trackDescriptor['type'] == TrackType.SUBTITLE:
-
-                row_key, col_key = self.subtitleStreamsTable.coordinate_to_cell_key(self.subtitleStreamsTable.cursor_coordinate)
-
-                self.subtitleStreamsTable.update_cell(row_key, self.column_key_subtitle_language, trackDescriptor['language'].label())
-                self.subtitleStreamsTable.update_cell(row_key, self.column_key_subtitle_title, trackDescriptor['title'])
-                self.subtitleStreamsTable.update_cell(row_key, self.column_key_subtitle_default, 'Yes' if TrackDisposition.DEFAULT in trackDescriptor['disposition_list'] else 'No')
-                self.subtitleStreamsTable.update_cell(row_key, self.column_key_subtitle_forced, 'Yes' if TrackDisposition.FORCED in trackDescriptor['disposition_list'] else 'No')
 
         except CellDoesNotExist:
             pass
 
 
-    def handle_delete_track(self, trackDescriptor):
+    def handle_delete_track(self, trackDescriptor : TrackDescriptor):
+        self.updateTracks()
 
-        try:
-            if trackDescriptor['type'] == TrackType.AUDIO:
-                self.updateAudioTracks()
 
-            if trackDescriptor['type'] == TrackType.SUBTITLE:
-                self.updateSubtitleTracks()
 
-        except CellDoesNotExist:
+    def handle_update_tag(self, tag):
-            pass
+
+        if self.__pattern is None:
+            raise click.ClickException(f"PatternDetailsScreen.handle_update_tag: pattern not set")
+
+        if self.__tac.updateMediaTag(self.__pattern.getId(), tag[0], tag[1]) is not None:
+            self.updateTags()
+
+    def handle_delete_tag(self, tag):
+
+        if self.__pattern is None:
+            raise click.ClickException(f"PatternDetailsScreen.handle_delete_tag: pattern not set")
+
+        if self.__tac.deleteMediaTagByKey(self.__pattern.getId(), tag[0]):
+                self.updateTags()

bin/ffx/process.py

@@ -0,0 +1,9 @@
+import subprocess
+from typing import List
+
+def executeProcess(commandSequence: List[str], directory: str = None):
+    # process = subprocess.Popen([t.encode('utf-8') for t in commandSequence], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    process = subprocess.Popen(commandSequence, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding='utf-8', cwd = directory)
+    output, error = process.communicate()
+    # return output.decode('utf-8'), error.decode('utf-8'), process.returncode
+    return output, error, process.returncode

bin/ffx/show_controller.py

@@ -1,6 +1,7 @@
 import click
 
 from ffx.model.show import Show
+from ffx.show_descriptor import ShowDescriptor
 
 
 class ShowController():
@@ -8,51 +9,68 @@ class ShowController():
     def __init__(self, context):
         
         self.context = context
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
 
-    def getShowDesciptor(self, showId):
+    def getShowDescriptor(self, showId):
 
         try:
             s = self.Session()
             q = s.query(Show).filter(Show.id == showId)
 
-            showDescriptor = {}
-
             if q.count():
-                show = q.first()
+                show: Show = q.first() 
-                
+                return show.getDescriptor(self.context)
-                showDescriptor['id'] = int(show.id)
-                showDescriptor['name'] = str(show.name)
-                showDescriptor['year'] = int(show.year)
-
-                showDescriptor['index_season_digits'] = int(show.index_season_digits)
-                showDescriptor['index_episode_digits'] = int(show.index_episode_digits)
-                showDescriptor['indicator_season_digits'] = int(show.indicator_season_digits)
-                showDescriptor['indicator_episode_digits'] = int(show.indicator_episode_digits)
-
-            return showDescriptor
 
         except Exception as ex:
-            raise click.ClickException(f"ShowController.getShowDesciptor(): {repr(ex)}")
+            raise click.ClickException(f"ShowController.getShowDescriptor(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def getShow(self, showId):
+
+        try:
+            s = self.Session()
+            q = s.query(Show).filter(Show.id == showId)
+
+            return q.first() if q.count() else None
+
+        except Exception as ex:
+            raise click.ClickException(f"ShowController.getShow(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def getAllShows(self):
+
+        try:
+            s = self.Session()
+            q = s.query(Show)
+
+            if q.count():
+                return q.all()
+            else:
+                return []
+
+        except Exception as ex:
+            raise click.ClickException(f"ShowController.getAllShows(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def updateShow(self, showDescriptor):
+    def updateShow(self, showDescriptor: ShowDescriptor):
 
         try:
             s = self.Session()
-            q = s.query(Show).filter(Show.id == showDescriptor['id'])
+            q = s.query(Show).filter(Show.id == showDescriptor.getId())
 
             if not q.count():
-                show = Show(id = int(showDescriptor['id']),
+                show = Show(id = int(showDescriptor.getId()),
-                        name = str(showDescriptor['name']),
+                        name = str(showDescriptor.getName()),
-                        year = int(showDescriptor['year']),
+                        year = int(showDescriptor.getYear()),
-                        index_season_digits = showDescriptor['index_season_digits'],
+                        index_season_digits = showDescriptor.getIndexSeasonDigits(),
-                        index_episode_digits = showDescriptor['index_episode_digits'],
+                        index_episode_digits = showDescriptor.getIndexEpisodeDigits(),
-                        indicator_season_digits = showDescriptor['indicator_season_digits'],
+                        indicator_season_digits = showDescriptor.getIndicatorSeasonDigits(),
-                        indicator_episode_digits = showDescriptor['indicator_episode_digits'])
+                        indicator_episode_digits = showDescriptor.getIndicatorEpisodeDigits())
 
                 s.add(show)
                 s.commit()
@@ -62,24 +80,24 @@ class ShowController():
                 currentShow = q.first()
 
                 changed = False
-                if currentShow.name != str(showDescriptor['name']):
+                if currentShow.name != str(showDescriptor.getName()):
-                    currentShow.name = str(showDescriptor['name'])
+                    currentShow.name = str(showDescriptor.getName())
                     changed = True
-                if currentShow.year != int(showDescriptor['year']):
+                if currentShow.year != int(showDescriptor.getYear()):
-                    currentShow.year = int(showDescriptor['year'])
+                    currentShow.year = int(showDescriptor.getYear())
                     changed = True
 
-                if currentShow.index_season_digits != int(showDescriptor['index_season_digits']):
+                if currentShow.index_season_digits != int(showDescriptor.getIndexSeasonDigits()):
-                    currentShow.index_season_digits = int(showDescriptor['index_season_digits'])
+                    currentShow.index_season_digits = int(showDescriptor.getIndexSeasonDigits())
                     changed = True
-                if currentShow.index_episode_digits != int(showDescriptor['index_episode_digits']):
+                if currentShow.index_episode_digits != int(showDescriptor.getIndexEpisodeDigits()):
-                    currentShow.index_episode_digits = int(showDescriptor['index_episode_digits'])
+                    currentShow.index_episode_digits = int(showDescriptor.getIndexEpisodeDigits())
                     changed = True
-                if currentShow.indicator_season_digits != int(showDescriptor['indicator_season_digits']):
+                if currentShow.indicator_season_digits != int(showDescriptor.getIndicatorSeasonDigits()):
-                    currentShow.indicator_season_digits = int(showDescriptor['indicator_season_digits'])
+                    currentShow.indicator_season_digits = int(showDescriptor.getIndicatorSeasonDigits())
                     changed = True
-                if currentShow.indicator_episode_digits != int(showDescriptor['indicator_episode_digits']):
+                if currentShow.indicator_episode_digits != int(showDescriptor.getIndicatorEpisodeDigits()):
-                    currentShow.indicator_episode_digits = int(showDescriptor['indicator_episode_digits'])
+                    currentShow.indicator_episode_digits = int(showDescriptor.getIndicatorEpisodeDigits())
                     changed = True
 
                 if changed:

bin/ffx/show_delete_screen.py

@@ -1,12 +1,6 @@
-import click
-
-from textual import events
-from textual.app import App, ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button, Input
+from textual.widgets import Header, Footer, Static, Button
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
-
-from ffx.model.show import Show
 
 from .show_controller import ShowController
 
@@ -48,17 +42,16 @@ class ShowDeleteScreen(Screen):
         super().__init__()
 
         self.context = self.app.getContext()
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
         self.__sc = ShowController(context = self.context)
-        self.show_obj = self.__sc.getShowDesciptor(showId) if showId is not None else {}
+        
+        self.__showDescriptor = self.__sc.getShowDescriptor(showId) if showId is not None else {}
 
 
     def on_mount(self):
-
+        if not self.__showDescriptor is None:
-        if self.show_obj:
+            self.query_one("#showlabel", Static).update(f"{self.__showDescriptor.getId()} - {self.__showDescriptor.getName()} ({self.__showDescriptor.getYear()})")
-
-            self.query_one("#showlabel", Static).update(f"{self.show_obj['id']} - {self.show_obj['name']} ({self.show_obj['year']})")
 
 
     def compose(self):
@@ -90,8 +83,9 @@ class ShowDeleteScreen(Screen):
 
         if event.button.id == "delete_button":
 
-            if self.__sc.deleteShow(self.show_obj['id']):
+            if not self.__showDescriptor is None:
-                self.dismiss(self.show_obj['id'])
+                if self.__sc.deleteShow(self.__showDescriptor.getId()):
+                    self.dismiss(self.__showDescriptor)
 
             else:
                 #TODO: Meldung

bin/ffx/show_descriptor.py

@@ -0,0 +1,105 @@
+import logging
+
+
+class ShowDescriptor():
+    """This class represents the structural content of a media file including streams and metadata"""
+
+    CONTEXT_KEY = 'context'
+    
+    ID_KEY = 'id'
+    NAME_KEY = 'name'
+    YEAR_KEY = 'year'
+
+    INDEX_SEASON_DIGITS_KEY = 'index_season_digits'
+    INDEX_EPISODE_DIGITS_KEY = 'index_episode_digits'
+    INDICATOR_SEASON_DIGITS_KEY = 'indicator_season_digits'
+    INDICATOR_EPISODE_DIGITS_KEY = 'indicator_episode_digits'
+
+    DEFAULT_INDEX_SEASON_DIGITS = 2
+    DEFAULT_INDEX_EPISODE_DIGITS = 2
+    DEFAULT_INDICATOR_SEASON_DIGITS = 2
+    DEFAULT_INDICATOR_EPISODE_DIGITS = 2
+
+
+    def __init__(self, **kwargs):
+
+        if ShowDescriptor.CONTEXT_KEY in kwargs.keys():
+            if type(kwargs[ShowDescriptor.CONTEXT_KEY]) is not dict:
+                raise TypeError(
+                    f"ShowDescriptor.__init__(): Argument {ShowDescriptor.CONTEXT_KEY} is required to be of type dict"
+                )
+            self.__context = kwargs[ShowDescriptor.CONTEXT_KEY]
+            self.__logger = self.__context['logger']
+        else:
+            self.__context = {}
+            self.__logger = logging.getLogger('FFX').addHandler(logging.NullHandler())
+
+        if ShowDescriptor.ID_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.ID_KEY]) is not int:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.ID_KEY} is required to be of type int")
+                self.__showId = kwargs[ShowDescriptor.ID_KEY]
+        else:
+                self.__showId = -1
+
+        if ShowDescriptor.NAME_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.NAME_KEY]) is not str:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.NAME_KEY} is required to be of type str")
+                self.__showName = kwargs[ShowDescriptor.NAME_KEY]
+        else:
+                self.__showName = ''
+
+        if ShowDescriptor.YEAR_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.YEAR_KEY]) is not int:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.YEAR_KEY} is required to be of type int")
+                self.__showYear = kwargs[ShowDescriptor.YEAR_KEY]
+        else:
+                self.__showYear = -1
+
+
+        if ShowDescriptor.INDEX_SEASON_DIGITS_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.INDEX_SEASON_DIGITS_KEY]) is not int:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.INDEX_SEASON_DIGITS_KEY} is required to be of type int")
+                self.__indexSeasonDigits = kwargs[ShowDescriptor.INDEX_SEASON_DIGITS_KEY]
+        else:
+                self.__indexSeasonDigits = ShowDescriptor.DEFAULT_INDEX_SEASON_DIGITS
+
+        if ShowDescriptor.INDEX_EPISODE_DIGITS_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.INDEX_EPISODE_DIGITS_KEY]) is not int:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.INDEX_EPISODE_DIGITS_KEY} is required to be of type int")
+                self.__indexEpisodeDigits = kwargs[ShowDescriptor.INDEX_EPISODE_DIGITS_KEY]
+        else:
+                self.__indexEpisodeDigits = ShowDescriptor.DEFAULT_INDEX_EPISODE_DIGITS
+
+        if ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY]) is not int:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY} is required to be of type int")
+                self.__indicatorSeasonDigits = kwargs[ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY]
+        else:
+                self.__indicatorSeasonDigits = ShowDescriptor.DEFAULT_INDICATOR_SEASON_DIGITS
+
+        if ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY in kwargs.keys():
+                if type(kwargs[ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY]) is not int:
+                        raise TypeError(f"ShowDescriptor.__init__(): Argument {ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY} is required to be of type int")
+                self.__indicatorEpisodeDigits = kwargs[ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY]
+        else:
+                self.__indicatorEpisodeDigits = ShowDescriptor.DEFAULT_INDICATOR_EPISODE_DIGITS
+
+
+    def getId(self):
+        return self.__showId
+    def getName(self):
+        return self.__showName
+    def getYear(self):
+        return self.__showYear
+
+    def getIndexSeasonDigits(self):
+        return self.__indexSeasonDigits
+    def getIndexEpisodeDigits(self):
+        return self.__indexEpisodeDigits
+    def getIndicatorSeasonDigits(self):
+        return self.__indicatorSeasonDigits
+    def getIndicatorEpisodeDigits(self):
+        return self.__indicatorEpisodeDigits
+
+    def getFilenamePrefix(self):
+        return f"{self.__showName} ({str(self.__showYear)})"

bin/ffx/show_details_screen.py

@@ -1,10 +1,9 @@
 import click
+from datetime import datetime
 
-from textual import events
-from textual.app import App, ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button, Input
+from textual.widgets import Header, Footer, Static, Button, DataTable, Input
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
 from textual.widgets._data_table import CellDoesNotExist
 
 
@@ -16,6 +15,12 @@ from .pattern_delete_screen import PatternDeleteScreen
 
 from .show_controller import ShowController
 from .pattern_controller import PatternController
+from .tmdb_controller import TmdbController
+
+from .show_descriptor import ShowDescriptor
+
+from .helper import filterFilename
+
 
 # Screen[dict[int, str, int]]
 class ShowDetailsScreen(Screen):
@@ -76,42 +81,47 @@ class ShowDetailsScreen(Screen):
         super().__init__()
 
         self.context = self.app.getContext()
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
         
         self.__sc = ShowController(context = self.context)
         self.__pc = PatternController(context = self.context)
+        self.__tc = TmdbController()
 
-        self.show_obj = self.__sc.getShowDesciptor(showId) if showId is not None else {}
+        self.__showDescriptor = self.__sc.getShowDescriptor(showId) if showId is not None else None
 
 
-    def loadPatterns(self, show_id):
+    def loadPatterns(self, show_id : int):
 
         try:
             s = self.Session()
             q = s.query(Pattern).filter(Pattern.show_id == int(show_id))
 
-            return [{'id': int(p.id), 'pattern': p.pattern} for p in q.all()]
+            return [{'id': int(p.id), 'pattern': str(p.pattern)} for p in q.all()]
 
         except Exception as ex:
-            click.ClickException(f"loadPatterns(): {repr(ex)}")
+            raise click.ClickException(f"ShowDetailsScreen.loadPatterns(): {repr(ex)}")
         finally:
             s.close()
 
 
     def on_mount(self):
 
-        if self.show_obj:
+        if not self.__showDescriptor is None:
 
-            self.query_one("#id_wdg", Static).update(str(self.show_obj['id']))
+            self.query_one("#id_static", Static).update(str(self.__showDescriptor.getId()))
-            self.query_one("#name_input", Input).value = str(self.show_obj['name'])
+            self.query_one("#name_input", Input).value = str(self.__showDescriptor.getName())
-            self.query_one("#year_input", Input).value = str(self.show_obj['year'])
+            self.query_one("#year_input", Input).value = str(self.__showDescriptor.getYear())
 
-            self.query_one("#index_season_digits_input", Input).value = str(self.show_obj['index_season_digits'])
+            self.query_one("#index_season_digits_input", Input).value = str(self.__showDescriptor.getIndexSeasonDigits())
-            self.query_one("#index_episode_digits_input", Input).value = str(self.show_obj['index_episode_digits'])
+            self.query_one("#index_episode_digits_input", Input).value = str(self.__showDescriptor.getIndexEpisodeDigits())
-            self.query_one("#indicator_season_digits_input", Input).value = str(self.show_obj['indicator_season_digits'])
+            self.query_one("#indicator_season_digits_input", Input).value = str(self.__showDescriptor.getIndicatorSeasonDigits())
-            self.query_one("#indicator_episode_digits_input", Input).value = str(self.show_obj['indicator_episode_digits'])
+            self.query_one("#indicator_episode_digits_input", Input).value = str(self.__showDescriptor.getIndicatorEpisodeDigits())
 
-            for pattern in self.loadPatterns(int(self.show_obj['id'])):
+            showId = int(self.__showDescriptor.getId())
+            #raise click.ClickException(f"show_id {showId}")
+            patternList = self.loadPatterns(showId)
+            # raise click.ClickException(f"patternList {patternList}")
+            for pattern in patternList:
                 row = (pattern['pattern'],)
                 self.patternTable.add_row(*map(str, row))
 
@@ -136,7 +146,7 @@ class ShowDetailsScreen(Screen):
             if row_key is not None:
                 selected_row_data = self.patternTable.get_row(row_key)
 
-                selectedPattern['show_id'] = self.show_obj['id']
+                selectedPattern['show_id'] = self.__showDescriptor.getId()
                 selectedPattern['pattern'] = str(selected_row_data[0])
 
         except CellDoesNotExist:
@@ -149,8 +159,8 @@ class ShowDetailsScreen(Screen):
 
 
     def action_add_pattern(self):
-        if self.show_obj:
+        if not self.__showDescriptor is None:
-            self.app.push_screen(PatternDetailsScreen(showId = self.show_obj['id']), self.handle_add_pattern) # <-
+            self.app.push_screen(PatternDetailsScreen(showId = self.__showDescriptor.getId()), self.handle_add_pattern) # <-
 
 
     def handle_add_pattern(self, screenResult):
@@ -168,9 +178,9 @@ class ShowDetailsScreen(Screen):
             selectedPatternId = self.__pc.findPattern(selectedPatternDescriptor)
             
             if selectedPatternId is None:
-                raise click.ClickException(f"ShowDetailsScreen.action_edit_pattern(): Pattern to remove has no id")
+                raise click.ClickException(f"ShowDetailsScreen.action_edit_pattern(): Pattern to edit has no id")
 
-            self.app.push_screen(PatternDetailsScreen(patternId = selectedPatternId, showId = self.show_obj['id']), self.handle_edit_pattern) # <-
+            self.app.push_screen(PatternDetailsScreen(patternId = selectedPatternId, showId = self.__showDescriptor.getId()), self.handle_edit_pattern) # <-
 
 
     def handle_edit_pattern(self, screenResult):
@@ -195,7 +205,7 @@ class ShowDetailsScreen(Screen):
             if selectedPatternId is None:
                 raise click.ClickException(f"ShowDetailsScreen.action_remove_pattern(): Pattern to remove has no id")
 
-            self.app.push_screen(PatternDeleteScreen(patternId = selectedPatternId, showId = self.show_obj['id']), self.handle_remove_pattern)
+            self.app.push_screen(PatternDeleteScreen(patternId = selectedPatternId, showId = self.__showDescriptor.getId()), self.handle_remove_pattern)
 
 
     def handle_remove_pattern(self, screenResult):
@@ -215,25 +225,24 @@ class ShowDetailsScreen(Screen):
 
         # Define the columns with headers
         self.column_key_pattern = self.patternTable.add_column("Pattern", width=150)
-        #self.column_key_name = self.patternTable.add_column("Name", width=50)
-        #self.column_key_year = self.patternTable.add_column("Year", width=10)
 
         self.patternTable.cursor_type = 'row'
 
-
         yield Header()
 
         with Grid():
 
             # 1
-            yield Static("Show" if self.show_obj else "New Show", id="toplabel", classes="five")
+            yield Static("Show" if not self.__showDescriptor is None else "New Show", id="toplabel")
+            yield Button("Identify", id="identify_button")
+            yield Static(" ", classes="three")
 
             # 2
             yield Static("ID")
-            if self.show_obj:
+            if not self.__showDescriptor is None:
-                yield Static("", id="id_wdg", classes="four")
+                yield Static("", id="id_static", classes="four")
             else:
-                yield Input(type="integer", id="id_wdg", classes="four")
+                yield Input(type="integer", id="id_input", classes="four")
             
             # 3
             yield Static("Name")
@@ -283,22 +292,44 @@ class ShowDetailsScreen(Screen):
 
     def getShowDescriptorFromInput(self):
 
-        showDescriptor = {}
+        kwargs = {}
         
-        if self.show_obj:
+        try:
-            showDescriptor['id'] = int(self.show_obj['id'])
+            if self.__showDescriptor:
+                kwargs[ShowDescriptor.ID_KEY] = int(self.__showDescriptor.getId())
             else:
-            showDescriptor['id'] = int(self.query_one("#id_wdg", Input).value)
+                kwargs[ShowDescriptor.ID_KEY] = int(self.query_one("#id_input", Input).value)
+        except ValueError:
+            return None
 
-        showDescriptor['name'] = str(self.query_one("#name_input", Input).value)
+        try:    
-        showDescriptor['year'] = int(self.query_one("#year_input", Input).value)
+            kwargs[ShowDescriptor.NAME_KEY] = str(self.query_one("#name_input", Input).value)
+        except ValueError:
+            pass
+        try:
+            kwargs[ShowDescriptor.YEAR_KEY] = int(self.query_one("#year_input", Input).value)
+        except ValueError:
+            pass
 
-        showDescriptor['index_season_digits'] = int(self.query_one("#index_season_digits_input", Input).value)
+        try:
-        showDescriptor['index_episode_digits'] = int(self.query_one("#index_episode_digits_input", Input).value)
+            kwargs[ShowDescriptor.INDEX_SEASON_DIGITS_KEY] = int(self.query_one("#index_season_digits_input", Input).value)
-        showDescriptor['indicator_season_digits'] = int(self.query_one("#indicator_season_digits_input", Input).value)
+        except ValueError:
-        showDescriptor['indicator_episode_digits'] = int(self.query_one("#indicator_episode_digits_input", Input).value)
+            pass
             
-        return showDescriptor
+        try:
+            kwargs[ShowDescriptor.INDEX_EPISODE_DIGITS_KEY] = int(self.query_one("#index_episode_digits_input", Input).value)
+        except ValueError:
+            pass
+        try:
+            kwargs[ShowDescriptor.INDICATOR_SEASON_DIGITS_KEY] = int(self.query_one("#indicator_season_digits_input", Input).value)
+        except ValueError:
+            pass
+        try:
+            kwargs[ShowDescriptor.INDICATOR_EPISODE_DIGITS_KEY] = int(self.query_one("#indicator_episode_digits_input", Input).value)
+        except ValueError:
+            pass
+
+        return ShowDescriptor(**kwargs)
 
 
    # Event handler for button press
@@ -308,6 +339,7 @@ class ShowDetailsScreen(Screen):
 
             showDescriptor = self.getShowDescriptorFromInput()
 
+            if not showDescriptor is None:
                 if self.__sc.updateShow(showDescriptor):
                     self.dismiss(showDescriptor)
                 else:
@@ -317,3 +349,13 @@ class ShowDetailsScreen(Screen):
         if event.button.id == "cancel_button":
             self.app.pop_screen()
 
+
+        if event.button.id == "identify_button":
+
+            showDescriptor = self.getShowDescriptorFromInput()
+            if not showDescriptor is None:
+                showResult = self.__tc.queryShow(showDescriptor.getId())
+                firstAirDate = datetime.strptime(showResult['first_air_date'], '%Y-%m-%d')
+
+                self.query_one("#name_input", Input).value = filterFilename(showResult['name'])
+                self.query_one("#year_input", Input).value = str(firstAirDate.year)

bin/ffx/shows_screen.py

@@ -1,15 +1,18 @@
 import click
 
-from textual.app import App, ComposeResult
 from textual.screen import Screen
 from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
 
 from ffx.model.show import Show
 
+from .show_controller import ShowController
+
 from .show_details_screen import ShowDetailsScreen
 from .show_delete_screen import ShowDeleteScreen
 
+from ffx.show_descriptor import ShowDescriptor
+
 from .help_screen import HelpScreen
 
 from textual.widgets._data_table import CellDoesNotExist
@@ -56,9 +59,9 @@ class ShowsScreen(Screen):
         super().__init__()
 
         self.context = self.app.getContext()
+        self.Session = self.context['database']['session'] # convenience
 
-        self.Session = self.context['database_session'] # convenience
+        self.__sc = ShowController(context = self.context)
-
 
 
     def getSelectedShowId(self):
@@ -96,14 +99,14 @@ class ShowsScreen(Screen):
                 self.app.push_screen(ShowDetailsScreen(showId = selectedShowId), self.handle_edit_screen)
 
 
-    def handle_edit_screen(self, screenResult):
+    def handle_edit_screen(self, showDescriptor: ShowDescriptor):
 
         try:
 
             row_key, col_key = self.table.coordinate_to_cell_key(self.table.cursor_coordinate)
 
-            self.table.update_cell(row_key, self.column_key_name,  screenResult['name'])
+            self.table.update_cell(row_key, self.column_key_name,  showDescriptor.getName())
-            self.table.update_cell(row_key, self.column_key_year,  screenResult['year'])        
+            self.table.update_cell(row_key, self.column_key_year,  showDescriptor.getYear())        
 
         except CellDoesNotExist:
             pass
@@ -119,7 +122,7 @@ class ShowsScreen(Screen):
             self.app.push_screen(ShowDeleteScreen(showId = selectedShowId), self.handle_delete_show)
 
 
-    def handle_delete_show(self, screenResult):
+    def handle_delete_show(self, showDescriptor: ShowDescriptor):
 
         try:
             row_key, col_key = self.table.coordinate_to_cell_key(self.table.cursor_coordinate)
@@ -129,24 +132,10 @@ class ShowsScreen(Screen):
             pass
 
 
-
-    def loadShows(self):
-
-        try:
-            s = self.Session()
-            q = s.query(Show)
-
-            return [(int(s.id), s.name, s.year) for s in q.all()]
-
-        except Exception as ex:
-            raise click.ClickException(f"ShowsScreen.loadShows(): {repr(ex)}")
-        finally:
-            s.close()
-
-
     def on_mount(self) -> None:
-        for show in self.loadShows():
+        for show in self.__sc.getAllShows():
-            self.table.add_row(*map(str, show))  # Convert each element to a string before adding
+            row = (int(show.id), show.name, show.year) # Convert each element to a string before adding
+            self.table.add_row(*map(str, row))
 
 
     def compose(self):

bin/ffx/tag_controller.py

@@ -0,0 +1,220 @@
+import click
+
+from ffx.model.track import Track
+
+from ffx.model.media_tag import MediaTag
+from ffx.model.track_tag import TrackTag
+
+
+class TagController():
+    
+    def __init__(self, context):
+        
+        self.context = context
+        self.Session = self.context['database']['session'] # convenience
+
+
+    def updateMediaTag(self, patternId, tagKey, tagValue):
+
+        try:
+            s = self.Session()
+
+            q = s.query(MediaTag).filter(MediaTag.pattern_id == int(patternId),
+                                MediaTag.key == str(tagKey))
+            tag = q.first()
+            if tag:
+                tag.value = str(tagValue)
+            else:
+                tag = MediaTag(pattern_id = int(patternId),
+                                key = str(tagKey),
+                                value = str(tagValue))
+                s.add(tag)
+            s.commit()
+
+            return int(tag.id)
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.updateTrackTag(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def updateTrackTag(self, trackId, tagKey, tagValue):
+
+        try:
+            s = self.Session()
+
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId),
+                                TrackTag.key == str(tagKey))
+            tag = q.first()
+            if tag:
+                tag.value = str(tagValue)
+            else:
+                tag = TrackTag(track_id = int(trackId),
+                                key = str(tagKey),
+                                value = str(tagValue))
+                s.add(tag)
+            s.commit()
+
+            return int(tag.id)
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.updateTrackTag(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def deleteMediaTagByKey(self, patternId, tagKey):
+
+        try:
+            s = self.Session()
+
+            q = s.query(MediaTag).filter(MediaTag.pattern_id == int(patternId),
+                                MediaTag.key == str(tagKey))
+            if q.count():
+                tag = q.first()
+                s.delete(tag)
+                s.commit()
+                return True
+            else:
+                return False
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.deleteMediaTagByKey(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def deleteTrackTagByKey(self, trackId, tagKey):
+
+        try:
+            s = self.Session()
+
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId),
+                                TrackTag.key == str(tagKey))
+            tag = q.first()
+            if tag:
+                s.delete(tag)
+                s.commit()
+                return True
+            else:
+                return False
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.deleteTrackTagByKey(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def findAllMediaTags(self, patternId) -> dict:
+
+        try:
+            s = self.Session()
+                
+            q = s.query(MediaTag).filter(MediaTag.pattern_id == int(patternId))
+
+            if q.count():
+                return {t.key:t.value for t in q.all()}
+            else:
+                return {}
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.findAllMediaTags(): {repr(ex)}")
+        finally:
+            s.close()
+
+
+    def findAllTrackTags(self, trackId) -> dict:
+
+        try:
+            s = self.Session()
+                
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId))
+
+            if q.count():
+                return {t.key:t.value for t in q.all()}
+            else:
+                return {}
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.findAllTracks(): {repr(ex)}")
+        finally:
+            s.close()
+
+
+    def findMediaTag(self, trackId : int, trackKey : str) -> MediaTag:
+        
+        try:
+            s = self.Session()
+            q = s.query(Track).filter(MediaTag.track_id == int(trackId), MediaTag.key == str(trackKey))
+
+            if q.count():
+                return q.first()
+            else:
+                return None
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.findMediaTag(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def findTrackTag(self, trackId : int, tagKey : str) -> TrackTag:
+        
+        try:
+            s = self.Session()
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId), TrackTag.key == str(tagKey))
+
+            if q.count():
+                return q.first()
+            else:
+                return None
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.findTrackTag(): {repr(ex)}")
+        finally:
+            s.close()
+
+
+
+    def deleteMediaTag(self, tagId) -> bool:
+        try:
+            s = self.Session()
+            q = s.query(MediaTag).filter(MediaTag.id == int(tagId))
+
+            if q.count():
+
+                tag = q.first()
+
+                s.delete(tag)
+
+                s.commit()
+                return True
+
+            return False
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.deleteMediaTag(): {repr(ex)}")
+        finally:
+            s.close()
+
+
+    def deleteTrackTag(self, tagId : int) -> bool:
+
+        if type(tagId) is not int:
+            raise TypeError('TagController.deleteTrackTag(): Argument tagId is required to be of type int')
+
+        try:
+            s = self.Session()
+            q = s.query(TrackTag).filter(TrackTag.id == int(tagId))
+
+            if q.count():
+
+                tag = q.first()
+
+                s.delete(tag)
+
+                s.commit()
+                return True
+
+            return False
+
+        except Exception as ex:
+            raise click.ClickException(f"TagController.deleteTrackTag(): {repr(ex)}")
+        finally:
+            s.close()

bin/ffx/tag_delete_screen.py

@@ -0,0 +1,98 @@
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static, Button
+from textual.containers import Grid
+
+
+# Screen[dict[int, str, int]]
+class TagDeleteScreen(Screen):
+
+    CSS = """
+
+    Grid {
+        grid-size: 4 9;
+        grid-rows: 2 2 2 2 2 2 2 2 2;
+        grid-columns: 30 30 30 30;
+        height: 100%;
+        width: 100%;
+        padding: 1;
+    }
+
+    Input {
+        border: none;
+    }
+    Button {
+        border: none;
+    }
+    #toplabel {
+        height: 1;
+    }
+
+    .two {
+        column-span: 2;
+    }
+    .three {
+        column-span: 3;
+    }
+    .four {
+        column-span: 4;
+    }
+    .five {
+        column-span: 5;
+    }
+
+    .box {
+        height: 100%;
+        border: solid green;
+    }
+    """
+
+    def __init__(self, key=None, value=None):
+        super().__init__()
+        self.__key = key
+        self.__value = value
+
+
+    def on_mount(self):
+
+        self.query_one("#keylabel", Static).update(str(self.__key))
+        self.query_one("#valuelabel", Static).update(str(self.__value))
+
+
+    def compose(self):
+
+        yield Header()
+
+        with Grid():
+            
+            #1
+            yield Static(f"Are you sure to delete this tag ?", id="toplabel", classes="five")
+
+            #2
+            yield Static("Key")
+            yield Static(" ", id="keylabel", classes="four")
+
+            #3
+            yield Static("Value")
+            yield Static(" ", id="valuelabel", classes="four")
+
+            #4
+            yield Static(" ", classes="five")
+
+            #9
+            yield Button("Delete", id="delete_button")
+            yield Button("Cancel", id="cancel_button")
+
+        yield Footer()
+
+
+   # Event handler for button press
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+
+        if event.button.id == "delete_button":
+
+            tag = (self.__key, self.__value)                  
+            self.dismiss(tag)
+
+        if event.button.id == "cancel_button":
+            self.app.pop_screen()
+

bin/ffx/tag_details_screen.py

@@ -0,0 +1,121 @@
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static, Button, Input
+from textual.containers import Grid
+
+
+# Screen[dict[int, str, int]]
+class TagDetailsScreen(Screen):
+
+    CSS = """
+
+    Grid {
+        grid-size: 5 20;
+        grid-rows: 2 2 2 2 2 3 2 2 2 2 2 6 2 2 6 2 2 2 2 6;
+        grid-columns: 25 25 25 25 225;
+        height: 100%;
+        width: 100%;
+        padding: 1;
+    }
+
+    Input {
+        border: none;
+    }
+    Button {
+        border: none;
+    }
+    SelectionList {
+        border: none;
+        min-height: 6;
+    }
+    Select {
+        border: none;
+    }
+    DataTable {
+        min-height: 6;
+    }
+
+    #toplabel {
+        height: 1;
+    }
+
+    .two {
+        column-span: 2;
+    }
+    .three {
+        column-span: 3;
+    }
+    
+    .four {
+        column-span: 4;
+    }
+    .five {
+        column-span: 5;
+    }
+
+    .box {
+        height: 100%;
+        border: solid green;
+    }
+    """
+
+    def __init__(self, key=None, value=None):
+        super().__init__()
+        self.__key = key
+        self.__value = value
+
+
+    def on_mount(self):
+
+        if self.__key is not None:
+            self.query_one("#key_input", Input).value = str(self.__key)
+
+        if self.__value is not None:
+            self.query_one("#value_input", Input).value = str(self.__value)
+
+
+    def compose(self):
+
+        yield Header()
+
+        with Grid():
+
+            # 8
+            yield Static("Key")
+            yield Input(id="key_input", classes="four")
+
+            yield Static("Value")
+            yield Input(id="value_input", classes="four")
+
+            # 17
+            yield Static(" ", classes="five")
+
+            # 18
+            yield Button("Save", id="save_button")
+            yield Button("Cancel", id="cancel_button")
+
+            # 19
+            yield Static(" ", classes="five")
+
+            # 20
+            yield Static(" ", classes="five", id="messagestatic")
+
+        yield Footer(id="footer")
+
+
+    def getTagFromInput(self):
+
+        tagKey = self.query_one("#key_input", Input).value
+        tagValue = self.query_one("#value_input", Input).value
+
+        return (tagKey, tagValue)
+
+
+   # Event handler for button press
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+
+        # Check if the button pressed is the one we are interested in
+        if event.button.id == "save_button":
+            self.dismiss(self.getTagFromInput())
+
+        if event.button.id == "cancel_button":
+            self.app.pop_screen()

bin/ffx/test/_basename_combinator_1.py

@@ -0,0 +1,64 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .basename_combinator import BasenameCombinator
+
+from .indicator_combinator import IndicatorCombinator
+from .label_combinator import LabelCombinator
+
+class BasenameCombinator2(BasenameCombinator):
+    """documentation_site"""
+
+    VARIANT = 'B2'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return BasenameCombinator2.VARIANT
+
+    def getPayload(self):
+        return ''
+
+    def assertFunc(self, mediaDescriptor: MediaDescriptor):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for L in LabelCombinator.getAllClassReferences():
+#            for I in IndicatorCombinator.getAllClassReferences():
+#                for S in SiteCombinator.getAllClassReferences():
+#                    for T in TitleCombinator.getAllClassReferences():
+#
+
+            l = L(self._context)
+
+            yieldObj = {}
+
+            yieldObj['identifier'] = self.getIdentifier()
+
+            yieldObj['variants'] = [self.getVariant(),
+                                    l.getVariant()]
+
+            yieldObj['payload'] = {'label': l.getPayload()}
+
+            yieldObj['assertSelectors'] = ['B', 'L']
+
+            yieldObj['assertFuncs'] = [self.assertFunc,
+                                        l.assertFunc]
+
+            yieldObj['shouldFail'] = (self.shouldFail()
+                                        | l.shouldFail())
+
+            yield yieldObj

bin/ffx/test/basename_combinator.py

@@ -0,0 +1,35 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class BasenameCombinator():
+
+    IDENTIFIER = 'basename'
+
+    BASENAME = 'media'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return BasenameCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[20:-3]
+                for p
+                in glob.glob(f"{ basePath }/basename_combinator_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.basename_combinator_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.basename_combinator_{ identifier }"]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'BasenameCombinator' and name.startswith('BasenameCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [BasenameCombinator.getClassReference(i) for i in BasenameCombinator.list()]

bin/ffx/test/basename_combinator_0.py

@@ -0,0 +1,107 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .basename_combinator import BasenameCombinator
+
+from .indicator_combinator import IndicatorCombinator
+from .label_combinator import LabelCombinator
+
+
+class BasenameCombinator0(BasenameCombinator):
+    """base[_indicator]"""
+
+    VARIANT = 'B0'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return BasenameCombinator0.VARIANT
+
+    def getPayload(self, indicator = '', label = ''):
+
+        basename = BasenameCombinator.BASENAME
+        expectedBasename = label if label else BasenameCombinator.BASENAME
+
+        if indicator:
+            basename += f"_{indicator}"
+            expectedBasename += f"_{indicator}"
+
+        return {'basename': basename,
+                'label': label,
+                'expectedBasename': expectedBasename}
+
+
+    def assertFunc(self, indicator = '', label = ''):
+
+        def f(testObj: dict = {}):
+
+            if not 'filenames' in testObj.keys():
+                raise KeyError("testObj does not contain key 'filenames'")
+
+            fNames = testObj['filenames']
+
+            assert len(fNames) == 1, "More than one result file was created"
+
+            resultFilename = fNames[0]
+
+            fTokens = resultFilename.split('.')
+
+            resultBasename = '.'.join(fTokens[:-1])
+            resultExtension = fTokens[-1]
+
+            if not indicator and not label:
+                
+                assert resultBasename == BasenameCombinator.BASENAME, f"Result basename is not {BasenameCombinator.BASENAME}"
+            if not indicator and     label:
+                assert resultBasename == label, f"Result basename is not {label}"
+            if     indicator and not label:
+                assert resultBasename == f"{BasenameCombinator.BASENAME}_{indicator}", f"Result basename is not {BasenameCombinator.BASENAME}_{indicator}"
+            if     indicator and     label:
+                assert resultBasename == f"{label}_{indicator}", f"Result basename is not {label}_{indicator}"
+
+        return f
+
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        ic = IndicatorCombinator(self._context)
+
+        for L in LabelCombinator.getAllClassReferences():
+            for i in ic.getYield():
+
+                l = L(self._context)
+
+                indicator = i['indicator']
+                indicatorVariant = i['variant']
+
+                yieldObj = {}
+
+                yieldObj['identifier'] = self.getIdentifier()
+
+                yieldObj['variants'] = [self.getVariant(),
+                                        l.getVariant(),
+                                        indicatorVariant]
+
+                yieldObj['payload'] = self.getPayload(indicator = indicator,
+                                                        label = l.getPayload())
+
+                yieldObj['assertSelectors'] = ['B', 'L', 'I']
+
+                yieldObj['assertFuncs'] = [self.assertFunc(indicator, l.getPayload()), l.assertFunc, ic.assertFunc]
+
+                yieldObj['shouldFail'] = (self.shouldFail()
+                                            | l.shouldFail()
+                                            | ic.shouldFail())
+
+                yield yieldObj

bin/ffx/test/basename_combinator_2.py

@@ -0,0 +1,159 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .basename_combinator import BasenameCombinator
+
+from .indicator_combinator import IndicatorCombinator
+from .label_combinator import LabelCombinator
+from .title_combinator import TitleCombinator
+from .release_combinator import ReleaseCombinator
+from .show_combinator import ShowCombinator
+
+
+class BasenameCombinator2(BasenameCombinator):
+    """show[_indicator]_group"""
+
+    VARIANT = 'B2'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return BasenameCombinator2.VARIANT
+
+#
+#    SHOW_LIST = [
+#        'Boruto: Naruto Next Generations (2017)',
+#        'The Rising of the Shield Hero (2019)',
+#        'Scrubs - Die Anfänger (2001)'
+#    ]
+#
+#    RELEASE_LIST = [
+#        ".GerEngSub.AAC.1080pINDICATOR.WebDL.x264-Tanuki",
+#        ".German.AC3.DL.1080pINDICATOR.BluRay.x264-AST4u",
+#        "-720pINDICATOR"
+#    ]
+
+
+    def getPayload(self,
+                    indicator = '',
+                    label = '',
+                    show = '',
+                    release = ''):
+
+        if label:
+            basename = label
+            expectedBasename = label
+            if indicator:
+                basename += f"_{indicator}"
+                expectedBasename += f"_{indicator}"
+        else:
+            basename = show+release
+            expectedBasename = basename
+
+        return {'basename': basename,
+                'label': label,
+                'expectedBasename': expectedBasename}
+
+
+    def createAssertFunc(self,
+                    indicator = '',
+                    label = '',
+                    show = '',
+                    release = ''):
+
+        def f(testObj: dict = {}):
+
+            if not 'filenames' in testObj.keys():
+                raise KeyError("testObj does not contain key 'filenames'")
+
+            fNames = testObj['filenames']
+
+            assert len(fNames) == 1, "More than one result file was created"
+
+            resultFilename = fNames[0]
+
+            fTokens = resultFilename.split('.')
+
+            resultBasename = '.'.join(fTokens[:-1])
+            resultExtension = fTokens[-1]
+
+            if not indicator and not label:
+                assert resultBasename == show+release, f"Result basename is not {show+release}"
+            elif not indicator and     label:
+                assert resultBasename == label, f"Result basename is not {label}"
+            elif     indicator and not label:
+                assert resultBasename == show+release, f"Result basename is not {show+release}"
+            elif     indicator and     label:
+                assert resultBasename == f"{label}_{indicator}", f"Result basename is not {label}_{indicator}"
+
+        return f
+
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        ic = IndicatorCombinator(self._context)
+        sc = ShowCombinator(self._context)
+
+        for L in LabelCombinator.getAllClassReferences():
+            for iy in ic.getYield():
+
+                indicator = iy['indicator']
+                indicatorVariant = iy['variant']
+
+                rc = ReleaseCombinator(self._context, indicator=indicator)
+
+                for sy in sc.getYield():
+                    for ry in rc.getYield():
+
+                        l = L(self._context)
+
+                        show = sy['show']
+                        showVariant = sy['variant']
+
+                        release = ry['release']
+                        releaseVariant = ry['variant']
+
+                        yieldObj = {}
+
+                        yieldObj['identifier'] = self.getIdentifier()
+
+                        yieldObj['variants'] = [self.getVariant(),
+                                                l.getVariant(),
+                                                indicatorVariant,
+                                                showVariant,
+                                                releaseVariant]
+
+                        yieldObj['payload'] = self.getPayload(indicator = indicator,
+                                                                label = l.getPayload(),
+                                                                show = show,
+                                                                release = release)
+
+                        yieldObj['assertSelectors'] = ['B', 'L', 'I', 'S', 'R']
+
+                        yieldObj['assertFuncs'] = [self.createAssertFunc(indicator,
+                                                                    l.getPayload(),
+                                                                    show = show,
+                                                                    release = release),
+                                                    l.assertFunc,
+                                                    ic.assertFunc,
+                                                    sc.assertFunc,
+                                                    rc.assertFunc]
+
+                        yieldObj['shouldFail'] = (self.shouldFail()
+                                                    | l.shouldFail()
+                                                    | ic.shouldFail()
+                                                    | sc.shouldFail()
+                                                    | rc.shouldFail())
+
+                        yield yieldObj

bin/ffx/test/combinator.py

@@ -0,0 +1,13 @@
+class Combinator():
+
+    def __init__(self, SubCombinations: dict):
+        self._SubCombinators = SubCombinations
+
+    def getPayload(self):
+        pass
+
+    def assertFunc(self, testObj):
+        pass
+
+    def getYield(yieldObj: dict):
+        pass

bin/ffx/test/disposition_combinator_2.py

@@ -0,0 +1,35 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class DispositionCombinator2():
+
+    IDENTIFIER = 'disposition2'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return DispositionCombinator2.IDENTIFIER
+    def getVariant(self):
+        return self._variant
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[25:-3]
+                for p
+                in glob.glob(f"{ basePath }/disposition_combinator_2_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.disposition_combinator_2_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.disposition_combinator_2_{ identifier }"]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'DispositionCombinator2' and name.startswith('DispositionCombinator2'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [DispositionCombinator2.getClassReference(i) for i in DispositionCombinator2.list()]

bin/ffx/test/disposition_combinator_2_0.py

@@ -0,0 +1,76 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator20(DispositionCombinator2):
+
+    # COMMENT
+    # DESCRIPTIONS
+
+    VARIANT = 'D00'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator20.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set()
+        subtrack1 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'forced' disposition"
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                    # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                    # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved set 'descriptions' disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_2_1.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator21(DispositionCombinator2):
+
+    VARIANT = 'D10'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator21.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+        else:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        assert not (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'forced' disposition"
+                        # source subIndex 0
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved set 'comment' disposition"
+
+            else:
+
+                def f(assertObj: dict):
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'comment' disposition"
+                        # source subIndex 1
+                        assert not (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved set 'forced' disposition"
+
+        else:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # source subIndex 0
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+
+            else:
+
+                def f(assertObj: dict):
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+                        # source subIndex 1
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_2_2.py

@@ -0,0 +1,79 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator22(DispositionCombinator2):
+
+    VARIANT = 'D01'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator22.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+        else:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):                        
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'descriptions' disposition"
+                    # source subIndex 1
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                    # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                    # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved 'forced' disposition"
+
+        else:
+
+            def f(assertObj: dict):                        
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    # source subIndex 1
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_2_3 .py

@@ -0,0 +1,43 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator23(DispositionCombinator2):
+
+    VARIANT = 'D11'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator23.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+    #TODO: tmdb cases
+    def createAssertFunc(self):
+        def f(assertObj: dict = {}):
+            pass
+        return f
+
+    def shouldFail(self):
+        return True

bin/ffx/test/disposition_combinator_3.py

@@ -0,0 +1,34 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class DispositionCombinator3():
+
+    IDENTIFIER = 'disposition3'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return DispositionCombinator3.IDENTIFIER
+
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[25:-3]
+                for p
+                in glob.glob(f"{ basePath }/disposition_combinator_3_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.disposition_combinator_3_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.disposition_combinator_3_{ identifier }"]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'DispositionCombinator3' and name.startswith('DispositionCombinator3'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [DispositionCombinator3.getClassReference(i) for i in DispositionCombinator3.list()]

bin/ffx/test/disposition_combinator_3_0.py

@@ -0,0 +1,92 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator30(DispositionCombinator3):
+
+    VARIANT = 'D000'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator30.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set()
+        subtrack1 = set()
+        subtrack2 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+                    
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+
+                trackDescriptors = assertObj['tracks']
+
+                # source subIndex 0
+                assert not (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved default disposition"
+
+                # source subIndex 1
+                assert not (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+
+                # source subIndex 2
+                assert not (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+                # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                    
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+
+                trackDescriptors = assertObj['tracks']
+
+                # source subIndex 0
+                assert not (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+
+                # source subIndex 1
+                assert not (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+                # source subIndex 2
+                assert not (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+        return f
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_3_1.py

@@ -0,0 +1,147 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator31(DispositionCombinator3):
+
+    VARIANT = 'D100'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator31.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set()
+            subtrack1 = set()
+            subtrack2 = set([TrackDisposition.DEFAULT])
+        else:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+            subtrack2 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+    def createAssertFunc(self):
+        
+        if self.__createPresets:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):
+                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved descriptions disposition"
+
+                        # source subIndex 2
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                        # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+
+                        # source subIndex 0
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved set default disposition"
+
+            else:
+                def f(assertObj: dict):
+
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved default disposition"
+
+                        # source subIndex 1
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+
+                        # source subIndex 2
+                        assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                        # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):
+                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+
+                        # source subIndex 2
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+                        # source subIndex 0
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+
+            else:
+                def f(assertObj: dict):
+
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+
+                        # source subIndex 1
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+                        # source subIndex 2
+                        assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_3_2.py

@@ -0,0 +1,132 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator32(DispositionCombinator3):
+
+    VARIANT = 'D010'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator32.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+            subtrack2 = set()
+        else:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+            subtrack2 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+            subtrack2.add(TrackDisposition.FORCED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set default disposition"
+                        # source subIndex 2
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+                        # source subIndex 1
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                        # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved descriptions disposition"
+
+            else:
+
+                def f(assertObj: dict):
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set default disposition"
+                        # source subIndex 1
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                        # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved descriptions disposition"
+                        # source subIndex 2
+                        assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # source subIndex 2
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        # source subIndex 1
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+
+            else:
+
+                def f(assertObj: dict):
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # source subIndex 1
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                        # source subIndex 2
+                        assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+        return f
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_3_3.py

@@ -0,0 +1,132 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator33(DispositionCombinator3):
+
+    VARIANT = 'D001'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator33.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+            subtrack2 = set()
+        else:
+            subtrack0 = set()
+            subtrack1 = set()
+            subtrack2 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set default disposition"
+                        # source subIndex 2
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                        # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+                        # source subIndex 1
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved descriptions disposition"
+
+            else:
+
+                def f(assertObj: dict):
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                        # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set default disposition"
+                        # source subIndex 1
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved descriptions disposition"
+                        # source subIndex 2
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+                        # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                        # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # source subIndex 2
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        # source subIndex 1
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+
+            else:
+
+                def f(assertObj: dict):
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 0
+                        assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                        # source subIndex 1
+                        assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                        # source subIndex 2
+                        assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                        ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+        return f
+
+    def shouldFail(self):
+        return False

bin/ffx/test/disposition_combinator_3_4.py

@@ -0,0 +1,46 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator34(DispositionCombinator3):
+
+    VARIANT = 'D101'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator34.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set()
+        subtrack2 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+    #TODO: tmpdb cases
+    def createAssertFunc(self):
+        def f(assertObj: dict = {}):
+            pass
+        return f
+
+    def shouldFail(self):
+        return True

bin/ffx/test/helper.py

@@ -0,0 +1,277 @@
+import os, math, tempfile, click
+
+
+from ffx.ffx_controller import FfxController
+
+from ffx.process import executeProcess
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.track_type import TrackType
+
+from ffx.helper import dictCache
+
+
+SHORT_SUBTITLE_SEQUENCE = [{'start': 1, 'end': 2, 'text': 'yolo'},
+                           {'start': 3, 'end': 4, 'text': 'zolo'},
+                           {'start': 5, 'end': 6, 'text': 'golo'}]
+
+def getTimeString(hours: float = 0.0,
+                    minutes: float = 0.0,
+                    seconds: float = 0.0,
+                    millis: float = 0.0,
+                    format: str = ''):
+
+    duration = (hours * 3600.0
+                + minutes * 60.0
+                + seconds
+                + millis / 1000.0)
+
+    hours = math.floor(duration / 3600.0)
+    remaining = duration - 3600.0 * hours
+
+    minutes = math.floor(remaining / 60.0)
+    remaining = remaining - 60.0 * minutes
+
+    seconds = math.floor(remaining)
+    remaining = remaining - seconds
+
+    millis = math.floor(remaining * 1000)
+
+    if format == 'ass':
+        return f"{hours:01d}:{minutes:02d}:{seconds:02d}.{millis:02d}"
+
+    # srt & vtt
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}.{millis:03d}"
+
+
+def createAssFile(entries: dict, directory = None):
+
+    # [Script Info]
+    # ; Script generated by FFmpeg/Lavc61.3.100
+    # ScriptType: v4.00+
+    # PlayResX: 384
+    # PlayResY: 288
+    # ScaledBorderAndShadow: yes
+    # YCbCr Matrix: None
+    # 
+    # [V4+ Styles]
+    # Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+    # Style: Default,Arial,16,&Hffffff,&Hffffff,&H0,&H0,0,0,0,0,100,100,0,0,1,1,0,2,10,10,10,1
+    # 
+    # [Events]
+    # Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+    # Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,yolo
+    # Dialogue: 0,0:00:03.00,0:00:04.00,Default,,0,0,0,,zolo
+    # Dialogue: 0,0:00:05.00,0:00:06.00,Default,,0,0,0,,golo
+    tmpFileName = tempfile.mktemp(suffix=".ass", dir = directory)
+
+    with open(tmpFileName, 'w') as tmpFile:
+
+        tmpFile.write("[Script Info]\n")
+        tmpFile.write("; Script generated by Ffx\n")
+        tmpFile.write("ScriptType: v4.00+\n")
+        tmpFile.write("PlayResX: 384\n")
+        tmpFile.write("PlayResY: 288\n")
+        tmpFile.write("ScaledBorderAndShadow: yes\n")
+        tmpFile.write("YCbCr Matrix: None\n")
+        tmpFile.write("\n")
+        tmpFile.write("[V4+ Styles]\n")
+        tmpFile.write("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n")
+        tmpFile.write("Style: Default,Arial,16,&Hffffff,&Hffffff,&H0,&H0,0,0,0,0,100,100,0,0,1,1,0,2,10,10,10,1\n")
+        tmpFile.write("\n")
+        tmpFile.write("[Events]\n")
+        tmpFile.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
+
+        for entryIndex in range(len(entries)):
+            tmpFile.write(f"Dialogue: 0,{getTimeString(seconds=entries[entryIndex]['start'], format='ass')},{getTimeString(seconds=entries[entryIndex]['end'], format='ass')},Default,,0,0,0,,{entries[entryIndex]['text']}\n")
+
+    return tmpFileName
+
+def createSrtFile(entries: dict, directory = None):
+    # 1
+    # 00:00:00,000 --> 00:00:02,500
+    # Welcome to the Example Subtitle File!
+    # 
+    # 2
+    # 00:00:03,000 --> 00:00:06,000
+    # This is a demonstration of SRT subtitles.
+    # 
+    # 3
+    # 00:00:07,000 --> 00:00:10,500
+    # You can use SRT files to add subtitles to your videos.
+
+    tmpFileName = tempfile.mktemp(suffix=".srt", dir = directory)
+
+    with open(tmpFileName, 'w') as tmpFile:
+
+        for entryIndex in range(len(entries)):
+
+            tmpFile.write(f"{entryIndex}\n")
+            tmpFile.write(f"{getTimeString(seconds=entries[entryIndex]['start'])} --> {getTimeString(seconds=entries[entryIndex]['end'])}\n")
+            tmpFile.write(f"{entries[entryIndex]['text']}\n\n")
+
+    return tmpFileName
+
+
+def createVttFile(entries: dict, directory = None):
+    # WEBVTT
+    # 
+    # 01:20:33.050 --> 01:20:35.050
+    # Yolo
+
+    tmpFileName = tempfile.mktemp(suffix=".vtt", dir = directory)
+
+    with open(tmpFileName, 'w') as tmpFile:
+
+        tmpFile.write("WEBVTT\n")
+
+        for entryIndex in range(len(entries)):
+
+            tmpFile.write("\n")
+            tmpFile.write(f"{getTimeString(seconds=entries[entryIndex]['start'])} --> {getTimeString(seconds=entries[entryIndex]['end'])}\n")
+            tmpFile.write(f"{entries[entryIndex]['text']}\n")
+
+
+    return tmpFileName
+
+
+def createMediaTestFile(mediaDescriptor: MediaDescriptor,
+                    directory: str = '',
+                    baseName: str = 'media',
+                    format: str = '',
+                    extension: str = 'mkv',
+                    sizeX: int = 1280,
+                    sizeY: int = 720,
+                    rate: int = 25,
+                    length: int = 10,
+                    logger = None):
+
+    # subtitleFilePath = createVttFile(SHORT_SUBTITLE_SEQUENCE)
+
+    # commandTokens = FfxController.COMMAND_TOKENS
+    commandTokens = ['ffmpeg', '-y']
+
+    generatorCache = []
+    generatorTokens = []
+    mappingTokens = []
+    importTokens = []
+    metadataTokens = []
+
+
+    for mediaTagKey, mediaTagValue in mediaDescriptor.getTags().items():
+        metadataTokens += ['-metadata:g', f"{mediaTagKey}={mediaTagValue}"]
+
+    subIndexCounter = {}
+
+    for trackDescriptor in mediaDescriptor.getAllTrackDescriptors():
+
+        trackType = trackDescriptor.getType()
+
+        if trackType == TrackType.VIDEO:
+
+            cacheIndex, generatorCache = dictCache({'type': TrackType.VIDEO}, generatorCache)
+            # click.echo(f"createMediaTestFile() cache index={cacheIndex} size={len(generatorCache)}")
+
+            if cacheIndex == -1:
+                generatorTokens += ['-f',
+                                    'lavfi',
+                                    '-i',
+                                    f"color=size={sizeX}x{sizeY}:rate={rate}:color=black"]
+
+            sourceIndex = len(generatorCache) - 1 if cacheIndex == -1 else cacheIndex
+            mappingTokens += ['-map', f"{sourceIndex}:v:0"]
+
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            for mediaTagKey, mediaTagValue in trackDescriptor.getTags().items():
+                metadataTokens += [f"-metadata:s:{trackType.indicator()}:{subIndexCounter[trackType]}",
+                                    f"{mediaTagKey}={mediaTagValue}"]
+            subIndexCounter[trackType] += 1
+
+        if trackType == TrackType.AUDIO:
+
+            audioLayout = 'stereo'
+
+            cacheIndex, generatorCache = dictCache({'type': TrackType.AUDIO, 'layout': audioLayout}, generatorCache)
+            # click.echo(f"createMediaTestFile() cache index={cacheIndex} size={len(generatorCache)}")
+
+            # click.echo(f"generartorCache index={cacheIndex} len={len(generatorCache)}")
+            if cacheIndex == -1:
+                generatorTokens += ['-f',
+                                    'lavfi',
+                                    '-i',
+                                    f"anullsrc=channel_layout={audioLayout}:sample_rate=44100"]
+
+            sourceIndex = len(generatorCache) - 1 if cacheIndex == -1 else cacheIndex
+            mappingTokens += ['-map', f"{sourceIndex}:a:0"]
+
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            for mediaTagKey, mediaTagValue in trackDescriptor.getTags().items():
+                metadataTokens += [f"-metadata:s:{trackType.indicator()}:{subIndexCounter[trackType]}",
+                                    f"{mediaTagKey}={mediaTagValue}"]
+            subIndexCounter[trackType] += 1
+
+        if trackType == TrackType.SUBTITLE:
+
+            cacheIndex, generatorCache = dictCache({'type': TrackType.SUBTITLE}, generatorCache)
+            # click.echo(f"createMediaTestFile() cache index={cacheIndex} size={len(generatorCache)}")
+
+            if cacheIndex == -1:
+                importTokens = ['-i', createVttFile(SHORT_SUBTITLE_SEQUENCE, directory=directory if directory else None)]
+
+            sourceIndex = len(generatorCache) - 1 if cacheIndex == -1 else cacheIndex
+            mappingTokens += ['-map', f"{sourceIndex}:s:0"]
+
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            for mediaTagKey, mediaTagValue in trackDescriptor.getTags().items():
+                metadataTokens += [f"-metadata:s:{trackType.indicator()}:{subIndexCounter[trackType]}",
+                                    f"{mediaTagKey}={mediaTagValue}"]
+            subIndexCounter[trackType] += 1
+
+    ffxContext = {'logger': logger}
+    fc = FfxController(ffxContext, mediaDescriptor)
+
+    commandTokens += (generatorTokens
+                        + importTokens
+                        + mappingTokens
+                        + metadataTokens
+                        + fc.generateDispositionTokens())
+
+
+    commandTokens += ['-t', str(length)]
+
+    if format:
+        commandTokens += ['-f', format]
+
+    fileName = f"{baseName}.{extension}"
+
+    if directory:
+        outputPath = os.path.join(directory, fileName)
+    else:
+        outputPath = fileName
+
+    commandTokens += [outputPath]
+
+
+    if not logger is None:
+        logger.debug(f"createMediaTestFile(): Command sequence: {commandTokens}")
+
+    out, err, rc = executeProcess(commandTokens)
+
+    if not logger is None:
+        if out:
+            logger.debug(f"createMediaTestFile(): Process output: {out}")
+        if rc:
+            logger.debug(f"createMediaTestFile(): Process returned ERROR {rc} ({err})")
+
+
+    return outputPath
+
+
+def createEmptyDirectory():
+    return tempfile.mkdtemp()
+
+def createEmptyFile(suffix=None):
+    return tempfile.mkstemp(suffix=suffix)

bin/ffx/test/indicator_combinator.py

@@ -0,0 +1,43 @@
+class IndicatorCombinator():
+
+    IDENTIFIER = 'indicator'
+
+    MAX_SEASON = 2
+    MAX_EPISODE = 3
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return IndicatorCombinator.IDENTIFIER
+        
+    def getPayload(self, season: int = -1, episode: int = -1):
+        if season == -1 and episode == -1:
+            return {
+                'variant': 'S00E00',
+                'indicator': '',
+                'season': season,
+                'episode': episode
+            }
+        else:
+            return {
+                'variant': f"S{season:02d}E{episode:02d}",
+                'indicator': f"S{season:02d}E{episode:02d}",
+                'season': season,
+                'episode': episode
+            }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        yield self.getPayload()
+        for season in range(IndicatorCombinator.MAX_SEASON):
+            for episode in range(IndicatorCombinator.MAX_EPISODE):
+                yield self.getPayload(season+1, episode+1)

bin/ffx/test/jellyfin_combinator.py

@@ -0,0 +1,33 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class JellyfinCombinator():
+
+    IDENTIFIER = 'jellyfin'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return JellyfinCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[20:-3]
+                for p
+                in glob.glob(f"{ basePath }/jellyfin_combinator_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.jellyfin_combinator_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.jellyfin_combinator_{ identifier }"]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'JellyfinCombinator' and name.startswith('JellyfinCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [JellyfinCombinator.getClassReference(i) for i in JellyfinCombinator.list()]

bin/ffx/test/jellyfin_combinator_0.py

@@ -0,0 +1,34 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .jellyfin_combinator import JellyfinCombinator
+
+
+class JellyfinCombinator0(JellyfinCombinator):
+
+    VARIANT = 'J0'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinators
+
+    def getVariant(self):
+        return JellyfinCombinator0.VARIANT
+
+
+    def getPayload(self):
+        return False
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False

bin/ffx/test/jellyfin_combinator_1.py

@@ -0,0 +1,34 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .jellyfin_combinator import JellyfinCombinator
+
+class JellyfinCombinator1(JellyfinCombinator):
+
+    VARIANT = 'J1'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+    def getVariant(self):
+        return JellyfinCombinator1.VARIANT
+
+
+    def getPayload(self):
+        return True
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False

bin/ffx/test/label_combinator.py

@@ -0,0 +1,36 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class LabelCombinator():
+
+    IDENTIFIER = 'label'
+    PREFIX = 'label_combinator_'
+
+    LABEL = 'ffx'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return LabelCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[len(LabelCombinator.PREFIX):-3]
+                for p
+                in glob.glob(f"{ basePath }/{LabelCombinator.PREFIX}*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.{LabelCombinator.PREFIX}{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.{LabelCombinator.PREFIX}{ identifier }"]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'LabelCombinator' and name.startswith('LabelCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [LabelCombinator.getClassReference(i) for i in LabelCombinator.list()]

bin/ffx/test/label_combinator_0.py

@@ -0,0 +1,30 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .label_combinator import LabelCombinator
+
+
+class LabelCombinator0(LabelCombinator):
+
+    VARIANT = 'L0'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return LabelCombinator0.VARIANT
+
+    def getPayload(self):
+        return ''
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False

bin/ffx/test/label_combinator_1.py

@@ -0,0 +1,30 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .label_combinator import LabelCombinator
+
+class LabelCombinator1(LabelCombinator):
+
+    VARIANT = 'L1'
+
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return LabelCombinator1.VARIANT
+
+    def getPayload(self):
+        return LabelCombinator.LABEL
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False

bin/ffx/test/media_combinator.py

@@ -0,0 +1,33 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class MediaCombinator():
+
+    IDENTIFIER = 'media'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return MediaCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[17:-3]
+                for p
+                in glob.glob(f"{ basePath }/media_combinator_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.media_combinator_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.media_combinator_{ identifier }"]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'MediaCombinator' and name.startswith('MediaCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [MediaCombinator.getClassReference(i) for i in MediaCombinator.list()]

bin/ffx/test/media_combinator_0.py

@@ -0,0 +1,104 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator0(MediaCombinator):
+
+    VARIANT = 'VA'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator0.VARIANT
+
+
+
+    def getPayload(self):
+
+        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 = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor1,
+                                                                trackDescriptor2]
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+
+            mtc = MTC(self._context)
+
+            yObj = {}
+
+            yObj['identifier'] = self.getIdentifier()
+            yObj['variants'] = [self.getVariant(),
+                                    mtc.getVariant()]
+            yObj['payload'] = self.getPayload()
+
+            yObj['assertSelectors'] = ['M', 'MT']
+            yObj['assertFuncs'] = [self.assertFunc, 
+                                        mtc.createAssertFunc()]
+            yObj['shouldFail'] = (self.shouldFail()
+                                        | mtc.shouldFail())
+
+            yieldObj = {'target': yObj}
+
+            if self.__createPresets:
+
+                mtc_p = MTC(self._context, createPresets = True)
+
+                yObj_p = {}
+
+                yObj_p['identifier'] = self.getIdentifier()
+                yObj_p['variants'] = [self.getVariant(),
+                                        mtc_p.getVariant()]
+
+                yObj_p['payload'] = self.getPayload()
+
+                yObj_p['assertSelectors'] = ['M', 'MT']
+                yObj_p['assertFuncs'] = [self.assertFunc, 
+                                            mtc_p.createAssertFunc()]
+                yObj_p['shouldFail'] = (self.shouldFail()
+                                            | mtc_p.shouldFail())
+
+                yieldObj['preset'] = yObj_p
+
+            yield yieldObj

bin/ffx/test/media_combinator_1.py

@@ -0,0 +1,115 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator1(MediaCombinator):
+
+    VARIANT = 'VAS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator1.VARIANT
+
+
+    def getPayload(self):
+
+        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 = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+
+            mtc = MTC(self._context)
+
+            yObj = {}
+
+            yObj['identifier'] = self.getIdentifier()
+            yObj['variants'] = [self.getVariant(),
+                                    mtc.getVariant()]
+
+            yObj['payload'] = self.getPayload()
+
+            yObj['assertSelectors'] = ['M', 'MT']
+            yObj['assertFuncs'] = [self.assertFunc,
+                                        mtc.createAssertFunc()]
+
+            yObj['shouldFail'] = (self.shouldFail()
+                                        | mtc.shouldFail())
+
+            yieldObj = {'target': yObj}
+
+            if self.__createPresets:
+
+                mtc_p = MTC(self._context, createPresets = True)
+
+                yObj_p = {}
+
+                yObj_p['identifier'] = self.getIdentifier()
+                yObj_p['variants'] = [self.getVariant(),
+                                        mtc_p.getVariant()]
+
+                yObj_p['payload'] = self.getPayload()
+
+                yObj_p['assertSelectors'] = ['M', 'MT']
+                yObj_p['assertFuncs'] = [self.assertFunc,
+                                            mtc_p.createAssertFunc()]
+
+                yObj_p['shouldFail'] = (self.shouldFail()
+                                            | mtc_p.shouldFail())
+                yieldObj['preset'] = yObj_p
+
+            yield yieldObj

bin/ffx/test/media_combinator_2.py

@@ -0,0 +1,166 @@
+import os, sys, importlib, glob, inspect, itertools, click
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+from .track_tag_combinator_2 import TrackTagCombinator2
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator2(MediaCombinator):
+
+    VARIANT = 'VASS'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaCombinator2.VARIANT
+
+
+    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)
+      
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] =  [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2 in DispositionCombinator2.getAllClassReferences():
+                for TC2 in TrackTagCombinator2.getAllClassReferences():
+                    for J in JellyfinCombinator.getAllClassReferences():
+
+                        j = J(self._context)
+                        self._context['use_jellyfin'] = j.getPayload()
+
+                        dc2 = DC2(self._context)
+                        tc2 = TC2(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"S:{dc2.getVariant()}",
+                                                f"S:{tc2.getVariant()}",
+                                                mtc.getVariant(),
+                                                j.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc2.getPayload(),
+                                                          tc2.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'SD', 'ST', 'MT', 'J']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc2.createAssertFunc(),
+                                                    tc2.createAssertFunc(),
+                                                    mtc.createAssertFunc(),
+                                                    j.assertFunc]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                    | dc2.shouldFail()
+                                                    | tc2.shouldFail()
+                                                    | mtc.shouldFail()
+                                                    | j.shouldFail())
+
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc2_p = DC2(self._context, createPresets = True)
+                            tc2_p = TC2(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"S:{dc2_p.getVariant()}",
+                                                    f"S:{tc2_p.getVariant()}",
+                                                    mtc_p.getVariant(),
+                                                    j.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc2_p.getPayload(),
+                                                                tc2_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'SD', 'ST', 'MT', 'J']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc2_p.createAssertFunc(),
+                                                        tc2_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc(),
+                                                        j.assertFunc]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                        | dc2_p.shouldFail()
+                                                        | tc2_p.shouldFail()
+                                                        | mtc_p.shouldFail()
+                                                        | j.shouldFail())
+
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

bin/ffx/test/media_combinator_3.py

@@ -0,0 +1,175 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_3 import DispositionCombinator3
+from .track_tag_combinator_3 import TrackTagCombinator3
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator3(MediaCombinator):
+
+    VARIANT = 'VASSS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator3.VARIANT
+
+
+    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)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] =  [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3,
+                trackDescriptor4]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC3 in DispositionCombinator3.getAllClassReferences():
+                for TC3 in TrackTagCombinator3.getAllClassReferences():
+                    for J in JellyfinCombinator.getAllClassReferences():
+
+                        j = J(self._context)
+                        self._context['use_jellyfin'] = j.getPayload()
+
+                        dc3 = DC3(self._context)
+                        tc3 = TC3(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"S:{dc3.getVariant()}",
+                                                f"S:{tc3.getVariant()}",
+                                                mtc.getVariant(),
+                                                j.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc3.getPayload(),
+                                                            tc3.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'SD', 'ST', 'MT', 'J']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc3.createAssertFunc(),
+                                                    tc3.createAssertFunc(),
+                                                    mtc.createAssertFunc(),
+                                                    j.assertFunc]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                    | dc3.shouldFail()
+                                                    | tc3.shouldFail()
+                                                    | mtc.shouldFail()
+                                                    | j.shouldFail())
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc3_p = DC3(self._context, createPresets = True)
+                            tc3_p = TC3(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"S:{dc3_p.getVariant()}",
+                                                    f"S:{tc3_p.getVariant()}",
+                                                    mtc_p.getVariant(),
+                                                    j.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc3_p.getPayload(),
+                                                                tc3_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'SD', 'ST', 'MT', 'J']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc3_p.createAssertFunc(),
+                                                        tc3_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc(),
+                                                        j.assertFunc]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                        | dc3_p.shouldFail()
+                                                        | tc3_p.shouldFail()
+                                                        | mtc_p.shouldFail()
+                                                        | j.shouldFail())
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

bin/ffx/test/media_combinator_4.py

@@ -0,0 +1,155 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+from .track_tag_combinator_2 import TrackTagCombinator2
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator4(MediaCombinator):
+
+    VARIANT = 'VAA'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator4.VARIANT
+
+
+    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[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] =  [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2 in DispositionCombinator2.getAllClassReferences():
+                for TC2 in TrackTagCombinator2.getAllClassReferences():
+                    for J in JellyfinCombinator.getAllClassReferences():
+
+                        j = J(self._context)
+                        self._context['use_jellyfin'] = j.getPayload()
+
+                        dc2 = DC2(self._context)
+                        tc2 = TC2(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"A:{dc2.getVariant()}",
+                                                f"A:{tc2.getVariant()}",
+                                                mtc.getVariant(),
+                                                j.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc2.getPayload(),
+                                                            tc2.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'AD', 'AT', 'MT', 'J']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc2.createAssertFunc(),
+                                                    tc2.createAssertFunc(),
+                                                    mtc.createAssertFunc(),
+                                                    j.assertFunc]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                | dc2.shouldFail()
+                                                | tc2.shouldFail()
+                                                | mtc.shouldFail()
+                                                | j.shouldFail())
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc2_p = DC2(self._context, createPresets = True)
+                            tc2_p = TC2(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"A:{dc2_p.getVariant()}",
+                                                    f"A:{tc2_p.getVariant()}",
+                                                    mtc_p.getVariant(),
+                                                    j.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc2_p.getPayload(),
+                                                                tc2_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'MT', 'J']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc2_p.createAssertFunc(),
+                                                        tc2_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc(),
+                                                        j.assertFunc]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                    | dc2_p.shouldFail()
+                                                    | tc2_p.shouldFail()
+                                                    | mtc_p.shouldFail()
+                                                    | j.shouldFail())
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

bin/ffx/test/media_combinator_5.py

@@ -0,0 +1,165 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+from .track_tag_combinator_2 import TrackTagCombinator2
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator5(MediaCombinator):
+
+    VARIANT = 'VAAS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator5.VARIANT
+
+
+    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)
+
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2 in DispositionCombinator2.getAllClassReferences():
+                for TC2 in TrackTagCombinator2.getAllClassReferences():
+                    for J in JellyfinCombinator.getAllClassReferences():
+
+                        j = J(self._context)
+                        self._context['use_jellyfin'] = j.getPayload()
+
+                        dc2 = DC2(self._context)
+                        tc2 = TC2(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"A:{dc2.getVariant()}",
+                                                f"A:{tc2.getVariant()}",
+                                                mtc.getVariant(),
+                                                j.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc2.getPayload(),
+                                                          tc2.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'AD', 'AT', 'MT', 'J']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc2.createAssertFunc(),
+                                                    tc2.createAssertFunc(),
+                                                    mtc.createAssertFunc(),
+                                                    j.assertFunc]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                    | dc2.shouldFail()
+                                                    | tc2.shouldFail()
+                                                    | mtc.shouldFail()
+                                                    | j.shouldFail())
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc2_p = DC2(self._context, createPresets = True)
+                            tc2_p = TC2(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"A:{dc2_p.getVariant()}",
+                                                    f"A:{tc2_p.getVariant()}",
+                                                    mtc_p.getVariant(),
+                                                    j.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc2_p.getPayload(),
+                                                                tc2_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'MT', 'J']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc2_p.createAssertFunc(),
+                                                        tc2_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc(),
+                                                        j.assertFunc]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                        | dc2_p.shouldFail()
+                                                        | tc2_p.shouldFail()
+                                                        | mtc_p.shouldFail()
+                                                        | j.shouldFail())
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

bin/ffx/test/media_combinator_6.py

@@ -0,0 +1,201 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+from .track_tag_combinator_2 import TrackTagCombinator2
+from .jellyfin_combinator import JellyfinCombinator
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator6(MediaCombinator):
+
+    VARIANT = 'VAASS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator6.VARIANT
+
+
+    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)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3,
+                trackDescriptor4]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2_A in DispositionCombinator2.getAllClassReferences():
+                for TC2_A in TrackTagCombinator2.getAllClassReferences():
+                    for DC2_S in DispositionCombinator2.getAllClassReferences():
+                        for TC2_S in TrackTagCombinator2.getAllClassReferences():
+                            for J in JellyfinCombinator.getAllClassReferences():
+                
+                                j = J(self._context)
+                                self._context['use_jellyfin'] = j.getPayload()
+                                
+                                dc2a = DC2_A(self._context)
+                                tc2a = TC2_A(self._context)
+                                dc2s = DC2_S(self._context)
+                                tc2s = TC2_S(self._context)
+
+                                mtc = MTC(self._context)
+
+                                yObj = {}
+
+                                yObj['identifier'] = self.getIdentifier()
+                                yObj['variants'] = [self.getVariant(),
+                                                        f"A:{dc2a.getVariant()}",
+                                                        f"A:{tc2a.getVariant()}",
+                                                        f"S:{dc2s.getVariant()}",
+                                                        f"S:{tc2s.getVariant()}",
+                                                        mtc.getVariant(),
+                                                        j.getVariant()]
+
+                                yObj['payload'] = self.getPayload(dc2a.getPayload(),
+                                                                    tc2a.getPayload(),
+                                                                    dc2s.getPayload(),
+                                                                    tc2s.getPayload())
+
+                                yObj['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT', 'J']
+                                yObj['assertFuncs'] = [self.assertFunc,
+                                                            dc2a.createAssertFunc(),
+                                                            tc2a.createAssertFunc(),
+                                                            dc2s.createAssertFunc(),
+                                                            tc2s.createAssertFunc(),
+                                                            mtc.createAssertFunc(),
+                                                            j.assertFunc]
+
+                                yObj['shouldFail'] = (self.shouldFail()
+                                                            | dc2a.shouldFail()
+                                                            | tc2a.shouldFail()
+                                                            | dc2s.shouldFail()
+                                                            | tc2s.shouldFail()
+                                                            | mtc.shouldFail()
+                                                            | j.shouldFail())
+                                yieldObj = {'target': yObj}
+
+                                if self.__createPresets:
+
+                                    dc2a_p = DC2_A(self._context, createPresets = True)
+                                    tc2a_p = TC2_A(self._context, createPresets = True)
+                                    dc2s_p = DC2_S(self._context, createPresets = True)
+                                    tc2s_p = TC2_S(self._context, createPresets = True)
+
+                                    mtc_p = MTC(self._context, createPresets = True)
+
+                                    yObj_p = {}
+
+                                    yObj_p['identifier'] = self.getIdentifier()
+                                    yObj_p['variants'] = [self.getVariant(),
+                                                            f"A:{dc2a_p.getVariant()}",
+                                                            f"A:{tc2a_p.getVariant()}",
+                                                            f"S:{dc2s_p.getVariant()}",
+                                                            f"S:{tc2s_p.getVariant()}",
+                                                            mtc_p.getVariant(),
+                                                            j.getVariant()]
+
+                                    yObj_p['payload'] = self.getPayload(dc2a_p.getPayload(),
+                                                                        tc2a_p.getPayload(),
+                                                                        dc2s_p.getPayload(),
+                                                                        tc2s_p.getPayload())
+
+                                    yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT', 'J']
+                                    yObj_p['assertFuncs'] = [self.assertFunc,
+                                                                dc2a_p.createAssertFunc(),
+                                                                tc2a_p.createAssertFunc(),
+                                                                dc2s_p.createAssertFunc(),
+                                                                tc2s_p.createAssertFunc(),
+                                                                mtc_p.createAssertFunc(),
+                                                                j.assertFunc]
+
+                                    yObj_p['shouldFail'] = (self.shouldFail()
+                                                                | dc2a_p.shouldFail()
+                                                                | tc2a_p.shouldFail()
+                                                                | dc2s_p.shouldFail()
+                                                                | tc2s_p.shouldFail()
+                                                                | mtc_p.shouldFail()
+                                                                | j.shouldFail())
+                                    yieldObj['preset'] = yObj_p
+
+                                yield yieldObj

bin/ffx/test/media_combinator_7.py

@@ -0,0 +1,215 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+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
+
+class MediaCombinator7(MediaCombinator):
+
+    VARIANT = 'VAASSS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator7.VARIANT
+
+
+    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 = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3,
+                trackDescriptor4,
+                trackDescriptor5]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        # mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2_A 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():
+                
+                                j = J(self._context)
+                                self._context['use_jellyfin'] = j.getPayload()
+                                
+                                dc2a = DC2_A(self._context)
+                                tc2a = TC2_A(self._context)
+                                dc3s = DC3_S(self._context)
+                                tc3s = TC3_S(self._context)
+
+                                mtc = MTC(self._context)
+
+                                yObj = {}
+
+                                yObj['identifier'] = self.getIdentifier()
+                                yObj['variants'] = [self.getVariant(),
+                                                        f"A:{dc2a.getVariant()}",
+                                                        f"A:{tc2a.getVariant()}",
+                                                        f"S:{dc3s.getVariant()}",
+                                                        f"S:{tc3s.getVariant()}",
+                                                        mtc.getVariant(),
+                                                        j.getVariant()]
+
+                                yObj['payload'] = self.getPayload(dc2a.getPayload(),
+                                                                    tc2a.getPayload(),
+                                                                    dc3s.getPayload(),
+                                                                    tc3s.getPayload())
+
+                                yObj['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT', 'J']
+
+                                yObj['assertFuncs'] = [self.assertFunc,
+                                                            dc2a.createAssertFunc(),
+                                                            tc2a.createAssertFunc(),
+                                                            dc3s.createAssertFunc(),
+                                                            tc3s.createAssertFunc(),
+                                                            mtc.createAssertFunc(),
+                                                            j.assertFunc]
+
+                                yObj['shouldFail'] = (self.shouldFail()
+                                                            | dc2a.shouldFail()
+                                                            | tc2a.shouldFail()
+                                                            | dc3s.shouldFail()
+                                                            | tc3s.shouldFail()
+                                                            | mtc.shouldFail()
+                                                            | j.shouldFail())
+                                yieldObj = {'target': yObj}
+
+                                if self.__createPresets:
+
+                                    dc2a_p = DC2_A(self._context, createPresets = True)
+                                    tc2a_p = TC2_A(self._context, createPresets = True)
+                                    dc3s_p = DC3_S(self._context, createPresets = True)
+                                    tc3s_p = TC3_S(self._context, createPresets = True)
+
+                                    mtc_p = MTC(self._context, createPresets = True)
+
+                                    yObj_p = {}
+
+                                    yObj_p['identifier'] = self.getIdentifier()
+                                    yObj_p['variants'] = [self.getVariant(),
+                                                            f"A:{dc2a_p.getVariant()}",
+                                                            f"A:{tc2a_p.getVariant()}",
+                                                            f"S:{dc3s_p.getVariant()}",
+                                                            f"S:{tc3s_p.getVariant()}",
+                                                            mtc_p.getVariant(),
+                                                            j.getVariant()]
+
+                                    yObj_p['payload'] = self.getPayload(dc2a_p.getPayload(),
+                                                                        tc2a_p.getPayload(),
+                                                                        dc3s_p.getPayload(),
+                                                                        tc3s_p.getPayload())
+
+                                    yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT', 'J']
+
+                                    yObj_p['assertFuncs'] = [self.assertFunc,
+                                                                dc2a_p.createAssertFunc(),
+                                                                tc2a_p.createAssertFunc(),
+                                                                dc3s_p.createAssertFunc(),
+                                                                tc3s_p.createAssertFunc(),
+                                                                mtc_p.createAssertFunc(),
+                                                                j.assertFunc]
+
+                                    yObj_p['shouldFail'] = (self.shouldFail()
+                                                                | dc2a_p.shouldFail()
+                                                                | tc2a_p.shouldFail()
+                                                                | dc3s_p.shouldFail()
+                                                                | tc3s_p.shouldFail()
+                                                                | mtc_p.shouldFail()
+                                                                | j.shouldFail())
+                                    yieldObj['preset'] = yObj_p
+
+                                yield yieldObj

bin/ffx/test/media_tag_combinator.py

@@ -0,0 +1,33 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class MediaTagCombinator():
+
+    IDENTIFIER = 'mediaTag'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return MediaTagCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[21:-3]
+                for p
+                in glob.glob(f"{ basePath }/media_tag_combinator_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.media_tag_combinator_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.media_tag_combinator_{ identifier }"]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'MediaTagCombinator' and name.startswith('MediaTagCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [MediaTagCombinator.getClassReference(i) for i in MediaTagCombinator.list()]

bin/ffx/test/media_tag_combinator_0.py

@@ -0,0 +1,55 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaTagCombinator0(MediaTagCombinator):
+
+    VARIANT = 'MT0'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaTagCombinator0.VARIANT
+
+
+    def getPayload(self):
+        mediaTags = {}
+        if self.__createPresets:
+            mediaTags['THIS_IS'] = 'FFX'
+        return mediaTags
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tags'")
+                mediaTags = assertObj['tags']
+
+                assert ('THIS_IS' in mediaTags.keys() and mediaTags.keys()['THIS_IS'] == 'FFX'
+                ), "Media tag 'THIS_IS' was not preserved"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                pass
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/media_tag_combinator_1.py

@@ -0,0 +1,59 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_tag_combinator import MediaTagCombinator
+
+class MediaTagCombinator1(MediaTagCombinator):
+
+    VARIANT = 'MT1'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaTagCombinator1.VARIANT
+
+
+    def getPayload(self):
+        mediaTags = {'From': 'Encoders'}
+        if self.__createPresets:
+            mediaTags['THIS_IS'] = 'FFX'
+        return mediaTags
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tags'")
+                mediaTags = assertObj['tags']
+
+                assert ('From' in mediaTags.keys()
+                ), "'From' not in media tag keys"
+                assert (mediaTags.keys()['From'] == 'Encoders'
+                ), "Media tag value not 'Encoders' for key 'To'"
+
+                assert ('THIS_IS' in mediaTags.keys() and mediaTags.keys()['THIS_IS'] == 'FFX'
+                ), "Media tag 'THIS_IS' was not preserved"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                pass
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/media_tag_combinator_2.py

@@ -0,0 +1,64 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_tag_combinator import MediaTagCombinator
+
+class MediaTagCombinator2(MediaTagCombinator):
+
+    VARIANT = 'MT2'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaTagCombinator2.VARIANT
+
+
+    def getPayload(self):
+        mediaTags = {'To': 'Fanz',
+                        'Yolo': 'Holo'}
+        if self.__createPresets:
+            mediaTags['THIS_IS'] = 'FFX'
+        return mediaTags
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tags'")
+                mediaTags = assertObj['tags']
+
+                assert ('To' in mediaTags.keys()
+                ), "'To' not in media tag keys"
+                assert (mediaTags.keys()['To'] == 'Fanz'
+                ), "Media tag value not 'Fanz' for key 'To'"
+                assert ('Yolo' in mediaTags.keys()
+                ), "'Yolo' not in media tag keys"
+                assert (mediaTags.keys()['Yolo'] == 'Holo'
+                ), "Media tag value not 'Holo' for key 'Yolo'"
+
+                assert ('THIS_IS' in mediaTags.keys() and mediaTags.keys()['THIS_IS'] == 'FFX'
+                ), "Media tag 'THIS_IS' was not preserved"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                pass
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/release_combinator.py

@@ -0,0 +1,37 @@
+class ReleaseCombinator():
+
+    IDENTIFIER = 'release'
+
+    RELEASE_LIST = [
+        ".GerEngSub.AAC.1080pINDICATOR.WebDL.x264-Tanuki",
+        ".German.AC3.DL.1080pINDICATOR.BluRay.x264-AST4u",
+        "-720pINDICATOR"
+    ]
+
+    def __init__(self, context = None, indicator = ''):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        self.__indicator = indicator
+
+    def getIdentifier(self):
+        return ReleaseCombinator.IDENTIFIER
+
+    def getPayload(self, releaseIndex):
+        releaseStr: str = ReleaseCombinator.RELEASE_LIST[releaseIndex]
+        return {
+            'variant': f"R{releaseIndex}",
+            'release': releaseStr.replace('INDICATOR', f".{self.__indicator}")
+                    if self.__indicator else releaseStr.replace('INDICATOR', '')
+        }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for releaseIndex in range(len(ReleaseCombinator.RELEASE_LIST)):
+            yield self.getPayload(releaseIndex)

bin/ffx/test/scenario.py

@@ -0,0 +1,150 @@
+import os, glob, sys, importlib, glob, inspect
+
+from ffx.show_controller import ShowController
+from ffx.pattern_controller import PatternController
+from ffx.media_controller import MediaController
+
+from ffx.test.helper import createEmptyDirectory
+from ffx.database import databaseContext
+
+class Scenario():
+    """Scenarios
+    
+    Scenario1: Jellyfin, MediaTags, Stream-Kombinationen, Dispositions und StreamTags per Kombinatoren
+
+    Scenario2: <pattern> mit 3 Files x Scenario1
+
+    Scenario3: <tmdb+pattern> mit 3 Files (wenn TMDB API Key verfügbar)
+
+    Naming:
+
+    1: test.mkv             no tmdb, no pattern
+    2: test_s01e02.mkv
+    
+    Operationen:
+    
+    tmdb lookup: Set Showname as prefix, append episode name
+    pattern lookup: Set/update tags/dispositions; Filter/Reorder Tracks
+    jellyfin reordering: default track last (2)
+    
+    MediaTag-Kombinationen (2)
+    
+    0: nichs
+    1: Yolo=Holo
+
+    Stream-Kombinationen (8)
+    
+    VA      D=1     T=1     =1
+    VAS     D=1     T=1     =1
+    VASS    D=4     T=4     =16
+    VASSS   D=5     T=5     =25
+    VAA     D=4     T=4     =16
+    VAAS    D=4     T=4     =16
+    VAASS   D=16    T=16    =256
+    VAASSS  D=20    T=20    =400
+                            =731
+
+    Dispositions-Kombinationen (per TrackType)
+    
+    0 = keine
+    1 = DEFAULT
+
+    2 Streams (4):
+    
+    D1: 00
+    D2: 01
+    D3: 10
+    D4: 11
+
+    3 Streams (5):
+    
+    D5: 000
+    D6: 001
+    D7: 010
+    D8: 100
+    D9: 101
+
+    Stream-Tag-Kombinationen (per TrackType)
+    
+    0 = keine
+    1 = lang+title
+
+    2 Streams:
+    
+    00
+    01
+    10
+    11
+
+    3 Streams:
+    
+    000
+    001
+    010
+    100
+    101
+    
+    
+    
+    """
+
+    def __init__(self, context = None):
+        self._context = context
+        self._testDirectory = createEmptyDirectory()
+        self._ffxExecutablePath = os.path.join(
+                                    os.path.dirname(
+                                        os.path.dirname(
+                                            os.path.dirname(__file__))),
+                                            'ffx.py')
+
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        self._testDbFilePath = os.path.join(self._testDirectory, 'test.db')
+        self.createEmptyTestDatabase()
+
+
+    def createEmptyTestDatabase(self):
+
+        if not self._context['database'] is None:
+            self._context['database']['engine'].dispose()
+
+        if os.path.isfile(self._testDbFilePath):
+            os.unlink(self._testDbFilePath)
+        self._context['database'] = None
+
+        self._logger.debug(f"Creating test db with path {self._testDbFilePath}")
+        self._context['database'] = databaseContext(databasePath=self._testDbFilePath)
+
+        self._sc = ShowController(context = self._context)
+        self._pc = PatternController(context = self._context)
+        self._mc = MediaController(context = self._context)
+    
+
+    def clearTestDirectory(self):
+        testFiles = glob.glob(f"{self._testDirectory}/*")
+        for f in testFiles:
+            os.remove(f)
+
+    def getFilePathsInTestDirectory(self):
+        return [f for f in glob.glob(f"{self._testDirectory}/*")]
+
+    def getFilenamesInTestDirectory(self):
+        return [os.path.basename(f) for f in self.getFilePathsInTestDirectory()]
+
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[9:-3]
+                for p
+                in glob.glob(f"{ basePath }/scenario_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.scenario_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.scenario_{ identifier }"]):
+            #HINT: Excluding Scenario as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'Scenario' and name.startswith('Scenario'):
+                return obj

bin/ffx/test/scenario_1.py

@@ -0,0 +1,176 @@
+import os, sys, click, glob
+
+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_0 import MediaCombinator0
+
+from ffx.test.basename_combinator import BasenameCombinator
+
+
+class Scenario1(Scenario):
+    """Creating file VAa, h264/aac/aac
+    Converting to VaA, vp9/opus/opus
+    No tmdb, default parameters"""
+
+    TEST_FILE_EXTENSION = 'mkv'
+    EXPECTED_FILE_EXTENSION = 'webm'
+
+
+    def __init__(self, context):
+
+        context['use_jellyfin'] = True
+        context['use_tmdb'] = False
+        context['use_pattern'] = False
+
+        super().__init__(context)
+
+    def getScenario(self):
+        return self.__class__.__name__[8:]
+
+
+    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}"
+
+        mc0 = MediaCombinator0(context = testContext)
+        sourceMediaDescriptor: MediaDescriptor = mc0.getPayload()
+
+        assertSelectorList: list = yieldObj['assertSelectors']
+        assertFuncList = yieldObj['assertFuncs']
+        shouldFail = yieldObj['shouldFail']
+
+        variantPayload = yieldObj['payload']
+        variantBasename = variantPayload['basename']
+        variantFilenameLabel = variantPayload['label']
+        expectedBasename = variantPayload['expectedBasename']
+
+        variantFilename = f"{variantBasename}.{Scenario1.TEST_FILE_EXTENSION}"
+        expectedFilename = f"{expectedBasename}.{Scenario1.EXPECTED_FILE_EXTENSION}"
+
+
+        if self._context['test_variant'] and variantIdentifier != self._context['test_variant']:
+            return
+
+
+        self._logger.debug(f"Running Job: {variantLabel}")
+
+
+        # Phase 1: Setup source files
+
+        if not variantBasename:
+            raise ValueError(f"{variantLabel}: Testfile basename is falsy")
+
+
+        self.clearTestDirectory()
+
+        self._logger.debug(f"Creating test file: {variantFilename}")
+        mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor,
+                                            baseName=variantBasename,
+                                            directory=self._testDirectory,
+                                            logger=self._logger,
+                                            length = 2)
+
+
+        # Phase 2: Run ffx
+
+        commandSequence = [sys.executable,
+                            self._ffxExecutablePath]
+        
+        # if self._context['verbosity']:
+        #     commandSequence += ['--verbose',
+        #                         str(self._context['verbosity'])]
+
+        commandSequence += ['convert',
+                            mediaFilePath,
+                            '--no-prompt']
+        
+        if variantFilenameLabel:
+            commandSequence += ['--label', variantFilenameLabel]
+
+
+        if not testContext['use_jellyfin']:
+            commandSequence += ['--no-jellyfin']
+
+        commandSequence += ['--no-pattern']
+        commandSequence += ['--no-tmdb']
+
+
+        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 3: Evaluate results
+            
+        resultFilenames = [rf for rf in self.getFilenamesInTestDirectory() if rf != 'ffmpeg2pass-0.log' and rf != variantFilename]
+        self._logger.debug(f"{variantLabel}: Result filenames: {resultFilenames}")
+
+
+        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:
+
+                expectedResultFilePath = os.path.join(self._testDirectory, f"{expectedFilename}")
+
+                assert (os.path.isfile(expectedResultFilePath)
+                ), f"Result file {expectedFilename} in path '{self._testDirectory}' wasn't created"
+
+                for assertIndex in range(len(assertSelectorList)):
+
+                    assertSelector = assertSelectorList[assertIndex]
+                    assertFunc = assertFuncList[assertIndex]
+                    assertVariant = variantList[assertIndex]
+
+                    if assertSelector == 'B':
+                        #TODO: per file find
+                        testObj = {'filenames': resultFilenames}
+                        assertFunc(testObj=testObj)
+                    if assertSelector == 'L':
+                        assertFunc()
+                    if assertSelector == 'I':
+                        assertFunc()
+
+            self._context['test_passed_counter'] += 1
+            self._reportLogger.info(f"{variantLabel}: Test passed")
+
+        except AssertionError as ae:
+
+            self._context['test_failed_counter'] += 1
+            self._reportLogger.error(f"{variantLabel}: Test FAILED ({ae})")
+
+
+    def run(self):
+        for BC in BasenameCombinator.getAllClassReferences():
+            self._logger.debug(f"BC={BC.__name__}")
+            bc = BC(context = self._context)
+            for y in bc.getYield():
+                self.job(y)

bin/ffx/test/scenario_2.py

@@ -0,0 +1,174 @@
+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"""
+
+    TEST_FILE_EXTENSION = 'mkv'
+    EXPECTED_FILE_EXTENSION = 'webm'
+
+
+    def __init__(self, context):
+
+        context['use_jellyfin'] = True
+        context['use_tmdb'] = False
+        context['use_pattern'] = False
+
+        super().__init__(context)
+        
+    def getScenario(self):
+        return self.__class__.__name__[8:]
+
+
+    def job(self, yieldObj: dict):
+
+        testContext = self._context.copy()
+
+        targetYieldObj = yieldObj['target']
+        # presetYieldObj = yieldObj['preset'] # not used here
+
+        identifier = targetYieldObj['identifier']
+        variantList = targetYieldObj['variants']
+
+        variantIdentifier = '-'.join(variantList)
+        variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
+
+        sourceMediaDescriptor: MediaDescriptor = targetYieldObj['payload']
+
+        assertSelectorList: list = targetYieldObj['assertSelectors']
+        assertFuncList = targetYieldObj['assertFuncs']
+        shouldFail = targetYieldObj['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']:
+        if self._context['test_variant'] and not variantIdentifier.startswith(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: 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 3: Evaluate results
+
+        resultFilenames = [rf for rf in self.getFilenamesInTestDirectory() if rf.endswith(f".{Scenario2.EXPECTED_FILE_EXTENSION}")]
+
+        self._logger.debug(f"{variantLabel}: Result filenames: {resultFilenames}")
+
+        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({'tracks': resultMediaDescriptor.getAudioTracks()})
+
+                    elif assertSelector == 'SD' or assertSelector == 'ST':
+                        assertFunc({'tracks': resultMediaDescriptor.getSubtitleTracks()})
+
+                    elif type(assertSelector) is str:
+                        if assertSelector == 'J':
+                            assertFunc()
+
+
+            self._context['test_passed_counter'] += 1
+            self._reportLogger.info(f"{variantLabel}: Test passed")
+
+        except AssertionError as ae:
+
+            self._context['test_failed_counter'] += 1
+            self._reportLogger.error(f"{variantLabel}: Test FAILED ({ae})")
+
+
+    def run(self):
+        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)

bin/ffx/test/scenario_4.py

@@ -0,0 +1,277 @@
+import os, sys, click
+
+from .scenario import Scenario
+
+from ffx.test.helper import createMediaTestFile
+from ffx.process import executeProcess
+from ffx.database import databaseContext
+from ffx.test.helper import createEmptyDirectory
+
+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
+from ffx.test.indicator_combinator import IndicatorCombinator
+
+from ffx.show_descriptor import ShowDescriptor
+
+
+from ffx.tmdb_controller import TmdbController
+from ffx.tmdb_controller import TMDB_API_KEY_NOT_PRESENT_EXCEPTION
+
+class Scenario4(Scenario):
+
+    TEST_SHOW_IDENTIFIER = 83095
+    TEST_SHOW_NAME = 'The Rising of the Shield Hero'
+    TEST_SHOW_YEAR = 2019
+
+    TEST_FILE_LABEL = 'rotsh'
+    TEST_FILE_EXTENSION = 'mkv'
+
+    TEST_PATTERN = f"{TEST_FILE_LABEL}_{FileProperties.SEASON_EPISODE_INDICATOR_MATCH}.{TEST_FILE_EXTENSION}"
+
+    EXPECTED_FILE_EXTENSION = 'webm'
+
+
+    def __init__(self, context):
+        super().__init__(context)
+
+        self.__tmdbApiKey = os.environ.get('TMDB_API_KEY', None)
+        if self.__tmdbApiKey is None:
+            raise TMDB_API_KEY_NOT_PRESENT_EXCEPTION
+
+        self.__ic = IndicatorCombinator(context = context)
+        self.__tc = TmdbController()
+
+
+        kwargs = {}
+        kwargs[ShowDescriptor.ID_KEY] = Scenario4.TEST_SHOW_IDENTIFIER
+        kwargs[ShowDescriptor.NAME_KEY] = Scenario4.TEST_SHOW_NAME
+        kwargs[ShowDescriptor.YEAR_KEY] = Scenario4.TEST_SHOW_YEAR
+
+        self.__testShowDescriptor = ShowDescriptor(**kwargs)
+
+    def getScenario(self):
+        return self.__class__.__name__[8:]
+
+
+    def prepareTestDatabase(self, sourceMediaDescriptor: MediaDescriptor):
+
+        if not self._context['database'] is None:
+            self._context['database']['engine'].dispose()
+
+        if os.path.isfile(self._testDbFilePath):
+            os.unlink(self._testDbFilePath)
+        self._context['database'] = None
+
+        self._logger.debug(f"Creating test db with path {self._testDbFilePath}")
+        self._context['database'] = databaseContext(databasePath=self._testDbFilePath)
+
+
+        self._logger.debug(f"Adding test show '{self.__testShowDescriptor.getFilenamePrefix()}' to test db")
+        if not self._sc.updateShow(self.__testShowDescriptor):
+            raise click.ClickException('Could not create test show in db')
+
+        testPatternDescriptor = {
+             'show_id': Scenario4.TEST_SHOW_IDENTIFIER,
+             'pattern': Scenario4.TEST_PATTERN
+        }
+        patternId = self._pc.addPattern(testPatternDescriptor)
+
+        if patternId:
+            self._mc.setPatternMediaDescriptor(sourceMediaDescriptor, patternId)
+
+
+    def job(self, yieldObj: dict):
+
+        testContext = self._context.copy()
+
+        if 'preset' not in yieldObj.keys():
+            raise KeyError('yieldObj did not contain presets')
+
+        targetYieldObj = yieldObj['target']
+        presetYieldObj = yieldObj['preset']
+
+        identifier = targetYieldObj['identifier']
+        variantList = targetYieldObj['variants']
+
+        variantIdentifier = '-'.join(variantList)
+        variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
+
+        sourceMediaDescriptor: MediaDescriptor = targetYieldObj['payload']
+        presetMediaDescriptor: MediaDescriptor = presetYieldObj['payload']
+
+        assertSelectorList: list = presetYieldObj['assertSelectors']
+        assertFuncList = presetYieldObj['assertFuncs']
+        shouldFail = presetYieldObj['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
+
+        for l in presetMediaDescriptor.getConfiguration(label = 'presetMediaDescriptor'):
+            self._logger.debug(l)
+
+        for l in sourceMediaDescriptor.getConfiguration(label = 'sourceMediaDescriptor'):
+            self._logger.debug(l)
+
+        self._logger.debug(f"Running Job: {variantLabel}")
+
+
+        # Phase 1: Setup source files
+
+        self.clearTestDirectory()
+
+        testFileList = []
+        for indicatorObj in [y for y in self.__ic.getYield() if y['indicator']]:
+
+            indicator = indicatorObj['indicator']
+
+            testFileObj = {}
+            testFileObj['season'] = indicatorObj['season']
+            testFileObj['episode'] = indicatorObj['episode']
+
+            testFileObj['basename'] = f"{Scenario4.TEST_FILE_LABEL}_{indicator}"
+
+            testFileObj['path'] = createMediaTestFile(mediaDescriptor = presetMediaDescriptor,
+                                                directory = self._testDirectory,
+                                                baseName = testFileObj['basename'],
+                                                logger=self._logger,
+                                                length = 2)
+            testFileObj['filename'] = f"{testFileObj['basename']}.{Scenario4.TEST_FILE_EXTENSION}"
+
+            testFileList.append(testFileObj)
+
+
+        # Phase 2: Prepare database
+
+        self.createEmptyTestDatabase()
+        self.prepareTestDatabase(sourceMediaDescriptor)
+
+
+        # Phase 3: Run ffx
+
+        commandSequence = [sys.executable,
+                            self._ffxExecutablePath,
+                            '--database-file',
+                            self._testDbFilePath,
+                            'convert']
+        commandSequence += [tfo['filename'] for tfo in testFileList]
+
+        commandSequence += ['--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
+
+        resultFilenames = [rf for rf in self.getFilenamesInTestDirectory() if rf.endswith(f".{Scenario4.EXPECTED_FILE_EXTENSION}")]
+
+        self._logger.debug(f"{variantLabel}: Result filenames: {resultFilenames}")
+        
+
+        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:
+
+                for tfo in testFileList:
+
+                    tmdbEpisodeResult = self.__tc.queryEpisode(Scenario4.TEST_SHOW_IDENTIFIER,
+                                                                tfo['season'], tfo['episode']) 
+
+                    expectedFileBasename = TmdbController.getEpisodeFileBasename(self.__testShowDescriptor.getFilenamePrefix(),
+                                                                    tmdbEpisodeResult['name'],
+                                                                    tfo['season'], tfo['episode']) 
+
+                    expectedFilename = f"{expectedFileBasename}.{Scenario4.EXPECTED_FILE_EXTENSION}"
+                    expectedFilePath = os.path.join(self._testDirectory, expectedFilename)
+
+                    assert (os.path.isfile(expectedFilePath)
+                    ), f"Result file '{expectedFilename}' in path '{self._testDirectory}' wasn't created"
+
+
+                    rfp = FileProperties(testContext, expectedFilePath)
+                    self._logger.debug(f"{variantLabel}: Result file properties: {rfp.getFilename()} season={rfp.getSeason()} episode={rfp.getEpisode()}")
+
+                    rmd = rfp.getMediaDescriptor()
+                    rmt = rmd.getAllTrackDescriptors()
+
+                    for l in rmd.getConfiguration(label = 'resultMediaDescriptor'):
+                        self._logger.debug(l)
+
+                    if testContext['use_jellyfin']:
+                        sourceMediaDescriptor.applyJellyfinOrder()
+
+                    # num tracks differ
+                    rmd.applySourceIndices(sourceMediaDescriptor)
+
+
+                    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() == rmt[variantIndex].getType().indicator()
+                                ), f"Stream #{variantIndex} is not of type {rmt[variantIndex].getType().label()}"
+
+                        if assertSelector == 'AD' or assertSelector == 'AT':
+                            assertFunc({'tracks': rmd.getAudioTracks()})
+
+                        elif assertSelector == 'SD' or assertSelector == 'ST':
+                            assertFunc({'tracks': rmd.getSubtitleTracks()})
+
+                        elif type(assertSelector) is str:
+                            if assertSelector == 'J':
+                                assertFunc()
+
+
+            self._context['test_passed_counter'] += 1
+            self._reportLogger.info(f"{variantLabel}: Test passed")
+
+        except AssertionError as ae:
+
+            self._context['test_failed_counter'] += 1
+            self._reportLogger.error(f"{variantLabel}: Test FAILED ({ae})")
+
+        # exit()
+
+    def run(self):
+
+        MC_list = [MediaCombinator.getClassReference(6)]
+        for MC in MC_list:
+            self._logger.debug(f"MC={MC.__name__}")
+            mc = MC(context = self._context, createPresets = True)
+            for y in mc.getYield():
+                self.job(y)

bin/ffx/test/show_combinator.py

@@ -0,0 +1,33 @@
+class ShowCombinator():
+
+    IDENTIFIER = 'show'
+
+    SHOW_LIST = [
+        'Boruto; Naruto Next Generations (2017)',
+        'The Rising of the Shield Hero (2019)',
+        'Scrubs - Die Anfänger (2001)'
+    ]
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return ShowCombinator.IDENTIFIER
+
+    def getPayload(self, showIndex):
+        return {
+            'variant': f"S{showIndex}",
+            'show': ShowCombinator.SHOW_LIST[showIndex]
+        }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for showIndex in range(len(ShowCombinator.SHOW_LIST)):
+            yield self.getPayload(showIndex)

bin/ffx/test/title_combinator.py

@@ -0,0 +1,33 @@
+class TitleCombinator():
+
+    IDENTIFIER = 'title'
+
+    TITLE_LIST = [
+        'The Sound of Space',
+        '2001; Odyssee im Weltraum (1968)',
+        'Ansible 101'
+    ]
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return TitleCombinator.IDENTIFIER
+        
+    def getPayload(self, titleIndex):
+        return {
+            'variant': f"S{titleIndex}",
+            'show': TitleCombinator.TITLE_LIST[titleIndex]
+        }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for titleIndex in range(len(TitleCombinator.TITLE_LIST)):
+            yield self.getPayload(titleIndex)

bin/ffx/test/track_tag_combinator_2.py

@@ -0,0 +1,33 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class TrackTagCombinator2():
+
+    IDENTIFIER = 'trackTag2'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return TrackTagCombinator2.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[23:-3]
+                for p
+                in glob.glob(f"{ basePath }/track_tag_combinator_2_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.track_tag_combinator_2_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.track_tag_combinator_2_{ identifier }"]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'TrackTagCombinator2' and name.startswith('TrackTagCombinator2'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [TrackTagCombinator2.getClassReference(i) for i in TrackTagCombinator2.list()]

bin/ffx/test/track_tag_combinator_2_0.py

@@ -0,0 +1,89 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator20(TrackTagCombinator2):
+
+    VARIANT = 'T00'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator20.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = {}
+        subTrack1 = {}
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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 ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+                assert (not '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 set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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"
+                
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_2_1.py

@@ -0,0 +1,96 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator21(TrackTagCombinator2):
+
+    VARIANT = 'T10'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator21.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = ({'language': 'rus', 'title': 'Russisch'}
+                        if self.__createPresets else {'language': 'fra', 'title': 'Französisch'})
+        subTrack1 = {}
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('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 not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('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 not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('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 not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('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 not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_2_2.py

@@ -0,0 +1,97 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator21(TrackTagCombinator2):
+
+    VARIANT = 'T01'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator21.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = {}
+        subTrack1 = ({'language': 'chn', 'title': 'China'}
+                        if self.__createPresets else {'language': 'bas', 'title': 'Baskisch'})
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+    
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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 ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                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'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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"
+
+                # source subIndex 1
+                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'"
+
+        return f
+
+
+    def shouldFail(self):
+        return False
+    

bin/ffx/test/track_tag_combinator_2_3.py

@@ -0,0 +1,106 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator23(TrackTagCombinator2):
+
+    VARIANT = 'T11'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return TrackTagCombinator23.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = ({'language': 'chn', 'title': 'China'}
+                        if self.__createPresets else {'language': 'deu', 'title': 'Deutsch'})
+        subTrack1 = {'language': 'jpn', 'title': 'Japanisch'}
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('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 not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'deu'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'"
+                assert ('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 not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Deutsch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                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'] == 'jpn'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'"
+                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'] == 'Japanisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('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 not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'deu'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'"
+                assert ('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 not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Deutsch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'"
+
+                # source subIndex 1
+                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'] == 'jpn'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'"
+                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'] == 'Japanisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_3.py

@@ -0,0 +1,33 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class TrackTagCombinator3():
+
+    IDENTIFIER = 'trackTag3'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return TrackTagCombinator3.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[23:-3]
+                for p
+                in glob.glob(f"{ basePath }/track_tag_combinator_3_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        importlib.import_module(f"ffx.test.track_tag_combinator_3_{ identifier }")
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.track_tag_combinator_3_{ identifier }"]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'TrackTagCombinator3' and name.startswith('TrackTagCombinator3'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [TrackTagCombinator3.getClassReference(i) for i in TrackTagCombinator3.list()]

bin/ffx/test/track_tag_combinator_3_0.py

@@ -0,0 +1,105 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator30(TrackTagCombinator3):
+
+    VARIANT = 'T000'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator30.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {}
+        subtrack1 = {}
+        subtrack2 = {}
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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 ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert not ('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 set language tag"
+                assert not ('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 set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert not ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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"
+
+                # source subIndex 1
+                assert not ('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 set language tag"
+                assert not ('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 set title tag"
+
+                # source subIndex 2
+                assert not ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_3_1.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator31(TrackTagCombinator3):
+
+    VARIANT = 'T100'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator31.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = ({'language': 'rus', 'title': 'Russisch'}
+                        if self.__createPresets else {'language': 'fra', 'title': 'Französisch'})
+        subtrack1 = {}
+        subtrack2 = {}
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('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 not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('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 not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('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 not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('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 not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_3_2.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator32(TrackTagCombinator3):
+
+    VARIANT = 'T010'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator32.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {}
+        subtrack1 = ({'language': 'chn', 'title': 'China'}
+                        if self.__createPresets else {'language': 'bas', 'title': 'Baskisch'})
+        subtrack2 = {}
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+ 
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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 ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                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 ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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"
+
+                # source subIndex 1
+                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'"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_3_3.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator33(TrackTagCombinator3):
+
+    VARIANT = 'T001'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator33.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {}
+        subtrack1 = {}
+        subtrack2 = ({'language': 'tkm', 'title': 'Turkmenistan'}
+                        if self.__createPresets else {'language': 'eng', 'title': 'English'})
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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 ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'eng'"
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                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'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                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"
+
+                # source subIndex 1
+                assert (not '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 set language tag"
+                assert (not '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 set title tag"
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'eng'"
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                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'"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/test/track_tag_combinator_3_4.py

@@ -0,0 +1,214 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator34(TrackTagCombinator3):
+
+    VARIANT = 'T111'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator34.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {'language': 'jpn', 'title': 'Japanisch'}
+        subtrack1 = {'language': 'deu', 'title': 'Deutsch'}
+        subtrack2 = ({'language': 'tkm', 'title': 'Turkmenistan'}
+                        if self.__createPresets else {'language': 'eng', 'title': 'English'})
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'jpn'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'")
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Japanisch'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'")
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys()
+                and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS")
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'deu'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'")
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Deutsch'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'")
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys()
+                and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS")
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'eng'")
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[2].getTags()['title'] == 'English'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'English'")
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys()
+                and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS")
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'jpn'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'")
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Japanisch'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'")
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'deu'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag 'deu'")
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Deutsch'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set title 'Deutsch'")
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set language tag 'eng'")
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[2].getTags()['title'] == 'English'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set title 'English'")
+
+        return f
+
+
+    def shouldFail(self):
+        return False

bin/ffx/tmdb_controller.py

@@ -1,21 +1,101 @@
-import os, click, requests
+import os, click, requests, json, time, logging
+
+class TMDB_REQUEST_EXCEPTION(Exception):
+    def __init__(self, statusCode, statusMessage):
+        errorMessage = f"TMDB query failed with status code {statusCode}: {statusMessage}"
+        super().__init__(errorMessage)
+
+class TMDB_API_KEY_NOT_PRESENT_EXCEPTION(Exception):
+    def __str__(self):
+        return 'TMDB api key is not available, please set environment variable TMDB_API_KEY'
+
+class TMDB_EXCESSIVE_USAGE_EXCEPTION(Exception):
+    def __str__(self):
+        return 'Rate limit was triggered too often'
 
 
 class TmdbController():
 
     DEFAULT_LANGUAGE = 'de-DE'
 
-    def __init__(self):
+    RATE_LIMIT_WAIT_SECONDS = 10
+    RATE_LIMIT_RETRIES = 3
 
-        try:  
+    def __init__(self, context = None):
-            self.__tmdbApiKey = os.environ['TMDB_API_KEY']
+        self.__context = context
-        except KeyError: 
+        self.__logger = (context['logger'] if context is not None and 'logger' in context.keys()
-            click.ClickException('TMDB api key is not available, please set environment variable TMDB_API_KEY')
+                            else logging.getLogger('FFX').addHandler(logging.NullHandler()))
+
+        self.__tmdbApiKey = os.environ.get('TMDB_API_KEY', None)
+        if self.__tmdbApiKey is None:
+            raise TMDB_API_KEY_NOT_PRESENT_EXCEPTION
         
         self.tmdbLanguage = TmdbController.DEFAULT_LANGUAGE
 
 
-    def queryTmdb(self, showId, season, episode):
+    def getTmdbRequest(self, tmdbUrl):
+        retries = TmdbController.RATE_LIMIT_RETRIES
+        while True:
+            response = requests.get(tmdbUrl)
+            if response.status_code == 429:
+                if not retries:
+                    raise TMDB_EXCESSIVE_USAGE_EXCEPTION()
+                self.__logger.warning('TMDB Rate limit (status_code 429)')
+                time.sleep(TmdbController.RATE_LIMIT_WAIT_SECONDS)
+                retries -= 1
+            else:
+                jsonResult = response.json()
+                if ('success' in jsonResult.keys()
+                            and not jsonResult['success']):
+                    raise TMDB_REQUEST_EXCEPTION(jsonResult['status_code'], jsonResult['status_message'])
+                return jsonResult
+
+
+    def queryShow(self, showId):
+        """
+        First level keys in the response object:
+        adult bool
+        backdrop_path str
+        created_by []
+        episode_run_time []
+        first_air_date str YYYY-MM-DD
+        genres []
+        homepage str
+        id int
+        in_production bool
+        languages []
+        last_air_date str YYYY-MM-DD
+        last_episode_to_air {}
+        name str
+        next_episode_to_air null
+        networks []
+        number_of_episodes int
+        number_of_seasons int
+        origin_country []
+        original_language str
+        original_name str
+        overview str
+        popularity float
+        poster_path str
+        production_companies []
+        production_countries []
+        seasons []
+        spoken_languages []
+        status str
+        tagline str
+        type str
+        vote_average float
+        vote_count int
+        """
+        
+        urlParams = f"?language={self.tmdbLanguage}&api_key={self.__tmdbApiKey}"
+        
+        tmdbUrl = f"https://api.themoviedb.org/3/tv/{showId}{urlParams}"
+
+        return self.getTmdbRequest(tmdbUrl)
+
+
+    def queryEpisode(self, showId, season, episode):
         """
         First level keys in the response object:
         air_date str 'YYY-MM-DD'
@@ -37,15 +117,14 @@ class TmdbController():
         
         tmdbUrl = f"https://api.themoviedb.org/3/tv/{showId}/season/{season}/episode/{episode}{urlParams}"
 
-        return requests.get(tmdbUrl).json()
+        return self.getTmdbRequest(tmdbUrl)
 
 
-    def getEpisodeFilename(self,
+    @staticmethod
-                            showName,
+    def getEpisodeFileBasename(showName,
                                 episodeName,
                                 season,
                                 episode,
-                            extension,
                                 indexSeasonDigits = 2,
                                 indexEpisodeDigits = 2,
                                 indicatorSeasonDigits = 2,
@@ -93,6 +172,7 @@ class TmdbController():
         if indicatorEpisodeDigits:
             filenameTokens += ['E{num:{fill}{width}}'.format(num=episode, fill='0', width=indicatorEpisodeDigits)]
 
-        filenameTokens += ['.', extension]
-        
         return ''.join(filenameTokens)
+
+    def importShow(self, showId: int):
+        pass

bin/ffx/track_controller.py

@@ -9,42 +9,54 @@ from .iso_language import IsoLanguage
 
 from .track_type import TrackType
 
+from ffx.model.track_tag import TrackTag
+from ffx.track_descriptor import TrackDescriptor
+
 
 class TrackController():
     
     def __init__(self, context):
         
         self.context = context
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
 
-    def addTrack(self, trackDescriptor):
+    def addTrack(self, trackDescriptor : TrackDescriptor, patternId = None):
+
+        # option to override pattern id in case track descriptor has not set it
+        patId = int(trackDescriptor.getPatternId() if patternId is None else patternId)
 
         try:
             s = self.Session()
-
+            track = Track(pattern_id = patId,
-            track = Track(pattern_id = int(trackDescriptor['pattern_id']),
+                            track_type = int(trackDescriptor.getType().index()),
-
+                            codec_name = str(trackDescriptor.getCodec()),
-                            track_type = int(trackDescriptor['type'].value),
+                            index = int(trackDescriptor.getIndex()),
-
+                            source_index = int(trackDescriptor.getSourceIndex()),
-                            sub_index = int(trackDescriptor['sub_index']),
+                            disposition_flags = int(TrackDisposition.toFlags(trackDescriptor.getDispositionSet())),
-
+                            audio_layout = trackDescriptor.getAudioLayout().index())
-                            language = str(trackDescriptor['language'].threeLetter()),
-
-                            title = str(trackDescriptor['title']),
-
-                            disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list'])))
 
             s.add(track)
             s.commit()
 
+            for k,v in trackDescriptor.getTags().items():
+
+                tag = TrackTag(track_id = track.id,
+                                key = k,
+                                value = v)
+                s.add(tag)
+            s.commit()
+
         except Exception as ex:
             raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def updateTrack(self, trackId, trackDescriptor):
+    def updateTrack(self, trackId, trackDescriptor : TrackDescriptor):
+
+        if type(trackDescriptor) is not TrackDescriptor:
+            raise TypeError('TrackController.updateTrack(): Argument trackDescriptor is required to be of type TrackDescriptor')
 
         try:
             s = self.Session()
@@ -52,131 +64,177 @@ class TrackController():
 
             if q.count():
 
-                track = q.first()
+                track : Track = q.first()
 
-                track.sub_index = int(trackDescriptor['sub_index'])
+                track.track_type = int(trackDescriptor.getType().index())
-                track.language = str(trackDescriptor['language'].threeLetter())
+                track.codec_name = str(trackDescriptor.getCodec())
-                track.title = str(trackDescriptor['title'])
+                track.audio_layout = int(trackDescriptor.getAudioLayout().index())
-                track.disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list']))
+
+                track.disposition_flags = int(TrackDisposition.toFlags(trackDescriptor.getDispositionSet()))
+
+                descriptorTagKeys = trackDescriptor.getTags()
+                tagKeysInDescriptor = set(descriptorTagKeys.keys())
+                tagKeysInDb = {t.key for t in track.track_tags}
+
+                for k in tagKeysInDescriptor & tagKeysInDb: # to update
+                    tags = [t for t in track.track_tags if t.key == k]
+                    tags[0].value = descriptorTagKeys[k]
+                for k in tagKeysInDescriptor - tagKeysInDb: # to add
+                    tag = TrackTag(track_id=track.id, key=k, value=descriptorTagKeys[k])
+                    s.add(tag)
+                for k in tagKeysInDb - tagKeysInDescriptor: # to remove
+                    tags = [t for t in track.track_tags if t.key == k]
+                    s.delete(tags[0])
 
                 s.commit()
-
                 return True
 
             else:
                 return False
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+            raise click.ClickException(f"TrackController.updateTrack(): {repr(ex)}")
         finally:
             s.close()
 
-
+    def findTracks(self, patternId):
-    def findAllTracks(self, patternId):
 
         try:
             s = self.Session()
 
-            trackDescriptors = {}
+            q = s.query(Track).filter(Track.pattern_id == int(patternId))
-            trackDescriptors[TrackType.AUDIO.label()] = []
+            return [a for a in q.all()]
-            trackDescriptors[TrackType.SUBTITLE.label()] = []
-
-            q_audio = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.AUDIO.value)
-
-            for audioTrack in q_audio.all():
-                trackDescriptors[TrackType.AUDIO.label()].append(audioTrack.id)
-                
-            q_subtitle = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.SUBTITLE.value)
-            for subtitleTrack in q_subtitle.all():
-                trackDescriptors[TrackType.SUBTITLE.label()].append(subtitleTrack.id)
-
-
-            return trackDescriptors
-
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.findAllTracks(): {repr(ex)}")
+            raise click.ClickException(f"TrackController.findTracks(): {repr(ex)}")
+        finally:
+            s.close()
+
+    #TODO: mit optionalem Parameter lösen ^
+    def findVideoTracks(self, patternId):
+
+        try:
+            s = self.Session()
+
+            q = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.VIDEO.index())
+            return [a for a in q.all()]
+
+        except Exception as ex:
+            raise click.ClickException(f"TrackController.findVideoTracks(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def findAudioTracks(self, patternId):
+
+        try:
+            s = self.Session()
+
+            q = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.AUDIO.index())
+            return [a for a in q.all()]
+
+        except Exception as ex:
+            raise click.ClickException(f"TrackController.findAudioTracks(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def findSubtitleTracks(self, patternId):
+
+        try:
+            s = self.Session()
+                
+            q = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.SUBTITLE.index())
+            return [s for s in q.all()]
+
+        except Exception as ex:
+            raise click.ClickException(f"TrackController.findSubtitleTracks(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def findTrack(self, patternId, trackType : TrackType, subIndex):
+    def getTrack(self, patternId : int, index: int) -> Track:
         
         try:
             s = self.Session()
-            q = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == trackType.value, Track.sub_index == int(subIndex))
+            q = s.query(Track).filter(Track.pattern_id == int(patternId), Track.index == int(index))
 
             if q.count():
-                track = q.first()
+                return q.first()
-                return int(track.id)
             else:
                 return None
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.findTrack(): {repr(ex)}")
+            raise click.ClickException(f"TrackController.getTrack(): {repr(ex)}")
         finally:
             s.close()
 
+    def setDispositionState(self, patternId: int, index: int, disposition : TrackDisposition, state : bool):
 
-    def getTrackDict(self, track):
+        if type(patternId) is not int:
-        trackDescriptor = {}
+            raise TypeError('TrackController.setTrackDisposition(): Argument patternId is required to be of type int')
-        trackDescriptor['id'] = int(track.id)
+        if type(index) is not int:
-        trackDescriptor['pattern_id'] = int(track.pattern_id)
+            raise TypeError('TrackController.setTrackDisposition(): Argument index is required to be of type int')
-        trackDescriptor['type'] = TrackType(track.track_type)
+        if type(disposition) is not TrackDisposition:
-        trackDescriptor['sub_index'] = int(track.sub_index)
+            raise TypeError('TrackController.setTrackDisposition(): Argument disposition is required to be of type TrackDisposition')
-        trackDescriptor['language'] = IsoLanguage.findThreeLetter(track.language)
+        if type(state) is not bool:
-        trackDescriptor['title'] = str(track.title)
+            raise TypeError('TrackController.setTrackDisposition(): Argument state is required to be of type bool')
-        trackDescriptor['disposition_list'] = TrackDisposition.toList(track.disposition_flags)
-        return trackDescriptor
-
-
-    def getTrackDescriptor(self, trackId):
 
         try:
             s = self.Session()
-            q = s.query(Track).filter(Track.id == int(trackId))
+            q = s.query(Track).filter(Track.pattern_id == patternId, Track.index == index)
-
-            if q.count():
-                track = q.first()
-                return self.getTrackDict(track)
-            else:
-                return {}
-
-        except Exception as ex:
-            raise click.ClickException(f"TrackController.getTrackDescriptor(): {repr(ex)}")
-        finally:
-            s.close()
-
-
-    def deleteTrack(self, trackId):
-        try:
-            s = self.Session()
-            q = s.query(Track).filter(Track.id == int(trackId))
 
             if q.count():
 
-                trackDescriptor = self.getTrackDict(q.first())
+                track : Track = q.first()
 
-
+                if state:
-                q_siblings = s.query(Track).filter(Track.pattern_id == int(trackDescriptor['pattern_id']), Track.track_type == trackDescriptor['type'].value).order_by(Track.sub_index)
+                    track.setDisposition(disposition)
-
-                subIndex = 0
-                for track in q_siblings.all():
-
-                    if track.sub_index == trackDescriptor['sub_index']:
-                        s.delete(track)
                 else:
-                        track.sub_index = subIndex
+                    track.resetDisposition(disposition)
-                        subIndex += 1
 
                 s.commit()
                 return True
 
-
+            else:
                 return False
 
+        except Exception as ex:
+            raise click.ClickException(f"TrackController.updateTrack(): {repr(ex)}")
+        finally:
+            s.close()
+
+    def deleteTrack(self, trackId):
+        try:
+            s = self.Session()
+
+            q = s.query(Track).filter(Track.id == int(trackId))
+
+            if q.count():
+                patternId = int(q.first().pattern_id)
+
+                q_siblings = s.query(Track).filter(Track.pattern_id == patternId).order_by(Track.index)
+
+                index = 0
+                for track in q_siblings.all():
+
+                    if track.id == int(trackId):
+                        s.delete(track)
+                    else:
+                        track.index = index
+                        index += 1
+
+                s.commit()
+                return True
+
+            return False
 
         except Exception as ex:
             raise click.ClickException(f"TrackController.deleteTrack(): {repr(ex)}")
         finally:
             s.close()
+
+
+    def setDefaultSubTrack(self, trackType, subIndex):
+            pass
+
+    def setForcedSubTrack(self, trackType, subIndex):
+            pass

bin/ffx/track_delete_screen.py

@@ -3,13 +3,13 @@ import click
 from textual import events
 from textual.app import App, ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button, Input
+from textual.widgets import Header, Footer, Static, Button
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
 
 from ffx.model.pattern import Pattern
+from ffx.model.track import Track
+from ffx.track_descriptor import TrackDescriptor
 
-# from .show_controller import ShowController
-# from .pattern_controller import PatternController
 from .track_controller import TrackController
 
 from .track_type import TrackType
@@ -54,26 +54,26 @@ class TrackDeleteScreen(Screen):
     }
     """
 
-    def __init__(self, trackId = None):
+    def __init__(self, trackDescriptor : TrackDescriptor):
         super().__init__()
 
         self.context = self.app.getContext()
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
-        if trackId is None:
+        if type(trackDescriptor) is not TrackDescriptor:
-            raise click.ClickException('TrackDeleteScreen.init(): trackId is required to be set')
+            raise click.ClickException('TrackDeleteScreen.init(): trackDescriptor is required to be of type TrackDescriptor')
 
         self.__tc = TrackController(context = self.context)
 
-        self.track_obj = self.__tc.getTrackDescriptor(trackId)
+        self.__trackDescriptor = trackDescriptor
 
 
     def on_mount(self):
 
-        self.query_one("#subindexlabel", Static).update(str(self.track_obj['sub_index']))
+        self.query_one("#subindexlabel", Static).update(str(self.__trackDescriptor.getSubIndex()))
-        self.query_one("#patternlabel", Static).update(str(self.track_obj['pattern_id']))
+        self.query_one("#patternlabel", Static).update(str(self.__trackDescriptor.getPatternId()))
-        self.query_one("#languagelabel", Static).update(str(self.track_obj['language'].label()))
+        self.query_one("#languagelabel", Static).update(str(self.__trackDescriptor.getLanguage().label()))
-        self.query_one("#titlelabel", Static).update(str(str(self.track_obj['title'])))
+        self.query_one("#titlelabel", Static).update(str(str(self.__trackDescriptor.getTitle())))
 
 
     def compose(self):
@@ -83,7 +83,7 @@ class TrackDeleteScreen(Screen):
         with Grid():
             
             #1
-            yield Static(f"Are you sure to delete the following {self.track_obj['type'].label()} track?", id="toplabel", classes="four")
+            yield Static(f"Are you sure to delete the following {self.__trackDescriptor.getType().label()} track?", id="toplabel", classes="four")
 
             #2
             yield Static("sub index")
@@ -122,12 +122,15 @@ class TrackDeleteScreen(Screen):
 
         if event.button.id == "delete_button":
 
-            trackId = self.__tc.findTrack(self.track_obj['pattern_id'], self.track_obj['type'], self.track_obj['sub_index'])
+            track = self.__tc.getTrack(self.__trackDescriptor.getPatternId(), self.__trackDescriptor.getIndex())
 
-            if trackId is not None:
+            if track is None:
+                raise click.ClickException(f"Track is none: patternId={self.__trackDescriptor.getPatternId()} type={self.__trackDescriptor.getType()} subIndex={self.__trackDescriptor.getSubIndex()}")
 
-                if self.__tc.deleteTrack(trackId):                    
+            if track is not None:
-                    self.dismiss(self.track_obj)
+
+                if self.__tc.deleteTrack(track.getId()):                    
+                    self.dismiss(self.__trackDescriptor)
 
                 else:
                     #TODO: Meldung

bin/ffx/track_descriptor.py

@@ -1,56 +1,331 @@
-from language_data import LanguageData
+import logging
-from stream_type import StreamType
 
-class StreamDescriptor():
+from .iso_language import IsoLanguage
+from .track_type import TrackType
+from .audio_layout import AudioLayout
+from .track_disposition import TrackDisposition
 
-    def __init__(self,
+from .helper import dictDiff, setDiff
-                streamType : StreamType,
-                language : LanguageData,
-                title : str,
-                codec : str,
-                subIndex : int = -1):
 
-        self.__streamType = streamType
+
+class TrackDescriptor:
+
+    CONTEXT_KEY = "context"
+
+    ID_KEY = "id"
+    INDEX_KEY = "index"
+    SOURCE_INDEX_KEY = "source_index"
+    SUB_INDEX_KEY = "sub_index"
+    PATTERN_ID_KEY = "pattern_id"
+    EXTERNAL_SOURCE_FILE_PATH_KEY = "external_source_file"
+
+    DISPOSITION_SET_KEY = "disposition_set"
+    TAGS_KEY = "tags"
+
+    TRACK_TYPE_KEY = "track_type"
+    CODEC_NAME_KEY = "codec_name"
+    AUDIO_LAYOUT_KEY = "audio_layout"
+
+    FFPROBE_INDEX_KEY = "index"
+    FFPROBE_DISPOSITION_KEY = "disposition"
+    FFPROBE_TAGS_KEY = "tags"
+    FFPROBE_CODEC_TYPE_KEY = "codec_type"
+    FFPROBE_CODEC_NAME_KEY = "codec_name"
+    
+    CODEC_PGS = 'hdmv_pgs_subtitle'
+
+    def __init__(self, **kwargs):
+
+        if TrackDescriptor.CONTEXT_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.CONTEXT_KEY]) is not dict:
+                raise TypeError(
+                    f"TrackDescriptor.__init__(): Argument {TrackDescriptor.CONTEXT_KEY} is required to be of type dict"
+                )
+            self.__context = kwargs[TrackDescriptor.CONTEXT_KEY]
+            self.__logger = self.__context['logger']
+        else:
+            self.__context = {}
+            self.__logger = logging.getLogger('FFX').addHandler(logging.NullHandler())
+
+        if TrackDescriptor.ID_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.ID_KEY]) is not int:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.ID_KEY} is required to be of type int"
+                )
+            self.__trackId = kwargs[TrackDescriptor.ID_KEY]
+        else:
+            self.__trackId = -1
+
+        if TrackDescriptor.PATTERN_ID_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.PATTERN_ID_KEY]) is not int:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.PATTERN_ID_KEY} is required to be of type int"
+                )
+            self.__patternId = kwargs[TrackDescriptor.PATTERN_ID_KEY]
+        else:
+            self.__patternId = -1
+
+        if TrackDescriptor.EXTERNAL_SOURCE_FILE_PATH_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.EXTERNAL_SOURCE_FILE_PATH_KEY]) is not str:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.EXTERNAL_SOURCE_FILE_PATH_KEY} is required to be of type str"
+                )
+            self.__externalSourceFilePath = kwargs[TrackDescriptor.EXTERNAL_SOURCE_FILE_PATH_KEY]
+        else:
+            self.__externalSourceFilePath = ''
+
+        if TrackDescriptor.INDEX_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.INDEX_KEY]) is not int:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.INDEX_KEY} is required to be of type int"
+                )
+            self.__index = kwargs[TrackDescriptor.INDEX_KEY]
+        else:
+            self.__index = -1
+
+        if (
+            TrackDescriptor.SOURCE_INDEX_KEY in kwargs.keys()
+            and type(kwargs[TrackDescriptor.SOURCE_INDEX_KEY]) is int
+        ):
+            self.__sourceIndex = kwargs[TrackDescriptor.SOURCE_INDEX_KEY]
+        else:
+            self.__sourceIndex = self.__index
+
+        if TrackDescriptor.SUB_INDEX_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.SUB_INDEX_KEY]) is not int:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.SUB_INDEX_KEY} is required to be of type int"
+                )
+            self.__subIndex = kwargs[TrackDescriptor.SUB_INDEX_KEY]
+        else:
+            self.__subIndex = -1
+
+        if TrackDescriptor.TRACK_TYPE_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.TRACK_TYPE_KEY]) is not TrackType:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.TRACK_TYPE_KEY} is required to be of type TrackType"
+                )
+            self.__trackType = kwargs[TrackDescriptor.TRACK_TYPE_KEY]
+        else:
+            self.__trackType = TrackType.UNKNOWN
+
+        if TrackDescriptor.CODEC_NAME_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.CODEC_NAME_KEY]) is not str:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.CODEC_NAME_KEY} is required to be of type str"
+                )
+            self.__codecName = kwargs[TrackDescriptor.CODEC_NAME_KEY]
+        else:
+            self.__codecName = ''
+
+        if TrackDescriptor.TAGS_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.TAGS_KEY]) is not dict:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.TAGS_KEY} is required to be of type dict"
+                )
+            self.__trackTags = kwargs[TrackDescriptor.TAGS_KEY]
+        else:
+            self.__trackTags = {}
+
+        if TrackDescriptor.DISPOSITION_SET_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.DISPOSITION_SET_KEY]) is not set:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.DISPOSITION_SET_KEY} is required to be of type set"
+                )
+            for d in kwargs[TrackDescriptor.DISPOSITION_SET_KEY]:
+                if type(d) is not TrackDisposition:
+                    raise TypeError(
+                        f"TrackDesciptor.__init__(): All elements of argument set {TrackDescriptor.DISPOSITION_SET_KEY} is required to be of type TrackDisposition"
+                    )
+            self.__dispositionSet = kwargs[TrackDescriptor.DISPOSITION_SET_KEY]
+        else:
+            self.__dispositionSet = set()
+
+        if TrackDescriptor.AUDIO_LAYOUT_KEY in kwargs.keys():
+            if type(kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY]) is not AudioLayout:
+                raise TypeError(
+                    f"TrackDesciptor.__init__(): Argument {TrackDescriptor.AUDIO_LAYOUT_KEY} is required to be of type AudioLayout"
+                )
+            self.__audioLayout = kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY]
+        else:
+            self.__audioLayout = AudioLayout.LAYOUT_UNDEFINED
+
+    @classmethod
+    def fromFfprobe(cls, streamObj, subIndex: int = -1):
+        """Processes ffprobe stream data as array with elements according to the following example
+        {
+        "index": 4,
+        "codec_name": "hdmv_pgs_subtitle",
+        "codec_long_name": "HDMV Presentation Graphic Stream subtitles",
+        "codec_type": "subtitle",
+        "codec_tag_string": "[0][0][0][0]",
+        "codec_tag": "0x0000",
+        "r_frame_rate": "0/0",
+        "avg_frame_rate": "0/0",
+        "time_base": "1/1000",
+        "start_pts": 0,
+        "start_time": "0.000000",
+        "duration_ts": 1421035,
+        "duration": "1421.035000",
+        "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0,
+                "non_diegetic": 0,
+                "captions": 0,
+                "descriptions": 0,
+                "metadata": 0,
+                "dependent": 0,
+                "still_image": 0
+        },
+        "tags": {
+                "language": "ger",
+                "title": "German Full"
+        }
+        }
+        """
+
+        trackType = (
+            TrackType.fromLabel(streamObj["codec_type"])
+            if "codec_type" in streamObj.keys()
+            else TrackType.UNKNOWN
+        )
+
+        if trackType != TrackType.UNKNOWN:
+
+            kwargs = {}
+
+            kwargs[TrackDescriptor.INDEX_KEY] = (
+                int(streamObj[TrackDescriptor.FFPROBE_INDEX_KEY])
+                if TrackDescriptor.FFPROBE_INDEX_KEY in streamObj.keys()
+                else -1
+            )
+            kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = kwargs[TrackDescriptor.INDEX_KEY]
+            kwargs[TrackDescriptor.SUB_INDEX_KEY] = subIndex
+
+            kwargs[TrackDescriptor.TRACK_TYPE_KEY] = trackType
+            kwargs[TrackDescriptor.CODEC_NAME_KEY] = str(streamObj[TrackDescriptor.FFPROBE_CODEC_NAME_KEY])
+
+            kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = (
+                {
+                    t
+                    for d in (
+                        k
+                        for (k, v) in streamObj[
+                            TrackDescriptor.FFPROBE_DISPOSITION_KEY
+                        ].items()
+                        if v
+                    )
+                    if (t := TrackDisposition.find(d)) is not None
+                }
+                if TrackDescriptor.FFPROBE_DISPOSITION_KEY in streamObj.keys()
+                else set()
+            )
+            kwargs[TrackDescriptor.TAGS_KEY] = (
+                streamObj[TrackDescriptor.FFPROBE_TAGS_KEY]
+                if TrackDescriptor.FFPROBE_TAGS_KEY in streamObj.keys()
+                else {}
+            )
+            kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY] = (
+                AudioLayout.identify(streamObj)
+                if trackType == TrackType.AUDIO
+                else AudioLayout.LAYOUT_UNDEFINED
+            )
+
+            return cls(**kwargs)
+        else:
+            return None
+
+    def getId(self):
+        return self.__trackId
+
+    def getPatternId(self):
+        return self.__patternId
+
+    def getIndex(self):
+        return self.__index
+
+    def setIndex(self, index):
+        self.__index = index
+
+    def getSourceIndex(self):
+        return self.__sourceIndex
+
+    def setSourceIndex(self, sourceIndex: int):
+        self.__sourceIndex = int(sourceIndex)
+
+    def getSubIndex(self):
+        return self.__subIndex
+
+    def setSubIndex(self, subIndex):
         self.__subIndex = subIndex
 
-        self.__streamLanguage = language
+    def getType(self):
-        self.__streamTitle = title
+        return self.__trackType
     
-        self.__codecName = codec
+    def getCodec(self):
+        return self.__codecName
 
-#             "index": 4,
+    def getLanguage(self):
-#             "codec_name": "hdmv_pgs_subtitle",
+        if "language" in self.__trackTags.keys():
-#             "codec_long_name": "HDMV Presentation Graphic Stream subtitles",
+            return IsoLanguage.findThreeLetter(self.__trackTags["language"])
-#             "codec_type": "subtitle",
+        else:
-#             "codec_tag_string": "[0][0][0][0]",
+            return IsoLanguage.UNDEFINED
-#             "codec_tag": "0x0000",
+
-#             "r_frame_rate": "0/0",
+    def getTitle(self):
-#             "avg_frame_rate": "0/0",
+        if "title" in self.__trackTags.keys():
-#             "time_base": "1/1000",
+            return str(self.__trackTags["title"])
-#             "start_pts": 0,
+        else:
-#             "start_time": "0.000000",
+            return ""
-#             "duration_ts": 1421035,
+
-#             "duration": "1421.035000",
+    def getAudioLayout(self):
-#             "disposition": {
+        return self.__audioLayout
-#                 "default": 1,
+
-#                 "dub": 0,
+    def getTags(self):
-#                 "original": 0,
+        return self.__trackTags
-#                 "comment": 0,
+
-#                 "lyrics": 0,
+    def getDispositionSet(self):
-#                 "karaoke": 0,
+        return self.__dispositionSet
-#                 "forced": 0,
+
-#                 "hearing_impaired": 0,
+    def getDispositionFlag(self, disposition: TrackDisposition) -> bool:
-#                 "visual_impaired": 0,
+        return bool(disposition in self.__dispositionSet)
-#                 "clean_effects": 0,
+
-#                 "attached_pic": 0,
+    def setDispositionFlag(self, disposition: TrackDisposition, state: bool):
-#                 "timed_thumbnails": 0,
+        if state:
-#                 "non_diegetic": 0,
+            self.__dispositionSet.add(disposition)
-#                 "captions": 0,
+        else:
-#                 "descriptions": 0,
+            self.__dispositionSet.discard(disposition)
-#                 "metadata": 0,
+
-#                 "dependent": 0,
+    def compare(self, vsTrackDescriptor):
-#                 "still_image": 0
+
-#             },
+        compareResult = {}
-#             "tags": {
+
-#                 "language": "ger",
+        tagsDiffResult = dictDiff(vsTrackDescriptor.getTags(), self.getTags())
-#                 "title": "German Full"
+
+        if tagsDiffResult:
+            compareResult[TrackDescriptor.TAGS_KEY] = tagsDiffResult
+
+        vsDispositions = vsTrackDescriptor.getDispositionSet()
+        dispositions = self.getDispositionSet()
+
+        dispositionDiffResult = setDiff(vsDispositions, dispositions)
+
+        if dispositionDiffResult:
+            compareResult[TrackDescriptor.DISPOSITION_SET_KEY] = dispositionDiffResult
+
+        return compareResult
+
+    def setExternalSourceFilePath(self, filePath: str):
+        self.__externalSourceFilePath = str(filePath)
+
+    def getExternalSourceFilePath(self):
+        return self.__externalSourceFilePath

bin/ffx/track_details_screen.py

@@ -3,21 +3,28 @@ import click, time
 from textual import events
 from textual.app import App, ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label, ListView, ListItem, Static, DataTable, Button, Input, Checkbox, SelectionList, Select
+from textual.widgets import Header, Footer, Static, Button, SelectionList, Select, DataTable, Input
-from textual.containers import Grid, Horizontal
+from textual.containers import Grid
 
-
-from ffx.model.show import Show
 from ffx.model.pattern import Pattern
+from ffx.model.track import Track
 
 from .track_controller import TrackController
 from .pattern_controller import PatternController
-# from .show_controller import ShowController
+from .tag_controller import TagController
 
 from .track_type import TrackType
 
 from .iso_language import IsoLanguage
 from .track_disposition import TrackDisposition
+from .audio_layout import AudioLayout
+
+from .track_descriptor import TrackDescriptor
+
+from .tag_details_screen import TagDetailsScreen
+from .tag_delete_screen import TagDeleteScreen
+
+from textual.widgets._data_table import CellDoesNotExist
 
 
 # Screen[dict[int, str, int]]
@@ -26,9 +33,9 @@ class TrackDetailsScreen(Screen):
     CSS = """
 
     Grid {
-        grid-size: 5 20;
+        grid-size: 5 24;
-        grid-rows: 2 2 2 2 2 3 2 2 2 2 2 6 2 2 6 2 2 2 2 6;
+        grid-rows: 2 2 2 2 2 3 3 2 2 3 2 2 2 2 2 6 2 2 6 2 2 2;
-        grid-columns: 25 25 25 25 225;
+        grid-columns: 25 25 25 25 125;
         height: 100%;
         width: 100%;
         padding: 1;
@@ -73,61 +80,83 @@ class TrackDetailsScreen(Screen):
         height: 100%;
         border: solid green;
     }
+
+    .yellow {
+        tint: yellow 40%;
+    }
     """
 
-    def __init__(self, trackId = None, patternId = None, trackType : TrackType = None, subIndex = None):
+    def __init__(self, trackDescriptor : TrackDescriptor = None, patternId = None, trackType : TrackType = None, index = None, subIndex = None):
         super().__init__()
 
         self.context = self.app.getContext()
-        self.Session = self.context['database_session'] # convenience
+        self.Session = self.context['database']['session'] # convenience
 
         self.__tc = TrackController(context = self.context)
         self.__pc = PatternController(context = self.context)
+        self.__tac = TagController(context = self.context)
 
-        self.track_obj = self.__tc.getTrackDescriptor(trackId) if trackId is not None else {}
+        self.__isNew = trackDescriptor is None
-
+        if self.__isNew:
-        if self.track_obj:
+            self.__trackType = trackType
-            self.trackType = self.track_obj['type']
+            self.__audioLayout = AudioLayout.LAYOUT_UNDEFINED
-            self.subIndex = self.track_obj['sub_index']
+            self.__index = index
-            self.pattern_obj = self.__pc.getPatternDescriptor(self.track_obj['pattern_id'])
+            self.__subIndex = subIndex
-            self.track_obj['is_new'] = False
+            self.__trackDescriptor : TrackDescriptor = None
+            self.__pattern : Pattern = self.__pc.getPattern(patternId) if patternId is not None else {}
         else:
-            self.trackType = trackType
+            self.__trackType = trackDescriptor.getType()
-            self.subIndex = subIndex
+            self.__audioLayout = trackDescriptor.getAudioLayout()
-            self.pattern_obj = self.__pc.getPatternDescriptor(patternId) if patternId is not None else {}
+            self.__index = trackDescriptor.getIndex()
-            self.track_obj['is_new'] = True
+            self.__subIndex = trackDescriptor.getSubIndex()
+            self.__trackDescriptor : TrackDescriptor = trackDescriptor
+            self.__pattern : Pattern = self.__pc.getPattern(self.__trackDescriptor.getPatternId())
 
-        if self.trackType is None:
+
-            raise click.ClickException('Track type is required to be set')
+
-        if self.subIndex is None:
+    def updateTags(self):
-            raise click.ClickException('Sub index for track is required to be set')
+
+        self.trackTagsTable.clear()
+
+        trackId = self.__trackDescriptor.getId()
+
+        if trackId != -1:
+
+            trackTags = self.__tac.findAllTrackTags(trackId)
+
+            for k,v in trackTags.items():
+
+                if k != 'language' and k != 'title':
+                    row = (k,v)
+                    self.trackTagsTable.add_row(*map(str, row))
 
 
     def on_mount(self):
 
-        if self.pattern_obj:
+        self.query_one("#index_label", Static).update(str(self.__index) if self.__index is not None else '-')
-            self.query_one("#patternlabel", Static).update(str(self.pattern_obj['pattern']))
+        self.query_one("#subindex_label", Static).update(str(self.__subIndex)if self.__subIndex is not None else '-')
 
+        if self.__pattern is not None:
+            self.query_one("#pattern_label", Static).update(self.__pattern.getPattern())
 
-        if self.subIndex is not None:
+        if self.__trackType is not None:
-            self.query_one("#subindexlabel", Static).update(str(self.subIndex))
+            self.query_one("#type_select", Select).value = self.__trackType.label()
-
+            if self.__trackType == TrackType.AUDIO:
+                self.query_one("#audio_layout_select", Select).value = self.__audioLayout.label()
 
         for d in TrackDisposition:
 
-            dispositionIsSet = (self.track_obj
+            dispositionIsSet = (self.__trackDescriptor is not None
-                                and 'disposition_list' in self.track_obj.keys()
+                                and d in self.__trackDescriptor.getDispositionSet())
-                                and d in self.track_obj['disposition_list'])
 
-            disposition = (d.label(), d.index(), dispositionIsSet)
+            dispositionOption = (d.label(), d.index(), dispositionIsSet)
-            self.query_one("#dispositions_selection_list", SelectionList).add_option(disposition) 
+            self.query_one("#dispositions_selection_list", SelectionList).add_option(dispositionOption) 
 
-        if 'language' in self.track_obj.keys():
+        if self.__trackDescriptor is not None:
-            self.query_one("#language_select", Select).value = self.track_obj['language'].label()
-
-        if 'title' in self.track_obj.keys():
-            self.query_one("#title_input", Input).value = str(self.track_obj['title'])
 
+            self.query_one("#language_select", Select).value = self.__trackDescriptor.getLanguage().label()
+            self.query_one("#title_input", Input).value = self.__trackDescriptor.getTitle()
+            self.updateTags()
 
 
     def compose(self):
@@ -136,7 +165,7 @@ class TrackDetailsScreen(Screen):
 
         # Define the columns with headers
         self.column_key_track_tag_key = self.trackTagsTable.add_column("Key", width=10)
-        self.column_key_track_tag_value = self.trackTagsTable.add_column("Value", width=30)
+        self.column_key_track_tag_value = self.trackTagsTable.add_column("Value", width=125)
 
         self.trackTagsTable.cursor_type = 'row'
 
@@ -148,70 +177,87 @@ class TrackDetailsScreen(Screen):
         with Grid():
 
             # 1
-            yield Static(f"New {self.trackType.label()} stream" if self.track_obj['is_new'] else f"Edit {self.trackType.label()} stream", id="toplabel", classes="five")
+            yield Static(f"New stream" if self.__isNew else f"Edit stream", id="toplabel", classes="five")
 
             # 2
             yield Static("for pattern")
-            yield Static("", id="patternlabel", classes="four")
+            yield Static("", id="pattern_label", classes="four")
 
             # 3
-            yield Static("sub index")
+            yield Static(" ", classes="five")
-            yield Static("", id="subindexlabel", classes="four")
 
             # 4
-            yield Static(" ", classes="five")
+            yield Static("Index / Subindex")
+            yield Static("", id="index_label", classes="two")
+            yield Static("", id="subindex_label", classes="two")
+
             # 5
             yield Static(" ", classes="five")
 
             # 6
-            yield Static("Language")
+            yield Static("Type")
-            yield Select.from_values(languages, classes="four", id="language_select")
+            yield Select.from_values([t.label() for t in TrackType], classes="four", id="type_select")
+
             # 7
-            yield Static(" ", classes="five")
+            yield Static("Audio Layout")
+            yield Select.from_values([t.label() for t in AudioLayout], classes="four", id="audio_layout_select")
 
             # 8
-            yield Static("Title")
+            yield Static(" ", classes="five")
-            yield Input(id="title_input", classes="four")
 
             # 9
             yield Static(" ", classes="five")
 
             # 10
+            yield Static("Language")
+            yield Select.from_values(languages, classes="four", id="language_select")
+            # 11
             yield Static(" ", classes="five")
 
-            # 11
-            yield Static("Stream tags")
-            yield Static(" ", classes="two")
-            yield Button("Add", id="button_add_stream_tag")
-            yield Button("Delete", id="button_delete_stream_tag")
             # 12
-            yield self.trackTagsTable
+            yield Static("Title")
+            yield Input(id="title_input", classes="four")
 
             # 13
             yield Static(" ", classes="five")
 
             # 14
-            yield Static("Stream dispositions", classes="five")
+            yield Static(" ", classes="five")
 
             # 15
+            yield Static("Stream tags")
+            yield Static(" ")
+            yield Button("Add", id="button_add_stream_tag")
+            yield Button("Edit", id="button_edit_stream_tag")
+            yield Button("Delete", id="button_delete_stream_tag")
+            # 16
+            yield self.trackTagsTable
+
+            # 17
+            yield Static(" ", classes="five")
+
+            # 18
+            yield Static("Stream dispositions", classes="five")
+
+            # 19
             yield SelectionList[int](
                 classes="five",
                 id = "dispositions_selection_list"
             )
 
-            # 16
+            # 20
             yield Static(" ", classes="five")
-            # 17
+            # 21
             yield Static(" ", classes="five")
 
-            # 18
+            # 22
             yield Button("Save", id="save_button")
             yield Button("Cancel", id="cancel_button")
 
-            # 19
+            # 23
             yield Static(" ", classes="five")
 
-            # 20
+            # 24
             yield Static(" ", classes="five", id="messagestatic")
 
 
@@ -220,50 +266,88 @@ class TrackDetailsScreen(Screen):
 
     def getTrackDescriptorFromInput(self):
 
-        trackDescriptor = {}
+        kwargs = {}
 
-        trackDescriptor['pattern_id'] = int(self.pattern_obj['id'])
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self.context
 
-        trackDescriptor['type'] = TrackType(self.trackType)
+        kwargs[TrackDescriptor.PATTERN_ID_KEY] = int(self.__pattern.getId())
-        trackDescriptor['sub_index'] = self.subIndex
 
-        trackDescriptor['language'] = IsoLanguage.find(str(self.query_one("#language_select", Select).value))
+        kwargs[TrackDescriptor.INDEX_KEY] = self.__index
-        trackDescriptor['title'] = str(self.query_one("#title_input", Input).value)
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = self.__subIndex #!
+
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.fromLabel(self.query_one("#type_select", Select).value)
+        kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY] = AudioLayout.fromLabel(self.query_one("#audio_layout_select", Select).value)
+
+        trackTags = {}
+        language = self.query_one("#language_select", Select).value
+        if language:
+            trackTags['language'] = IsoLanguage.find(language).threeLetter()
+        title = self.query_one("#title_input", Input).value
+        if title:
+            trackTags['title'] = title
+
+        tableTags = {row[0]:row[1] for r in self.trackTagsTable.rows if (row := self.trackTagsTable.get_row(r)) and row[0] != 'language' and row[0] != 'title'}
+
+        kwargs[TrackDescriptor.TAGS_KEY] = trackTags | tableTags
+
+        dispositionFlags = sum([2**f for f in self.query_one("#dispositions_selection_list", SelectionList).selected])
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = TrackDisposition.toSet(dispositionFlags)
+
+        return TrackDescriptor(**kwargs)
 
 
-        disposition_flags = sum([2**f for f in self.query_one("#dispositions_selection_list", SelectionList).selected])
 
-        trackDescriptor['disposition_list'] = TrackDisposition.toList(disposition_flags)
+    def getSelectedTag(self):
 
+        try:
+
+            # Fetch the currently selected row when 'Enter' is pressed
+            #selected_row_index = self.table.cursor_row
+            row_key, col_key = self.trackTagsTable.coordinate_to_cell_key(self.trackTagsTable.cursor_coordinate)
+
+            if row_key is not None:
+                selected_tag_data = self.trackTagsTable.get_row(row_key)
+
+                tagKey = str(selected_tag_data[0])
+                tagValue = str(selected_tag_data[1])
+
+                return tagKey, tagValue
+
+            else:
+                return None
+
+        except CellDoesNotExist:
+            return None
 
-        return trackDescriptor
 
 
    # Event handler for button press
     def on_button_pressed(self, event: Button.Pressed) -> None:
+
         # Check if the button pressed is the one we are interested in
         if event.button.id == "save_button":
 
-            trackDescriptor = self.getTrackDescriptorFromInput()
-
-
             # Check for multiple default/forced disposition flags
 
-            trackIdList = self.__tc.findAllTracks(self.pattern_obj['id'])[self.trackType.label()]
+            if self.__trackType == TrackType.VIDEO:
+                trackList = self.__tc.findVideoTracks(self.__pattern.getId())
+            if self.__trackType == TrackType.AUDIO:
+                trackList = self.__tc.findAudioTracks(self.__pattern.getId())
+            elif self.__trackType == TrackType.SUBTITLE:
+                trackList = self.__tc.findSubtitleTracks(self.__pattern.getId())
+            else:
+                trackList = []
 
-            descriptorList = [d for d in (self.__tc.getTrackDescriptor(t) for t in trackIdList)    
+            siblingTrackList = [t for t in trackList if t.getType() == self.__trackType and t.getIndex() != self.__index]
-                                if d['type'] == self.trackType
-                                and d['sub_index'] != self.subIndex]
 
+            numDefaultTracks = len([t for t in siblingTrackList if TrackDisposition.DEFAULT in t.getDispositionSet()])
+            numForcedTracks = len([t for t in siblingTrackList if TrackDisposition.FORCED in t.getDispositionSet()])
 
-            numDefaultTracks = [d for d in descriptorList if TrackDisposition.DEFAULT in d['disposition_list']]
+            self.__subIndex = len(trackList)
-            numForcedTracks = [d for d in descriptorList if TrackDisposition.FORCED in d['disposition_list']]
+            trackDescriptor = self.getTrackDescriptorFromInput()
 
-            doubleDefaultOrForced = ((TrackDisposition.DEFAULT in trackDescriptor['disposition_list'] and numDefaultTracks)
+            if ((TrackDisposition.DEFAULT in trackDescriptor.getDispositionSet() and numDefaultTracks)
-                                        or (TrackDisposition.FORCED in trackDescriptor['disposition_list'] and numForcedTracks))
+                    or (TrackDisposition.FORCED in trackDescriptor.getDispositionSet() and numForcedTracks)):
-
-
-            if doubleDefaultOrForced:
 
                 self.query_one("#messagestatic", Static).update("Cannot add another stream with disposition flag 'debug' or 'forced' set")
 
@@ -271,21 +355,59 @@ class TrackDetailsScreen(Screen):
 
                 self.query_one("#messagestatic", Static).update(" ")
 
-                if self.track_obj['is_new']:
+                if self.__isNew:
 
+                    # Track per Screen hinzufügen
                     self.__tc.addTrack(trackDescriptor)
                     self.dismiss(trackDescriptor)
 
                 else:
 
-                    trackId = self.__tc.findTrack(self.pattern_obj['id'], self.trackType, self.subIndex)
+                    track = self.__tc.getTrack(self.__pattern.getId(), self.__index)
 
-                    if self.__tc.updateTrack(trackId, trackDescriptor):
+                    # Track per details screen updaten
+                    if self.__tc.updateTrack(track.getId(), trackDescriptor):
                         self.dismiss(trackDescriptor)
 
                     else:
                         self.app.pop_screen()
 
-
         if event.button.id == "cancel_button":
             self.app.pop_screen()
+
+
+        if event.button.id == "button_add_stream_tag":
+            if not self.__isNew:
+                self.app.push_screen(TagDetailsScreen(), self.handle_update_tag)
+
+        if event.button.id == "button_edit_stream_tag":
+            tagKey, tagValue = self.getSelectedTag()
+            self.app.push_screen(TagDetailsScreen(key=tagKey, value=tagValue), self.handle_update_tag)
+
+        if event.button.id == "button_delete_stream_tag":
+            tagKey, tagValue = self.getSelectedTag()
+            self.app.push_screen(TagDeleteScreen(key=tagKey, value=tagValue), self.handle_delete_tag)
+
+
+    def handle_update_tag(self, tag):
+
+        trackId = self.__trackDescriptor.getId()
+
+        if trackId == -1:
+            raise click.ClickException(f"TrackDetailsScreen.handle_update_tag: trackId not set (-1) trackDescriptor={self.__trackDescriptor}")
+
+        if self.__tac.updateTrackTag(trackId, tag[0], tag[1]) is not None:
+            self.updateTags()
+
+    def handle_delete_tag(self, trackTag):
+
+        trackId = self.__trackDescriptor.getId()
+
+        if trackId == -1:
+            raise click.ClickException(f"TrackDetailsScreen.handle_delete_tag: trackId not set (-1) trackDescriptor={self.__trackDescriptor}")
+
+        tag = self.__tac.findTrackTag(trackId, trackTag[0])
+
+        if tag is not None:
+            if self.__tac.deleteTrackTag(tag.id):
+                self.updateTags()

bin/ffx/track_disposition.py

@@ -1,27 +1,30 @@
+import difflib, click
+
 from enum import Enum
-import difflib
+
 
 class TrackDisposition(Enum):
 
-    DEFAULT             = {"name": "default", "index": 0}
+    DEFAULT             = {"name": "default", "index": 0, "indicator": "DEF"}
-    FORCED              = {"name": "forced", "index": 1}
+    FORCED              = {"name": "forced", "index": 1, "indicator": "FOR"}
+
+    DUB                 = {"name": "dub", "index": 2, "indicator": "DUB"}
+    ORIGINAL            = {"name": "original", "index": 3, "indicator": "ORG"}
+    COMMENT             = {"name": "comment", "index": 4, "indicator": "COM"}
+    LYRICS              = {"name": "lyrics", "index": 5, "indicator": "LYR"}
+    KARAOKE             = {"name": "karaoke", "index": 6, "indicator": "KAR"}
+    HEARING_IMPAIRED    = {"name": "hearing_impaired", "index": 7, "indicator": "HIM"}
+    VISUAL_IMPAIRED     = {"name": "visual_impaired", "index": 8, "indicator": "VIM"}
+    CLEAN_EFFECTS       = {"name": "clean_effects", "index": 9, "indicator": "CLE"}
+    ATTACHED_PIC        = {"name": "attached_pic", "index": 10, "indicator": "ATP"}
+    TIMED_THUMBNAILS    = {"name": "timed_thumbnails", "index": 11, "indicator": "TTH"}
+    NON_DIEGETICS       = {"name": "non_diegetic", "index": 12, "indicator": "NOD"}
+    CAPTIONS            = {"name": "captions", "index": 13, "indicator": "CAP"}
+    DESCRIPTIONS        = {"name": "descriptions", "index": 14, "indicator": "DES"}
+    METADATA            = {"name": "metadata", "index": 15, "indicator": "MED"}
+    DEPENDENT           = {"name": "dependent", "index": 16, "indicator": "DEP"}
+    STILL_IMAGE         = {"name": "still_image", "index": 17, "indicator": "STI"}
 
-    DUB                 = {"name": "dub", "index": 2}
-    ORIGINAL            = {"name": "original", "index": 3}
-    COMMENT             = {"name": "comment", "index": 4}
-    LYRICS              = {"name": "lyrics", "index": 5}
-    KARAOKE             = {"name": "karaoke", "index": 6}
-    HEARING_IMPAIRED    = {"name": "hearing_impaired", "index": 7}
-    VISUAL_IMPAIRED     = {"name": "visual_impaired", "index": 8}
-    CLEAN_EFFECTS       = {"name": "clean_effects", "index": 9}
-    ATTACHED_PIC        = {"name": "attached_pic", "index": 10}
-    TIMED_THUMBNAILS    = {"name": "timed_thumbnails", "index": 11}
-    NON_DIEGETICS       = {"name": "non_diegetic", "index": 12}
-    CAPTIONS            = {"name": "captions", "index": 13}
-    DESCRIPTIONS        = {"name": "descriptions", "index": 14}
-    METADATA            = {"name": "metadata", "index": 15}
-    DEPENDENT           = {"name": "dependent", "index": 16}
-    STILL_IMAGE         = {"name": "still_image", "index": 17}
 
     def label(self):
         return str(self.value['name'])
@@ -29,21 +32,37 @@ class TrackDisposition(Enum):
     def index(self):
         return int(self.value['index'])
 
+    def indicator(self):
+        return str(self.value['indicator'])
+
 
     @staticmethod
-    def toFlags(dispositionList):
+    def toFlags(dispositionSet):
         """Flags stored in integer bits (2**index)"""
 
+        if type(dispositionSet) is not set:
+            raise click.ClickException('TrackDisposition.toFlags(): Argument is not of type set')
+
         flags = 0
-        for d in dispositionList:
+        for d in dispositionSet:
+            if type(d) is not TrackDisposition:
+                raise click.ClickException('TrackDisposition.toFlags(): Element not of type TrackDisposition')
             flags += 2 ** d.index()
         return flags
 
     @staticmethod
-    def toList(flags):
+    def toSet(flags):
-        
+        dispositionSet = set()
-        dispositionList = []
         for d in TrackDisposition:
             if flags & int(2 ** d.index()):
-                dispositionList += [d]
+                dispositionSet.add(d)
-        return dispositionList
+        return dispositionSet
+
+
+    @staticmethod
+    def find(label):
+        matchingDispositions = [d for d in TrackDisposition if d.label() == str(label)]
+        if matchingDispositions:
+            return matchingDispositions[0]
+        else:
+            return None

bin/ffx/track_type.py

@@ -2,18 +2,37 @@ from enum import Enum
 
 class TrackType(Enum):
 
-    VIDEO = 1
+    VIDEO       = {'label': 'video', 'index': 1}
-    AUDIO = 2
+    AUDIO       = {'label': 'audio', 'index': 2}
-    SUBTITLE = 3
+    SUBTITLE    = {'label': 'subtitle', 'index': 3}
+
+    UNKNOWN    = {'label': 'unknown', 'index': 0}
 
 
     def label(self):
         """Returns the stream type as string"""
+        return str(self.value['label'])
 
-        labels = {
+    def indicator(self):
-            TrackType.VIDEO: "video",
+        """Returns the stream type as single letter"""
-            TrackType.AUDIO: "audio",
+        return self.label()[0]
-            TrackType.SUBTITLE: "subtitle"
-        }
 
-        return labels.get(self, "undefined")
+    def index(self):
+        """Returns the stream type index"""
+        return int(self.value['index'])
+
+    @staticmethod
+    def fromLabel(label : str):
+        tlist = [t for t in TrackType if t.value['label'] == str(label)]
+        if tlist:
+            return tlist[0]
+        else:
+            return TrackType.UNKNOWN
+
+    @staticmethod
+    def fromIndex(index : int):
+        tlist = [t for t in TrackType if t.value['index'] == int(index)]
+        if tlist:
+            return tlist[0]
+        else:
+            return TrackType.UNKNOWN

bin/ffx/video_encoder.py

@@ -0,0 +1,32 @@
+from enum import Enum
+
+class VideoEncoder(Enum):
+
+    AV1         = {'label': 'av1', 'index': 1}
+    VP9         = {'label': 'vp9', 'index': 2}
+    
+    UNDEFINED   = {'label': 'undefined', 'index': 0}
+
+    def label(self):
+        """Returns the stream type as string"""
+        return str(self.value['label'])
+
+    def index(self):
+        """Returns the stream type index"""
+        return int(self.value['index'])
+
+    @staticmethod
+    def fromLabel(label : str):
+        tlist = [t for t in VideoEncoder if t.value['label'] == str(label)]
+        if tlist:
+            return tlist[0]
+        else:
+            return VideoEncoder.UNDEFINED
+
+    @staticmethod
+    def fromIndex(index : int):
+        tlist = [t for t in VideoEncoder if t.value['index'] == int(index)]
+        if tlist:
+            return tlist[0]
+        else:
+            return VideoEncoder.UNDEFINED

bin/ffx/warning_screen.py

@@ -1,11 +0,0 @@
-from textual.app import App, ComposeResult
-from textual.screen import Screen
-from textual.widgets import Header, Footer, Placeholder, Label
-
-class WarningScreen(Screen):
-    def __init__(self):
-        super().__init__()
-        context = self.app.getContext()
-    def compose(self) -> ComposeResult:
-        yield Label("Warning! This file is not compliant to the defined source schema!")
-        yield Footer()

bin/ffx_tests.py

@@ -0,0 +1,124 @@
+#! /usr/bin/python3
+
+import os, logging, click
+
+from ffx.configuration_controller import ConfigurationController
+
+from ffx.file_properties import FileProperties
+from ffx.ffx_controller import FfxController
+
+from ffx.database import databaseContext
+
+from ffx.test.helper import createMediaTestFile
+
+from ffx.test.scenario import Scenario
+from ffx.tmdb_controller import TMDB_API_KEY_NOT_PRESENT_EXCEPTION
+
+
+@click.group()
+@click.pass_context
+@click.option('-v', '--verbose', type=int, default=0, help='Set verbosity of output')
+@click.option("--dry-run", is_flag=True, default=False)
+def ffx(ctx, verbose, dry_run):
+    """FFX"""
+
+    ctx.obj = {}
+
+    ctx.obj['config'] = ConfigurationController()
+
+    ctx.obj['database'] = None
+    ctx.obj['dry_run'] = dry_run
+
+    ctx.obj['verbosity'] = verbose
+
+    # Critical 50
+    # Error 40
+    # Warning 30
+    # Info 20
+    # Debug 10
+    fileLogVerbosity = max(40 - verbose * 10, 10)
+    consoleLogVerbosity = max(20 - verbose * 10, 10)
+
+    ctx.obj['logger'] = logging.getLogger('FFX Tests')
+    ctx.obj['logger'].setLevel(logging.DEBUG)
+
+    ctx.obj['report_logger'] = logging.getLogger('FFX Test Result')
+    ctx.obj['report_logger'].setLevel(logging.INFO)
+
+    ffxFileHandler = logging.FileHandler(ctx.obj['config'].getLogFilePath())
+    ffxFileHandler.setLevel(fileLogVerbosity)
+    ffxConsoleHandler = logging.StreamHandler()
+    ffxConsoleHandler.setLevel(consoleLogVerbosity)
+
+    if os.path.isfile('ffx_test_report.log'):
+        os.unlink('ffx_test_report.log')
+    ffxTestReportFileHandler = logging.FileHandler('ffx_test_report.log')
+
+    fileFormatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    ffxFileHandler.setFormatter(fileFormatter)
+    consoleFormatter = logging.Formatter(
+        '%(message)s')
+    ffxConsoleHandler.setFormatter(consoleFormatter)
+    reportFormatter = logging.Formatter(
+        '%(message)s')
+    ffxTestReportFileHandler.setFormatter(reportFormatter)
+
+    ctx.obj['logger'].addHandler(ffxConsoleHandler)
+    ctx.obj['logger'].addHandler(ffxFileHandler)
+
+    ctx.obj['report_logger'].addHandler(ffxConsoleHandler)
+    ctx.obj['report_logger'].addHandler(ffxTestReportFileHandler)
+    
+
+# Another subcommand
+@ffx.command()
+@click.pass_context
+@click.option('--scenario', type=str, default='', help='Only run tests from this scenario')
+@click.option('--variant', type=str, default='', help='Only run this test variant')
+def run(ctx, scenario, variant):
+    """Run ffx test sequences"""
+
+    ctx.obj['logger'].info('Starting FFX test runs')
+    ctx.obj['test_passed_counter'] = 0
+    ctx.obj['test_failed_counter'] = 0
+
+    ctx.obj['test_variant'] = variant
+
+    for si in Scenario.list():
+
+        try:
+            SCEN = Scenario.getClassReference(si)
+            scen = SCEN(ctx.obj)
+
+            if scenario and scenario != scen.getScenario():
+                continue
+
+            ctx.obj['logger'].debug(f"Running scenario {si}")
+
+            scen.run()
+
+        except TMDB_API_KEY_NOT_PRESENT_EXCEPTION:
+            ctx.obj['logger'].info(f"TMDB_API_KEY not set: Skipping {SCEN.__class__.__name__}")    
+
+    ctx.obj['logger'].info(f"\n{ctx.obj['test_passed_counter']} tests passed")
+    ctx.obj['logger'].info(f"{ctx.obj['test_failed_counter']} test failed")
+    ctx.obj['logger'].info('\nDone.')
+
+
+@ffx.command()
+@click.pass_context
+@click.argument('paths', nargs=-1)
+def dupe(ctx, paths):
+
+    existingSourcePaths = [p for p in paths if os.path.isfile(p) and p.split('.')[-1] in FfxController.INPUT_FILE_EXTENSIONS]
+
+    for sourcePath in existingSourcePaths:
+
+        sourceFileProperties = FileProperties(ctx.obj, sourcePath)
+        sourceMediaDescriptor = sourceFileProperties.getMediaDescriptor()
+
+        createMediaTestFile(sourceMediaDescriptor, baseName='dupe')
+
+if __name__ == '__main__':
+    ffx()