From 22f4b00e760952b3a9de8fd8eb50099c5740b1e2 Mon Sep 17 00:00:00 2001 From: Maveno Date: Thu, 31 Oct 2024 10:59:56 +0100 Subject: [PATCH] rework combinators --- bin/ffx/test/disposition_combinator_2.py | 47 +---- bin/ffx/test/disposition_combinator_2_0.py | 5 +- bin/ffx/test/disposition_combinator_2_1.py | 3 - bin/ffx/test/disposition_combinator_2_2.py | 3 - bin/ffx/test/disposition_combinator_2_3 .py | 7 +- bin/ffx/test/disposition_combinator_3.py | 47 +---- bin/ffx/test/disposition_combinator_3_0.py | 3 - bin/ffx/test/disposition_combinator_3_1.py | 3 - bin/ffx/test/disposition_combinator_3_2.py | 3 - bin/ffx/test/disposition_combinator_3_3.py | 3 - bin/ffx/test/disposition_combinator_3_4.py | 6 +- ...rack_combinator.py => media_combinator.py} | 16 +- bin/ffx/test/media_combinator_0.py | 65 +++++++ bin/ffx/test/media_combinator_1.py | 71 ++++++++ bin/ffx/test/media_combinator_2.py | 85 +++++++++ bin/ffx/test/media_combinator_3.py | 95 ++++++++++ bin/ffx/test/media_combinator_4.py | 81 +++++++++ bin/ffx/test/media_combinator_5.py | 88 ++++++++++ bin/ffx/test/media_combinator_6.py | 97 +++++++++++ bin/ffx/test/media_combinator_7.py | 107 ++++++++++++ bin/ffx/test/scenario_1.py | 163 +++--------------- bin/ffx/test/track_combinator_0.py | 87 ---------- bin/ffx/test/track_combinator_1.py | 91 ---------- bin/ffx/test/track_combinator_2.py | 115 ------------ bin/ffx/test/track_combinator_3.py | 123 ------------- bin/ffx/test/track_combinator_4.py | 108 ------------ bin/ffx/test/track_combinator_5.py | 114 ------------ bin/ffx/test/track_combinator_6.py | 138 --------------- bin/ffx/test/track_combinator_7.py | 155 ----------------- 29 files changed, 733 insertions(+), 1196 deletions(-) rename bin/ffx/test/{track_combinator.py => media_combinator.py} (62%) create mode 100644 bin/ffx/test/media_combinator_0.py create mode 100644 bin/ffx/test/media_combinator_1.py create mode 100644 bin/ffx/test/media_combinator_2.py create mode 100644 bin/ffx/test/media_combinator_3.py create mode 100644 bin/ffx/test/media_combinator_4.py create mode 100644 bin/ffx/test/media_combinator_5.py create mode 100644 bin/ffx/test/media_combinator_6.py create mode 100644 bin/ffx/test/media_combinator_7.py delete mode 100644 bin/ffx/test/track_combinator_0.py delete mode 100644 bin/ffx/test/track_combinator_1.py delete mode 100644 bin/ffx/test/track_combinator_2.py delete mode 100644 bin/ffx/test/track_combinator_3.py delete mode 100644 bin/ffx/test/track_combinator_4.py delete mode 100644 bin/ffx/test/track_combinator_5.py delete mode 100644 bin/ffx/test/track_combinator_6.py delete mode 100644 bin/ffx/test/track_combinator_7.py diff --git a/bin/ffx/test/disposition_combinator_2.py b/bin/ffx/test/disposition_combinator_2.py index f233044..b2e7767 100644 --- a/bin/ffx/test/disposition_combinator_2.py +++ b/bin/ffx/test/disposition_combinator_2.py @@ -2,13 +2,15 @@ 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 self._identifier + return DispositionCombinator2.IDENTIFIER def getVariant(self): return self._variant @@ -31,46 +33,3 @@ class DispositionCombinator2(): @staticmethod def getAllClassReferences(): return [DispositionCombinator2.getClassReference(i) for i in DispositionCombinator2.list()] - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - yieldObj[self.getIdentifier()] = self.getPayload() - - #assertFuncList = yieldObj.pop('asserts', []) - #variants = yieldObj.pop('variants', set()) - - sc_list = [(k,v) for k,v in self._SubCombinators.items()] - - #y = [] - for p in itertools.product(*[v.getYield() for k,v in sc_list]): - z = {} - for i in range(len(p)): - z[sc_list[i][0]] = p[i] - - - #y.append(z) - for k,v in z.items(): - yieldObj[k] = v - - assertFunc = getattr(v, "assertFunc", None) - if callable(assertFunc): - yieldObj['asserts'].append(assertFunc) - - shouldFailFunc = getattr(v, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yieldObj['shouldFail'] = True - - yieldObj['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yieldObj diff --git a/bin/ffx/test/disposition_combinator_2_0.py b/bin/ffx/test/disposition_combinator_2_0.py index 22f4e95..7700e07 100644 --- a/bin/ffx/test/disposition_combinator_2_0.py +++ b/bin/ffx/test/disposition_combinator_2_0.py @@ -5,16 +5,13 @@ from .disposition_combinator_2 import DispositionCombinator2 class DispositionCombinator20(DispositionCombinator2): - - IDENTIFIER = 'disposition2' + VARIANT = 'D00' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator20.IDENTIFIER self._variant = DispositionCombinator20.VARIANT - def getPayload(self): return (set(), # 0 diff --git a/bin/ffx/test/disposition_combinator_2_1.py b/bin/ffx/test/disposition_combinator_2_1.py index 620a8c3..73520db 100644 --- a/bin/ffx/test/disposition_combinator_2_1.py +++ b/bin/ffx/test/disposition_combinator_2_1.py @@ -6,16 +6,13 @@ from .disposition_combinator_2 import DispositionCombinator2 class DispositionCombinator21(DispositionCombinator2): - IDENTIFIER = 'disposition2' VARIANT = 'D10' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator21.IDENTIFIER self._variant = DispositionCombinator21.VARIANT - def getPayload(self): return (set([TrackDisposition.DEFAULT]), # 0 set()) # 1 diff --git a/bin/ffx/test/disposition_combinator_2_2.py b/bin/ffx/test/disposition_combinator_2_2.py index bd9d75f..80ef8c1 100644 --- a/bin/ffx/test/disposition_combinator_2_2.py +++ b/bin/ffx/test/disposition_combinator_2_2.py @@ -6,16 +6,13 @@ from .disposition_combinator_2 import DispositionCombinator2 class DispositionCombinator22(DispositionCombinator2): - IDENTIFIER = 'disposition2' VARIANT = 'D01' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator22.IDENTIFIER self._variant = DispositionCombinator22.VARIANT - def getPayload(self): return (set(), # 0 set([TrackDisposition.DEFAULT])) # 1 diff --git a/bin/ffx/test/disposition_combinator_2_3 .py b/bin/ffx/test/disposition_combinator_2_3 .py index 904376e..e96e44b 100644 --- a/bin/ffx/test/disposition_combinator_2_3 .py +++ b/bin/ffx/test/disposition_combinator_2_3 .py @@ -6,22 +6,19 @@ from .disposition_combinator_2 import DispositionCombinator2 class DispositionCombinator23(DispositionCombinator2): - IDENTIFIER = 'disposition2' VARIANT = 'D11' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator23.IDENTIFIER self._variant = DispositionCombinator23.VARIANT - def getPayload(self): return (set([TrackDisposition.DEFAULT]), # 0 set([TrackDisposition.DEFAULT])) # 1 - # def assertFunc(self, trackDescriptors): - # pass + def assertFunc(self, trackDescriptors): + pass def shouldFail(self): return True diff --git a/bin/ffx/test/disposition_combinator_3.py b/bin/ffx/test/disposition_combinator_3.py index b5b724a..7309b44 100644 --- a/bin/ffx/test/disposition_combinator_3.py +++ b/bin/ffx/test/disposition_combinator_3.py @@ -2,13 +2,15 @@ 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 self._identifier + return DispositionCombinator3.IDENTIFIER def getVariant(self): return self._variant @@ -31,46 +33,3 @@ class DispositionCombinator3(): @staticmethod def getAllClassReferences(): return [DispositionCombinator3.getClassReference(i) for i in DispositionCombinator3.list()] - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - yieldObj[self.getIdentifier()] = self.getPayload() - - #assertFuncList = yieldObj.pop('asserts', []) - #variants = yieldObj.pop('variants', set()) - - sc_list = [(k,v) for k,v in self._SubCombinators.items()] - - #y = [] - for p in itertools.product(*[v.getYield() for k,v in sc_list]): - z = {} - for i in range(len(p)): - z[sc_list[i][0]] = p[i] - - - #y.append(z) - for k,v in z.items(): - yieldObj[k] = v - - assertFunc = getattr(v, "assertFunc", None) - if callable(assertFunc): - yieldObj['asserts'].append(assertFunc) - - shouldFailFunc = getattr(v, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yieldObj['shouldFail'] = True - - yieldObj['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yieldObj diff --git a/bin/ffx/test/disposition_combinator_3_0.py b/bin/ffx/test/disposition_combinator_3_0.py index 29f7187..a25ad75 100644 --- a/bin/ffx/test/disposition_combinator_3_0.py +++ b/bin/ffx/test/disposition_combinator_3_0.py @@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3 class DispositionCombinator30(DispositionCombinator3): - IDENTIFIER = 'disposition3' VARIANT = 'D000' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator30.IDENTIFIER self._variant = DispositionCombinator30.VARIANT - def getPayload(self): return (set(), # 0 set(), # 1 diff --git a/bin/ffx/test/disposition_combinator_3_1.py b/bin/ffx/test/disposition_combinator_3_1.py index e523f86..4e337ae 100644 --- a/bin/ffx/test/disposition_combinator_3_1.py +++ b/bin/ffx/test/disposition_combinator_3_1.py @@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3 class DispositionCombinator31(DispositionCombinator3): - IDENTIFIER = 'disposition3' VARIANT = 'D100' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator31.IDENTIFIER self._variant = DispositionCombinator31.VARIANT - def getPayload(self): return (set([TrackDisposition.DEFAULT]), # 0 set(), # 1 diff --git a/bin/ffx/test/disposition_combinator_3_2.py b/bin/ffx/test/disposition_combinator_3_2.py index 3aa4ee3..716e427 100644 --- a/bin/ffx/test/disposition_combinator_3_2.py +++ b/bin/ffx/test/disposition_combinator_3_2.py @@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3 class DispositionCombinator32(DispositionCombinator3): - IDENTIFIER = 'disposition3' VARIANT = 'D010' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator32.IDENTIFIER self._variant = DispositionCombinator32.VARIANT - def getPayload(self): return (set(), # 0 set([TrackDisposition.DEFAULT]), # 1 diff --git a/bin/ffx/test/disposition_combinator_3_3.py b/bin/ffx/test/disposition_combinator_3_3.py index be096cc..763f836 100644 --- a/bin/ffx/test/disposition_combinator_3_3.py +++ b/bin/ffx/test/disposition_combinator_3_3.py @@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3 class DispositionCombinator33(DispositionCombinator3): - IDENTIFIER = 'disposition3' VARIANT = 'D001' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator33.IDENTIFIER self._variant = DispositionCombinator33.VARIANT - def getPayload(self): return (set(), # 0 set(), # 1 diff --git a/bin/ffx/test/disposition_combinator_3_4.py b/bin/ffx/test/disposition_combinator_3_4.py index 000e38e..1830b7f 100644 --- a/bin/ffx/test/disposition_combinator_3_4.py +++ b/bin/ffx/test/disposition_combinator_3_4.py @@ -6,13 +6,11 @@ from .disposition_combinator_3 import DispositionCombinator3 class DispositionCombinator34(DispositionCombinator3): - IDENTIFIER = 'disposition3' VARIANT = 'D101' def __init__(self, context): super().__init__(context) - self._identifier = DispositionCombinator34.IDENTIFIER self._variant = DispositionCombinator34.VARIANT def getPayload(self): @@ -20,8 +18,8 @@ class DispositionCombinator34(DispositionCombinator3): set(), # 1 set([TrackDisposition.DEFAULT])) # 2 - # def assertFunc(self, trackDescriptors): - # pass + def assertFunc(self, trackDescriptors): + pass def shouldFail(self): return True diff --git a/bin/ffx/test/track_combinator.py b/bin/ffx/test/media_combinator.py similarity index 62% rename from bin/ffx/test/track_combinator.py rename to bin/ffx/test/media_combinator.py index ea34085..81cd5e7 100644 --- a/bin/ffx/test/track_combinator.py +++ b/bin/ffx/test/media_combinator.py @@ -1,6 +1,8 @@ import os, sys, importlib, glob, inspect, itertools -class TrackCombinator(): +class MediaCombinator(): + + IDENTIFIER = 'media' def __init__(self, context = None): self._context = context @@ -17,17 +19,17 @@ class TrackCombinator(): basePath = os.path.dirname(__file__) return [os.path.basename(p)[17:-3] for p - in glob.glob(f"{ basePath }/track_combinator_*.py", recursive = True) + in glob.glob(f"{ basePath }/media_combinator_*.py", recursive = True) if p != __file__] @staticmethod def getClassReference(identifier): - importlib.import_module(f"ffx.test.track_combinator_{ identifier }") - for name, obj in inspect.getmembers(sys.modules[f"ffx.test.track_combinator_{ identifier }"]): - #HINT: Excluding TrackCombinator as it seems to be included by import (?) - if inspect.isclass(obj) and name != 'TrackCombinator' and name.startswith('TrackCombinator'): + 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 [TrackCombinator.getClassReference(i) for i in TrackCombinator.list()] + return [MediaCombinator.getClassReference(i) for i in MediaCombinator.list()] diff --git a/bin/ffx/test/media_combinator_0.py b/bin/ffx/test/media_combinator_0.py new file mode 100644 index 0000000..0566ef5 --- /dev/null +++ b/bin/ffx/test/media_combinator_0.py @@ -0,0 +1,65 @@ +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 + + +class MediaCombinator0(MediaCombinator): + + VARIANT = 'VA' + + # 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 + + self._identifier = MediaCombinator0.IDENTIFIER + self._variant = MediaCombinator0.VARIANT + + + def getPayload(self): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + 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): + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator0.IDENTIFIER + yieldObj['variants'] = [MediaCombinator0.VARIANT] + yieldObj['payload'] = self.getPayload() + + yieldObj['assertFuncs'] = [self.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_1.py b/bin/ffx/test/media_combinator_1.py new file mode 100644 index 0000000..2c12963 --- /dev/null +++ b/bin/ffx/test/media_combinator_1.py @@ -0,0 +1,71 @@ +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 + +class MediaCombinator1(MediaCombinator): + + VARIANT = 'VAS' + + # 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 + + self._identifier = MediaCombinator1.IDENTIFIER + self._variant = MediaCombinator1.VARIANT + + def getPayload(self): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + 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): + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator1.IDENTIFIER + yieldObj['variants'] = [MediaCombinator1.VARIANT] + + yieldObj['payload'] = self.getPayload() + yieldObj['assertFuncs'] = [self.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_2.py b/bin/ffx/test/media_combinator_2.py new file mode 100644 index 0000000..81791f2 --- /dev/null +++ b/bin/ffx/test/media_combinator_2.py @@ -0,0 +1,85 @@ +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 + +class MediaCombinator2(MediaCombinator): + + VARIANT = 'VASS' + + # 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 + + self._identifier = MediaCombinator2.IDENTIFIER + self._variant = MediaCombinator2.VARIANT + + def getPayload(self, subtitleDispositionTuple = (set(), set())): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] + trackDescriptor2 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[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 DC2 in DispositionCombinator2.getAllClassReferences(): + + dc2 = DC2(self._context) + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator2.IDENTIFIER + yieldObj['variants'] = [MediaCombinator2.VARIANT, f"S:{dc2.getVariant()}"] + + yieldObj['payload'] = self.getPayload(dc2.getPayload()) + yieldObj['assertFuncs'] = [self.assertFunc, dc2.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() | dc2.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_3.py b/bin/ffx/test/media_combinator_3.py new file mode 100644 index 0000000..b29ad66 --- /dev/null +++ b/bin/ffx/test/media_combinator_3.py @@ -0,0 +1,95 @@ +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 + + +class MediaCombinator3(MediaCombinator): + + VARIANT = 'VASSS' + + # 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 + + self._identifier = MediaCombinator3.IDENTIFIER + self._variant = MediaCombinator3.VARIANT + + + def getPayload(self, subtitleDispositionTuple = (set(), set(), set())): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] + trackDescriptor2 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] + trackDescriptor3 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[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 DC3 in DispositionCombinator3.getAllClassReferences(): + + dc3 = DC3(self._context) + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator3.IDENTIFIER + yieldObj['variants'] = [MediaCombinator3.VARIANT, f"S:{dc3.getVariant()}"] + + yieldObj['payload'] = self.getPayload(dc3.getPayload()) + yieldObj['assertFuncs'] = [self.assertFunc, dc3.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() | dc3.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_4.py b/bin/ffx/test/media_combinator_4.py new file mode 100644 index 0000000..1443994 --- /dev/null +++ b/bin/ffx/test/media_combinator_4.py @@ -0,0 +1,81 @@ +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 + + +class MediaCombinator4(MediaCombinator): + + VARIANT = 'VAA' + + # 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 + + self._identifier = MediaCombinator4.IDENTIFIER + self._variant = MediaCombinator4.VARIANT + + def getPayload(self, audioDispositionTuple = (set(), set())): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[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 DC2 in DispositionCombinator2.getAllClassReferences(): + + dc2 = DC2(self._context) + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator4.IDENTIFIER + yieldObj['variants'] = [MediaCombinator4.VARIANT, f"A:{dc2.getVariant()}"] + + yieldObj['payload'] = self.getPayload(dc2.getPayload()) + yieldObj['assertFuncs'] = [self.assertFunc, dc2.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() | dc2.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_5.py b/bin/ffx/test/media_combinator_5.py new file mode 100644 index 0000000..4799045 --- /dev/null +++ b/bin/ffx/test/media_combinator_5.py @@ -0,0 +1,88 @@ +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 + + +class MediaCombinator5(MediaCombinator): + + VARIANT = 'VAAS' + + # 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 + + self._identifier = MediaCombinator5.IDENTIFIER + self._variant = MediaCombinator5.VARIANT + + def getPayload(self, audioDispositionTuple = (set(), set())): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] + trackDescriptor2 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + 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 DC2 in DispositionCombinator2.getAllClassReferences(): + + dc2 = DC2(self._context) + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator5.IDENTIFIER + yieldObj['variants'] = [MediaCombinator5.VARIANT, f"A:{dc2.getVariant()}"] + + yieldObj['payload'] = self.getPayload(dc2.getPayload()) + yieldObj['assertFuncs'] = [self.assertFunc, dc2.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() | dc2.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_6.py b/bin/ffx/test/media_combinator_6.py new file mode 100644 index 0000000..4a2adbd --- /dev/null +++ b/bin/ffx/test/media_combinator_6.py @@ -0,0 +1,97 @@ +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 + + +class MediaCombinator6(MediaCombinator): + + VARIANT = 'VAASS' + + # 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 + + self._identifier = MediaCombinator6.IDENTIFIER + self._variant = MediaCombinator6.VARIANT + + def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set())): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] + trackDescriptor2 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] + trackDescriptor3 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[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 DC2_A in DispositionCombinator2.getAllClassReferences(): + for DC2_S in DispositionCombinator2.getAllClassReferences(): + + dc2a = DC2_A(self._context) + dc2s = DC2_S(self._context) + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator6.IDENTIFIER + yieldObj['variants'] = [MediaCombinator6.VARIANT, f"A:{dc2a.getVariant()}", f"S:{dc2s.getVariant()}"] + + yieldObj['payload'] = self.getPayload(dc2a.getPayload(), dc2s.getPayload()) + yieldObj['assertFuncs'] = [self.assertFunc, dc2a.assertFunc, dc2s.assertFunc] + yieldObj['shouldFail'] = self.shouldFail() | dc2a.shouldFail() | dc2s.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/media_combinator_7.py b/bin/ffx/test/media_combinator_7.py new file mode 100644 index 0000000..a12bff6 --- /dev/null +++ b/bin/ffx/test/media_combinator_7.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 .media_combinator import MediaCombinator + +from .disposition_combinator_2 import DispositionCombinator2 +from .disposition_combinator_3 import DispositionCombinator3 + + +class MediaCombinator7(MediaCombinator): + + VARIANT = 'VAASSS' + + # 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 + + self._identifier = MediaCombinator7.IDENTIFIER + self._variant = MediaCombinator7.VARIANT + + def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set(), set())): + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO + trackDescriptor0 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] + trackDescriptor1 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] + trackDescriptor2 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] + trackDescriptor3 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] + trackDescriptor4 = TrackDescriptor(**kwargs) + + kwargs = {} + kwargs[TrackDescriptor.CONTEXT_KEY] = self._context + kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE + kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[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 DC2_A in DispositionCombinator2.getAllClassReferences(): + for DC3_S in DispositionCombinator3.getAllClassReferences(): + + dc2a = DC2_A(self._context) + dc3s = DC3_S(self._context) + + yieldObj = {} + + yieldObj['identifier'] = MediaCombinator7.IDENTIFIER + yieldObj['variants'] = [MediaCombinator7.VARIANT, f"A:{dc2a.getVariant()}", f"S:{dc3s.getVariant()}"] + + yieldObj['payload'] = self.getPayload(dc2a.getPayload(), dc3s.getPayload()) + + yieldObj['assertFuncs'] = [self.assertFunc, dc2a.assertFunc, dc3s.assertFunc] + + yieldObj['shouldFail'] = self.shouldFail() | dc2a.shouldFail() | dc3s.shouldFail() + + yield yieldObj diff --git a/bin/ffx/test/scenario_1.py b/bin/ffx/test/scenario_1.py index fd78cb0..a6d5dc8 100644 --- a/bin/ffx/test/scenario_1.py +++ b/bin/ffx/test/scenario_1.py @@ -13,7 +13,7 @@ from ffx.track_descriptor import TrackDescriptor from ffx.track_type import TrackType from ffx.track_disposition import TrackDisposition -from ffx.test.track_combinator import TrackCombinator +from ffx.test.media_combinator import MediaCombinator class Scenario1(Scenario): @@ -25,147 +25,17 @@ class Scenario1(Scenario): super().__init__(context) - def run(self): - - TC_list = TrackCombinator.getAllClassReferences() - - for TC in TC_list: - - self._logger.debug(f"TC={TC.__name__}") + def job(self, yieldObj: dict): - tc = TC(context = self._context) + identifier = yieldObj['identifier'] + variantList = yieldObj['variants'] + variantIdentifier = '-'.join(variantList) + mediaDescriptor = yieldObj['payload'] + assertFuncList = yieldObj['assertFuncs'] + shouldFail = yieldObj['shouldFail'] - for y in tc.getYield(): - print(y) + self._logger.info(f"Running Scenario 1 Job {variantIdentifier}") - -# def run(self): -# -# # TrackCombinations -> asserts -# # * Dispositions[2] -> asserts[2] -# # * Tags[2] -> asserts[2] -# # * MediaTags -> asserts -# -# for tci in TrackCombination.list(): -# # combinationContext = self._context.copy() -# self._context['use_jellyfin'] = True -# self._context['use_tmdb'] = False -# self._context['use_pattern'] = False -# trackCombination = TrackCombination.getClassReference(tci)(self._context) -# -# subcombinations = trackCombination.getSubcombinations() -# if not subcombinations is None: -# for trackDescriptors, evaluateFunc, shouldFail, combinationIdentifier in subcombinations: -# -# kwargs = {} -# kwargs[MediaDescriptor.CONTEXT_KEY] = self._context -# kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = trackDescriptors -# self._logger.debug(f"src track dispositions {[d.getDispositionSet() for d in trackDescriptors]}") -# sourceMediaDescriptor = MediaDescriptor(**kwargs) -# sourceMediaDescriptor.reindexSubIndices() -# # sourceMediaDescriptor.reindexIndices() -# -# # Phase 1: Setup source files -# # TODO: -# # src track dispositions [set(), set(), {}, set(), set()] -# # vs -# # Stream #0:4: Subtitle: ass (ssa) (default) -# mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory) -# -# # Phase 2: Prepare database -# -# # Phase 3: Run ffx -# commandSequence = [sys.executable, -# self._ffxExecutablePath, -# 'convert', -# mediaFilePath, -# '--no-prompt'] -# -# if not self._context['use_jellyfin']: -# commandSequence += ['--no-jellyfin'] -# -# self._logger.debug(f"Scenario1.run(): sub={trackCombination.getIdentifier()},{combinationIdentifier} test sequence: {commandSequence}") -# -# out, err, rc = executeProcess(commandSequence, directory = self._testDirectory) -# -# self._logger.debug(f"Scenario1.run(): sub={trackCombination.getIdentifier()},{combinationIdentifier} process returned: {rc}") -# -# # if out: -# # self._logger.debug(f"Scenario1.run(): process output: {out}") -# # if rc: -# # self._logger.error(f"Scenario1.run(): process resultet in error {rc}: {err}") -# -# # Phase 4: Evaluate results -# -# try: -# -# if rc: -# # Stuck with prompt: More than one default subtitle stream detected! Please select stream: -# # TODO: Catch prompt is add option to fail at prompt -# assert shouldFail, "ffmpeg run didn't fail" if shouldFail else "ffmpeg run failed" -# self._reportLogger.info(f"Scenario 1 sub={trackCombination.getIdentifier()},{combinationIdentifier} test passed") -# else: -# -# 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(self._context, resultFile) -# resultMediaDescriptor = resultFileProperties.getMediaDescriptor() -# -# resultMediaTracks = resultMediaDescriptor.getAllTrackDescriptors() -# -# assert len(resultMediaTracks) == len(trackDescriptors), f"Result file contains unexpected number of streams" -# -# # assert resultMediaTracks[0].getType() == TrackType.VIDEO, f"Stream #0 is not of type video" -# -# # assert resultMediaTracks[1].getType() == TrackType.AUDIO, f"Stream #1 is not of type audio" -# -# # assert resultMediaTracks[2].getType() == TrackType.AUDIO, f"Stream #2 is not of type audio" -# -# self._logger.debug(f"tgt track dispositions {[d.getDispositionSet() for d in resultMediaDescriptor.getSubtitleTracks()]}") -# -# # assert dispositions -# evaluateFunc(resultMediaTracks) -# -# self._reportLogger.info(f"Scenario 1 sub={trackCombination.getIdentifier()},{combinationIdentifier} test passed") -# -# except AssertionError as ae: -# -# self._reportLogger.error(f"Scenario 1 sub={trackCombination.getIdentifier()},{combinationIdentifier} test failed ({ae})") -# -# -# -# -# def job(self): -# -# self._logger.info(f"Running {self.__class__.__name__}") -# -# kwargs = {} -# kwargs[TrackDescriptor.CONTEXT_KEY] = self._context -# kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO -# kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = set([TrackDisposition.DEFAULT]) -# trackDescriptor1 = TrackDescriptor(**kwargs) -# -# kwargs = {} -# kwargs[TrackDescriptor.CONTEXT_KEY] = self._context -# kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO -# kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = set([TrackDisposition.DEFAULT]) -# trackDescriptor2 = TrackDescriptor(**kwargs) -# -# kwargs = {} -# kwargs[TrackDescriptor.CONTEXT_KEY] = self._context -# kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO -# trackDescriptor3 = TrackDescriptor(**kwargs) -# -# kwargs = {} -# kwargs[MediaDescriptor.CONTEXT_KEY] = self._context -# kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor1, -# trackDescriptor2, -# trackDescriptor3] -# sourceMediaDescriptor = MediaDescriptor(**kwargs) -# sourceMediaDescriptor.reindexSubIndices() -# # # Phase 1: Setup source files # mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory) # @@ -214,3 +84,18 @@ class Scenario1(Scenario): # except AssertionError as ae: # # self._reportLogger.error(f"Scenario 1 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) + diff --git a/bin/ffx/test/track_combinator_0.py b/bin/ffx/test/track_combinator_0.py deleted file mode 100644 index 930e710..0000000 --- a/bin/ffx/test/track_combinator_0.py +++ /dev/null @@ -1,87 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - - -class TrackCombinator0(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VA' - - def __init__(self, SubCombinators: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinators - - self._identifier = TrackCombinator0.IDENTIFIER - self._variant = TrackCombinator0.VARIANT - - - def getPayload(self): - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - trackDescriptor1 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1] - - - # def assertFunc(self, testObj): - # pass - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - yo = yieldObj.copy() - - yo[self.getIdentifier()] = self.getPayload() - - yo['variants'].add(self.getVariant()) - -# #assertFuncList = yo.pop('asserts', []) -# #variants = yo.pop('variants', set()) -# -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) -# -# #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_1.py b/bin/ffx/test/track_combinator_1.py deleted file mode 100644 index 09c7248..0000000 --- a/bin/ffx/test/track_combinator_1.py +++ /dev/null @@ -1,91 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -class TrackCombinator1(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VAS' - - def __init__(self, SubCombinations: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinations - - self._identifier = TrackCombinator1.IDENTIFIER - self._variant = TrackCombinator1.VARIANT - - def getPayload(self): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - trackDescriptor2 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2] - - - # def assertFunc(self, testObj): - # pass - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - yo = yieldObj.copy() - - yo[self.getIdentifier()] = self.getPayload() - - yo['variants'].add(self.getVariant()) - -# #assertFuncList = yo.pop('asserts', []) -# #variants = yo.pop('variants', set()) -# -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) -# -# #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_2.py b/bin/ffx/test/track_combinator_2.py deleted file mode 100644 index e9a3f19..0000000 --- a/bin/ffx/test/track_combinator_2.py +++ /dev/null @@ -1,115 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -from .disposition_combinator_2 import DispositionCombinator2 - -class TrackCombinator2(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VASS' - - def __init__(self, SubCombinators: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinators - - self._identifier = TrackCombinator2.IDENTIFIER - self._variant = TrackCombinator2.VARIANT - - def getPayload(self, subtitleDispositionTuple = (set(), set())): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] - trackDescriptor2 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] - trackDescriptor3 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2, - trackDescriptor3] - - - # def assertFunc(self, testObj): - # pass - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - - - for DC in DispositionCombinator2.getAllClassReferences(): - - yo = yieldObj.copy() - - yo['variants'].add(self.getVariant()) - - dc = DC(context = self._context) - yo[self.getIdentifier()] = self.getPayload(dc.getPayload()) - - assertFunc = getattr(dc, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - - shouldFailFunc = getattr(dc, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yo['shouldFail'] = True - - yo['variants'].add(dc.getVariant()) - -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_3.py b/bin/ffx/test/track_combinator_3.py deleted file mode 100644 index a141b54..0000000 --- a/bin/ffx/test/track_combinator_3.py +++ /dev/null @@ -1,123 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -from .disposition_combinator_3 import DispositionCombinator3 - - -class TrackCombinator3(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VASSS' - - def __init__(self, SubCombinations: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinations - - self._identifier = TrackCombinator3.IDENTIFIER - self._variant = TrackCombinator3.VARIANT - - - def getPayload(self, subtitleDispositionTuple = (set(), set(), set())): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] - trackDescriptor2 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] - trackDescriptor3 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2] - trackDescriptor4 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2, - trackDescriptor3, - trackDescriptor4] - - - # def assertFunc(self, testObj): - # pass - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - - for DC in DispositionCombinator3.getAllClassReferences(): - - yo = yieldObj.copy() - - yo['variants'].add(self.getVariant()) - - dc = DC(context = self._context) - yo[self.getIdentifier()] = self.getPayload(dc.getPayload()) - - assertFunc = getattr(dc, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - - shouldFailFunc = getattr(dc, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yo['shouldFail'] = True - - yo['variants'].add(dc.getVariant()) - -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_4.py b/bin/ffx/test/track_combinator_4.py deleted file mode 100644 index b2897e8..0000000 --- a/bin/ffx/test/track_combinator_4.py +++ /dev/null @@ -1,108 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -from .disposition_combinator_2 import DispositionCombinator2 - - -class TrackCombinator4(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VAA' - - def __init__(self, SubCombinations: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinations - - self._identifier = TrackCombinator4.IDENTIFIER - self._variant = TrackCombinator4.VARIANT - - def getPayload(self, audioDispositionTuple = (set(), set())): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] - trackDescriptor2 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2] - - # def assertFunc(self, testObj): - # pass - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - - for DC in DispositionCombinator2.getAllClassReferences(): - - yo = yieldObj.copy() - - yo['variants'].add(self.getVariant()) - - dc = DC(context = self._context) - yo[self.getIdentifier()] = self.getPayload(dc.getPayload()) - - assertFunc = getattr(dc, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - - shouldFailFunc = getattr(dc, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yo['shouldFail'] = True - - yo['variants'].add(dc.getVariant()) - -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_5.py b/bin/ffx/test/track_combinator_5.py deleted file mode 100644 index d62987a..0000000 --- a/bin/ffx/test/track_combinator_5.py +++ /dev/null @@ -1,114 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -from .disposition_combinator_2 import DispositionCombinator2 - - -class TrackCombinator5(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VAAS' - - def __init__(self, SubCombinations: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinations - - self._identifier = TrackCombinator5.IDENTIFIER - self._variant = TrackCombinator5.VARIANT - - def getPayload(self, audioDispositionTuple = (set(), set())): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] - trackDescriptor2 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - trackDescriptor3 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2, - trackDescriptor3] - - # def assertFunc(self, testObj): - # pass - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - - for DC in DispositionCombinator2.getAllClassReferences(): - - yo = yieldObj.copy() - - yo['variants'].add(self.getVariant()) - - dc = DC(context = self._context) - yo[self.getIdentifier()] = self.getPayload(dc.getPayload()) - - assertFunc = getattr(dc, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - - shouldFailFunc = getattr(dc, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yo['shouldFail'] = True - - yo['variants'].add(dc.getVariant()) - -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_6.py b/bin/ffx/test/track_combinator_6.py deleted file mode 100644 index b8d5b9f..0000000 --- a/bin/ffx/test/track_combinator_6.py +++ /dev/null @@ -1,138 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -from .disposition_combinator_2 import DispositionCombinator2 - - -class TrackCombinator6(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VAASS' - - def __init__(self, SubCombinations: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinations - - self._identifier = TrackCombinator6.IDENTIFIER - self._variant = TrackCombinator6.VARIANT - - def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set())): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] - trackDescriptor2 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] - trackDescriptor3 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] - trackDescriptor4 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2, - trackDescriptor3, - trackDescriptor4] - - # def assertFunc(self, testObj): - # pass - - - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - - - for DC_A in DispositionCombinator2.getAllClassReferences(): - for DC_S in DispositionCombinator2.getAllClassReferences(): - - yo = yieldObj.copy() - - yo['variants'].add(self.getVariant()) - - dc_a = DC_A(context = self._context) - dc_s = DC_S(context = self._context) - - yo[self.getIdentifier()] = self.getPayload(dc_a.getPayload(), dc_s.getPayload()) - - assertFunc = getattr(dc_a, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - - shouldFailFunc = getattr(dc_a, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yo['shouldFail'] = True - - yo['variants'].add(dc_a.getVariant()) - - assertFunc = getattr(dc_s, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - - shouldFailFunc = getattr(dc_s, "shouldFail", None) - if callable(shouldFailFunc): - if shouldFailFunc(): - yo['shouldFail'] = True - - yo['variants'].add(dc_s.getVariant()) - - -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yieldObj[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yieldObj['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yieldObj['shouldFail'] = True -# -# yieldObj['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo diff --git a/bin/ffx/test/track_combinator_7.py b/bin/ffx/test/track_combinator_7.py deleted file mode 100644 index 170481b..0000000 --- a/bin/ffx/test/track_combinator_7.py +++ /dev/null @@ -1,155 +0,0 @@ -import os, sys, importlib, glob, inspect, itertools - -from ffx.track_type import TrackType -from ffx.track_descriptor import TrackDescriptor -from .track_combinator import TrackCombinator - -from .disposition_combinator_2 import DispositionCombinator2 -from .disposition_combinator_3 import DispositionCombinator3 - - -class TrackCombinator7(TrackCombinator): - - IDENTIFIER = 'tracks' - VARIANT = 'VAASSS' - - def __init__(self, SubCombinations: dict = {}, context = None): - self._context = context - self._logger = context['logger'] - self._reportLogger = context['report_logger'] - - self._SubCombinators = SubCombinations - - self._identifier = TrackCombinator7.IDENTIFIER - self._variant = TrackCombinator7.VARIANT - - def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set(), set())): - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO - trackDescriptor0 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0] - trackDescriptor1 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1] - trackDescriptor2 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0] - trackDescriptor3 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1] - trackDescriptor4 = TrackDescriptor(**kwargs) - - kwargs = {} - kwargs[TrackDescriptor.CONTEXT_KEY] = self._context - kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE - kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2] - trackDescriptor5 = TrackDescriptor(**kwargs) - - return [trackDescriptor0, - trackDescriptor1, - trackDescriptor2, - trackDescriptor3, - trackDescriptor4, - trackDescriptor5] - - # def assertFunc(self, testObj): - # pass - - #1 yieldObj leer, kommt aus Schleife in Scenario1 - def getYield(self, yieldObj: dict = {}): - - if not 'asserts' in yieldObj.keys(): - yieldObj['asserts'] = [] - if not 'variants' in yieldObj.keys(): - yieldObj['variants'] = set() - if not 'shouldFail' in yieldObj.keys(): - yieldObj['shouldFail'] = False - - yieldObj['variants'].add(self.getVariant()) - - - for DC_A in DispositionCombinator2.getAllClassReferences(): - for DC_S in DispositionCombinator3.getAllClassReferences(): - - yo = {} - yo['asserts'] = yieldObj['asserts'] - yo['variants'] = yieldObj['variants'] - yo['shouldFail'] = yieldObj['shouldFail'] - - self._logger.debug(f"Iterating DC_A={DC_A.__name__} DC_S={DC_S.__name__}") - self._logger.debug(f"><))))^> yieldObj id={id(yieldObj)}") - self._logger.debug(f"><))))^> yo id={id(yo)}") - - dc_a = DC_A(context = self._context) - dc_s = DC_S(context = self._context) - - - yo[self.getIdentifier()] = self.getPayload(dc_a.getPayload(), dc_s.getPayload()) - - assertFunc = getattr(dc_a, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - -# shouldFailFunc = getattr(dc_a, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# - yo['variants'].add(f"{dc_a.getVariant()}A") -# - - assertFunc = getattr(dc_s, "assertFunc", None) - if callable(assertFunc): - yo['asserts'].append(assertFunc) - -# shouldFailFunc = getattr(dc_s, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# - yo['variants'].add(f"{dc_s.getVariant()}S") - - -# sc_list = [(k,v) for k,v in self._SubCombinators.items()] -# -# #y = [] -# for p in itertools.product(*[v.getYield() for k,v in sc_list]): -# z = {} -# for i in range(len(p)): -# z[sc_list[i][0]] = p[i] -# -# -# #y.append(z) -# for k,v in z.items(): -# yo[k] = v -# -# assertFunc = getattr(v, "assertFunc", None) -# if callable(assertFunc): -# yo['asserts'].append(assertFunc) -# -# shouldFailFunc = getattr(v, "shouldFail", None) -# if callable(shouldFailFunc): -# if shouldFailFunc(): -# yo['shouldFail'] = True -# -# yo['variants'].add(v.getVariant()) - - #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys - - yield yo - # yield yo | yieldObj