cuemsutils 0.0.1__py3-none-any.whl

cuemsutils/cues/Cue.py

@@ -0,0 +1,251 @@
+from time import sleep
+from threading import Thread
+
+from cuemsutils.log import logged
+from cuemsutils.CTimecode import CTimecode
+
+class Cue(dict):
+    def __init__(self, init_dict = None):
+        if init_dict:
+            super().__init__(init_dict)
+            
+        self._target_object = None
+        self._conf = None
+        self._armed_list = None
+        self._start_mtc = CTimecode()
+        self._end_mtc = CTimecode()
+        self._end_reached = False
+        self._go_thread = None
+        self._stop_requested = False
+        self._local = False
+
+    @property
+    def uuid(self):
+        return super().__getitem__('uuid')
+
+    @uuid.setter
+    def uuid(self, uuid):
+        super().__setitem__('uuid', uuid)
+
+    @property
+    def id(self):
+        return super().__getitem__('id')
+
+    @id.setter
+    def id(self, id):
+        super().__setitem__('id', id)
+
+    @property
+    def name(self):
+        return super().__getitem__('name')
+
+    @name.setter
+    def name(self, name):
+        super().__setitem__('name', name)
+
+    @property
+    def description(self):
+        return super().__getitem__('description')
+
+    @description.setter
+    def description(self, description):
+        super().__setitem__('description', description)
+
+    @property
+    def enabled(self):
+        return super().__getitem__('enabled')
+
+    @enabled.setter
+    def enabled(self, enabled):
+        super().__setitem__('enabled', enabled)
+
+    @property
+    def loaded(self):
+        return super().__getitem__('loaded')
+
+    @loaded.setter
+    def loaded(self, loaded):
+        super().__setitem__('loaded', loaded)
+
+    @property
+    def timecode(self):
+        return super().__getitem__('timecode')
+
+    @timecode.setter
+    def timecode(self, timecode):
+        super().__setitem__('timecode', timecode)
+
+    @property
+    def offset(self):
+        return super().__getitem__('offset')
+
+    @offset.setter
+    def offset(self, offset):
+        self.__setitem__('offset', offset)
+
+    @property
+    def loop(self):
+        return super().__getitem__('loop')
+
+    @loop.setter
+    def loop(self, loop):
+        super().__setitem__('loop', loop)
+
+    @property
+    def prewait(self):
+        return super().__getitem__('prewait')
+
+    @prewait.setter
+    def prewait(self, prewait):
+        super().__setitem__('prewait', prewait)
+
+    @property
+    def postwait(self):
+        return super().__getitem__('postwait')
+
+    @postwait.setter
+    def postwait(self, postwait):
+        super().__setitem__('postwait', postwait)
+
+    @property
+    def post_go(self):
+        return super().__getitem__('post_go')
+
+    @post_go.setter
+    def post_go(self, post_go):
+        super().__setitem__('post_go', post_go)
+
+    @property
+    def target(self):
+        return super().__getitem__('target')
+
+    @target.setter
+    def target(self, target):
+        super().__setitem__('target', target)
+
+    @property
+    def ui_properties(self):
+        return super().__getitem__('ui_properties')
+
+    @ui_properties.setter
+    def ui_properties(self, ui_properties):
+        super().__setitem__('ui_properties', ui_properties)
+
+    @property
+    def media(self):
+        return super().__getitem__('Media')
+
+    @media.setter
+    def media(self, media):
+        super().__setitem__('Media', media)
+
+    def target_object(self, target_object):
+        self._target_object = target_object
+
+    def type(self):
+        return type(self)
+
+    def __setitem__(self, key, value):
+        if (key in ['offset', 'prewait', 'postwait']) and (value not in (None, "")):
+            if isinstance(value, CTimecode):
+                ctime_value = value
+            else:
+                if isinstance(value, (int, float)):
+                    ctime_value = CTimecode(start_seconds = value)
+                    ctime_value.frames = ctime_value.frames + 1
+                elif isinstance(value, str):
+                    ctime_value = CTimecode(value)
+                elif isinstance(value, dict):
+                    dict_timecode = value.pop('CTimecode', None)
+                    if dict_timecode is None:
+                        ctime_value = CTimecode()
+                    elif isinstance(dict_timecode, int):
+                        ctime_value = CTimecode(start_seconds = dict_timecode)
+                    else:
+                        ctime_value = CTimecode(dict_timecode)
+
+            super().__setitem__(key, ctime_value)
+
+        else:
+            super().__setitem__(key, value)
+
+    def arm(self, conf, ossia, armed_list, init = False):
+        self._conf = conf
+        self._armed_list = armed_list
+
+        if not self.enabled:
+            if self.loaded and self in self._armed_list:
+                self.disarm(ossia)
+            return False
+        elif self.loaded and not init:
+            if not self in self._armed_list:
+                self._armed_list.append(self)
+            return True
+
+        if self.post_go == 'go':
+            self._target_object.arm(self._conf, ossia, self._armed_list, init)
+
+        return True
+
+    @logged
+    def go(self, ossia, mtc):
+        if not self.loaded:
+            raise Exception(f'{self.__class__.__name__} {self.uuid} not loaded to go')
+
+        else:
+            # THREADED GO
+            thread = Thread(
+                name = f'GO:{self.__class__.__name__}:{self.uuid}',
+                target = self.go_thread,
+                args = [ossia, mtc]
+            )
+            thread.start()
+
+    def go_thread(self, ossia, mtc):
+        # ARM NEXT TARGET
+        if self._target_object:
+            self._target_object.arm(self._conf, ossia, self._armed_list)
+
+        # PREWAIT
+        if self.prewait > 0:
+            sleep(self.prewait.milliseconds / 1000)
+
+        # PLAY WHATEVER A SIMPLE CUE WOULD PLAY
+
+        # POSTWAIT
+        if self.postwait > 0:
+            sleep(self.postwait.milliseconds / 1000)
+
+        # POST-GO GO
+        if self.post_go == 'go':
+            self._target_object.go(ossia, mtc)
+
+        if self in self._armed_list:
+            self.disarm(ossia)
+
+
+    def disarm(self, ossia = None):
+        if self.loaded is True:
+            self.loaded = False
+
+            if self in self._armed_list:
+                self._armed_list.remove(self)
+
+            return True
+        else:
+            return False
+
+    def get_next_cue(self):
+        if self.target:
+            if self.post_go == 'pause':
+                return self._target_object
+            else:
+                return self._target_object.get_next_cue()
+        else:
+            return None
+
+    def check_mappings(self, settings):
+        return True
+
+    def stop(self):
+        pass

cuemsutils/cues/CueList.py

@@ -0,0 +1,160 @@
+from time import sleep
+from threading import Thread
+from Cue import Cue
+from cuemsutils.log import logged, Logger
+
+class CueList(Cue):
+    def __init__(self, init_dict = None):
+        super().__init__(init_dict)
+
+    @property    
+    def contents(self):
+        return super().__getitem__('contents')
+
+    @contents.setter
+    def contents(self, contents):
+        super().__setitem__('contents', contents)
+
+    @property
+    def uuid(self):
+        return super().__getitem__('uuid')
+    
+    def __add__(self, other):
+        new_contents = self['contents'].copy()
+        new_contents.append(other)
+        return new_contents
+
+    def __iadd__(self, other):
+        self['contents'].__iadd__(other)
+        return self
+
+    def times(self):
+        timelist = list()
+        for item in self['contents']:
+            timelist.append(item.offset)
+        return timelist
+
+    def find(self, uuid):
+        if self.uuid == uuid:
+            return self
+        else:
+            for item in self.contents:
+                if item.uuid == uuid:
+                    return item
+                elif isinstance(item, CueList):
+                    recursive = item.find(uuid)
+                    if recursive != None:
+                        return recursive
+            
+        return None
+
+    def get_media(self):
+        media_dict = dict()
+        for item in self.contents:
+            if isinstance(item, CueList):
+                media_dict.update( item.get_media() )
+            else:
+                try:
+                    if item.media:
+                        media_dict[item.uuid] = [item.media.file_name, item.__class__.__name__]
+                except KeyError:
+                        media_dict[item.uuid] = {'media' : None, 'type' : item.__class__.__name__}
+        
+        return media_dict
+
+    def arm(self, conf, ossia_server, armed_list, init = False):
+        self.conf = conf
+        self.armed_list = armed_list
+
+        if self.enabled and self.loaded == init:
+            if not self in armed_list:
+                self.contents[0].arm(self.conf, ossia_server, self.armed_list, init)
+
+                self.loaded = True
+
+                armed_list.append(self)
+
+            if self.post_go == 'go':
+                self._target_object.arm(self.conf, ossia_server, self.armed_list, init)
+
+            return True
+        else:
+            return False
+
+    @logged
+    def go(self, ossia, mtc):
+        if not self.loaded:
+            raise Exception(f'{self.__class__.__name__} {self.uuid} not loaded to go')
+        else:
+            # THREADED GO
+            thread = Thread(name = f'GO:{self.__class__.__name__}:{self.uuid}', target = self.go_thread, args = [ossia, mtc])
+            thread.start()
+
+    @logged
+    def go_thread(self, ossia, mtc):
+        # ARM NEXT TARGET
+        if self._target_object:
+            self._target_object.arm(self.conf, ossia, self.armed_list)
+
+        # PREWAIT
+        if self.prewait > 0:
+            sleep(self.prewait.milliseconds / 1000)
+
+        # PLAY : specific go the first cue in the list
+        try:
+            if self.contents:
+                self.contents[0].go(ossia, mtc)
+        except Exception as e:
+            Logger.log_error(
+                f'GO failed for content {self.contents[0].uuid}: {e}',
+                extra = {"caller": self.__class__.__name__}
+            )
+
+        # POSTWAIT
+        if self.postwait > 0:
+            sleep(self.postwait.milliseconds / 1000)
+
+        if self.post_go == 'go':
+            self._target_object.go(ossia, mtc)
+
+        '''
+        if self.post_go == 'go_at_end':
+            self._target_object.go(ossia, mtc)
+        '''
+
+        if self in self.armed_list:
+            self.disarm(ossia)
+
+    def disarm(self):
+        try:
+            if self in self.armed_list:
+                self.armed_list.remove(self)
+        except:
+            pass
+        
+        self.loaded = False
+
+    def get_next_cue(self):
+        cue_to_return = None
+        if self.contents:
+            if self.contents[0].post_go == 'pause':
+                cue_to_return = self.contents[0]._target_object
+            else:
+                cue_to_return = self.contents[0].get_next_cue()
+            
+            if cue_to_return:
+                return cue_to_return       
+
+        if self.target:
+            if self.post_go == 'pause':
+                return self._target_object
+            else:
+                return self._target_object.get_next_cue()
+        else:
+            return None
+
+    def check_mappings(self, settings):
+        # By now let's presume all CueList objects are _local
+        self._local = True
+
+        return True

cuemsutils/cues/CueOutput.py

@@ -0,0 +1,13 @@
+class CueOutput(dict):
+    def __init__(self, init_dict = None):
+        if init_dict:
+            super().__init__(init_dict)
+
+class AudioCueOutput(CueOutput):
+    pass
+
+class VideoCueOutput(CueOutput):
+    pass
+
+class DmxCueOutput(CueOutput):
+    pass

cuemsutils/cues/CuemsScript.py

@@ -0,0 +1,124 @@
+from cuemsutils.log import logged
+from CueList import CueList
+
+class CuemsScript(dict):
+    def __init__(self, init_dict = None):
+        if init_dict:
+            super().__init__(init_dict)       
+
+    @property
+    def uuid(self):
+        return super().__getitem__('uuid')
+
+    @uuid.setter
+    def uuid(self, uuid):
+        super().__setitem__('uuid', uuid)
+
+    @property
+    def unix_name(self):
+        return super().__getitem__('unix_name')
+
+    @unix_name.setter
+    def unix_name(self, unix_name):
+        super().__setitem__('unix_name', unix_name)
+
+    @property
+    def name(self):
+        return super().__getitem__('name')
+
+    @name.setter
+    def name(self, name):
+        super().__setitem__('name', name)
+
+    @property
+    def description(self):
+        return super().__getitem__('description')
+
+    @description.setter
+    def description(self, description):
+        super().__setitem__('description', description)
+
+    @property
+    def created(self):
+        return super().__getitem__('created')
+
+    @created.setter
+    def created(self, created):
+        super().__setitem__('created', created)
+
+    @property
+    def modified(self):
+        return super().__getitem__('modified')
+
+    @modified.setter
+    def modified(self, modified):
+        super().__setitem__('modified', modified)
+
+    @property
+    def cuelist(self):
+        return super().__getitem__('cuelist')
+
+    @cuelist.setter
+    def cuelist(self, cuelist):
+        if isinstance(cuelist, CueList):
+            super().__setitem__('cuelist', cuelist)
+        else:
+            raise NotImplementedError
+
+    # returns a dict of UNIQUE media (no duplicates)
+
+    @logged
+    def get_media(self, cuelist = None):
+        '''Gets all the media files list present on a cuelist.'''
+        media_dict = dict()
+
+        # If no cuelist is specified we are looking inside our own
+        # script object, so our cuelist is our self cuelist
+        if not cuelist:
+            cuelist = self.cuelist
+
+        if cuelist.contents:
+            for cue in cuelist.contents:
+                if type(cue)==CueList:
+                    # If the cue is a cuelist, let's recurse
+                    media_dict.update(self.get_media(cuelist=cue))
+                else:
+                    try:
+                        if cue.media:
+                            media_dict[cue.media.file_name] = cue
+                    except KeyError:
+                        pass
+                        # logger.debug("cue with no media")
+        return media_dict
+
+    @logged
+    def get_own_media(self, cuelist = None, config = None):
+        '''Gets the media files list present on the script which are 
+        related to the specified node uuid, usually our local UUID,
+        as we are looking for our own needed media files'''
+
+        media_dict = dict()
+
+        # If no cuelist is specified we are looking inside our own
+        # script object, so our cuelist is our self cuelist
+        if not cuelist:
+            cuelist = self.cuelist
+
+        if cuelist.contents:
+            for cue in cuelist.contents:
+                if type(cue)==CueList:
+                    # If the cue is a cuelist, let's recurse
+                    media_dict.update(self.get_own_media(cuelist=cue, config=config))
+                else:
+                    try:
+                        if cue.media:
+                            cue.check_mappings(config)
+                            if cue._local:
+                                media_dict[cue.media.file_name] = cue
+                    except KeyError:
+                        pass
+                        # logger.debug("cue with no media")
+        return media_dict
+
+    def find(self, uuid):
+        return self.cuelist.find(uuid)