lexonomy_custom_editor/src/export.py

from browser import document
from model.tags import export_tag


def export_to_xml(model):
    xml_document = export_entry(model.entry)
    serializer = __new__(XMLSerializer())
    return serializer.serializeToString(xml_document);


def export_entry(entry):
    parser = __new__(DOMParser())
    doc = parser.parseFromString("<entry />", "text/xml")

    entry_xml = doc.firstChild

    # create head
    head = doc.createElement("head")
    entry_xml.appendChild(head)

    status = doc.createElement("status")
    status.textContent = entry.status
    head.appendChild(status)
    
    headword = doc.createElement("headword")
    headword_lemma = doc.createElement("lemma")
    headword_lemma.textContent = entry.headword
    headword.appendChild(headword_lemma)
    head.appendChild(headword)
    
    # if({}) works uncorrectly in transcrypt
    if len(entry.lexical_unit) > 0:
        lexunit = doc.createElement("lexicalUnit")
        lexunit.setAttribute("id", entry.lexical_unit["id"])
        lexunit.setAttribute("type", "single")
        lexeme = doc.createElement("lexeme")
        lexeme.setAttribute("lexical_unit_lexeme_id", entry.lexical_unit["id"])
        lexeme.textContent = entry.lexical_unit["text"]
        
        lexunit.appendChild(lexeme)
        head.appendChild(lexunit)
        
    grammar = doc.createElement("grammar")
    grammar_category = doc.createElement("category")
    grammar_category.textContent = entry.grammar
    grammar.appendChild(grammar_category)
    head.appendChild(grammar)
    
    if len(entry.measure) > 0:
        measure_list = doc.createElement("measureList")
        measure = doc.createElement("measure")
        measure.setAttribute("source", entry.measure["source"])
        measure.setAttribute("type", entry.measure["type"])
        measure.textContent = entry.measure["text"]
        
        measure_list.appendChild(measure)
        head.appendChild(measure_list)
     
    variants = doc.createElement("variantList")
    head.appendChild(variants)
    
    for v in entry.variants:
        variant = doc.createElement("variant")
        variant.textContent = v
        variants.appendChild(variant)
        
    relist = doc.createElement("relatedEntryList")
    head.appendChild(relist)
    
    for re in entry.related_entries:
        relateEntry = doc.createElement("relatedEntry")
        relateEntry.textContent = re
        relist.appendChild(relateEntry)
    
    head.appendChild(_export_label_list(doc, entry.labels))
    
    comment = doc.createElement("comment")
    comment.textContent = entry.comment
    head.appendChild(comment)
        
    # now lets do body
    body = doc.createElement("body")
    entry_xml.appendChild(body)
    
    sense_list = doc.createElement("senseList")
    body.appendChild(sense_list)
    
    for sense in entry.senses:
        sense_list.appendChild(export_sense(doc, sense))
        
    return doc
    

def export_sense(doc, sense):
    sense_xml = doc.createElement("sense")
    sense_xml.appendChild(_export_label_list(doc, sense.labels))
    
    definition_list = doc.createElement("definitionList")
    sense_xml.appendChild(definition_list)
    
    for typ, text in sense.definition.items():
        definition = doc.createElement("definition")
        definition.textContent = text
        definition.setAttribute("type", typ)
        definition_list.appendChild(definition)
    
    translation_container_list = doc.createElement("translationContainerList")
    export_translation_list(doc, sense, translation_container_list)
    sense_xml.appendChild(translation_container_list)
    
    example_container_list = doc.createElement("exampleContainerList")
    sense_xml.appendChild(example_container_list)
    
    for example in sense.examples:
        example_container = example.export(doc)
        export_translation_list(doc, example, example_container)
        example_container_list.appendChild(example_container)
        
    return sense_xml

def export_translation_list(doc, py_parent, xml_parent):
    for cidx, cluster in enumerate(py_parent.translations):
        for translation in cluster:
            translation_container = export_translation(doc, translation)
            translation_container.setAttribute("cluster", str(cidx + 1))
            xml_parent.appendChild(translation_container)
    

def export_translation(doc, translation):
    translation_xml = doc.createElement("translationContainer")
    
    actual_t = doc.createElement("translation")
    actual_t.textContent = translation.translation
    actual_t.setAttribute("targetLang", translation.targetLang)
    
    if translation.source:
        actual_t.setAttribute("source", translation.source)
    translation_xml.appendChild(actual_t)
    
    explanation = doc.createElement("explanation")
    explanation.textContent = translation.explanation
    translation_xml.appendChild(explanation)
    
    translation_xml.appendChild(_export_label_list(doc, translation.tags))
    return translation_xml
    

def _export_label_list(doc, lst):
    result = doc.createElement("labelList")
    for key, value in lst:
        key, value = export_tag(key, value)
        
        label_el = doc.createElement("label")
        label_el.textContent = value
        label_el.setAttribute('type', key)
        result.appendChild(label_el)
    return result