def main():
  parser = argparse.ArgumentParser(description='Migrate XML to YAML')
  parser.add_argument('idspace',
      type=str,
      help='the project IDSPACE, e.g. FOO')
  parser.add_argument('xml_file',
      type=argparse.FileType('r'),
      default=sys.stdin,
      nargs='?',
      help='read from the XML file (or STDIN)')
  parser.add_argument('yaml_file',
      type=argparse.FileType('w'),
      default=sys.stdout,
      nargs='?',
      help='write to the YAML file (or STDOUT)')
  args = parser.parse_args()

  args.upper_idspace = args.idspace.upper()
  args.lower_idspace = args.idspace.lower()
  args.base_url = '/obo/' + args.lower_idspace

  sax = xml.sax.make_parser()
  sax.setContentHandler(OCLCHandler(args))
  sax.parse(args.xml_file)

  entries = exact + sorted(prefix, key=lambda k: len(k['id']), reverse=True)
  if len(entries) == 0:
    raise ValueError('No entries to migrate')

  args.yaml_file.write(header_template %
      (args.base_url, args.upper_idspace, args.base_url, args.lower_idspace, args.lower_idspace))
  for entry in entries:
    args.yaml_file.write(entry_template %
        (entry['rule'], entry['id'], entry['url']))

    def _read_xml(self):
        '''Read input as Excel XML. This creates the entire message
        file collection'''
        excelHandler = ExcelHandler()
        sax.parse(self.input, excelHandler)

        self.apps = excelHandler.tables.keys()

        for app in self.apps:
            table = excelHandler.tables[app]
            langs = table[0][2:]        # first row is the languages
            numlang = len(langs)
            for i in xrange(numlang):
                lang = langs[i]

                # Extract language from header line
                if ':' in lang: 
                    lang = lang[lang.index(':')+1:].strip()

                # if language not specified in the XML and only one
                # language requested then use requested language
                # instead
                if (lang == '' or lang == 'new language') and len(self.languages) == 1:
                    lang = self.languages[0]

                if lang in self.languages:
                    mf = MessageFile()
                    self.files.append(mf)
                    mf.app = app
                    mf.lang = lang
                    say(DEBUG, 'i %d app %s lang %s' % (i, app, mf.lang))
                    for row in table[1:]:
                        if len(row) >= 2+numlang:
                            mf.tags[row[1]] = row[2+i]

    def __call__(self, play=False, fav = 1):
        flag = self.plugin.Execute('screamer.exe',self.plugin.ScreamerPath)                        
        if self.plugin.path2:
            self.plugin.Execute('Start_SR_Events.exe',self.plugin.path2)

        if flag:
                if self.plugin.path2:
                    self.plugin.Execute('Start_SR_Events.exe',self.plugin.path2)
                if play:
                    for n in range(50):                
                        sleep(.2)
                        hwnds = Handle()
                        if len(hwnds) > 0:
                            flag = False
                            break
                    if not flag:
                        sleep(2)
                        ScreamerPath = self.plugin.ScreamerPath
                        xmltoparse = ScreamerPath+'\\favorites.xml'
                        self.dh2 = my_xml_handler2()
                        sax.parse(xmltoparse.encode(eg.systemEncoding), self.dh2)
                        if fav <= len(self.plugin.favList):
                            self.plugin.fav_num=fav-1
                            PostMessage(hwnds[0], WM_COMMAND, 9216+fav, 0)
                            return str(fav)+": "+self.plugin.favList[self.plugin.fav_num]
                        else:
                            return self.text.over % (str(fav),\
                                str(len(self.plugin.favList)))
                    else:
                        return self.plugin.text.text1
                else:
                    return self.text.alt_ret                    

def readNet(filename, **others):
    """ load a .net.xml file
    The following named options are supported:

        'net' : initialize data structurs with an existing net object (default Net())
        'withPrograms' : import all traffic light programs (default False)
        'withLatestPrograms' : import only the last program for each traffic light.
                               This is the program that would be active in sumo by default.
                               (default False)
        'withConnections' : import all connections (default True)
        'withFoes' : import right-of-way information (default True)
        'withInternal' : import internal edges and lanes (default False)
    """
    netreader = NetReader(**others)
    try:
        if not os.path.isfile(filename):
            print("Network file '%s' not found" % filename, file=sys.stderr)
            sys.exit(1)
        parse(filename, netreader)
    except None:
        print(
            "Please mind that the network format has changed in 0.13.0, you may need to update your network!",
            file=sys.stderr)
        sys.exit(1)
    return netreader.getNet()

   def do_check(self):
     # check the http code
     code = self.response.getcode()
     if code != 200:
       logging.warning('%s returned %d' % (self.url, code))
       return False 

     # check the mime type     
     mime = self.response.info().type
     if mime != self.conf['mime']:
       logging.warning('Expected mime type: %s, but got %s' % (
          self.conf['mime'], mime))
       return False

     # do some extended checks for XML
     if mime.endswith('xml') and self.conf['root']:
        class Handler(sax.handler.ContentHandler):
          def startElement(self, name, attrs):  
            if not hasattr(self, 'root'):
              self.root = name

        h = Handler()
        sax.parse(self.response, h)
        if h.root != self.conf['root']:
          logging.warning('Expected root element: %s, but got %s' % (
            self.conf['root'], h.root))
          return False

     return True

def main(filename):
    f = open(filename)
    wp = WikiParser()
    sax.parse(f, wp)
    f.close()

    wp.out.close()

def main():
    handler = BioProjectXMLHandler()
    sax.parse(open('/Users/admin/Documents/rnammer_errors_bioprojects.xml', 'rb'), handler)
    bioprojects = handler.results;
    print 'Bioproject_Id\tBioproject\tINSDC/Chromosomes\tINSDC/Plasmids'
    for bioproject in bioprojects:
        print str(bioproject.bioproject_id) + '\t' + str(bioproject.bioproject_accession) + '\t' + str(bioproject.insdc_chromosomes) + '\t' + str(bioproject.insdc_plasmids)

 def __init__(self, xmlfile, drawing):
     # fill drawing's geometry lists
     self.vertices = drawing.vertices # sorted list of vertices
     self.edges = drawing.edges # sorted list of edges
     self.facets = drawing.facets # sorted list of facets
     self.loops = drawing.loops # chains of vertices in order connected
     self.polygons = drawing.polygons
     
     # parse path vertices into loops
     sax.parse(xmlfile, self)
     
     # discard open loops
     self.loops = [loop for loop in self.loops if loop.closed]
     
     # make sure loops run forwards (counterclockwise)
     for loop in self.loops:
         if not loop.is_forward():
             loop._vertices.reverse()
     
     # find loops that are holes in other loops and build polygons
     self._polygons_from_loops()
     
     # generate facets for each polygon
     for polygon in self.polygons:
         self._facets_from_loops(polygon)

def headersParser(headers):
    """
    This function calls a class that parses the input HTTP headers to
    fingerprint the back-end database management system operating system
    and the web application technology
    """

    # It is enough to parse the headers on first four HTTP responses
    if kb.headersCount > 3:
        return

    kb.headersCount += 1

    topHeaders = {
                   "cookie":                          "%s/cookie.xml" % paths.SQLMAP_XML_BANNER_PATH,
                   "microsoftsharepointteamservices": "%s/sharepoint.xml" % paths.SQLMAP_XML_BANNER_PATH,
                   "server":                          "%s/server.xml" % paths.SQLMAP_XML_BANNER_PATH,
                   "servlet-engine":                  "%s/servlet.xml" % paths.SQLMAP_XML_BANNER_PATH,
                   "set-cookie":                      "%s/cookie.xml" % paths.SQLMAP_XML_BANNER_PATH,
                   "x-aspnet-version":                "%s/x-aspnet-version.xml" % paths.SQLMAP_XML_BANNER_PATH,
                   "x-powered-by":                    "%s/x-powered-by.xml" % paths.SQLMAP_XML_BANNER_PATH,
                 }

    for header in headers:
        if header in topHeaders.keys():
            value   = headers[header]
            xmlfile = topHeaders[header]

            checkFile(xmlfile)

            handler = FingerprintHandler(value, kb.headersFp)

            parse(xmlfile, handler)
            parse(paths.GENERIC_XML, handler)

def get_cycles(recipe_xml_filepath):
  """
  returns the number of cycles found in Recipe*.xml
  """
  handler = CycleXmlHandler()
  sax.parse(recipe_xml_filepath, handler)
  return handler.cycle_count

def main(argv=None):
    opts, args = getopt.getopt(sys.argv[1:], "i:o:h", ["in=", "out=", "help"])
    input_file = sys.stdin
    output_file = sys.stdout
    for o, a in opts:
        if o in ("-i", "--in"):
            input_file = open(a, 'r')
        if o in ("-o", "--out"):
            output_file = open(a, 'w')
        if o in ("-h", "--help"):
            usage()
            sys.exit(0)

    # Using the SAX parser as it is at least 4X faster and far, far
    # smaller on this dataset than the DOM-based interface in xml.dom.minidom.
    # With SAX and a 5.4MB xml file, this requires about seven seconds of
    # wall-clock time and 32MB VSZ.  With the DOM interface, about 22 seconds
    # and over 270MB VSZ.

    handler = SimPerfHostXMLParser()
    sax.parse(input_file, handler)
    if input_file != sys.stdin:
        input_file.close()

    # Various format fixups:  string-to-num, gauge-to-counts, add
    # a time stamp, etc.
    simperf_host_xml_fixup(handler)
    
    # Create JSONable dict with interesting data and format/print it
    print >>output_file, simplejson.dumps({ "step" : handler.rrd_step,
                                            "lastupdate": handler.rrd_last_update * 1000,
                                            "ds" : handler.rrd_ds,
                                            "database" : handler.rrd_records })

    return 0

def get_word_paragraphs(xmlfile):
    """Return a list of paragraphs from
       the docx-formatted xml file at xmlfile"""
    class tagHandler(ContentHandler):
        def __init__(self):
            self.paragraphMarker = "w:p"
            self.textMarker = "w:t"
            self.paragraphs = []
            self.string = ""
            self.inText = False
            self.inParagraph = False
        def startElement(self, name, attr):
            if name == self.textMarker:
                self.inText = True
            elif name == self.paragraphMarker:
                self.inParagraph = True
        def endElement(self, name):
            if name == self.textMarker:
                self.inText = False
            elif name == self.paragraphMarker:
                self.inParagraph == False
                self.paragraphs.append(self.string)
                self.string = ""
        def characters(self, ch):
            if self.inText:
                self.string+=ch

    handler = tagHandler()
    parse(xmlfile, handler)
    return handler.paragraphs

    def readDistributionTable(self, table):
        """
        returns a list conataining dictionaries with the distribution data   
        reads from the current file
       
        """
        self._dist_data = {}
        self._dist_list = []

        class XmlReader(ContentHandler):
            def __init__(XmlReader, scrwid=79, *args):
                ContentHandler.__init__(XmlReader, *args)

            def startElement(XmlReader, name, attrs):
                # print "start element",name
                if name == "rule":
                    self._dist_data["ftp_source"] = attrs.get("ftp_source")
                    self._dist_data["remote_dir"] = attrs.get("remote_dir")
                    self._dist_data["target"] = attrs.get("target")
                    self._dist_data["ftp_mode"] = attrs.get("ftp_mode")

            def endElement(XmlReader, name):
                if name == "rule":
                    self._dist_list.append(dict(self._dist_data))
                    self._dist_data.clear()

            def characters(XmlReader, chars):
                pass

        parse(os.path.join(self.project, "setup", table), XmlReader())
        return self._dist_list

def main():
  parser = argparse.ArgumentParser(description='Migrate XML to YAML')
  parser.add_argument('base_url',
      type=str,
      help='the base URL, e.g. /obo/foo')
  parser.add_argument('xml_file',
      type=argparse.FileType('r'),
      default=sys.stdin,
      nargs='?',
      help='read from the XML file (or STDIN)')
  parser.add_argument('yaml_file',
      type=argparse.FileType('w'),
      default=sys.stdout,
      nargs='?',
      help='write to the YAML file (or STDOUT)')
  args = parser.parse_args()

  sax = xml.sax.make_parser()
  sax.setContentHandler(OCLCHandler(args))
  sax.parse(args.xml_file)

  args.yaml_file.write(header_template % (args.base_url, args.base_url))

  entries = exact + sorted(prefix, key=lambda k: len(k['id']), reverse=True)
  for entry in entries:
    args.yaml_file.write(entry_template %
        (entry['rule'], entry['id'], entry['url']))

def loadMap(filename, map=Map()):
	# Parse the file with our custom handler
	loader = MapLoader()
	loader.map = map
	parse(filename, loader)
	
	return loader.map

def parse_file(file):
    global graph
    graph = G.Graph()

    structure_handler = StructureHandler()
    XS.parse(file, structure_handler)

    return graph

    def parse(self, languages, filename):
        """
        Parse XML

        "languages" must be a list
        """
        self._languages = languages
        parse(filename, self)

def main(argv, outfile=None, vias={}, calledBy=""):
    routefile = argv[0]
    attrList = argv[1:]
    if outfile is None:
        parse(routefile, RouteReader(attrList, sys.stdout, vias, calledBy))
    else:
        with open(outfile, 'w') as outf:
            parse(routefile, RouteReader(attrList, outf, vias, calledBy))

def main(argv, outfile=None):
    routefile = argv[0]
    attrList = argv[1:]
    if outfile is None:
        parse(routefile, RouteReader(attrList, sys.stdout))
    else:
        with open(outfile, 'w') as outf:
            parse(routefile, RouteReader(attrList, outf))

 def __init__(self, filename):
     logging.debug("Trying to parse langs.xml")
     self.lh = LangHandler()
     try:
         sax.parse(filename, self.lh)
         logging.info("XML file succesfully parsed")
     except:
         logging.info("Error parsing XML file")