Python Element.find方法代码示例

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import find [as 别名]
class NotificationBase(object):
    """
    Base class with common functionality for notification actions.
    """
    xmlns = "{http://xml.vidispine.com/schema/vidispine}"

    def __init__(self, xmldoc):
        self.dataContent = xmldoc

    def new(self, parent = None):
        """
        Initialises a new notification document
        :return: self
        """
        from xml.etree.cElementTree import Element
        if parent is None:
            self.dataContent = Element("ns0:action")
        else:
            self.dataContent = parent
        return self

    def _safe_get_nodecontent(self, xpath, default=""):
        """
        Returns the content of the node identified by xpath, or the value identified by default= if it cannot be found
        """
        node = self.dataContent.find(xpath)
        if node is not None:
            return node.text
        return default

    def _safe_set_nodecontent(self, xpath, newval, parent=None):
        """
        Sets the value of the node identified by xpath to newval, or if the parent= parameter is set to an ElementTree
        node will attempt to create it if it does not already exist.
        """
        from xml.etree.cElementTree import SubElement
        if parent is None:
            parent = self.dataContent
        if not isinstance(newval,basestring):
            newval = str(newval)

        node = self.dataContent.find(xpath)
        if node is not None:
            node.text = newval
        else:
            if parent is None:
                raise KeyError("Node {xp} is not found and no parent node specified to create".format(xp=xpath))
            node = SubElement(parent,xpath)
            node.text = newval

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import find [as 别名]
    def readOptionXML(self, cell_xml : ET.Element):
        """
        Used for loading a new configuration.

        :param cell_xml:
        :return:
        """

        name_xml = cell_xml.find('name')

        self.label.setText(name_xml.text)
        self.line_edit.setText(name_xml.text)


        if isinstance(self, ChannelWidget):
            if 'slider' in name_xml.keys():
                slider_value = name_xml.get('slider')
                slider_active = name_xml.get('sliderActive')

                self.slider.setValue(int(slider_value))
                self.slider_value.setText(slider_value + "%")

                self.check_slider.setChecked(slider_active == "True")

        if isinstance(self, StateWidget):
            if 'duration' in name_xml.keys():
                duration = name_xml.get('duration')
                self.duration_edit.setText(duration)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import find [as 别名]
 def get_item_value(element: et.Element, *args, default=None) -> int:
     """Get an int value from an element"""
     for name in args:
         try:
             return int(round(float(element.find(name).get("Value")), 0))
         except AttributeError:
             continue
     if not default:
         raise ValueError("Failed to find any element matching {} for {}".format(args, element))
     return default

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import find [as 别名]
    def principal_update(self, **params):
        xml = Element('params')
        xml.append(Element('param', name='action'))
        xml[0].text = 'principal-update'

        for key, val in params.items():
            if key in self.principal_update.allowed_params and val is not None:
                xml.append(Element('param', name=key.replace('_', '-')))
                xml[len(xml) - 1].text = val

        xml = self.request(submit=buildXML(xml))
        return type(xml) == type(Element(None)) and ConnectPrincipal(xml.find('principal')) or xml

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import find [as 别名]
class VSNotification(VSApi):
    """
    This class represents a Vidispine notification definition
    """
    class UnknownActionType(StandardError):
        """
        Raised if an action type is found that we don't support
        """
        pass

    def __init__(self,*args,**kwargs):
        super(VSNotification, self).__init__(*args, **kwargs)
        from xml.etree.cElementTree import Element
        self.name = None
        self.objectclass = None
        self.dataContent = Element('NotificationDocument', {'xmlns:ns0': self.xmlns[1:-1]})

    def populate(self, objectclass, vsid):
        """
        Populates with data from Vidispine about the given notification
        :param objectclass: Type of vidispine object we're looking at, e.g. item, collection, etc.
        :param vsid: VS ID of the notification in question. Use VSNotificationCollection to list instead
        :return: None (but populates object)
        """
        self.name = vsid
        self.objectclass = objectclass

        url = "/{cls}/notification/{vsid}".format(cls=objectclass, vsid=vsid)
        self.dataContent = self.request(url)

    def save(self):
        """
        Saves the notification.  This is done by DELETING the old one, and then saving a new one, so the name property
        will change
        :return: None
        """
        from xml.etree.cElementTree import tostring
        from vidispine_api import VSNotFound
        from pprint import pprint
        
        try:
            self.delete()
        except VSNotFound: #if it does not exist yet or has not been set up, then ignore
            pass
            
        url = "/{cls}/notification".format(cls=self.objectclass)
        content = self.as_xml()
        response_content = self.request(url, method="POST", body=content)
        pprint(response_content)
        #FIXME: need to update the name property from the reply
        #raise StandardError("testing")

    def as_xml(self):
        from xml.etree.cElementTree import tostring
        import re
        
        #strip_attributes(self.dataContent, 'xmlns', 'xmlns:ns0')
        str = tostring(self.dataContent, encoding="UTF-8")
        str = re.sub(r'xmlns[^\s>]*','',str)
        str = re.sub(r'ns\d:','',str)
        str = re.sub(r'[^/]NotificationDocument',
                     '<NotificationDocument xmlns="{0}"'.format(self.xmlns[1:-1]),
                     str)
        
        return str

    def delete(self):
        """
        Deletes the notification in question
        :return: None
        """
        if self.name is None:
            return
            
        url = "/{cls}/notification/{vsid}".format(cls=self.objectclass, vsid=self.name)
        self.request(url, method="DELETE")

    def __unicode__(self):
        #raise StandardError("testing")
        return u'Notification {n} to {act} on {trig}'.format(n=self.name,
        act=','.join(map(lambda x: unicode(x),self.actions)),trig=self.trigger)
    
    @property
    def actions(self):
        """
        Generator that yields objects for every action associated with this notification
        :return: yields HttpNotification or similar subclass
        """
        from xml.etree.cElementTree import SubElement
        action_node = self.dataContent.find('{0}action'.format(self.xmlns))
        if action_node is None:
            action_node = SubElement(self.dataContent,'{0}action'.format(self.xmlns))
            #FIXME: shouldn't be hardcoded!
            type_node = SubElement(action_node,'{0}http'.format(self.xmlns), {'synchronous': 'false'})
            yield HttpNotification(type_node)
        else:
            for n in action_node:
                if n.tag == "{0}http".format(self.xmlns):
                    yield HttpNotification(n)
                else:
#.........这里部分代码省略.........

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import find [as 别名]
class Item2XML(BaseXML):

    def __init__(self, path):
        BaseXML.__init__(self, path)
        if not self.parsed:
            self.__create_root()

    def __str__(self):
        return "[%s - %s]" % (self.__class__.__name__, toString('/'.join(self.path.split('/')[-2:])))

    def __len__(self):
        items = self.xml_root_element.find('items')
        return items.findall('item') and len([item_el for item_el in items.findall('item')]) or 0

    def __create_root(self):
        self.xml_root_element = Element('root')
        SubElement(self.xml_root_element, 'items')

    def create_item(self, xml_item):
        log.debug("{0} create item - {1}".format(self, toString(xml_item)))
        item = self._get_item_cls(xml_item)()
        item.id = xml_item.attrib.get('id')
        item.addon_id = xml_item.attrib.get('addon_id')
        item.ctime = xml_item.attrib.get('ctime')
        item.name = xml_item.findtext('name')
        item.params = {}
        params = xml_item.find('params')
        for key, value in params.items():
            item.params[key] = value
        return self._update_item(item, xml_item)

    def _update_item(self, item, xml_item):
        return item

    def add_item(self, item):
        xml_item = self.create_xml_item(item)
        if xml_item:
            xml_item = self._update_xml_item(xml_item, item)

    def update_item(self, item):
        if item.id:
            self.remove_item(item)
        self.add_item(item)

    def create_xml_item(self, item):
        log.logDebug("%s create xml item - %s"%(self,item))
        log.debug("{0} create xml item - {1}".format(self, toString(item)))

        import time
        from datetime import datetime
        t = datetime.now()
        t1 = t.timetuple()
        uid = int(time.mktime(t1))
        if item.id:
            item.id = uid
            #log.logDebug("%s create xml item - %s already exists, skipping"%(self,item))
            #log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
            #return
        item_id = item.get_id()
        if self.find_item_by_id(item_id):
            item_id = uid
            item.id = uid
            #log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item))
            #log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
            #return
        addon_id = item.addon_id
        xml_item = SubElement(self.xml_root_element.find('items'), 'item')
        xml_item.set('id', toUnicode(item_id))
        xml_item.set('ctime', str(datetime.now()))
        if addon_id:
            xml_item.set('addon_id', toUnicode(addon_id))
        name = SubElement(xml_item, 'name')
        name.text = toUnicode(item.name)
        params = SubElement(xml_item, 'params')
        for key, value in item.params.iteritems():
            params.set(toUnicode(key), toUnicode(value))
        item.id = item_id
        return xml_item

    def _update_xml_item(self, xml_item, item):
        return xml_item

    def get_item(self, item_id):
        xml_item = self.find_item_by_id(item_id)
        if xml_item:
            item = self.create_item(xml_item)
            item = self._update_item(item, xml_item)
            return item

    def get_items(self):
        item_list = []
        items = self.xml_root_element.find('items')
        items = items.findall('item') or []
        for xml_item in items:
            item = self.create_item(xml_item)
            item = self._update_item(item, xml_item)
            item_list.append(item)
        return item_list

    def remove_item(self, item):
#.........这里部分代码省略.........