def GetProperty(self, name):
     subelement = self.element.find(name)
     if ET.iselement(subelement):
         data = subelement.text
     elif self.definition and ET.iselement(self.definition.find(name)):
         self.SetProperty(name,'')
         return ''
     else:
         error_str = "%s not found in %s." % (name, self.element.tag)
         log.debug(error_str)
         raise PropertyNotFoundError(error_str)
     if data:
         data = data.strip()
         if ET.iselement(self.definition):
             try:
                 type = self.definition.find(name).text
                 property = self.ApplyType(data, type)
             except ValueError:
                 property = self.ApplyType("", type)
             except AttributeError:
                 return data
         else:
              property = data
         return property
     if ET.iselement(self.definition):
         try:
             type = self.definition.find(name).text
             return self.ApplyType("", type)
         except AttributeError:
             return ""
     else:
         return ""

 def parseFeed(self, feed):
     root = ET.parse(feed)
     try:
         channel = root.find('.//channel')
         if channel:
             title = channel.find('title')
             self.title = ET.iselement(title) and title.text or 'None'
             description = channel.find('description')
             self.description = ET.iselement(description) and description.text or 'None'
             pubDate = channel.find('pubDate')
             self.pubDate = ET.iselement(pubDate) and pubDate.text or 'None'
             items = channel.findall('item')
             for item in items:
                 newItem = self.Item()
                 element = item.find('title')
                 newItem.title = element.text or 'None'
                 element = item.find('description')
                 newItem.description = element.text or 'None'
                 element = item.find('pubDate')
                 if element is not None:
                     newItem.date = element.text or 'None'
                 enclosure = item.find('enclosure')
                 if enclosure is not None:
                     newItem.url = 'url' in enclosure.attrib and enclosure.attrib['url'] or 'None'
                     newItem.type = 'type' in enclosure.attrib and enclosure.attrib['type'] or 'None'
                     newItem.length = 'length' in enclosure.attrib and enclosure.attrib['length'] or 'None'
                 self.items.append(newItem)
     except AttributeError:
         pass

    def __getMultiDict(self, xmlTree, xmlDict, cnt=0):
        """
        :Notes: Populates the Dictionary.

        :Args:
            xmlTree (XML): XML object of Request
            xmlDict (dict) : Dictionary to be populated

        Recursively generates all the (key,value) pairs as Dictionary.

        """

        if cElementTree.iselement(xmlTree) and xmlTree.getchildren():
            if xmlTree.tag in xmlDict:
                tag_count = len([i for i in xmlDict if i.startswith(xmlTree.tag)])
                key = xmlTree.tag + "_" + str(tag_count)
            else:
                key = xmlTree.tag
            xmlDict[key] = {}
            for elem in xmlTree.getchildren():
                self.__getMultiDict(elem, xmlDict[key])
        elif cElementTree.iselement(xmlTree) and not xmlTree.getchildren():
            if xmlTree.text:
                for key in valuedict:
                    if key in xmlTree.text:
                        xmlTree.text = xmlTree.text.replace(key, valuedict[key])
            if xmlTree.tag in xmlDict:
                tag_count = len([i for i in xmlDict if i.startswith(xmlTree.tag)])
                xmlDict[xmlTree.tag + "_" + str(tag_count)] = (xmlTree.text or "").strip() or None
            else:
                xmlDict[xmlTree.tag] = (xmlTree.text or "").strip() or None
        return xmlDict

def objToEl(el, objects):
    """
    Convert 'object' arguments to ET.Element types
    and append them to el.
    """
    assert ET.iselement(el)
    for obj in objects:
        if isinstance(obj, IntacctObjectType):
            obj = obj()
        elif isinstance(obj, str):
            obj = ET.fromstring(obj)
        if not ET.iselement(obj):
            raise Exception('Unable to process object: %s' % str(obj))
        el.append(obj)

def negateEvents(input, output=None, verbose=False):
    if not (ET.iselement(input) and input.tag == "sentence"):
        print >> sys.stderr, "Loading corpus file", input
        corpusTree = ETUtils.ETFromObj(input)
        corpusRoot = corpusTree.getroot()
    
    if not (ET.iselement(input) and input.tag == "sentence"):
        sentences = corpusRoot.getiterator("sentence")
    else:
        sentences = [input]
    counts = defaultdict(int)
    for sentence in sentences:
        for entity in sentence.findall("entity"):
            counts["all-entities"] += 1
            eType = entity.get("type")
            if not isNegatableEPITrigger(eType):
                counts["out-of-scope"] += 1
                continue
            eBaseType = getEPIBaseType(eType)
            eText = entity.get("text").lower()
            eNewType = determineNewType(eType, eText)
        
            # Insert changed charOffset
            counts["entities"] += 1
            if verbose:
                print "Entity", entity.get("id"), [entity.get("text")], [eType, eBaseType, eNewType],
            if eNewType != eBaseType:
                counts["negated"] += 1
                if verbose: print "NEGATED",
            if eNewType == eType:
                counts["correct"] += 1
                if verbose: print "CORRECT"
            else:
                counts["incorrect"] += 1
                if eNewType == eBaseType:
                    counts["incorrect-pos"] += 1
                else:
                    counts["incorrect-neg"] += 1
                if verbose: print "INCORRECT"
            entity.set("type", eNewType)
    if verbose:
        print counts
    
    if not (ET.iselement(input) and input.tag == "sentence"):
        if output != None:
            print >> sys.stderr, "Writing output to", output
            ETUtils.write(corpusRoot, output)
        return corpusTree                    

    def load_from_xml(self, element):
        """Populate object using Xml Document Node"""
        self._class_id = element.tag
        meta_class_id = CoreUtils.find_class_id_in_mo_meta_ignore_case(self._class_id)

        if meta_class_id:
            self._class_id = meta_class_id

        if NamingPropertyId.DN in element.attrib:
            self.dn = element.attrib[NamingPropertyId.DN]

        if self.dn:
            self.rn = os.path.basename(self.dn)

        # Write the attribute and value to dictionary properties, as it is .
        self.write_to_attributes(element)

        # Run the load_from_xml for each child_node recursively and populate child list too.
        child_elements = element.getchildren()
        if child_elements:
            for child_element in child_elements:
                if not ET.iselement(child_element) :
                    continue
                child = _GenericMO()
                self._child.append(child)
                child.load_from_xml(child_element)

    def from_xml(self, elem):  # , handle, modify_self=False, mo=None):
        """Method updates/fills the object from the xml representation
        of the external method object. """
        if elem.attrib:
            for attr_name, attr_value in elem.attrib.iteritems():
                if attr_name in self.__property_map:
                    attr = self.__property_map[attr_name]
                    method_prop_meta = self.__property_meta[attr]
                    if method_prop_meta.inp_out == "Input" or (method_prop_meta.is_complex_type):
                        continue
                    self.set_attr(attr, str(attr_value))
                elif attr_name in ExternalMethod._external_method_attrs:
                    self.set_attr(ExternalMethod._external_method_attrs[attr_name], str(attr_value))

        child_elems = elem.getchildren()
        if child_elems:
            for child_elem in child_elems:
                if not ET.iselement(child_elem):
                    continue
                child_name = child_elem.tag
                if child_name in self.__property_map:
                    child_name = self.__property_map[child_name]
                    method_prop_meta = self.__property_meta[child_name]
                    if method_prop_meta.inp_out == "Output" and (method_prop_meta.is_complex_type):
                        child_obj = ucscoreutils.get_ucs_obj(method_prop_meta.field_type, child_elem)
                        if child_obj is not None:
                            self.set_attr(child_name, child_obj)
                            # print child_method_obj.__dict__
                            child_obj.from_xml(child_elem)

def __SendDataPart(data, connection):
  """This method is deprecated, use atom.http._send_data_part"""
  deprecated('call to deprecated function __SendDataPart')
  if isinstance(data, six.binary_type):
    connection.send(data)
    return
  elif isinstance(data, six.text_type):
    connection.send(data.encode())
    return
  elif ElementTree.iselement(data):
    connection.send(ElementTree.tostring(data))
    return
  # Check to see if data is a file-like object that has a read method.
  elif hasattr(data, 'read'):
    # Read the file and send it a chunk at a time.
    while True:
      binarydata = data.read(100000)
      if not binarydata:
        break
      connection.send(binarydata)
    return
  else:
    # The data object was not a file.
    # Try to convert to a string and send the data.
    connection.send(str(data))
    return

    def __format_attributes(elt_data):
        """
            Private method which converts a single XML tag to a python dict.
            It also checks that the elt_data given as argument is of type
            xml.etree.ElementTree.Element

            :param elt_data: XML Element to be parsed or string
            to be converted to a XML Element

            :return: Element
        """

        rval = {}
        if not ET.iselement(elt_data):
            raise NmapParserException("Error while trying to parse supplied "
                                      "data attributes: format is not XML or "
                                      "XML tag is empty")
        try:
            for dkey in elt_data.keys():
                rval[dkey] = elt_data.get(dkey)
                if rval[dkey] is None:
                    raise NmapParserException("Error while trying to build-up "
                                              "element attributes: empty "
                                              "attribute {0}".format(dkey))
        except:
            raise
        return rval

    def __format_element(elt_data):
        """
            Private method which ensures that a XML portion to be parsed is
            of type xml.etree.ElementTree.Element.
            If elt_data is a string, then it is converted to an
            XML Element type.

            :param elt_data: XML Element to be parsed or string
            to be converted to a XML Element

            :return: Element
        """
        if isinstance(elt_data, str):
            try:
                xelement = ET.fromstring(elt_data)
            except:
                raise NmapParserException("Error while trying "
                                          "to instanciate XML Element from "
                                          "string {0}".format(elt_data))
        elif ET.iselement(elt_data):
            xelement = elt_data
        else:
            raise NmapParserException("Error while trying to parse supplied "
                                      "data: unsupported format")
        return xelement

 def __new__(cls,tag,thing = None,*args,**kwargs):
   if hasattr(tag,'__xml__'):
     return tag.__xml__()
   self = object.__new__(xml)
   if cElementTree.iselement(tag):
     self.__content = tag
   elif isinstance(tag,cElementTree.ElementTree):
     self.__content = tag.getroot()
   elif is_file(tag):
     self.__content = cElementTree.parse(tag).getroot()
   elif isinstance(tag,str) and len(tag) > 0 and tag[0] == '<':
     self.__content = cElementTree.fromstring(tag)
   else:
     if type(tag) != str:
       raise TypeError("Cannot convert %s object to xml" % str(type(tag)))
     self.__content = cElementTree.fromstring('<%s/>' % tag)
     if is_text(thing) or type(thing) == int:
       self.__content.text = text(thing)
     elif thing != None:
       self.append(xml(thing))
     for subthing in args:
       self.append(xml(subthing))
     for key,value in kwargs.items():
       if key == '__class' or key == 'klass':
         self['class'] = value
       else:
         self[key] = value
   if '{' in self.__content.tag:
     self.__prefix = PREFIX_PAT.search(self.__content.tag).groups()[0]
   else:
     self.__prefix = ''
   return self

    def get_title(self):
        title = self.xml_root.find("teiHeader/fileDesc/titleStmt/title")
        if not ET.iselement(title):
            return ""

        title_str = ET.tostring(title, encoding="gbk", method="text").strip()
        return title_str

    def get_author(self):
        author = self.xml_root.find("teiHeader/fileDesc/titleStmt/author")
        if not ET.iselement(author):
            return ""

        author_str = ET.tostring(author, encoding="gbk", method="text").strip()
        return author_str

    def get_date(self):
        date = self.xml_root.find("teiHeader/fileDesc/publicationStmt/date")
        if not ET.iselement(date):
            return ""

        date_str = ET.tostring(date, encoding="gbk", method="text").strip()
        return date_str

 def run(cls,inFile,multiplier=1.0,outFile=None,targetLabel="neg", binary=False):
     """inFile can be a string with file name (.xml or .xml.gz) or an ElementTree or an Element or an open input stream
     multiplier adjusts the level of boosting the non-negative predictions, it is a real number (0,inf)
     multiplier 1.0 does nothing, <1.0 decreases negative class confidence, >1.0 increases negative class confidence
     the root of the modified tree is returned and, if outFile is a string, written out to outFile as well"""
     print >> sys.stderr, "##### Recall adjust with multiplier " + str(multiplier)[:5] + " #####"
     tree=ETUtils.ETFromObj(inFile)
     if not ET.iselement(tree):
         assert isinstance(tree,ET.ElementTree)
         root=tree.getroot()
     else:
         root = tree
     
     if multiplier != -1:
         if binary:
             print >> sys.stderr, "Recall binary mode"
             classRanges = getClassRanges(root.getiterator("entity"))
             assert len(classRanges.keys()) in [0,2]
             if len(classRanges.keys()) == 0:
                 print >> sys.stderr, "Warning, recall adjustment skipped because no prediction weights found"
         else:
             print >> sys.stderr, "Recall multiclass mode"
             classRanges = None
         for entityNode in root.getiterator("entity"):
             adjustEntity(entityNode,targetLabel,multiplier,classRanges)
     if outFile:
         ETUtils.write(root,outFile)
     return tree

 def __init__(self, xmltree, imageprovider = None):
     self.root = None
     self.imageprovider = imageprovider
     self.stroke = None
     self.fill = None
     
     self.level = 0
     self.seen = set()
     self.skip = set()
     self.styles = {}
     self.hasFill = False
     self.gradient = None
     self.hasStroke = False
     
     self.bounds = Box()
     
     if hasattr(xmltree,'element'):
         xmltree = xmltree.element
     self.xmltree = xmltree
     
     # svg fragment?
     if etree.iselement(xmltree) and xmltree.tag == self.SVG_ROOT:
         root = xmltree
     else:
         root = xmltree.getroot()
         if not root.tag == self.SVG_ROOT:
             raise ValueError("Expected SVG fragment as root object")
         
     # parse svg constructs for quicker display
     self.preparse(root)

def convert(arg):
    """
    Convert an object to its xml representation
    """
    if iselement(arg):
        return arg # the element
    if isinstance(arg, dict_accessor):
        try:
            return arg.text_
        except:
            raise Exception("Cannot serialize %s, missing text_ attribute" % (arg,))
    if isinstance(arg, dict):
        return arg # attributes of the element
    if isinstance(arg, unicode):
        return arg
    if isinstance(arg, decimal.Decimal):
        return unicode(arg)
    if arg is True:
        return 'true'
    if arg is False:
        return 'false'
    if isinstance(arg, float):
        return unicode(round(arg, 2)) # there's nothing less than cents anyway
    if isinstance(arg, (int, long)):
        return unicode(arg)
    if isinstance(arg, str):
        raise Exception("'%s' not unicode: can only accept unicode strings" % (arg,))
    raise Exception("Cannot convert %s of type %s" % (arg, type(arg)))

	def _parse(self, block):
		""":returns: a parse tree given a string."""
		if ElementTree.iselement(block):
			xmlblock = block
		else:  # NB: parse because raw XML might contain entities etc.
			xmlblock = ElementTree.fromstring(block)
		return alpinotree(
				xmlblock, self.functions, self.morphology, self.lemmas)

	def path(self, element):
		path = []
		current = element
		while ET.iselement(current) :
			path.append(current)
			current = self.parent_map[current]
		path.reverse()
		return path

	def _set_elem(self, elem):
		"""Set elementtree element.
		
		:raise TypeError: invalid element
		"""
		if not etree.iselement(elem):
			raise TypeError('xml: invalid etree element (%s).' % _etree_elem)
		self._etree_elem = elem