cuemsutils 0.0.1__py3-none-any.whl

cuemsutils/cues/DmxCue.py

@@ -0,0 +1,309 @@
+from threading import Thread
+from time import sleep
+
+from collections.abc import Mapping
+# from os import path
+# from pyossia import ossia
+from Cue import Cue
+# from ..players.DmxPlayer import DmxPlayer
+# from ..OssiaServer import OssiaServer, OSCConfData, PlayerOSCConfData
+from cuemsutils.log import logged, Logger
+
+#### TODO: asegurar asignacion de escenas a cue, no copia!!
+
+class DmxCue(Cue):
+    # OSC_DMXPLAYER_CONF = {  '/quit' : [ossia.ValueType.Impulse, None],
+    #                         '/load' : [ossia.ValueType.String, None], 
+    #                         '/wait' : [ossia.ValueType.Float, None],
+    #                         '/play' : [ossia.ValueType.Impulse, None],
+    #                         '/stop' : [ossia.ValueType.Impulse, None],
+    #                         '/stoponlost' : [ossia.ValueType.Bool, None],
+    #                         # TODO '/mtcfollow' : [ossia.ValueType.Bool, None],
+    #                         '/check' : [ossia.ValueType.Impulse, None]
+    #                         }
+
+    def __init__(self, init_dict = None):
+        super().__init__(init_dict)
+            
+        self._player = None
+        self._osc_route = None
+        self._offset_route = '/offset'
+
+        # self.OSC_DMXPLAYER_CONF[self._offset_route] = [ossia.ValueType.Float, None]
+        
+
+    @property
+    def media(self):
+        return super().__getitem__('Media')
+
+    @media.setter
+    def media(self, media):
+        super().__setitem__('Media', media)
+
+    @property
+    def fadein_time(self):
+        return super().__getitem__('fadein_time')
+
+    @fadein_time.setter
+    def fadein_time(self, fadein_time):
+        super().__setitem__('fadein_time', fadein_time)
+
+    @property
+    def fadeout_time(self):
+        return super().__getitem__('fadeout_time')
+
+    @fadeout_time.setter
+    def fadeout_time(self, fadeout_time):
+        super().__setitem__('fadeout_time', fadeout_time)
+
+    def player(self, player):
+        self._player = player
+
+    def osc_route(self, osc_route):
+        self._osc_route = osc_route
+
+    def offset_route(self, offset_route):
+        self._offset_route = offset_route
+
+    def review_offset(self, timecode):
+        return -(float(timecode.milliseconds))
+
+    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
+
+        # Assign its own audioplayer object
+        # try:
+        #     self._player = DmxPlayer(
+        #         self._conf.players_port_index, 
+        #         self._conf.node_conf['dmxplayer']['path'],
+        #         str(self._conf.node_conf['dmxplayer']['args']),
+        #         str(
+        #             path.join(
+        #                 self._conf.library_path,
+        #                 'media',
+        #                 self.media['file_name']
+        #             )
+        #         )
+        #     )
+        # except Exception as e:
+        #     raise e
+
+        # self._player.start()
+
+        # And dinamically attach it to the ossia for remote control it
+        self._osc_route = f'/players/dmxplayer-{self.uuid}'
+
+        # ossia.add_player_nodes(
+        #     PlayerOSCConfData( 
+        #         device_name=self._osc_route, 
+        #         host=self._conf.node_conf['osc_dest_host'], 
+        #         in_port=self._player.port,
+        #         out_port=self._player.port + 1, 
+        #         dictionary=self.OSC_DMXPLAYER_CONF
+        #     )
+        # )
+
+        self.loaded = True
+        if not self in self._armed_list:
+            self._armed_list.append(self)
+
+        if self.post_go == 'go' and self._target_object:
+            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 : specific DMX cue stuff
+        try:
+            key = f'{self._osc_route}{self._offset_route}'
+            ossia.osc_registered_nodes[key][0].value = self.review_offset(mtc)
+            Logger.log_info(
+                f"DMX play {self.uuid}: {key} {str(ossia.osc_registered_nodes[key][0].value)}",
+                extra = {"caller": self.__class__.__name__}
+            )
+        except KeyError:
+            Logger.log_debug(
+                f'OSC Key error 1 in go_callback {key}',
+                extra = {"caller": self.__class__.__name__}
+            )
+        try:
+            key = f'{self._osc_route}/mtcfollow'
+            ossia.osc_registered_nodes[key][0].value = True
+        except KeyError:
+            Logger.log_debug(
+                f'OSC Key error 2 in go_callback {key}',
+                extra = {"caller": self.__class__.__name__}
+            )
+
+        # POSTWAIT
+        if self.postwait > 0:
+            sleep(self.postwait.milliseconds / 1000)
+
+        # POST-GO GO
+        if self.post_go == 'go' and self._target_object:
+            self._target_object.go(ossia, mtc)
+
+        try:
+            while self._player.is_alive():
+                sleep(0.05)
+        except AttributeError:
+            return
+        
+        if self in self._armed_list:
+            self.disarm(ossia)
+
+    def disarm(self, ossia):
+        if self.loaded is True:
+            try:
+                self._player.kill()
+                self._conf.players_port_index['used'].remove(self._player.port)
+                self._player.join()
+                self._player = None
+
+                # ossia.remove_nodes( OSCConfData(device_name=self._osc_route, dictionary = self.OSC_DMXPLAYER_CONF) )
+
+            except Exception as e:
+                Logger.log_warning(
+                    f'Could not properly unload {self.uuid} : {e}',
+                    extra = {"caller": self.__class__.__name__}
+                )
+                
+            try:
+                if self in self._armed_list:
+                    self._armed_list.remove(self)
+            except:
+                pass
+            
+            self.loaded = False
+
+            return True
+        else:
+            return False
+
+    @property
+    def scene(self):
+        return self['dmx_scene']
+
+    @scene.setter
+    def scene(self, scene):
+        if isinstance(scene, DmxScene):
+            super().__setitem__('dmx_scene', scene)
+        elif isinstance(scene, dict):
+            super().__setitem__('dmx_scene', DmxScene(init_dict=scene))
+        else:
+            raise NotImplementedError
+
+class DmxScene(dict):
+    def __init__(self, init_dict=None):
+        super().__init__()
+        if init_dict:
+            for k, v, in init_dict.items():
+                if isinstance(k, int):
+                    super().__setitem__(k, DmxUniverse(v))
+                elif k == 'DmxUniverse':
+                    for u in v:
+                        super().__setitem__(u['id'], DmxUniverse(init_dict=u))
+
+    def universe(self, num=None):
+        if num is not None:
+            return super().__getitem__(num)
+
+    def universes(self):
+        return self
+      
+    def set_universe(self, universe, num=0):
+        super().__setitem__(num, DmxUniverse(universe))
+
+       
+
+        #merge two universes, priority on the newcoming
+    def merge_universe(self, universe, num=0):
+        super().__getitem__(num).update(universe)
+
+
+
+class DmxUniverse(dict):
+
+    def __init__(self, init_dict=None):
+        super().__init__()
+        if init_dict:
+            for k, v, in init_dict.items():
+                if isinstance(k, int):
+                    super().__setitem__(k, DmxChannel(v))
+                elif k == 'DmxChannel':
+                    for u in v:
+                        super().__setitem__(u['id'], DmxChannel(u['&']))
+    
+
+
+    def channel(self, channel):
+        return super().__getitem__(channel)
+
+    def set_channel(self, channel, value):
+        if isinstance(value, DmxChannel):
+            super().__setitem__(channel, value)
+        else:
+            super().__setitem__(channel, DmxChannel(value))
+        return self
+
+    def setall(self, value):
+        for channel in range(512):
+            super().__setitem__(channel, value)
+        return self      #TODO: valorate return self to be able to do things like 'universe_full = DmxUniverse().setall(255)'
+
+    def update(self, other=None, **kwargs):
+        if other is not None:
+            for k, v in other.items() if isinstance(other, Mapping) else other:
+                self[k] = DmxChannel(v)
+        for k, v in kwargs.items():
+            self[k] = DmxChannel(v)
+
+class DmxChannel():
+    def __init__(self, value=None, init_dict = None):
+        self._value = value
+        if init_dict is not None:
+            self.value = init_dict
+
+    def __repr__(self):
+        return str(self.value)
+
+    @property
+    def value(self):
+        return self._value
+    
+    @value.setter
+    def value (self, value):
+        if value > 255:
+            value = 255
+        self._value = value

cuemsutils/cues/VideoCue.py

@@ -0,0 +1,287 @@
+from os import path
+# from pyossia import ossia
+from threading import Thread
+from time import sleep
+
+from Cue import Cue
+from cuemsutils.CTimecode import CTimecode
+# from ..players.VideoPlayer import VideoPlayer
+# from ..OssiaServer import OssiaServer, OSCConfData, PlayerOSCConfData
+from cuemsutils.log import logged, Logger
+class VideoCue(Cue):
+    '''
+    OSC_VIDEOPLAYER_CONF = {'/jadeo/xscale' : [ossia.ValueType.Float, None],
+                            '/jadeo/yscale' : [ossia.ValueType.Float, None], 
+                            '/jadeo/corners' : [ossia.ValueType.List, None],
+                            '/jadeo/corner1' : [ossia.ValueType.List, None],
+                            '/jadeo/corner2' : [ossia.ValueType.List, None],
+                            '/jadeo/corner3' : [ossia.ValueType.List, None],
+                            '/jadeo/corner4' : [ossia.ValueType.List, None],
+                            '/jadeo/start' : [ossia.ValueType.Bool, None],
+                            '/jadeo/load' : [ossia.ValueType.String, None],
+                            '/jadeo/quit' : [ossia.ValueType.Bool, None],
+                            '/jadeo/midi/connect' : [ossia.ValueType.String, None],
+                            '/jadeo/midi/disconnect' : [ossia.ValueType.Impulse, None]
+                            }
+    '''
+
+    def __init__(self, init_dict = None):
+        super().__init__(init_dict)
+            
+        self._player = None
+        self._osc_route = None
+        self._go_thread = None
+
+        # TODO: Adjust framerates for universal use, by now 25 fps for video
+        self._start_mtc = CTimecode(framerate=25)
+        self._end_mtc = CTimecode(framerate=25)
+
+        '''
+        self.OSC_VIDEOPLAYER_CONF['/jadeo/offset'] = [ossia.ValueType.String, None]
+        self.OSC_VIDEOPLAYER_CONF['/jadeo/offset'] = [ossia.ValueType.Int, None]
+        '''
+
+    @property
+    def media(self):
+        return super().__getitem__('Media')
+
+    @media.setter
+    def media(self, media):
+        super().__setitem__('Media', media)
+
+    @property
+    def outputs(self):
+        return super().__getitem__('Outputs')
+
+    @outputs.setter
+    def outputs(self, outputs):
+        super().__setitem__('Outputs', outputs)
+
+    def player(self, player):
+        self._player = player
+
+    def osc_route(self, osc_route):
+        self._osc_route = osc_route
+
+    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._local:
+            try:
+                key = f'{self._osc_route}/jadeo/cmd'
+                ossia.send_message(key, 'midi disconnect')
+                Logger.log_info(
+                    key + " " + str(ossia._oscquery_registered_nodes[key][0].value),
+                    extra = {"caller": self.__class__.__name__}
+                )
+            except KeyError:
+                Logger.log_debug(
+                    f'Key error 1 (disconnect) in arm_callback {key}',
+                    extra = {"caller": self.__class__.__name__}
+                )
+
+            try:
+                key = f'{self._osc_route}/jadeo/load'
+                value = str(path.join(self._conf.library_path, 'media', self.media.file_name))
+                ossia.send_message(key, value)
+                Logger.log_info(
+                    key + " " + str(ossia._oscquery_registered_nodes[key][0].value),
+                    extra = {"caller": self.__class__.__name__}
+                )
+            except KeyError:
+                Logger.log_debug(
+                    f'Key error 2 (load) in arm_callback {key}',
+                    extra = {"caller": self.__class__.__name__}
+                )
+        
+        self.loaded = True
+        if not self in self._armed_list:
+            self._armed_list.append(self)
+
+        if self.post_go == 'go' and self._target_object:
+            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
+            self._go_thread = Thread(name = f'GO:{self.__class__.__name__}:{self.uuid}', target = self.go_thread_func, args = [ossia, mtc])
+            self._go_thread.start()
+
+    def go_thread_func(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)
+        
+        ### harcoded for TODO: proto_fruta, need fixx
+         #try to make all cues start at sync at 10 second timecode!
+        harcoded_go_offset = 20000
+
+
+        if self._local:
+            # PLAY : specific video cue stuff
+            try:
+                key = f'{self._osc_route}/jadeo/offset'
+                #self._start_mtc = mtc.main_tc
+
+                ### harcoded for TODO: proto_fruta, need fixx             
+                self._start_mtc = CTimecode(frames=harcoded_go_offset)
+                
+                
+                duration = self.media.regions[0].out_time - self.media.regions[0].in_time
+                duration = duration.return_in_other_framerate(mtc.main_tc.framerate)
+                self._end_mtc = self._start_mtc + duration
+                cue_in_time_fr_adjusted = self.media.regions[0].in_time.return_in_other_framerate(mtc.main_tc.framerate)
+                offset_to_go = cue_in_time_fr_adjusted.frame_number - self._start_mtc.frame_number
+                # ossia._oscquery_registered_nodes[key][0].value = offset_to_go
+                ossia.send_message(key, offset_to_go)
+                Logger.log_info(
+                    key + " " + str(ossia._oscquery_registered_nodes[key][0].value),
+                    extra = {"caller": self.__class__.__name__}
+                )
+            except KeyError:
+                Logger.log_debug(
+                    f'Key error 1 (offset) in go_callback {key}',
+                    extra = {"caller": self.__class__.__name__}
+                )
+            
+            try:
+                key = f'{self._osc_route}/jadeo/cmd'
+                ossia.send_message(key, "midi connect Midi Through")
+            except KeyError:
+                Logger.log_debug(
+                    f'Key error 2 (connect) in go_callback {key}',
+                    extra = {"caller": self.__class__.__name__}
+                )
+
+        # POSTWAIT
+        if self.postwait > 0:
+            sleep(self.postwait.milliseconds / 1000)
+
+        if self.post_go == 'go' and self._target_object:
+            self._target_object.go(ossia, mtc)
+
+        try:
+            loop_counter = 0
+            duration = self.media.regions[0].out_time - self.media.regions[0].in_time
+            duration = duration.return_in_other_framerate(mtc.main_tc.framerate)
+            in_time_adjusted = self.media.regions[0].in_time.return_in_other_framerate(mtc.main_tc.framerate)
+
+            while not self.media.regions[0].loop or loop_counter < self.media.regions[0].loop:
+                while mtc.main_tc.milliseconds < self._end_mtc.milliseconds:
+                    sleep(0.005)
+
+                if self._local:
+                    try:
+                        key = f'{self._osc_route}/jadeo/offset'
+                        self._start_mtc = mtc.main_tc
+                        self._end_mtc = self._start_mtc + duration
+                        offset_to_go = in_time_adjusted.frame_number - self._start_mtc.frame_number
+                        ossia.send_message(key, offset_to_go)
+                        Logger.log_info(
+                            key + " " + str(ossia._oscquery_registered_nodes[key][0].value),
+                            extra = {"caller": self.__class__.__name__}
+                        )
+                    except KeyError:
+                        Logger.log_debug(
+                            f'Key error 1 (offset) in go_callback {key}',
+                            extra = {"caller": self.__class__.__name__}
+                        )
+                
+                loop_counter += 1
+
+            if self._local:
+                try:
+                    key = f'{self._osc_route}/jadeo/cmd'
+                    ossia.send_message(key, 'midi disconnect')
+                    Logger.log_info(
+                        key + " " + str(ossia._oscquery_registered_nodes[key][0].value),
+                        extra = {"caller": self.__class__.__name__}
+                    )
+                except KeyError:
+                    Logger.log_debug(
+                        f'Key error 1 (disconnect) in arm_callback {key}',
+                        extra = {"caller": self.__class__.__name__}
+                    )
+
+        except AttributeError:
+            pass
+        
+        if self in self._armed_list:
+            self.disarm(ossia)
+
+    def disarm(self, ossia = None):
+        if self.loaded is True:
+            '''
+            # Needed when each cue launched its own player
+            try:
+                self._player.kill()
+                self._conf.osc_port_index['used'].remove(self._player.port)
+                self._player.join()
+                self._player = None
+
+                ossia.remove_nodes( OSCConfData(device_name=self._osc_route, dictionary = self.OSC_VIDEOPLAYER_CONF) )
+
+            except Exception as e:
+                logger.warning(f'Could not properly unload {self.__class__.__name__} {self.uuid} : {e}')
+            '''
+
+            try:
+                if self in self._armed_list:
+                    self._armed_list.remove(self)
+            except:
+                pass
+            
+            self.loaded = False
+
+            return True
+        else:
+            return False
+
+    def stop(self):
+        self._stop_requested = True
+
+    def check_mappings(self, settings):
+        if not settings.project_node_mappings:
+            return True
+
+        found = True
+        
+        map_list = ['default']
+
+        if settings.project_node_mappings['video']['outputs']:
+            for elem in settings.project_node_mappings['video']['outputs']:
+                for map in elem['mappings']:
+                    map_list.append(map['mapped_to'])
+
+        for output in self.outputs:
+            # if output['node_uuid'] == settings.node_conf['uuid']:
+           
+            if output['output_name'][:36] == settings.node_conf['uuid']:
+                self._local = True
+                if output['output_name'][37:] not in map_list:
+                    found = False
+                    break
+            else:
+                self._local = False
+                found = True
+            
+        return found

cuemsutils/log.py

@@ -0,0 +1,77 @@
+import sys
+from logging import getLogger, StreamHandler, Formatter, DEBUG, INFO, ERROR, WARNING
+from logging.handlers import SysLogHandler
+from functools import wraps
+
+cuemsFormatter = Formatter('[%(asctime)s][%(levelname)s] \tFormitGo (PID: %(process)d)-(%(threadName)-9s)-(%(name)s:%(funcName)s:%(caller)s)> %(message)s')
+
+def root_logger(with_syslog = True, with_stdout = True):
+    """
+    Create a root logger with a custom formatter.
+    """
+    logger = getLogger()
+    logger.setLevel(DEBUG)
+
+    if with_stdout:
+        sh = StreamHandler(sys.stdout)
+        sh.setFormatter(cuemsFormatter)
+        logger.addHandler(sh)
+    
+    if with_syslog:
+        syslog_handler = SysLogHandler(
+            address = '/dev/log', facility = 'local0'
+        )
+        syslog_handler.setFormatter(cuemsFormatter)
+        logger.addHandler(syslog_handler)
+
+    return logger
+
+class Logger:
+    logger = root_logger()
+
+    @staticmethod
+    def log(level, message, extra):
+        Logger.logger.log(level, message, stacklevel = 4, extra = extra)
+    
+    @staticmethod
+    def log_debug(message, extra = {"caller": ''}):
+        Logger.log(DEBUG, message, extra = extra)
+    
+    @staticmethod
+    def log_info(message, extra = {"caller": ''}):
+        Logger.log(INFO, message, extra = extra)
+
+    @staticmethod
+    def log_error(message, extra = {"caller": ''}):
+        Logger.log(ERROR, message, extra = extra)
+
+    @staticmethod
+    def log_warning(message, extra = {"caller": ''}):
+        Logger.log(WARNING, message, extra = extra)
+
+def logged(func):
+    """
+    A decorator function to log information about function calls and their results.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        """
+        The wrapper function that logs function calls and their results.
+        """
+        d = {"caller": func.__name__}
+        Logger.logger = getLogger(func.__module__)
+        Logger.log_info(f"Call recieved", extra = d)
+        Logger.log_debug(f"Using args: {args} and kwargs: {kwargs}", extra = d)
+        try:
+            result = func(*args, **kwargs)
+            Logger.log_debug(f"Finished with result: {result}", extra = d)
+        
+        except Exception as e:
+            Logger.log_error(f"Error occurred: {e}", extra = d)
+            raise
+        
+        else:
+            return result
+
+    return wrapper

cuemsutils/schemas/outputs.xsd

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xs:schema targetNamespace="http://stagelab.net/cuems" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:cms="http://stagelab.net/cuems">
+    <xs:element name="CuemsOutputs">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element name="video_outputs" type="cms:OutputsType" />
+                <xs:element name="default_video_output" type="xs:string" />
+                <xs:element name="audio_outputs" type="cms:OutputsType" />
+                <xs:element name="default_audio_output" type="xs:string" />
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+
+    <!-- TYPES DEFINITIONS -->
+    <xs:complexType name="OutputsType">
+        <xs:sequence>
+            <xs:element name="output" type="xs:string" minOccurs="0" maxOccurs="unbounded" />
+        </xs:sequence>
+    </xs:complexType>
+
+</xs:schema>