class XmppXmlHandler(object):
    STREAM_TAG='{http://etherx.jabber.org/streams}stream'

    def __init__(self):
        self._stack = 0
        self._builder = TreeBuilder()
        self._results = deque()

    def data(self, data):
        self._builder.data(data)

    def start(self, tag, attrib):
        if tag == self.STREAM_TAG:
            return

        self._builder.start(tag, attrib)
        self._stack += 1

    def end(self, tag):
        self._stack -= 1
        elem = self._builder.end(tag)

        if self._stack == 0:
            self._results.append(elem)

    def get_elem(self):
        """If a top-level XML element has been completed since the last call to
        get_elem, return it; else return None."""
        try:
            return self._results.popleft()
        except IndexError:
            return None

 def test_xsd_sequence_callback(self):
     from xml.etree.ElementTree import TreeBuilder, tostring
     from c2cgeoportal.lib.dbreflection import _xsd_sequence_callback
     from papyrus.xsd import tag
     tb = TreeBuilder()
     with tag(tb, "xsd:sequence") as tb:
         _xsd_sequence_callback(tb, self.cls)
     e = tb.close()
     self.assertEqual(
         tostring(e),
         '<xsd:sequence>'
         '<xsd:element minOccurs="0" name="child1" nillable="true">'
         '<xsd:simpleType>'
         '<xsd:restriction base="xsd:string">'
         '<xsd:enumeration value="foo" />'
         '<xsd:enumeration value="bar" />'
         '</xsd:restriction>'
         '</xsd:simpleType>'
         '</xsd:element>'
         '<xsd:element minOccurs="0" name="child2" nillable="true">'
         '<xsd:simpleType>'
         '<xsd:restriction base="xsd:string">'
         '<xsd:enumeration value="foo" />'
         '<xsd:enumeration value="bar" />'
         '</xsd:restriction>'
         '</xsd:simpleType>'
         '</xsd:element>'
         '</xsd:sequence>')

    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 _get_new_album_body(self, title):
     '''
     Формирует XML-элемент для нового альбома.
     @param title: string
     @return Element
     '''
     builder = TreeBuilder(Element)
     builder.start('entry', {'xmlns': ATOM_NS})
     builder.start('title', {})
     builder.data(title.decode('utf8'))
     builder.end('title')
     builder.end('entry')
     node = builder.close()
     return tostring(node)

def save_xml(data, filename):
    tb = TreeBuilder()
    studyguide = tb.start("studyguide", {})
    
    for dataQuestion in data:
        xmlQuestion = SubElement(studyguide, "question", {})
        xmlQuestion.text = dataQuestion[0]
        for dataAnswer in dataQuestion[1]:
            if dataAnswer == dataQuestion[1][0]:
                xmlAnswer = SubElement(xmlQuestion, "answer", {'correct': "true"})
            else :
                xmlAnswer = SubElement(xmlQuestion, "answer", {'correct':"false"})
            xmlAnswer.text = dataAnswer
            
    #dump(studyguide)
    ElementTree(studyguide).write("xml/" + filename)

 def start(self, tag, attrs):
     elem = TreeBuilder.start(self, tag, attrs)
     for key, value in attrs.items():
         if key == _MELD_ID:
             if value in self.meldids:
                 raise ValueError('Repeated meld id "%s" in source' % value)
             self.meldids[value] = 1
             break
     return elem

def emit(output, title_string, structure):
    "Write an SVG file to output representing structure."
    global builder

    builder = TreeBuilder()

    builder.start("svg", dict(xmlns="http://www.w3.org/2000/svg",
                              width=str(width),
                              height=str(height)))
    
    title(title_string)
    structure.depth(3)
    for key, depth in [(3, 3),
                       (1, 5),
                       (2, 6),
                       (1, 10),
                       (1, 11),
                       (2, 15),
                       (3, 16),
                       (1, 22),
                       (2, 25),
                       (1, 25),
                       ]:
        structure.key(key, depth)

    builder.end("svg")

    ElementTree(builder.close()).write(output,
                                       encoding='utf-8',
                                       xml_declaration=True)
    output.write("\n")

  def __init__(self, filename):
    """ Opens file the parser needs to read from """
    self.filename = filename.replace(".jack", "")
    try:
      inFile = open(filename, 'r')
      self.code = inFile.read()
      inFile.close()
    except IOError:
      print "Unable to open input file."
      exit(-2)
      
    # Setup the Element Tree
    builder = TreeBuilder()
    builder.start("tokens", {})
    builder.data("\n")
    self.etree = ElementTree(builder.end("tokens"))
	 
    # Remove Comments
    self.removeComments()
    
    # Strip
    self.code = str.strip(self.code)
    
    # Set up enum of token types
    self.KEYWORDS = r'(\Aclass\b)|(\Aconstructor\b)|(\Afunction\b)|(\Amethod\b)|(\Afield\b)|(\Astatic\b)|(\Avar\b)|(\Aint\b)|(\Achar\b)|(\Aboolean\b)|(\Avoid\b)|(\Atrue\b)|(\Afalse\b)|(\Anull\b)|(\Athis\b)|(\Alet\b)|(\Ado\b)|(\Aif\b)|(\Aelse\b)|(\Awhile\b)|(\Areturn\b)'
    self.SYMBOLS = '[(\{)|(\})|(\()|(\))|(\[)|(\])|(\.)|(,)|(;)|(\+)|(\-)|(\*)|(\/)|(&)|(|)|(<)|(>)|(=)|(~)]'
    
    # Set up token as blank
    self.token = 'null'
    self.tokenType = 'NULL'

 def message(self):
     builder = TreeBuilder()
     builder.start(self.resource_type, dict())
     self.serialize(builder)
     builder.end(self.resource_type)
     msg = tostring(builder.close())
     return msg

  def __init__(self, filename):
    """ Opens file the parser needs to read from """
    self.filename = filename.replace(".jack", "")
    try:
      inFile = open(filename, 'r')
      self.code = inFile.read()
      inFile.close()
    except IOError:
      print "Unable to open input file."
      exit(-2)
      
    # Setup the Element Tree
    builder = TreeBuilder()
    builder.start("tokens", {})
    builder.data("\n")
    self.etree = ElementTree(builder.end("tokens"))
	 
    # Remove Comments
    self.removeComments()
    
    # Strip
    self.code = str.strip(self.code)
    
    # Set up enum of token types
    self.KEYWORDS = '(class)|(constructor)|(function)|(method)|(field)|(static)|(var)|(int)|(char)|(boolean)|(void)|(true)|(false)|(null)|(this)|(let)|(do)|(if)|(else)|(while)|(return)'
    self.SYMBOLS = '[(\{)|(\})|(\()|(\))|(\[)|(\])|(\.)|(,)|(;)|(\+)|(\-)|(\*)|(\/)|(&)|(|)|(<)|(>)|(=)|(~)]'
    
    # Set up token as blank
    self.token = 'null'
    self.tokenType = 'NULL'

 def compileClass(self):
   """ Compiles a complete class """
   if (self.DEBUG): print "Compiling class"
   
   # Add non-terminal break for the class
   builder = TreeBuilder()
   builder.start("class", {})
   builder.data("\n")
   self.etree = ElementTree(builder.end("class"))
   self.head.append(self.etree.getroot())
   
   # Check for class keyword
   self.validateAndRead("keyword", "class")
   
   # Check for identifier
   self.validateAndRead("identifier")
       
   # Check for { symbol
   self.validateAndRead("symbol", '{')
   
   # Check for Class Vars
   while (self.compileClassVarDec()):
     """ BLANK ON PURPOSE!!! """
       
   # Check for Subroutines
   while (self.compileSubroutine()):
     """ BLANK ON PURPOSE!!! """
     
    
   # Check for } symbol
   self.validateAndRead("symbol", '}')

 def addTerminal(self):
   """ Adds a terminal element to the XML tree """
   builder = TreeBuilder()
   builder.start(self.tag, {})
   builder.data(" %s " % (self.data))
   temp = builder.end(self.tag)
   temp.tail = "\n"
   self.head[-1].append(temp)

class XmppXmlHandler(object):
    STREAM_TAG = "{http://etherx.jabber.org/streams}stream"

    def __init__(self):
        self._stack = 0
        self._builder = TreeBuilder()
        self._results = deque()

    def data(self, data):
        self._builder.data(data)

    def start(self, tag, attrib):
        if tag == self.STREAM_TAG:
            return

        self._builder.start(tag, attrib)
        self._stack += 1

    def end(self, tag):
        self._stack -= 1
        elem = self._builder.end(tag)

        if self._stack == 0:
            self._results.append(elem)

    def get_elem(self):
        """If a top-level XML element has been completed since the last call to
        get_elem, return it; else return None."""
        try:
            elem = self._results.popleft()

            if elem.tag.endswith("failure") or elem.tag.endswith("error"):
                raise Exception("XMPP Error received - %s" % elem.tag)

            return elem

        except IndexError:
            return None

 def addNonTerminal(self, name):
   """ Adds a non-terminal element to the XML tree """
   builder = TreeBuilder()
   builder.start(name, {})
   builder.data("\n")
   temp = builder.end(name)
   temp.tail = "\n"
   self.head[-1].append(temp)
   self.head.append(temp)

 def addElement(self, tag):
   """ Adds the current token to the XML ElementTree """
   e = self.etree.getroot()
   builder = TreeBuilder()
   builder.start(tag, {})
   builder.data(" %s " % (self.token))
   temp = builder.end(tag)
   temp.tail = "\n"
   e.append(temp)
   return self.token

    class _XHTMLParser(parser.HTMLParser):
        # A helper class for parsing XHTML into an xml.etree.ElementTree
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.builder = TreeBuilder(element_factory=Element)

        def handle_starttag(self, tag, attrs):
            self.builder.start(tag, dict(attrs),)

        def handle_endtag(self, tag):
            self.builder.end(tag)

        def handle_data(self, data):
            self.builder.data(data)

def write_xml(f, taxes, _solr=None, rows=0):
    """ Export an XML file for the given taxonomies to the (open) file handle
        specified.
    
        If a SOLR connection is supplied, then include document elements for
        each category.
    
    """
    x = TreeBuilder()
    x.start("taxonomy", {})

    def f_pre(term):
        x.start("category", {"id": str(term.uid)})
        x.start("name", {})
        x.data(term.name)
        x.end("name")
        for clue, positive in term.iter_clues():
            attrs = {}
            if not positive:
                attrs["negative"] = "true"
            x.start("clue", attrs)
            x.data(clue)
            x.end("clue")
        if _solr is not None:
            count, docs = get_docs_for_category(_solr, term, rows=rows)
            x.start("count", {})
            x.data(str(count))
            x.end("count")
            for doc_id, title, score in docs:
                x.start("doc", {"id": doc_id, "score": str(score)})
                x.start("name", {})
                x.data(title)
                x.end("name")
                x.end("doc")

    def f_post(term):
        x.end("category")

    for term in taxes:
        term.walk(f_pre, f_post)

    x.end("taxonomy")

    xml = ElementTree(x.close())
    xml.write(f, xml_declaration=True, encoding="utf-8")

def generate_nic(network):
    builder = TreeBuilder()
    builder.start('interface', {'type': network['type']})
    builder.start('mac', {'address': network['mac']})
    builder.end('mac')
    builder.start('source', network['source'])
    builder.end('source')
    builder.start('model', {'type':'virtio'})
    builder.end('model')
    builder.end('interface')
    return builder.close()

# vim:set sw=4 ts=4 et:
# -*- coding: utf-8 -*-

def generate_disk(disk, devicename):
    """
    Creates XML representation of disk for libvirt based on disk_definition

    disk_definition is something like
            {
                'type': 'network',
                'device': 'disk',
                'format': 'raw',
                'source': {
                    'protocol': 'sheepdog',
                    'name': 'Alice',
                    'hosts': [('127.0.0.1', '7000'),],
                },
            }
     or
             {
                'type': 'file',
                'device': 'disk',
                'format': 'qcow2',
                'source': {
                    'file': '/var/lib/libvirt/images/Alice.img',
                },
            },

    devicename is string representing devicename (eg. vda, vdb, ...)
    """

    builder = TreeBuilder()
    builder.start('disk',
                {'type': disk['type'], 'device': disk['device']})
    builder.start('source', sans(disk['source'], 'hosts'))
    for host in disk['source'].get('hosts', []):
        builder.start('host', {'name': host[0], 'port': host[1]})
        builder.end('host')
    builder.end('source')
    builder.start('target', {'dev': devicename, 'bus': 'virtio'})
    builder.end('target')
    builder.start('driver', {'name': 'qemu', 'cache': 'none', 'type': disk['format']})
    builder.end('driver')
    builder.end('disk')
    return builder.close()

# http:#nikerunning.nike.com/nikeplus/v2/services/app/get_gps_detail.jsp?_plus=true&id=<run-id>&format=json
# 
# Save it to a file that ends in .json, and run this script: ./nike2gpx <filename>.json
# This will create a file <filename>.gpx in GPX format
#

from xml.etree.ElementTree import TreeBuilder, ElementTree
from datetime import datetime
import json
import sys

data = json.load(open(sys.argv[1], "r"))

route = data["plusService"]["route"]

builder = TreeBuilder()

gpxAttrs = {
			"version":				"1.1",
			"creator":				"Nike2GPX",
			"xmlns:xsi":			"http://www.w3.org/2001/XMLSchema-instance",
			"xmlns":				"http://www.topografix.com/GPX/1/1",
			"xsi:schemaLocation":	"http://www.topografix.com/GPX/1/1 http://www.topografix.com/gpx/1/1/gpx.xsd"
}
builder.start("gpx", gpxAttrs)

builder.start("metadata", {})

builder.start("name", {})
builder.data("Run " + sys.argv[1][:-5])
builder.end("name")