def build(self, root=None):
        if root is None:
            was_root = True
            root = TreeBuilder()
        else:
            was_root = False

        root.start(self.tagname(), self.attrs())
        for i, child in enumerate(self.children):
            if isinstance(child, HTMLBuilder):
                child.build(root=root)
            else:
                if i in self._formatted:
                    try:
                        proxy = TreeProxy(root)
                        parser = XMLParser(html=True, target=proxy)
                        parser.feed(child)
                        proxy.cleanup()
                    except Exception as e:
                        print("Bad formatting", e)
                        root.data(str(child))
                else:
                    root.data(str(child))
        root.end(self.tagname())

        if was_root:
            root = root.close()
            return str(tostring(root, method="html").decode('utf-8'))

    def parse(self):
        target = GetXmlAttrs()
        parser = XMLParser(target=target)
        if self.config:
            parser.feed(self.config)

        return target

def getQueryResult(query,detailedLog=True):
    parser = XMLParser(target=ProcessCSQueryResult())
    queryAnswerXML = urllib.urlopen(query).read()
    if detailedLog:
        log_CSQuery(queryAnswerXML)
    parser.feed(queryAnswerXML)
    return parser.close()

 def parse(self, fIn, oHolder):
     """Parse XML file into the card set holder"""
     oParser = XMLParser(target=self._cState(oHolder))
     try:
         for sLine in fIn:
             oParser.feed(sLine)
     except ParseError, oExp:
         raise IOError('Not an XML file: %s' % oExp)

def HTMLOfENML(text, resources={}):
  
  target = HTMLCreatorTarget(resources)
  parser = XMLParser(target=target)
  parser.feed(text)
  parser.close()
  
  return tostring(target.root, encoding='utf8', method='html')

def mm2otl(*arg, **kwarg):
    fname = arg[0][0]
    file = codecs.open(fname, 'r', encoding='utf-8')

    filelines = file.readlines()
    outline = Outline()
    parser = XMLParser(target=outline, encoding='utf-8')
    parser.feed(filelines[0].encode('utf-8'))
    parser.close()

 def _parse_xml(self, xml_data):
   """
   Parse the xml into a python dictionary
   """
   parser = XMLParser()
   tree = parser.feed(xml_data)
   root = parser.close()
   data_dict = XmlDictConfig(root)
   return data_dict

 def fromStream(cls, source):
     parser  = XMLParser(target=WebDAVContentHandler())
     try:
         while 1:
             data = source.read(65536)
             if not data:
                 break
             parser.feed(data)
     except XMLParseError, e:
         raise ValueError(e)

    def __init__(self):
        f = open(self.config_file)
        xml_src = f.read()
        f.close()

        parser = XMLParser()
        parser.feed(xml_src)
        self.config_tree = parser.close()

        self.parse()

def find_depth(chaine):
    target = MaxDepth()
    parser = XMLParser(target=target)
    exampleXml = """<feed xml:lang='en'>
        <title>HackerRank</title>
        <subtitle lang='en'>Programming challenges</subtitle>
        <link rel='alternate' type='text/html' href='http://hackerrank.com/'/>
        <updated>2013-12-25T12:00:00</updated>
    </feed>"""
    parser.feed(chaine)
    print(parser.close()-1)

def makeparser():
    """
        Returns an XML parser that knows about a few non-standard XML
        entities.   If your XML source uses other non-standard XML
        entities, add these to ENTITIES above.
    """
    parser = XMLParser()
    parser.parser.UseForeignDTD(True)
    for k in ENTITIES:
        parser.entity[k] = ENTITIES[k]
    return parser

	def __init__(self, config_file=None):
		if config_file:
			self.config_file = config_file
		f = open(self.config_file)
		xml_src = f.read()
		f.close()

		parser = XMLParser()
		parser.feed(xml_src)
		self.config_tree = parser.close()

		self.parse()

    def from_xml(xml):
        """
        Deserialize from a XML string.

        :param: xml string
        :rtype: object tree from XML string
        """
        handler = XMLHandler()
        parser = XMLParser(target=handler)
        parser.feed(xml)
        parser.close()
        return handler.root

def main():
    if 1 < len(sys.argv):  # .xml file path in $1 argument, else use /dev/stdin
        path = sys.argv[1]
        text = open(path).read()
    else:
        text = "\n".join(sys.stdin.readlines())
    ntg = sys.argv[2] if 2 < len(sys.argv) else None

    parser = XMLParser(target=_Parser_xml(ntg))
    text = re.sub('\\sxmlns="[^"]+"', '', text, count=1)
    parser.feed(text)
    parser.close()

def main():
    N = input()

    lines = []
    for n in xrange(N):
        line = raw_input()
        lines.append(line)

    parser = XMLParser(target=MaxDepth())
    parser.feed("\n".join(lines))

    print (parser.close() - 1)

def main():
    init()
    log.info("Parsing '%s'..." % os.path.basename(conf['source_file']))

    stopwatch_set()
    target = CustomParser()
    parser = XMLParser(target=target)
    parser.feed(open(conf['source_file']).read())

    log.info('')
    totals = 'Total: posts: {post}; pages: {page}; comments: {comment}'
    log.info(totals.format(**stats))
    log.info('Elapsed time: %s s' % stopwatch_get())

def load(file, env):
	cXMLParser = CXMLParser(env)

	parser = XMLParser(target=cXMLParser)

	f = open(file, 'r+')
	read_data = f.read();
	f.close()

	parser.feed(read_data)
	parser.close()
	
	return cXMLParser.env

 def parse(self, source=None, parser=None):
     try:
         if not parser:
             parser = XMLParser(target=TreeBuilder())
         while 1:
             data = self.mergeScreenConfigs()
             if not data:
                 break
             parser.feed(data)
         return parser.close()
         # self._root = parser.close()
         # return self._root
     except:
         pass

 def __init__(self, html=0, target=None, encoding=None,
              forbid_dtd=False, forbid_entities=True,
              forbid_external=True):
     # Python 2.x old style class
     _XMLParser.__init__(self, html, target, encoding)
     self.forbid_dtd = forbid_dtd
     self.forbid_entities = forbid_entities
     self.forbid_external = forbid_external
     parser = self._parser
     if self.forbid_dtd:
         parser.StartDoctypeDeclHandler = self.defused_start_doctype_decl
     if self.forbid_entities:
         parser.EntityDeclHandler = self.defused_entity_decl
         parser.UnparsedEntityDeclHandler = self.defused_unparsed_entity_decl
     if self.forbid_external:
         parser.ExternalEntityRefHandler = self.defused_external_entity_ref_handler

  def parse_reqdata(self, get_data, post_data):
    """
    parse query params and POST data into dictionary

    """
    print 'debuggery: runing parse_reqdata...'
    data_dict = {}
    parser = XMLParser()
    tree = parser.feed(post_data)
    root = parser.close()
    data_dict = XmlDictConfig(root)
    # merge the query_params data
    for k,v in self.parse_getparams(get_data).iteritems():
      data_dict[k] = v
    print 'debuggery: parsed !'
    # return the dictionary data
    return data_dict