nightl update from file krude

bin/ffx/helper.py

@@ -16,11 +16,11 @@ def dictDiff(a : dict, b : dict):
     diffResult = {}
 
     if a_only:
-        diffResult['removed'] = a_only
+        diffResult[DIFF_REMOVED_KEY] = a_only
     if b_only:
-        diffResult['added'] = b_only
+        diffResult[DIFF_ADDED_KEY] = b_only
     if changed:
-        diffResult['changed'] = changed
+        diffResult[DIFF_CHANGED_KEY] = changed
 
     return diffResult
 
@@ -33,8 +33,8 @@ def setDiff(a : set, b : set) -> set:
     diffResult = {}
 
     if a_only:
-        diffResult['removed'] = a_only
+        diffResult[DIFF_REMOVED_KEY] = a_only
     if b_only:
-        diffResult['added'] = b_only
+        diffResult[DIFF_ADDED_KEY] = b_only
 
     return diffResult

bin/ffx/media_descriptor.py

@@ -111,16 +111,15 @@ class MediaDescriptor():
 
 
         # Target track configuration (from DB)
-        tracks = [t for t in self.getAllTracks() if t.getType() != TrackType.VIDEO]
+        tracks = self.getAllTracks()
         numTracks = len(tracks)
 
         # Current track configuration (of file)
-        vsTracks = [t for t in vsMediaDescriptor.getAllTracks() if t.getType() != TrackType.VIDEO]
+        vsTracks = vsMediaDescriptor.getAllTracks()
         numVsTracks = len(vsTracks)
 
         maxNumOfTracks = max(numVsTracks, numTracks)
 
-        # raise click.ClickException(f"numTracks={numTracks} numVsTracks={numVsTracks}") # 1 4
 
         trackCompareResult = {}
 
@@ -128,25 +127,25 @@ class MediaDescriptor():
 
                 # Will trigger if tracks are missing in file
                 if tp > (numVsTracks - 1):
-                        if DIFF_REMOVED_KEY not in trackCompareResult.keys():
+                        if DIFF_ADDED_KEY not in trackCompareResult.keys():
-                                trackCompareResult[DIFF_REMOVED_KEY] = set()
+                                trackCompareResult[DIFF_ADDED_KEY] = set()
-                        trackCompareResult[DIFF_REMOVED_KEY].add(tracks[tp].getIndex())
+                        trackCompareResult[DIFF_ADDED_KEY].add(tracks[tp].getIndex())
                         continue
 
                 # Will trigger if tracks are missing in DB definition
                 if tp > (numTracks - 1):
-                        if DIFF_ADDED_KEY not in trackCompareResult.keys():
+                        if DIFF_REMOVED_KEY not in trackCompareResult.keys():
-                                trackCompareResult[DIFF_ADDED_KEY] = {}
+                                trackCompareResult[DIFF_REMOVED_KEY] = {}
-                        trackCompareResult[DIFF_ADDED_KEY][vsTracks[tp].getIndex()] = vsTracks[tp]
+                        trackCompareResult[DIFF_REMOVED_KEY][vsTracks[tp].getIndex()] = vsTracks[tp]
                         continue
 
                 # assumption is made here that the track order will not change for all files of a sequence
-                tdiff = tracks[tp].compare(vsTracks[tp])
+                trackDiff = tracks[tp].compare(vsTracks[tp])
 
-                if tdiff:
+                if trackDiff:
                         if DIFF_CHANGED_KEY not in trackCompareResult.keys():
                                 trackCompareResult[DIFF_CHANGED_KEY] = {}
-                        trackCompareResult[DIFF_CHANGED_KEY][vsTracks[tp].getIndex()] = tdiff
+                        trackCompareResult[DIFF_CHANGED_KEY][vsTracks[tp].getIndex()] = trackDiff
 
         if trackCompareResult:
               compareResult[MediaDescriptor.TRACKS_KEY] = trackCompareResult

bin/ffx/media_details_screen.py

@@ -126,66 +126,6 @@ class MediaDetailsScreen(Screen):
 
 
         self.loadProperties()
-#    def loadTracks(self, show_id):
-#
-#        try:
-#
-#            tracks = {}
-#            tracks['audio'] = {}
-#            tracks['subtitle'] = {}
-#
-#            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()]
-#
-#        except Exception as ex:
-#            raise click.ClickException(f"loadTracks(): {repr(ex)}")
-#        finally:
-#            s.close()
-#
-#
-#    def updateAudioTracks(self):
-#
-#        self.tracksTable.clear()
-#
-#        if self.__pattern is not None:
-#
-#            audioTracks = self.__tc.findAudioTracks(self.__pattern.getId())
-#
-#            for at in audioTracks:
-#
-#                dispoSet = at.getDispositionSet()
-#
-#                row = (at.getSubIndex(),
-#                        " ",
-#                        at.getLanguage().label(),
-#                        at.getTitle(),
-#                        'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
-#                        'Yes' if TrackDisposition.FORCED in dispoSet else 'No')
-#
-#                self.tracksTable.add_row(*map(str, row))
-#
-#    def updateSubtitleTracks(self):
-#
-#        self.subtitleStreamsTable.clear()
-#
-#        if self.__pattern is not None:
-#
-#            subtitleTracks = self.__tc.findSubtitleTracks(self.__pattern.getId())
-#
-#            for st in subtitleTracks:
-#
-#                dispoSet = st.getDispositionSet()
-#
-#                row = (st.getSubIndex(),
-#                        " ",
-#                        st.getLanguage().label(),
-#                        st.getTitle(),
-#                        'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
-#                        'Yes' if TrackDisposition.FORCED in dispoSet else 'No')
-#
-#                self.subtitleStreamsTable.add_row(*map(str, row))
 
 
     def getRowIndexFromShowId(self, showId : int) -> int:
@@ -225,58 +165,76 @@ class MediaDetailsScreen(Screen):
 
         self.differencesTable.clear()
 
-        if 'tags' in self.__mediaDifferences.keys():
+        if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():
 
             currentTags = self.__currentMediaDescriptor.getTags()
             targetTags = self.__targetMediaDescriptor.getTags()
 
-            if 'added' in self.__mediaDifferences['tags'].keys():
+            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
-                for addedTagKey in self.__mediaDifferences['tags']['added']:
+                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 'removed' in self.__mediaDifferences['tags'].keys():
+            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
-                for removedTagKey in self.__mediaDifferences['tags']['removed']:
+                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 'tracks' in self.__mediaDifferences.keys():
+        if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():
 
             currentTracks = self.__currentMediaDescriptor.getAllTracks() # 0,1,2,3
             targetTracks = self.__targetMediaDescriptor.getAllTracks() # 0 <- from DB
 
-            if 'added' in self.__mediaDifferences['tracks'].keys():
+            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
-                for addedTrackIndex in self.__mediaDifferences['tracks']['added'].keys():
+
-                    addedTrack : Track = currentTracks[addedTrackIndex]                        
+                #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 'removed' in self.__mediaDifferences['tracks'].keys():
+            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
-                for removedTrackIndex in self.__mediaDifferences['tracks']['removed']:
+                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 'changed' in self.__mediaDifferences['tracks'].keys():
+            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
-                for changedTrackIndex in self.__mediaDifferences['tracks']['changed'].keys():
+                for changedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].keys():
 
                     changedTrack : Track = targetTracks[changedTrackIndex]
-                    changedTrackDiff : dict = self.__mediaDifferences['tracks']['changed'][changedTrackIndex]                        
+                    changedTrackDiff : dict = self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY][changedTrackIndex]                        
-
-                    if 'tags' in changedTrackDiff.keys():
 
-                        if 'added' in changedTrackDiff['tags']:
+                    if MediaDescriptor.TAGS_KEY in changedTrackDiff.keys():
-                            for addedTagKey in changedTrackDiff['tags']['added']:
 
+                        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 'removed' in changedTrackDiff['tags']:
+                        if DIFF_REMOVED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
-                            for removedTagKey in changedTrackDiff['tags']['removed']:
+                            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):
 
@@ -693,26 +651,78 @@ class MediaDetailsScreen(Screen):
         """When updating the database the actions must reverse the difference (eq to diff db->file)"""
         
         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]:
-                    mediaTags = self.__currentMediaDescriptor.getTags()
+                    currentTags = self.__currentMediaDescriptor.getTags()
-                    self.__tac.updateMediaTag(self.__currentPattern.getId(), removedTagKey, mediaTags[removedTagKey])
+                    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]:
-                    pass
+                    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 addedTrackKey in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
+
-                    pass
+                for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
+                    targetTracks = [t for t in self.__targetMediaDescriptor.getAllTracks() 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 removedTrackKey in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY]:
+                for removedTrackIndex, removedTrack in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY].items():
-                    pass
+                    self.__tc.addTrack(removedTrack, patternId = self.__currentPattern.getId())
+
             if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
-                for changedTrackKey in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY]:
+
-                    pass
+                # [vsTracks[tp].getIndex()] = trackDiff
+                for changedTrackIndex, changedTrackDiff in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].items():
+
+                    changedTargetTracks = [t for t in self.__targetMediaDescriptor.getAllTracks() 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.getAllTracks() 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()
 

bin/ffx/model/track.py

@@ -164,6 +164,16 @@ class Track(Base):
         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, subIndex : int = -1) -> TrackDescriptor:
 
         kwargs = {}

bin/ffx/pattern_details_screen.py

@@ -74,10 +74,6 @@ class PatternDetailsScreen(Screen):
         border: solid green;
     }
 
-    #tracks_table {
-        row-span: 4;
-    }
-
     .yellow {
         tint: yellow 40%;
     }
@@ -206,7 +202,6 @@ class PatternDetailsScreen(Screen):
 
         self.tracksTable.cursor_type = 'row'
 
-        self.subtitleStreamsTable = DataTable(classes="five")
 
         yield Header()
 
@@ -268,6 +263,7 @@ class PatternDetailsScreen(Screen):
             # 12
             yield Button("Save", id="save_button")
             yield Button("Cancel", id="cancel_button")
+            yield Static(" ", classes="three")
 
             # 13
             yield Static(" ", classes="five")

bin/ffx/tag_controller.py

@@ -20,8 +20,7 @@ class TagController():
             s = self.Session()
 
             q = s.query(MediaTag).filter(MediaTag.pattern_id == int(patternId),
-                                MediaTag.key == str(tagKey),
+                                MediaTag.key == str(tagKey))
-                                MediaTag.value == str(tagValue))
             tag = q.first()
             if tag:
                 tag.value = str(tagValue)
@@ -45,8 +44,7 @@ class TagController():
             s = self.Session()
 
             q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId),
-                                TrackTag.key == str(tagKey),
+                                TrackTag.key == str(tagKey))
-                                TrackTag.value == str(tagValue))
             tag = q.first()
             if tag:
                 tag.value = str(tagValue)

bin/ffx/track_controller.py

@@ -21,11 +21,14 @@ class TrackController():
         self.Session = self.context['database']['session'] # convenience
 
 
-    def addTrack(self, trackDescriptor : 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 = int(trackDescriptor.getPatternId()),
+            track = Track(pattern_id = patId,
                             track_type = int(trackDescriptor.getType().index()),
                             index = int(trackDescriptor.getIndex()),
                             disposition_flags = int(TrackDisposition.toFlags(trackDescriptor.getDispositionSet())))
@@ -60,7 +63,6 @@ class TrackController():
 
                 track : Track = q.first()
 
-                track.sub_index = int(trackDescriptor.getSubIndex())
                 track.disposition_flags = int(TrackDisposition.toFlags(trackDescriptor.getDispositionSet()))
 
                 descriptorTagKeys = trackDescriptor.getTags()
@@ -158,6 +160,41 @@ class TrackController():
         finally:
             s.close()
 
+    def setDispositionState(self, patternId: int, index: int, disposition : TrackDisposition, state : bool):
+
+        if type(patternId) is not int:
+            raise TypeError('TrackController.setTrackDisposition(): Argument patternId is required to be of type int')
+        if type(index) is not int:
+            raise TypeError('TrackController.setTrackDisposition(): Argument index is required to be of type int')
+        if type(disposition) is not TrackDisposition:
+            raise TypeError('TrackController.setTrackDisposition(): Argument disposition is required to be of type TrackDisposition')
+        if type(state) is not bool:
+            raise TypeError('TrackController.setTrackDisposition(): Argument state is required to be of type bool')
+
+        try:
+            s = self.Session()
+            q = s.query(Track).filter(Track.pattern_id == patternId, Track.index == index)
+
+            if q.count():
+
+                track : Track = q.first()
+
+                if state:
+                    track.setDisposition(disposition)
+                else:
+                    track.resetDisposition(disposition)
+
+                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()

bin/ffx/track_descriptor.py

@@ -13,9 +13,10 @@ class TrackDescriptor():
         SUB_INDEX_KEY = 'sub_index'
         PATTERN_ID_KEY = 'pattern_id'
 
-        TRACK_TYPE_KEY = 'track_type'
         DISPOSITION_SET_KEY = 'disposition_set'
         TAGS_KEY = 'tags'
+
+        TRACK_TYPE_KEY = 'track_type'
         AUDIO_LAYOUT_KEY = 'audio_layout'
 
         FFPROBE_INDEX_KEY = 'index'
@@ -187,7 +188,6 @@ class TrackDescriptor():
                 return self.__dispositionSet
         
 
-
         def compare(self, vsTrackDescriptor):
 
                 compareResult = {}
@@ -195,7 +195,7 @@ class TrackDescriptor():
                 tagsDiffResult = dictDiff(vsTrackDescriptor.getTags(), self.getTags())
 
                 if tagsDiffResult:
-                        compareResult['tags'] = tagsDiffResult
+                        compareResult[TrackDescriptor.TAGS_KEY] = tagsDiffResult
 
                 vsDispositions = vsTrackDescriptor.getDispositionSet()
                 dispositions = self.getDispositionSet()
@@ -203,6 +203,6 @@ class TrackDescriptor():
                 dispositionDiffResult = setDiff(vsDispositions, dispositions)
 
                 if dispositionDiffResult:
-                        compareResult['dispositions'] = dispositionDiffResult
+                        compareResult[TrackDescriptor.DISPOSITION_SET_KEY] = dispositionDiffResult
 
                 return compareResult

bin/ffx/track_details_screen.py

@@ -329,7 +329,7 @@ class TrackDetailsScreen(Screen):
             else:
                 trackList = []
 
-            siblingTrackList = [t for t in trackList if t.getType() == self.__trackType and t.getSubIndex() != self.__subIndex]
+            siblingTrackList = [t for t in trackList if t.getType() == self.__trackType and t.getIndex() != self.__index]
 
             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()])