def __init__(self, filename, shortXMLfilename):
		self.filename = filename
		self.shortXMLfilename = shortXMLfilename
		
		try:
			self.tableFile = parse(filename)
		except:
			impl = getDOMImplementation()
			self.tableFile = impl.createDocument(None, "table", None)
			self.tableFile.getElementsByTagName("table")[0].setAttribute("class", "sortable")
			self.tableFile.getElementsByTagName("table")[0].setAttribute("id", "xeplist")
			self.tableFile.getElementsByTagName("table")[0].setAttribute("cellspacing", "0")
			self.tableFile.getElementsByTagName("table")[0].setAttribute("cellpadding", "3")
			self.tableFile.getElementsByTagName("table")[0].setAttribute("border", "1")
			
			header = parseString(
'''<tr class='xepheader'>
	<th align='left'>Number</th>
	<th align='left'>Name</th>
	<th align='left'>Type</th>
	<th align='left'>Status</th>
	<th align='left'>Date</th>
</tr>''')
			self.tableFile.getElementsByTagName("table")[0].appendChild(header.getElementsByTagName("tr")[0])
		
		try:
			self.botsFile = parse(shortXMLfilename)
		except:
			impl = getDOMImplementation()
			self.botsFile = impl.createDocument(None, "xeps", None)

def test_create_sliver(server, slice_urn, slice_credential, dom, api_version=2):
    if api_version < 3:
        print "Testing CreateSliver...",
    else:
        print "Testing Allocate...",
    options = None
    if api_version >= 2:
        options = dict()
        # FIXME: Build up a request_rspec for real
        nodes = dom.getElementsByTagName("node")
        dom_impl = minidom.getDOMImplementation()
        request_rspec = dom_impl.createDocument("http://www.geni.net/resources/rspec/3", "rspec", None)
        top = request_rspec.documentElement
        top.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
        top.setAttribute(
            "xsi:schemaLocation",
            "http://www.geni.net/resources/rspec/3 http://www.geni.net/resources/rspec/3/request.xsd",
        )
        top.setAttribute("xmlns", "http://www.geni.net/resources/rspec/3")
        top.setAttribute("type", "request")
        if nodes.length == 0:
            print "failed: no nodes available"
            return
        elif nodes.length == 1:
            top.appendChild(nodes.item(0).cloneNode(True))
        else:
            # pick two at random
            indices = range(nodes.length)
            for _ in range(2):
                index = random.choice(indices)
                indices.remove(index)
                top.appendChild(nodes.item(index).cloneNode(True))
    else:
        resources = dom.getElementsByTagName("resource")
        dom_impl = minidom.getDOMImplementation()
        request_rspec = dom_impl.createDocument(None, "rspec", None)
        top = request_rspec.documentElement
        if resources.length == 0:
            print "failed: no resources available"
            return
        elif resources.length == 1:
            top.appendChild(resources.item(0).cloneNode(True))
        else:
            # pick two at random
            indices = range(resources.length)
            for _ in range(2):
                index = random.choice(indices)
                indices.remove(index)
                top.appendChild(resources.item(index).cloneNode(True))
    users = [{"key": ""}]
    if options is not None:
        try:
            if api_version < 3:
                result = server.CreateSliver(slice_urn, slice_credential, request_rspec.toxml(), users, options)
            else:
                result = server.Allocate(slice_urn, slice_credential, request_rspec.toxml(), options)
        except Exception, e:
            print "failed: %s" % e
            return

 def __init__(self, document=None, node=None, root=None):
     self.document = document
     if self.document is None and node is not None:
         impl = minidom.getDOMImplementation()
         self.resource = impl.createDocument(None, None, None)
         self.resource.appendChild(node)
     elif self.document is None:
         impl = minidom.getDOMImplementation()
         self.resource = impl.createDocument(None, root, None)

 def Load(self,file,type):
     if os.path.exists(file):
         source=open(file)
         try:
             dom1=minidom.parse(source)
         except:
             impl=minidom.getDOMImplementation()
             dom1=impl.createDocument(None,type,None)
         return dom1
     else:
         impl=minidom.getDOMImplementation()
         doc=impl.createDocument(None, type,None)
         return doc

 def request_frame_document(self, message):
     frame = self.message_frame_dict[message]  
     doc = getDOMImplementation().createDocument(None, "stack", None)
     top_element = doc.documentElement
     if frame:
         self.addFrame(frame, top_element, doc, includeContent=True)
     return xmlrpclib.Binary(bz2.compress(doc.toxml()))

	def to_xml(self):
		"""
		Turn this into an XML
		document
		"""
		impl = getDOMImplementation()
		doc = impl.createDocument(None, 'Exception', None)

		rootNode = doc.documentElement

		type_node = doc.createElement("type")
		text_node = doc.createTextNode(self.__class__.__name__)
		type_node.appendChild(text_node)
		rootNode.appendChild(type_node)

		type_node = doc.createElement("code")
		text_node = doc.createTextNode(str(self.code))
		type_node.appendChild(text_node)
		rootNode.appendChild(type_node)

		type_node = doc.createElement("message")
		text_node = doc.createTextNode(self.message)
		type_node.appendChild(text_node)
		rootNode.appendChild(type_node)

		type_node = doc.createElement("description")
		text_node = doc.createTextNode(self.description)
		type_node.appendChild(text_node)
		rootNode.appendChild(type_node)

		return doc

	def generate(self, fileName):
		# Once all records have been calculated, create the XML structure itself
		self.document = getDOMImplementation().createDocument(None, 'data', None)
		topNode = self.document.documentElement
		for record in self.data['records']:
			recordNode = self.document.createElement('record')
			topNode.appendChild( recordNode )
			for field, value in record.iteritems():
				fieldNode = self.document.createElement( field )
				recordNode.appendChild( fieldNode )
				# The rest of field types must be converted into str
				if value == False:
					value = ''
				elif isinstance(value, str):
					value = unicode(value, 'utf-8')
				elif not isinstance(value, unicode):
					value = unicode(value)
				valueNode = self.document.createTextNode( value )
				fieldNode.appendChild( valueNode )
		# Once created, the only missing step is to store the XML into a file
		f = codecs.open( fileName, 'wb+', 'utf-8' )
		try:
			topNode.writexml( f )
		finally:
			f.close()

    def __init__(self):
        impl = getDOMImplementation()
        self.doc = impl.createDocument(None, 'urlset', None)

        self.urlset = self.doc.documentElement
        self.urlset.setAttribute('xmlns',
                                 'http://www.sitemaps.org/schemas/sitemap/0.9')

 def metadata(self, request, model_name=None):
     impl = minidom.getDOMImplementation()
     doc = None
     try:
         if model_name:
             model_handler = self.get_model_handler(model_name)
             if(not model_handler):
                 return None
             self.check_authority(request, OP_LIST, obj=None,
                                  model_name=model_name, prop_name=None)
             doc = impl.createDocument(XSD_NS, XSD_SCHEMA_NAME, None)
             doc.documentElement.attributes[XSD_ATTR_XMLNS] = XSD_NS
             model_handler.write_xsd_metadata(doc.documentElement,
                                              model_name)
         else:
             self.check_authority(request, OP_LIST, obj=None,
                                  model_name=None, prop_name=None)
             doc = impl.createDocument(None, TYPES_EL_NAME, None)
             types_el = doc.documentElement
             for model_name in self.model_handlers.iterkeys():
                 append_child(types_el, TYPE_EL_NAME, model_name)
         output = self.doc_to_output(request, doc)
     finally:
         if doc:
             doc.unlink()
     return self.out_to_response(output)

  def Generate(self):
    """Creates font a DOM with data for every table.

    Uses |table_data_generators| to plug in XML generators.

    Returns:
      A DOM ready for serialization.
    """
    doc = minidom.getDOMImplementation().createDocument(None,
                                                        'font_test_data', None)
    root_element = doc.documentElement
    # We need to set the path of the font as if in the root source directory
    # The assumption is that we have a '../' prefix
    root_element.setAttribute('path', self.font_path[3:])
    h = hashlib.new('sha1')
    h.update(open(self.font_path, 'r').read())
    root_element.setAttribute('sha1', h.hexdigest())
    font = ttLib.TTFont(self.font_path)
    # There is always a postscript name for Windows_BMP
    name_record = font['name'].getName(6, 3, 1)
    root_element.setAttribute('post_name',
                              self.Unpack(name_record.string))
    for (name, table_data_generator) in self.table_data_generators:
      name += '_table'
      table_element = doc.createElement(name)
      root_element.appendChild(table_element)
      table_data_generator.Generate(font, doc, table_element)
    return doc

    def makeRequest(self, params):
        """Create and serialise SOAP envelope from a DOM document"""
        global NS
        impl = minidom.getDOMImplementation()
        self.requestDoc = impl.createDocument(self.targetNs, "soap:Envelope", None)
        setDocAttr = self.requestDoc.documentElement.setAttribute
        
        setDocAttr("xmlns:soap", NS["soap"])

        for name, value in self.requestNamespaces.iteritems():
            setDocAttr("xmlns:" + name, value)

        setDocAttr("xmlns", self.targetNs)

        # create header
        if len(self._headers):
            header = self.requestDoc.createElementNS(NS["soap"], "soap:Header")
            self.addLiteral(self.requestDoc, header, self._headers)
            self.requestDoc.documentElement.appendChild(header)

        # and body
        body = self.requestDoc.createElementNS(NS["soap"], "soap:Body")
        self.requestDoc.documentElement.appendChild(body)
        
        operation = self.requestDoc.createElement(self.name)
        if type(params) == dict:
            self.addLiteral(self.requestDoc, operation, params)
        body.appendChild(operation)
    
        return self.requestDoc.toxml()

def DoTrackX(rgm, args):
  if len(args) != 1:
    return DoHelp(rgm, args)

  info = rgm.GetInfo()
  _, _, _, _, _, _, _, tracks, _ = info

  range_iter = ParseRange(args[0], 0, tracks-1)
  if not range_iter:
    return DoHelp(rgm, args)

  gpxdoc = minidom.getDOMImplementation().createDocument(
      'http://www.topografix.com/GPX/1/1', 'gpx', None)
  e_gpx = gpxdoc.documentElement
  e_gpx.setAttribute('version', '1.1')
  e_gpx.setAttribute('creator', 'rgm3800py')

  e_trk = gpxdoc.createElement('trk')
  e_gpx.appendChild(e_trk)

  for i in range_iter:
    e_trkseg = gpxdoc.createElement('trkseg')
    e_trk.appendChild(e_trkseg)

    waypoints = rgm.GetWaypoints(i)
    for wp in waypoints:
      e_trkseg.appendChild(wp.GetGPXTrackPT(gpxdoc))

  print gpxdoc.toxml()
  return 0

    def save(self):
        """
        _save_

        Serialise this to XML compatible with PhEDEx injection

        """
        impl = getDOMImplementation()

        doc = impl.createDocument(None, "block", None)
        result = doc.createElement("block")
        result.setAttribute('name', self.fileblockName)
        result.setAttribute('is-open', self.isOpen)
        for lfn, checksums, size in self:
            # checksums is a comma separated list of key:value pair
            formattedChecksums = ",".join(["%s:%s" % (x.lower(), y) for x, y \
                                           in checksums.items() \
                                           if y not in (None, '')])
            ifile = doc.createElement("file")
            ifile.setAttribute('name', lfn)
            ifile.setAttribute('checksum', formattedChecksums)
            ifile.setAttribute('bytes', str(size))
            result.appendChild(ifile)

        return result

    def __init__(self, samplerate, nframes, wavpath):
        """Init a sonic visualiser environment structure based on
        the attributes of the main audio file
        
        Args:
          samplerate(int): media sample rate (Hz)
          nframes(int): number of samples
          wavpath(str): Full path to the wav file used in the current environment

        """
        imp = minidom.getDOMImplementation()
        dt = imp.createDocumentType('sonic-visualiser', None, None)
        self.doc = doc = imp.createDocument(None,'sv', dt)
        root = doc.documentElement
        self.__dname = dict()

        self.data = root.appendChild(doc.createElement('data'))
        self.display = root.appendChild(doc.createElement('display'))
        window = self.display.appendChild(doc.createElement('window'))
        self.defwidth = 900
        window.setAttribute('width', str(self.defwidth))
        window.setAttribute('height', str(856))
        self.selections = root.appendChild(doc.createElement('selections'))


        self.nbdata = 0

        #self.nchannels = nchannels
        self.samplerate =  samplerate
        self.nframes = nframes

        self.__setMainWaveModel(wavpath)

def xml_document(top):
    # First, make the header
    impl = getDOMImplementation()
    xml = impl.createDocument(None, top, None)
    top = xml.documentElement

    return xml, top

    def __init__(self, cls, db_name, db_user, db_passwd,
                 db_host, db_port, db_table, ddl_dir, enable_ssl):
        self.cls = cls
        if not db_name:
            db_name = cls.__name__.lower()
        self.db_name = db_name
        self.db_user = db_user
        self.db_passwd = db_passwd
        self.db_host = db_host
        self.db_port = db_port
        self.db_table = db_table
        self.ddl_dir = ddl_dir
        self.s3 = None
        self.converter = XMLConverter(self)
        self.impl = getDOMImplementation()
        self.doc = self.impl.createDocument(None, 'objects', None)

        self.connection = None
        self.enable_ssl = enable_ssl
        self.auth_header = None
        if self.db_user:
            import base64
            base64string = base64.encodestring('%s:%s' % (self.db_user, self.db_passwd))[:-1]
            authheader =  "Basic %s" % base64string
            self.auth_header = authheader

 def _initEmptyManifest(self):
     self.doc = xml.getDOMImplementation().createDocument(None, 'manifest', None)
     root = self.doc.documentElement
     root.setAttribute('xmlns:android', 'http://schemas.android.com/apk/res/android')
     root.setAttribute('package', 'prj.chameleon.entry')
     applicationDoc = self.doc.createElement('application')
     root.appendChild(applicationDoc)

    def __init__(self, filename=""):
        super(DMPlaylist, self).__init__()
        self.document = parse(filename) if filename \
                        else getDOMImplementation().createDocument(None,
                                                            "DMPlaylist", None)
        self._categories = []
        self._items = []

        for node in self.document.documentElement.childNodes:
            if hasattr(node, "tagName"):
                if node.tagName == TAG_CATEGORY:
                    category = DMPlaylistCategory(self.document,
                                                node.getAttribute("name"))
                    for child in node.childNodes:
                        if hasattr(child, "tagName"):
                            childName = "".join(map(lambda x: x.data.strip(),
                                child.childNodes))
                            item = DMPlaylistItem(self.document,
                                childName,
                                child.getAttribute("source"),
                                child.getAttribute("played"))
                            category._items.append(item)
                    self._categories.append(category)
                elif node.tagName == TAG_ITEM:
                    childName = "".join(map(lambda x: x.data.strip(),
                        node.childNodes))
                    item = DMPlaylistItem(self.document,
                        childName,
                        node.getAttribute("source"),
                        node.getAttribute("played"))
                    self._items.append(item)

 def toDom(self):
     doc = getDOMImplementation().createDocument("http://info.teragrid.org/glue/2009/02/spec_2.0_r02",
                                                 "Entities",None)
     for share in self.data.shares:
         sdoc = ComputingShareTeraGridXml(share).toDom()
         doc.documentElement.appendChild(sdoc.documentElement.firstChild)
     return doc

	def generate(self, fileName):
		self.allRecords = []
		relations = self.report.relations()
		# The following loop generates one entry to allRecords list for each record
		# that will be created. If there are any relations it acts like a
		# LEFT JOIN against the main model/table.
		for record in self.pool.get(self.model).browse(self.cr, self.uid, self.ids, self.context):
			newRecords = self.generateIds( record, relations, '', [ { 'root': record } ] )
			copies = 1
			if self.report.copiesField() and record.__hasattr__(self.report.copiesField()):
				copies = int( record.__getattr__(self.report.copiesField()) )
			for new in newRecords:
				for x in xrange(copies):
					self.allRecords.append( new )

		# Once all records have been calculated, create the XML structure itself
		self.document = getDOMImplementation().createDocument(None, 'data', None)
		topNode = self.document.documentElement
		for records in self.allRecords:
			recordNode = self.document.createElement('record')
			topNode.appendChild( recordNode )
			self.generateXmlRecord( records['root'], records, recordNode, '', self.report.fields() )

		# Once created, the only missing step is to store the XML into a file
		f = codecs.open( fileName, 'wb+', 'utf-8' )
		try:
			topNode.writexml( f )
		finally:
			f.close()