def _ft_gen_texbundle_xml(
        b64bytes:bytes,
        entryfile="main.tex",
        worker='xelatex',
        timeout=60) -> str:
    """
    Generate xmlbundle from base64 bytes and given metadata as api_1_0.

    :returns: XML-formatted bundle string
    :rtype: str
    """

    impl = dom.getDOMImplementation()
    doc = impl.createDocument(None, "xmlbundle", None)
    reqNode = doc.createElement('request')
    workerNode = doc.createElement('worker')
    workerNode.appendChild(doc.createTextNode(worker))
    reqNode.appendChild(workerNode)
    timeoutNode = doc.createElement('timeout')
    timeoutNode.appendChild(doc.createTextNode(str(timeout)))
    reqNode.appendChild(timeoutNode)
    entryNode = doc.createElement('entryfile')
    entryNode.appendChild(doc.createTextNode(str(entryfile)))
    reqNode.appendChild(entryNode)
    doc.documentElement.appendChild(reqNode)
    bundleNode = doc.createElement('bundle')
    bundleNode.appendChild(doc.createTextNode(b64bytes.decode('UTF-8')))
    doc.documentElement.appendChild(bundleNode)

    return doc.toxml()

def store_params(*args):
    channels = {}
    for p in args:
        for ch in p.ch:
            if ch not in channels:
                channels[ch] = p
            else:
                raise AssertionError( "Duplicate channel {0} in parameter {1}. Already defined in {2} param.".format(ch, p.name, channells[ch].name) )
    
    impl = xml.getDOMImplementation()
    doc = impl.createDocument(None, None, None)
    root = doc.appendChild(doc.createElement("pydiag-test"))
    root.setAttribute("version", "0.1")
    info_node = root.appendChild(doc.createElement("info"))
    chgroups_node = info_node.appendChild(doc.createElement("chgroup"))
    
    max_len = max( [len(p) for p in args] )
    for p in args:
        p.expand(max_len)
    
    ch_list_sorted = sorted([key for key in channels], key = lambda i: i)
    root.setAttribute("channels", ",".join( [str(i) for i in ch_list_sorted]))


    for p in args:
        group_node = chgroups_node.appendChild(doc.createElement("group"))
        group_node.setAttribute("name", str(p.name))
        # @type p param
        group_node.setAttribute("channels", ",".join( [str(i) for i in p.ch ]))

        #Добавляем комментарии если они есть
        if len( p.comments ) != 0:
                group_comments_node = group_node.appendChild(doc.createElement("comments"))
                for tn in sorted([i for i in p.comments], key = lambda item: item ):
                    comment_node = group_comments_node.appendChild(doc.createElement("comment"))
                    comment_node.setAttribute("tn", str(tn))
                    comment_node.setAttribute("content", p.comments[tn])
                    

    for tn in xrange(max_len):
        tn_node = root.appendChild(doc.createElement("tn"))
        tn_node.setAttribute("number", str(tn))
        
        tn_data = []
        tn_mask = []
        tn_io   = []
        for ch in ch_list_sorted:
            p = channels[ch]
            tn_data.append( str (get_bit(p[tn][0], p.nbit(ch))) )
            tn_mask.append( str( get_bit(p[tn][1].mask, p.nbit(ch))))
            tn_io.append( str(  p[tn][2] ))
        tn_data = "".join(tn_data)
        tn_mask = "".join(tn_mask)
        tn_io = "".join(tn_io)

        tn_node.setAttribute("data", tn_data)
        tn_node.setAttribute("mask", tn_mask)
        tn_node.setAttribute("io", tn_io)

    print doc.toprettyxml()

    def get_records(self, url):
        """
        Returns the records listed in the webpage given as
        parameter as a xml String.

        @param url: the url of the Journal, Book, Protocol or Reference work
        """
        page = urllib2.urlopen(url)
        pages = [BeautifulSoup(page)]
        #content spread over several pages?
        numpag = pages[0].body.findAll('span', attrs={'class': 'number-of-pages'})
        if len(numpag) > 0:
            if re.search('^\d+$', numpag[0].string):
                for i in range(int(numpag[0].string)-1):
                    page = urllib2.urlopen('%s/page/%i' % (url, i+2))
                    pages.append(BeautifulSoup(page))
            else:
                print("number of pages %s not an integer" % (numpag[0].string))
        impl = getDOMImplementation()
        doc = impl.createDocument(None, "collection", None)
        links = []
        for page in pages:
            links += page.body.findAll('p', attrs={'class': 'title'})
            links += page.body.findAll('h3', attrs={'class': 'title'})
        for link in links:
            record = self._get_record(link)
            doc.firstChild.appendChild(record)
        return doc.toprettyxml()

    def __init__(self, title, description, link,
            copyright=None,
            email=None,
            pub_date=None,
            rss_link=None):
        self.document = getDOMImplementation().createDocument(None, "rss", None)
        rss = self.document.documentElement
        rss.setAttribute("version", "2.0")
        rss.setAttribute("xmlns:atom", "http://www.w3.org/2005/Atom")
        channel = self.document.createElement("channel")

        elem = self.document.createElement("title")
        elem.appendChild(self.document.createTextNode(title))
        channel.appendChild(elem)

        elem = self.document.createElement("description")
        elem.appendChild(self.document.createTextNode(description))
        channel.appendChild(elem)
        
        elem = self.document.createElement("link")
        elem.appendChild(self.document.createTextNode(link))
        channel.appendChild(elem)
        
        elem = self.document.createElement("docs")
        elem.appendChild(self.document.createTextNode("http://www.rssboard.org/rss-specification"))
        channel.appendChild(elem)
        
        elem = self.document.createElement("generator")
        elem.appendChild(self.document.createTextNode("Mr. Fusion"))
        channel.appendChild(elem)
        
        elem = self.document.createElement("lastBuildDate")
        elem.appendChild(self.document.createTextNode(formatdate()))
        channel.appendChild(elem)
        
        if copyright is not None:
            elem = self.document.createElement("copyright")
            elem.appendChild(self.document.createTextNode(copyright))
            channel.appendChild(elem)
        
        if email is not None:
            elem = self.document.createElement("managingEditor")
            elem.appendChild(self.document.createTextNode(email))
            channel.appendChild(elem)
            elem = self.document.createElement("webMaster")
            elem.appendChild(self.document.createTextNode(email))
            channel.appendChild(elem)
        
        if pub_date is not None:
            elem = self.document.createElement("pubDate")
            elem.appendChild(self.document.createTextNode(format_rfc822_date(pub_date)))
            channel.appendChild(elem)
        
        if rss_link is not None:
            elem = self.document.createElementNS("http://www.w3.org/2005/Atom", "atom:link")
            elem.setAttribute("rel", "self")
            elem.setAttribute("href", rss_link)
            channel.appendChild(elem)
        
        rss.appendChild(channel)

  def _createHadoopSiteXml(self):
    if self.restart:
      if not os.path.exists(self.confdir):
        os.makedirs(self.confdir)
    else:
      assert os.path.exists(self.confdir) == False
      os.makedirs(self.confdir)

    implementation = getDOMImplementation()
    doc = implementation.createDocument('', 'configuration', None)
    comment = doc.createComment("This is an auto generated hadoop-site.xml, do not modify")
    topElement = doc.documentElement
    topElement.appendChild(comment)
    
    finalAttr = self.desc.getfinalAttrs()
    self.createXML(doc, finalAttr, topElement, True)
    attr = {}
    attr1 = self.desc.getAttrs()
    for k,v in attr1.iteritems():
      if not finalAttr.has_key(k):
        attr[k] = v
    self.createXML(doc, attr, topElement, False)
              
    
    siteName = os.path.join(self.confdir, "hadoop-site.xml")
    sitefile = file(siteName, 'w')
    print >> sitefile, topElement.toxml()
    sitefile.close()
    self.log.debug('created %s' % (siteName))

    def create_xml_document(self, root_element_name):

        '''Create a new XML document with a child element object having the given
        root_element_name.
        '''

        return getDOMImplementation().createDocument(None, root_element_name, None)

    def xmlIfExtCloneTree (self, rootElementCopy):
        domImpl = getDOMImplementation()
#        documentCopy = domImpl.createDocument(rootElementCopy.xmlIfExtGetNamespaceURI(), rootElementCopy.xmlIfExtGetTagName(), None)
        documentCopy = domImpl.createDocument(None, None, None)
#        documentCopy = copy.copy(self.document)
        documentCopy.documentElement = rootElementCopy.element
        return self.__class__(documentCopy)

 def end(self):
     from xml.dom import getDOMImplementation
     impl = getDOMImplementation()
     doc = impl.createDocument(None, "messages", None)
     el_messages = doc.documentElement
     for message in self.messages:
         el_messages.appendChild(self.message_factory.create(doc, message))
     self.output.write(doc.toprettyxml(encoding = self.encoding))

def getRecordsForKeywords(n, keywordFile):
        impl = getDOMImplementation()
        doc = impl.createDocument(None, "root", None) 
        keywords = open(keywordFile)
        for keyword in keywords:
                print "Querying for " + str(n)+ " records using keyword: " + keyword
                dom = run(n, keyword)
                for record in dom.getElementsByTagNameNS(SRW, 'record'):
                        doc.firstChild.appendChild(record)
        print "Done"
        #print doc.toxml('utf-8')
        return doc.toxml('utf-8')

def convert_textgraph_to_xml(textgraph):
    impl = getDOMImplementation()
    newdoc = impl.createDocument(None, "root", None)
    root = newdoc.documentElement
    latest = root
    annotations_to_add = deque(textgraph.annotations_sorted)
    for counter, text_token in enumerate(textgraph.text_tokens):
        print(counter, text_token)
        if annotations_to_add[0].range_start == counter:
            print(annotations_to_add.popleft())
    return newdoc
    pass

    def __init__(self, svn_path, repos_path, item_url, feed_file, max_items, feed_url):
        Svn2Feed.__init__(self, svn_path, repos_path, item_url, feed_file, max_items, feed_url)
        from xml.dom import getDOMImplementation

        self.dom_impl = getDOMImplementation()

        self.pickle_file = self.feed_file + ".pickle"
        if os.path.exists(self.pickle_file):
            self.document = pickle.load(open(self.pickle_file, "r"))
            self.feed = self.document.getElementsByTagName("feed")[0]
        else:
            self._init_atom_document()

    def __init__(self, size=(300,300)):
        self.verbose = 0
        self.width, self.height = self.size = size
        # self.height = size[1]
        self.code = []
        self.style = {}
        self.path = ''
        self._strokeColor = self._fillColor = self._lineWidth = \
            self._font = self._fontSize = self._lineCap = \
            self._lineJoin = self._color = None

        implementation = getDOMImplementation('minidom')
        self.doc = implementation.createDocument(None, "svg", None)
        self.svg = self.doc.documentElement
        self.svg.setAttribute("width", str(size[0]))
        self.svg.setAttribute("height", str(self.height))

        #these suggested by Tim Roberts
        self.svg.setAttribute("xmlns", "http://www.w3.org/2000/svg")
        self.svg.setAttribute("xmlns:link", "http://www.w3.org/1999/xlink")
        self.svg.setAttribute("version", "1.0")
        self.svg.setAttribute("baseProfile", "full")

        title = self.doc.createElement('title')
        text = self.doc.createTextNode('...')
        title.appendChild(text)
        self.svg.appendChild(title)

        desc = self.doc.createElement('desc')
        text = self.doc.createTextNode('...')
        desc.appendChild(text)
        self.svg.appendChild(desc)

        self.setFont(STATE_DEFAULTS['fontName'], STATE_DEFAULTS['fontSize'])
        self.setStrokeColor(STATE_DEFAULTS['strokeColor'])
        self.setLineCap(2)
        self.setLineJoin(0)
        self.setLineWidth(1)

        # Add a rectangular clipping path identical to view area.
        clipPath = transformNode(self.doc, "clipPath", id="clip")
        clipRect = transformNode(self.doc, "rect", x=0, y=0,
            width=self.width, height=self.height)
        clipPath.appendChild(clipRect)
        self.svg.appendChild(clipPath)

        self.groupTree = transformNode(self.doc, "g",
            id="group",
            transform="scale(1,-1) translate(0,-%d)" % self.height,
            style="clip-path: url(#clip)")
        self.svg.appendChild(self.groupTree)
        self.currGroup = self.groupTree

	def createXMLFile(self,tag,list_options):
		impl = getDOMImplementation()
		self.xmldoc = impl.createDocument(None, tag, None)
		top_element = self.xmldoc.documentElement
		#top_element.appendChild(text)
		for option in list_options:
			var = option[0]
			value = option[1]
			attr = self.xmldoc.createAttribute(var)
			top_element.setAttributeNode(attr)
			top_element.attributes[var]._set_value(value)
		xmlcontent = self.xmldoc.toprettyxml()
		self._saveFile(xmlcontent)	

def purgeBatchForOneDomainToXml(purgeBatch):
    doc = dom.getDOMImplementation().createDocument('', 'purge-paths', '')
    purgeRootNode = util.getChildNode(doc, 'purge-paths')
    util.addElement(doc, purgeRootNode, 'version', "1.0.0")
    urls = purgeBatch.urls
    if urls is not None and len(urls) > 0 :
        for url in urls:
            util.addElement(doc, purgeRootNode, 'file-path', url)
    dirs = purgeBatch.dirs
    if dirs is not None and len(dirs) > 0:
        for dirItem in dirs:
            util.addElement(doc, purgeRootNode, "dir-path", dirItem)
    return doc.toprettyxml(indent = "", newl="", encoding = 'utf-8')

def prefetchToXml(purgeBatch):
    ''' PurgeBatch 对象 转换成 用来预缓存的xml '''
    doc = dom.getDOMImplementation().createDocument('', 'prefetch-urls', '')
    purgeRootNode = util.getChildNode(doc, 'prefetch-urls')
    util.addElement(doc, purgeRootNode, 'version', "1.0.0")
    urls = purgeBatch.urls
    if urls is not None and len(urls) > 0:
        for url in urls:
            util.addElement(doc, purgeRootNode, 'prefetch-url', url)
    dirs = purgeBatch.dirs
    if dirs is not None and len(dirs) > 0:
        for dirItem in dirs:
            util.addElement(doc, purgeRootNode, "prefetch-url", dirItem)
    return doc.toprettyxml(indent = "", newl="", encoding = 'utf-8')

def createJUnitRptTemplate():
    try:
        #Create a new xml document
        impl = dom.getDOMImplementation()
        doc = impl.createDocument(None, 'testsuite', None)
        root = doc.documentElement
        #Append attributes to root element
        ts_attributes = {'name':'', 'skips':'0', 'failures':'0', 'errors':'0', 'tests':'0', 'time':'0.0'}
        for (k,v) in ts_attributes.items():
            attr = doc.createAttribute(k)
            attr.value = v
            root.setAttributeNode(attr)
        return doc
    except Exception, ex:
        raise ex

    def __init__(self, size=(300, 300)):
        self.verbose = 0
        self.width, self.height = self.size = size
        # self.height = size[1]
        self.code = []
        self.style = {}
        self.path = ""
        self._strokeColor = (
            self._fillColor
        ) = self._lineWidth = self._font = self._fontSize = self._lineCap = self._lineJoin = self._color = None

        implementation = getDOMImplementation("minidom")
        self.doc = implementation.createDocument(None, "svg", None)
        self.svg = self.doc.documentElement
        self.svg.setAttribute("width", str(size[0]))
        self.svg.setAttribute("height", str(self.height))

        title = self.doc.createElement("title")
        text = self.doc.createTextNode("...")
        title.appendChild(text)
        self.svg.appendChild(title)

        desc = self.doc.createElement("desc")
        text = self.doc.createTextNode("...")
        desc.appendChild(text)
        self.svg.appendChild(desc)

        self.setFont(STATE_DEFAULTS["fontName"], STATE_DEFAULTS["fontSize"])
        self.setStrokeColor(STATE_DEFAULTS["strokeColor"])
        self.setLineCap(2)
        self.setLineJoin(0)
        self.setLineWidth(1)

        # Add a rectangular clipping path identical to view area.
        clipPath = transformNode(self.doc, "clipPath", id="clip")
        clipRect = transformNode(self.doc, "rect", x=0, y=0, width=self.width, height=self.height)
        clipPath.appendChild(clipRect)
        self.svg.appendChild(clipPath)

        self.groupTree = transformNode(
            self.doc,
            "g",
            id="group",
            transform="scale(1,-1) translate(0,-%d)" % self.height,
            style="clip-path: url(#clip)",
        )
        self.svg.appendChild(self.groupTree)
        self.currGroup = self.groupTree

	def __init__(self,BasePath=".",Name="Unnamed",Version="Unknown",Type="XMLVolume",Mode='database'):
		
		self.SourceMatrix = dom.getDOMImplementation()
		self.DocType = self.SourceMatrix.createDocumentType('volume','http://localhost/xmlvolume.dtd','xmlvolume.dtd')
		self.Document = self.SourceMatrix.createDocument("xmlvolume.dtd/volume","volume",self.DocType)
		
		self.Name = Name
		self.Document.documentElement.setAttribute("name",self.Name)
		
		self.Version = Version
		self.Document.documentElement.setAttribute("version",self.Version)
		
		self.BasePath = BasePath
		self.Type = Type
		self.Mode = Mode
		self.Trunk=None

    def get_records(self, url):
        """
        Returns the records listed in the webpage given as
        parameter as a xml String.

        @param url: the url of the Journal, Book, Protocol or Reference work
        """
        page = urllib2.urlopen(url)
        page = BeautifulSoup(page)
        links = page.body.findAll('p', attrs={'class': 'title'})
        links += page.body.findAll('h3', attrs={'class': 'title'})
        impl = getDOMImplementation()
        doc = impl.createDocument(None, "collection", None)
        for link in links:
            record = self._get_record(link)
            doc.firstChild.appendChild(record)
        return doc.toprettyxml()

def initDoc(namespace):
    impl = getDOMImplementation()
    doc = impl.createDocument(namespace, "registryObjects", None)

    appendAttribute(doc, doc.documentElement, namespace, "xmlns", "http://ands.org.au/standards/rif-cs/registryObjects")
    appendAttribute(
        doc,
        doc.documentElement,
        namespace,
        "xsi:schemaLocation",
        "http://ands.org.au/standards/rif-cs/registryObjects http://services.ands.org.au/documentation/rifcs/schema/registryObjects.xsd",
    )
    appendAttribute(doc, doc.documentElement, namespace, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
    appendAttribute(
        doc, doc.documentElement, namespace, "xmlns:rif", "http://ands.org.au/standards/rif-cs/registryObjects"
    )
    return doc