cuemsutils 0.0.1__py3-none-any.whl

cuemsutils/xml/CMLCuemsConverter.py

@@ -0,0 +1,177 @@
+import xmlschema
+from xml.etree.ElementTree import Element
+from xml.etree.ElementTree import register_namespace as etree_register_namespace
+from lxml.etree import Element as lxml_etree_element
+from lxml.etree import register_namespace as lxml_etree_register_namespace
+from xmlschema.exceptions import XMLSchemaTypeError, XMLSchemaValueError
+from collections import namedtuple
+
+ElementData = namedtuple('ElementData', ['tag', 'text', 'content', 'attributes'])
+
+class CMLCuemsConverter(xmlschema.XMLSchemaConverter):
+
+    def __init__(self, namespaces=None, dict_class=None, list_class=None,
+                 etree_element_class=None, text_key='&', attr_prefix='',
+                 cdata_prefix=None, indent=4, strip_namespaces=True,
+                 preserve_root=False, force_dict=False, force_list=False, **kwargs):
+
+        if etree_element_class is None or etree_element_class is Element:
+            register_namespace = etree_register_namespace
+        elif etree_element_class is lxml_etree_element:
+            register_namespace = lxml_etree_register_namespace
+        else:
+            raise XMLSchemaTypeError("unsupported element class {!r}".format(etree_element_class))
+
+        super(CMLCuemsConverter, self).__init__(namespaces=None, register_namespace=register_namespace, strip_namespaces=strip_namespaces)
+
+        self.dict = dict_class or dict
+        self.list = list_class or list
+        self.etree_element_class = etree_element_class or Element
+        self.text_key = text_key
+        self.attr_prefix = attr_prefix
+        self.cdata_prefix = cdata_prefix
+        self.indent = indent
+        self.preserve_root = preserve_root
+        self.force_dict = force_dict
+        self.force_list = force_list
+ 
+      
+    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+        """
+        Converts a decoded element data to a data structure.
+        :param data: ElementData instance decoded from an Element node.
+        :param xsd_element: the `XsdElement` associated to decoded the data.
+        :param xsd_type: optional `XsdType` for supporting dynamic type through \
+        xsi:type or xs:alternative.
+        :param level: the level related to the decoding process (0 means the root).
+        :return: a data structure containing the decoded data.
+        """
+        xsd_type = xsd_type or xsd_element.type
+        result_dict = self.dict()
+        if level == 0 and xsd_element.is_global() and not self.strip_namespaces and self:
+            schema_namespaces = set(xsd_element.namespaces.values())
+            result_dict.update(
+                ('%s:%s' % (self.ns_prefix, k) if k else self.ns_prefix, v)
+                for k, v in self._namespaces.items()
+                if v in schema_namespaces
+            )
+
+        if xsd_type.is_simple() or xsd_type.has_simple_content():
+            if data.attributes or self.force_dict and not xsd_type.is_simple():
+                result_dict.update(t for t in self.map_attributes(data.attributes))
+                if data.text is not None and data.text != '':
+                    result_dict[self.text_key] = data.text
+                return result_dict
+            else:
+                return data.text if data.text != '' else None
+        else:
+            if data.attributes:
+                result_dict.update(t for t in self.map_attributes(data.attributes))
+
+#            has_single_group = xsd_type.content_type.is_single()
+            list_types = list if self.list is list else (self.list, list)
+            dict_types = dict if self.dict is dict else (self.dict, dict)
+            if data.content:
+                for name, value, xsd_child in self.map_content(data.content):
+                    try:
+                        if isinstance(result_dict, list_types):
+                            result = result_dict
+                        else:
+                            result = result_dict[name]
+                    except KeyError:
+                        if xsd_child is not None and not xsd_child.is_single():
+                            result_dict = [{name:value}]
+                        else:
+                            result_dict[name] = self.list([value]) if self.force_list else value
+                    else:
+                        if isinstance(result, dict_types):
+                            result_dict[name] = self.list([result, value])
+                        elif isinstance(result, list_types) or not result:
+                            result_dict.append({name:value})
+                        else:
+                            result.append(value)
+                  
+
+            elif data.text is not None and data.text != '':
+                result_dict[self.text_key] = data.text
+
+            if level == 0 and self.preserve_root:
+                return self.dict(
+                    [(self.map_qname(data.tag), result_dict if result_dict else None)]
+                )
+            return result_dict if result_dict else None
+
+    def element_encode(self, obj, xsd_element, level=0):
+        """
+        Extracts XML decoded data from a data structure for encoding into an ElementTree.
+        :param obj: the decoded object.
+        :param xsd_element: the `XsdElement` associated to the decoded data structure.
+        :param level: the level related to the encoding process (0 means the root).
+        :return: an ElementData instance.
+        """
+        if level != 0:
+            tag = xsd_element.name
+        elif not self.preserve_root:
+            tag = xsd_element.qualified_name
+        else:
+            tag = xsd_element.qualified_name
+            try:
+                obj = obj.get(tag, xsd_element.local_name)
+            except (KeyError, AttributeError, TypeError):
+                pass
+
+        if not isinstance(obj, (self.dict, dict)):
+            if xsd_element.type.is_simple() or xsd_element.type.has_simple_content():
+                return ElementData(tag, obj, None, {})
+            elif xsd_element.type.mixed and not isinstance(obj, list):
+                return ElementData(tag, obj, None, {})
+            else:
+                return ElementData(tag, None, obj, {})
+
+        text = None
+        content = []
+        attributes = {}
+
+        for name, value in obj.items():
+            if name == self.text_key and self.text_key:
+                text = obj[self.text_key]
+            elif (self.cdata_prefix and name.startswith(self.cdata_prefix)) or \
+                    name[0].isdigit() and self.cdata_prefix == '':
+                index = int(name[len(self.cdata_prefix):])
+                content.append((index, value))
+            elif name == self.ns_prefix:
+                self[''] = value
+            elif name.startswith('%s:' % self.ns_prefix):
+                if not self.strip_namespaces:
+                    self[name[len(self.ns_prefix) + 1:]] = value
+            elif self.attr_prefix and name.startswith(self.attr_prefix):
+                attr_name = name[len(self.attr_prefix):]
+                ns_name = self.unmap_qname(attr_name, xsd_element.attributes)
+                attributes[ns_name] = value
+            elif not isinstance(value, (self.list, list)) or not value:
+                content.append((self.unmap_qname(name), value))
+            elif isinstance(value[0], (self.dict, dict, self.list, list)):
+                ns_name = self.unmap_qname(name)
+                content.extend((ns_name, item) for item in value)
+            else:
+                ns_name = self.unmap_qname(name)
+                for xsd_child in xsd_element.type.content_type.iter_elements():
+                    matched_element = xsd_child.match(ns_name, resolve=True)
+                    if matched_element is not None:
+                        if matched_element.type.is_list():
+                            content.append((ns_name, value))
+                        else:
+                            content.extend((ns_name, item) for item in value)
+                        break
+                else:
+                    if self.attr_prefix == '' and ns_name not in attributes:
+                        for key, xsd_attribute in xsd_element.attributes.items():
+                            if xsd_attribute.is_matching(ns_name):
+                                attributes[key] = value
+                                break
+                        else:
+                            content.append((ns_name, value))
+                    else:
+                        content.append((ns_name, value))
+
+        return ElementData(tag, text, content, attributes)

cuemsutils/xml/DictParser.py

@@ -0,0 +1,258 @@
+# DEV: Move to cuems-utils
+import distutils.util
+
+from ..CuemsScript import CuemsScript
+from ..cues.CueList import CueList
+from ..cues.Cue import Cue
+from ....dev.Media import Media, region
+from ..UI_properties import UI_properties
+from ..cues.CueOutput import CueOutput, AudioCueOutput, VideoCueOutput, DmxCueOutput
+from ..cues.AudioCue import AudioCue
+from ..cues.VideoCue import VideoCue
+from ..cues.ActionCue import ActionCue
+from ..cues.DmxCue import DmxCue, DmxScene, DmxUniverse, DmxChannel
+from ..cues.ActionCue import ActionCue
+from ..CTimecode import CTimecode
+from ..log import logger
+from ..cuems_nodeconf.CuemsNode import CuemsNodeDict, CuemsNode
+
+PARSER_SUFFIX = 'Parser'
+GENERIC_PARSER = 'GenericParser'
+
+class GenericDict(dict):
+    pass
+
+class CuemsParser():
+    def __init__(self, init_dict):
+        self.init_dict=init_dict
+
+    def get_parser_class(self, class_string):
+        parser_name = class_string + PARSER_SUFFIX
+        try:
+            parser_class = (globals()[parser_name], class_string)
+        except KeyError as err:
+            # logger.debug("Could not find class {0}, reverting to generic parser class".format(err))
+            parser_class = (globals()[GENERIC_PARSER], class_string)
+        return parser_class
+
+    def get_class(self, class_string):
+        
+        try:
+            _class = globals()[class_string]
+        except KeyError as err:
+            # logger.debug("Could not find class {0}".format(err))
+            _class = GenericDict
+        return _class
+
+    def get_first_key(self, _dict):
+        return list(_dict.keys())[0]
+
+
+    def get_contained_dict(self, _dict):
+        return list(_dict.values())[0]
+
+    def convert_string_to_value(self, _string):
+        bool_strings = ['true', 'false']
+        null_strings = ['none', 'null']
+        if isinstance(_string, str):
+            if (_string.lower() in bool_strings):
+                return bool(distutils.util.strtobool(_string.lower()))
+            elif (_string.lower() in null_strings):
+                return None
+            elif (_string.isdigit()):
+                return int(_string)
+            else:
+                try:
+                    return float(_string)
+                except ValueError:
+                    return _string
+        else:
+            return _string
+
+    def parse(self):
+        parser_class, class_string = self.get_parser_class(self.get_first_key(self.init_dict))
+        item_obj = parser_class(init_dict=self.get_contained_dict(self.init_dict), class_string=class_string).parse()
+        return item_obj
+
+class CuemsScriptParser(CuemsParser):
+    def __init__(self, init_dict, class_string):
+        self.init_dict = init_dict
+        self.class_string = class_string
+        self._class = self.get_class(class_string)
+        self.item_csp = self._class()
+    
+    def parse(self):
+        for dict_key, dict_value in self.init_dict.items():
+            if type(dict_value) is dict:
+                if (len(list(dict_value))> 0):
+                    parser_class, class_string = self.get_parser_class(dict_key)
+                    self.item_csp[dict_key.lower()] = parser_class(init_dict=dict_value, class_string=class_string).parse()
+                    
+            else:
+                dict_value = self.convert_string_to_value(dict_value)
+                self.item_csp[dict_key] = dict_value
+                
+        return self.item_csp
+
+class CueListParser(CuemsScriptParser):
+    def __init__(self, init_dict, class_string):
+        self.init_dict = init_dict
+        self.class_string = class_string
+        self._class = self.get_class(class_string)
+        self.item_clp = self._class()
+        
+    def parse(self):
+        for dict_key, dict_value in self.init_dict.items():
+            if isinstance(dict_value, list):
+                local_list = []
+                for cue in dict_value:
+                    parser_class, unused_class_string = self.get_parser_class(self.get_first_key(cue))
+                    item_obj = parser_class(init_dict=self.get_contained_dict(cue), class_string=self.get_first_key(cue)).parse()
+                    local_list.append(item_obj)
+
+                self.item_clp['contents'] = local_list
+            elif isinstance(dict_value, dict):
+                key_parser_class, key_class_string = self.get_parser_class(dict_key)
+                if key_parser_class == GenericParser:
+                    value_parser_class, value_class_string = self.get_parser_class(self.get_first_key(dict_value))
+                
+                if value_parser_class == GenericParser:
+                    self.item_clp[dict_key] = key_parser_class(init_dict=dict_value, class_string=key_class_string).parse()
+                else:
+                    self.item_clp[dict_key] = value_parser_class(init_dict=dict_value, class_string=value_class_string).parse()
+
+            else:
+                dict_value = self.convert_string_to_value(dict_value)
+                self.item_clp[dict_key] = dict_value
+                
+        return self.item_clp
+
+class GenericParser(CuemsScriptParser): 
+    def __init__(self, init_dict, class_string):
+        self.init_dict = init_dict
+        self.class_string = class_string
+        self._class = self.get_class(class_string)
+        self.item_gp = self._class()
+        
+    def parse(self):
+        if self._class == GenericDict:
+            self.item_gp = self.init_dict
+
+        elif isinstance(self.init_dict, dict):
+            for dict_key, dict_value in self.init_dict.items():
+                if isinstance (dict_value, dict):
+                    key_parser_class, key_class_string = self.get_parser_class(dict_key)
+                    if key_parser_class == GenericParser:
+                        value_parser_class, value_class_string = self.get_parser_class(self.get_first_key(dict_value))
+
+                    if value_parser_class == GenericParser:
+                        self.item_gp[dict_key] = key_parser_class(init_dict=dict_value, class_string=key_class_string).parse()
+                    else:
+                        self.item_gp[dict_key] = value_parser_class(init_dict=dict_value, class_string=value_class_string).parse()
+                elif isinstance(dict_value, list):
+                    local_list = []
+                    parser_class, class_string = self.get_parser_class(dict_key)
+                    for list_item in dict_value:
+
+                        item_obj = parser_class(init_dict=list_item, class_string=class_string).parse()
+                        local_list.append(item_obj)
+                    self.item_gp[dict_key] = local_list
+                else:
+                    dict_value = self.convert_string_to_value(dict_value)
+                    self.item_gp[dict_key] = dict_value
+
+        return self.item_gp
+
+class DmxSceneParser(GenericParser):
+    pass
+
+    def parse(self):
+        for class_string, class_item_list in self.init_dict.items():   
+            for class_item in class_item_list:
+                parser_class, class_string = self.get_parser_class(class_string)
+                item_obj = parser_class(init_dict=class_item, class_string=class_string).parse()
+                self.item_gp.set_universe(item_obj, class_item['id'])
+        return self.item_gp
+
+class DmxUniverseParser(GenericParser):
+
+    def parse(self):
+        for class_string, class_item_list in self.init_dict.items():
+            if class_string != 'id':
+                for class_item in class_item_list:
+                    parser_class, class_string = self.get_parser_class(class_string)
+                    item_obj = parser_class(init_dict=class_item, class_string=class_string).parse()
+                    self.item_gp.set_channel(class_item['id'], item_obj)
+        return self.item_gp
+
+class DmxChannelParser(GenericParser):
+
+    def parse(self):
+        self.item_gp.value = self.init_dict['&']
+        return self.item_gp
+
+class GenericSubObjectParser(GenericParser):
+    
+    def parse(self):
+        self.item_gp = self._class(self.init_dict)
+        return self.item_gp
+
+class CTimecodeParser(GenericSubObjectParser):  
+
+    def parse(self):
+        self.item_gp = self.init_dict
+        return self.item_gp
+
+
+class OutputsParser(GenericParser):
+    def __init__(self, init_dict, class_string, parent_class=None):
+        self.init_dict = init_dict
+
+    def parse(self):
+        for dict_key, dict_value in self.init_dict.items():
+            self._class = self.get_class(dict_key)
+            self.item_op = self._class(dict_value)
+
+        return self.item_op
+
+class regionsParser(GenericParser):
+    def __init__(self, init_dict, class_string, parent_class=None):
+        self.init_dict = init_dict
+        self.class_string = class_string
+        self._class = self.get_class(class_string)
+        self.item_rp = self._class()
+        
+    def parse(self):
+        for dict_key, dict_value in self.init_dict.items():
+            key_parser_class, key_class_string = self.get_parser_class(dict_key)
+            self.item_rp = key_parser_class(init_dict=dict_value, class_string=key_class_string).parse()
+
+        return self.item_rp
+
+class AudioCueOutputParser(OutputsParser):
+    pass
+
+class VideoCueOutputParser(OutputsParser):
+    pass
+class DmxCueOutputParser(OutputsParser):
+    pass
+
+class CuemsNodeDictParser(OutputsParser):
+    def parse(self):
+        self.item_rp = list()
+        for item in self.init_dict:
+            for dict_key, dict_value in item.items():
+                key_parser_class, key_class_string = self.get_parser_class(dict_key)
+                self.item_rp.append(key_parser_class(init_dict=dict_value, class_string=key_class_string).parse()) 
+
+        return self.item_rp
+
+class CuemsNodeParser(GenericParser):
+    pass
+
+class NoneTypeParser():
+    def __init__(self, init_dict, class_string):
+        pass
+
+    def parse(self):
+        return None