Example #1
0
 def _notify(self, statevars):
     # create the request body
     propset = Element("e:propertyset")
     propset.attrib['xmlns:e'] = "urn:schemas-upnp-org:event-1-0"
     prop = SubElement(propset, "e:property")
     # add each evented statevar to the property set
     for statevar in statevars:
         if statevar.sendEvents:
             SubElement(prop, statevar.name).text = statevar.text_value
         else:
             raise Exception("StateVar '%s' is not evented" % statevar.name)
     postData = xmlprint(propset)
     logger.log_debug("NOTIFY property set:\n" + postData)
     # send the NOTIFY request to each callback
     for url,urlparts in self.callbacks:
         # set the NOTIFY headers
         headers = {
             'Host': urlparts.netloc,
             'Content-Type': MimeType('text', 'xml'),
             'NT': 'upnp:event',
             'NTS': 'upnp:propchange',
             'SID': self.id,
             'SEQ': self.seqid
             }
         #
         creator = protocol.ClientCreator(reactor, HTTPClientProtocol)
         request = ClientRequest("NOTIFY", urlparts.path, headers, postData)
         d = creator.connectTCP(urlparts.hostname, urlparts.port)
         d.addCallback(self._sendNotifyRequest, request)
         logger.log_debug("sending NOTIFY to %s" % url)
     self.seqid = self.seqid + 1
    def process_task(self, target, command, args):

        OUT_FORMAT = '      {0:<35}{1}'.format

        sslConn = create_sslyze_connection(target, self._shared_settings)

        # Make sure OpenSSL was built with support for compression to avoid false negatives
        if 'zlib compression' not in sslConn.get_available_compression_methods():
            raise RuntimeError('OpenSSL was not built with support for zlib / compression. Did you build nassl yourself ?')

        try: # Perform the SSL handshake
            sslConn.connect()
            compName = sslConn.get_current_compression_method()
        except ClientAuthenticationError: # The server asked for a client cert
            compName = sslConn.get_current_compression_method()
        finally:
            sslConn.close()

        # Text output
        if compName:
            compTxt = 'Supported'
        else:
            compTxt = 'Disabled'

        cmdTitle = 'Compression'
        txtOutput = [self.PLUGIN_TITLE_FORMAT(cmdTitle)]
        txtOutput.append(OUT_FORMAT("DEFLATE Compression:", compTxt))

        # XML output
        xmlOutput = Element(command, title=cmdTitle)
        if compName:
            xmlNode = Element('compressionMethod', type="DEFLATE")
            xmlOutput.append(xmlNode)

        return PluginBase.PluginResult(txtOutput, xmlOutput)
Example #3
0
    def makeXML(self, work_directory):
        # </Artifact>
        TheArtifact = Element( 'Artifact')
        TheArtifact.attrib['xmlns']="http://geni.net/schema"
        TheArtifact.attrib['xmlns:xsi']="http://www.w3.org/2001/XMLSchema-instance"
        TheArtifact.attrib['xsi:schemaLocation']="http://geni.net/schema GENIObject.xsd"

        # <Artifact><Type/>
        Type = SubElement( TheArtifact, 'Type')

        # <Artifact><Type><Primary/>
        Primary = SubElement( Type, 'Primary')
        Primary.text = self.art_type_prime

        # <Artifact><Interpretation/>
        Interpretation = SubElement( TheArtifact, 'Interpretation')
    
        # <Artifact><Interpretation><Interpretation_read_me_text/>
        Read_me_text = SubElement( Interpretation, 'Interpretation_read_me_text')
        Read_me_text.text = self.interpretation_read_me

        #To print to file
        Test = ElementTree()
        Test._setroot(TheArtifact)
        root = Test.getroot()
        self.indent(root)
        Test.write(work_directory+'/artifact.xml')
Example #4
0
    def convert_to_xml(self):
        test_suites = Element('testsuites')

        for suite in self.suites:
            test_suites.append(suite.convert_to_xml())

        return test_suites
Example #5
0
    def process_task(self, target, command, args):
        if self._shared_settings['starttls']:
            raise Exception('Cannot use --hsts with --starttls.')

        hsts_supported = self._get_hsts_header(target)
        if hsts_supported:
            hsts_timeout = hsts_supported
            hsts_supported = True

        # Text output
        cmd_title = 'HTTP Strict Transport Security'
        txt_result = [self.PLUGIN_TITLE_FORMAT(cmd_title)]
        if hsts_supported:
            txt_result.append(self.FIELD_FORMAT("OK - HSTS header received:", hsts_timeout))
        else:
            txt_result.append(self.FIELD_FORMAT("NOT SUPPORTED - Server did not send an HSTS header.", ""))

        # XML output
        xml_hsts_attr = {'sentHstsHeader': str(hsts_supported)}
        if hsts_supported:
            xml_hsts_attr['hstsHeaderValue'] = hsts_timeout
        xml_hsts = Element('hsts', attrib = xml_hsts_attr)

        xml_result = Element('hsts', title = cmd_title)
        xml_result.append(xml_hsts)

        return PluginBase.PluginResult(txt_result, xml_result)
Example #6
0
def xml_response(results, mytype):
    root = Element('data')
    for result in results:
        child = Element(mytype)
        child.text = result
        root.append(child)
    return Response('<?xml version="1.0" encoding="UTF-8"?>' + tostring(root), mimetype='text/xml')
Example #7
0
 def as_xml(self) -> Element:
     xml_result = Element(self.scan_command.get_cli_argument(), title=self.scan_command.get_title())
     if self.compression_name:
         xml_result.append(Element('compressionMethod', type="DEFLATE", isSupported="True"))
     else:
         xml_result.append(Element('compressionMethod', type="DEFLATE", isSupported="False"))
     return xml_result
def insert_math(block, line):
    instream = Element(ns + 'instream-foreign-object')
    block.append(instream)
    math_obj =  asciitomathml.asciitomathml.AsciiMathML(mstyle={'scriptlevel': '-2'})
    math_obj.parse_string(line)
    math_tree = math_obj.get_tree()
    instream.append(math_tree)
def read_file(file_obj):
    it_obj = paragraphs(file_obj)
    fo_obj = make_fo_tree()
    flow = fo_obj[1][0]
    for para in it_obj:
        block = Element(ns + 'block')
        block.set('space-before', '12pt')
        flow.append(block)
        the_string = para
        while the_string:
            the_index = the_string.find('`')
            if the_index > -1:
                start = the_string[:the_index]
                insert_text(fo_obj, start)
                the_string = the_string[the_index + 1:]
                the_index = the_string.find('`')
                if the_index > -1:
                    math = the_string[:the_index]
                    the_string = the_string[the_index + 1:]
                    insert_math(block, math)
                else:
                    math = the_string
                    insert_math(block, math)
                    break
            else:
                insert_text(fo_obj, the_string)
                break
    return fo_obj
Example #10
0
    def render_documentheader(self, standoffheader):
        """Create the documentHeader Element.

        Returns
        -------
        documentheader : ElementTree
            Primary element of the primary data document header.

        """

        now = datetime.datetime.now()
        pubDate = now.strftime("%Y-%m-%d")

        documentheader = Element('documentHeader',
                                 {"xmlns": "http://www.xces.org/ns/GrAF/1.0/",
                                  "xmlns:xlink": "http://www.w3.org/1999/xlink",
                                  "docId": "PoioAPI-" + str(random.randint(1, 1000000)),
                                  "version": standoffheader.version,
                                  "creator": getpass.getuser(),
                                  "date.created": pubDate})

        filedesc = self.render_filedesc(standoffheader.filedesc)
        profiledesc = self.render_profiledesc(standoffheader.profiledesc)
        datadesc = self.render_datadesc(standoffheader.datadesc)

        profiledesc.append(datadesc.getchildren()[0])
        profiledesc.append(datadesc.getchildren()[1])

        documentheader.append(filedesc)
        documentheader.append(profiledesc)

        return documentheader
def dict_to_xml(tag, d):
    elem = Element(tag)
    for key, val in d.items():
        child = Element(key)
        child.text = str(val)
        elem.append(child)
        return elem
Example #12
0
def sort_time(source):
    """Sort the source Element elements along their time (for annotations) and id (for relations).

    Returns a new Element
    """
    dest=Element(source.tag)
    dest.attrib.update(source.attrib)
    
    antag=tag('annotation')
    reltag=tag('relation')

    rel=[ e for e in source if e.tag == reltag ]
    rel.sort(cmp_id)

    an=[ e for e in source if e.tag == antag ]
    # Pre-parse begin times
    for a in an:
        f=a.find(tag('millisecond-fragment'))
        if f is not None:
            a._begin = long(f.attrib['begin'])
        else:
            print "Error: cannot find begin time for ", a.attrib['id']
            a._begin = 0
    an.sort(cmp_time)
    
    for e in an:
        dest.append(e)
    for e in rel:
        dest.append(e)

    return dest
Example #13
0
    def write_header_elements(self, g):
        """
        Helper method for write_header.
        """

        graph_header = Element('graphHeader')

        graph_header.append(self.render_tag_usage(g))

        depends_on = g.header.depends_on
        dependencies = SubElement(graph_header, 'dependencies')
        if depends_on:
            for dependency in depends_on:
                if dependency:
                    SubElement(dependencies, 'dependsOn',
                               {'f.id': dependency})

        aspaces = g.annotation_spaces
        annotation_spaces = SubElement(graph_header, 'annotationSpaces')
        if aspaces:
            for aspace in aspaces:
                SubElement(annotation_spaces, 'annotationSpace',
                           {'as.id': aspace.as_id})

        roots = g.header.roots
        if roots:
            roots_element = SubElement(graph_header, 'roots')
            for root in roots:
                if root:
                    SubElement(roots_element, 'root').text = root

        return graph_header
Example #14
0
 def _create_xml_node(self, key, value=''):
     key = key.replace(' ', '').strip()
     if key[0].isdigit(): # Would generate invalid XML
             key = 'oid-' + key # Tags cannot start with a digit
     xml_node = Element(key)
     xml_node.text = value.strip()
     return xml_node
    def _command_resum_rate(self, target):
        """
        Performs 100 session resumptions with the server in order to estimate
        the session resumption rate.
        """
        # Create a thread pool and process the jobs
        NB_THREADS = 20
        MAX_RESUM = 100
        thread_pool = ThreadPool()
        for _ in xrange(MAX_RESUM):
            thread_pool.add_job((self._resume_with_session_id, (target, )))
        thread_pool.start(NB_THREADS)

        # Format session ID results
        (txt_resum, xml_resum) = self._format_resum_id_results(thread_pool, MAX_RESUM)

        # Text output
        cmd_title = 'Resumption Rate with Session IDs'
        txt_result = [self.PLUGIN_TITLE_FORMAT(cmd_title)+' '+ txt_resum[0]]
        txt_result.extend(txt_resum[1:])

        # XML output
        xml_result = Element('resum_rate', title = cmd_title)
        xml_result.append(xml_resum)

        thread_pool.join()
        return PluginBase.PluginResult(txt_result, xml_result)
Example #16
0
 def as_xml(self):
     xml_result = Element(self.plugin_command, title=self.COMMAND_TITLE)
     if self.compression_name:
         xml_result.append(Element('compressionMethod', type="DEFLATE", isSupported="True"))
     else:
         xml_result.append(Element('compressionMethod', type="DEFLATE", isSupported="False"))
     return xml_result
def getBaseXML():
    root = Element('soapenv:Envelope')
    root.set('xmlns:soapenv', 'http://schemas.xmlsoap.org/soap/envelope/')
    root.set('xmlns:ns', 'http://www.cisco.com/AXL/API/11.0')
    header = SubElement(root, 'soapenv:Header')
    body = SubElement(root, 'soapenv:Body')
    return root, body
Example #18
0
def _get_metadata_node(location):
    node = Element('location_data')
    for key, value in location.metadata.items():
        element = Element(key)
        element.text = value
        node.append(element)
    return node
Example #19
0
    def new_node(self, node, caption, type, text='', expand=True, edit=True, 
            modified=True, pos='sub', element=None):
                
#        element = self.get_element(node)
        if element is None:
            new_element = Element(type, caption=caption)
            new_element.text = text
        else:
            new_element = element
        self.add_element(node, new_element, pos)
        if type == 'folder':
            new_node = self.add_new_folder(node, caption, 
                data={'element':new_element}, modified=modified, 
                pos=pos)
        else:
            new_node = self.add_new_node(node, caption, 
                data={'element':new_element}, modified=modified,
                pos=pos)
        
        if expand:
            wx.CallAfter(self.tree.Expand, node)
        self.tree.SelectItem(new_node)
        if edit:
            wx.CallAfter(self.tree.EditLabel, new_node)
        
        return new_node
Example #20
0
def getItemsXML(expedition_id, category_id):
    """
    Endpoint to return an XML List of all items associated
    with a certain expedition and category
    :param expedition_id:
    :param category_id:
    """
    items = session.query(Item).filter_by(
        expedition_id=expedition_id,
        category_id=category_id).all()
    root = Element('allItems')
    comment = Comment('XML Endpoint Listing '
                      'all Item for a specific Category and Expedition')
    root.append(comment)
    for i in items:
        ex = SubElement(root, 'expedition')
        ex.text = i.expedition.title
        category_name = SubElement(ex, 'category_name')
        category_description = SubElement(category_name,
                                          'category_description')
        category_picture = SubElement(category_name, 'category_picture')
        category_name.text = i.category.name
        category_description.text = i.category.description
        category_picture.text = i.category.picture
        item_name = SubElement(category_name, 'item_name')
        item_decription = SubElement(item_name, 'item_description')
        item_picture = SubElement(item_name, 'item_picture')
        item_name.text = i.name
        item_decription.text = i.description
        item_picture.text = i.picture
    print tostring(root)
    return app.response_class(tostring(root), mimetype='application/xml')
def createElement(elementName,value,root):
    name = Element(elementName)
    root.append(name)
    if value:
        name.text = value
    else:
        name.text = " "
    def process_task(self, target, command, args):

        ctSSL_initialize()
        try:
            (can_reneg, is_secure) = self._test_renegotiation(target)
        finally:
            ctSSL_cleanup()
        
        # Text output
        reneg_txt = 'Honored' if can_reneg else 'Rejected'
        secure_txt = 'Supported' if is_secure else 'Not supported'
        cmd_title = 'Session Renegotiation'
        txt_result = [self.PLUGIN_TITLE_FORMAT.format(cmd_title)]
        
        RENEG_FORMAT = '      {0:<35} {1}'
        txt_result.append(RENEG_FORMAT.format('Client-initiated Renegotiations:', reneg_txt))
        txt_result.append(RENEG_FORMAT.format('Secure Renegotiation: ', secure_txt))
        
        # XML output
        xml_reneg_attr = {'canBeClientInitiated' : str(can_reneg),
                          'isSecure' : str(is_secure)}
        xml_reneg = Element('sessionRenegotiation', attrib = xml_reneg_attr)
        
        xml_result = Element(command, title = cmd_title)
        xml_result.append(xml_reneg)
        
        return PluginBase.PluginResult(txt_result, xml_result)
Example #23
0
def addToWorkingSet(newProjectPath):
        workingSetFilePath = os.path.expanduser("~") + os.sep + ".colt" + os.sep + "workingset.xml"
        projectsList = []

        # Populate projects list
        if os.path.exists(workingSetFilePath) :
                workingSetElement = parse(workingSetFilePath).getroot()
                for projectElement in workingSetElement :
                        projectPath = projectElement.attrib["path"]
                        if projectPath :
                                projectsList.append(projectPath)

        # Remove project path from the list
        projectsList = filter(lambda projectPath : projectPath != newProjectPath, projectsList)

        # Push new project
        projectsList.insert(0, newProjectPath)

        # Save the list
        workingSetElement = Element("workingset")
        workingSetElement.set("openRecent", "true")

        for projectPath in projectsList :
                projectElement = SubElement(workingSetElement, "project")
                projectElement.set("path", projectPath)

        workingSetFile = open(workingSetFilePath, "w")
        workingSetFile.write(tostring(workingSetElement))
        workingSetFile.close()
Example #24
0
    def _saveTracks(self, tracks):
        element = Element("tracks")
        for track in tracks:
            track_element = self._saveTrack(track)
            element.append(track_element)

        return element
Example #25
0
    def _saveTimelineObjects(self, timeline_objects):
        element = Element("timeline-objects")
        for timeline_object in timeline_objects:
            timeline_object_element = self._saveTimelineObject(timeline_object)
            element.append(timeline_object_element)

        return element
Example #26
0
def convert_MoocCheckboxesAssessment_to_xml(par):
    """Convert checkbox assignment into xml. """
    xml = Element('problem')

    for key in ['display_name', 'max_attempts']:
        xml.attrib[key] = str(par[key])

    p = SubElement(xml, 'p')
    p.text = par['question']

    p = SubElement(xml, 'p')
    p.text = 'Select the answers that match'

    sub = SubElement(xml, 'choiceresponse')
    sub = SubElement(sub, 'checkboxgroup')
    sub.attrib['label'] = "Select the answers that match"
    sub.attrib['direction'] = "vertical"

    for i, ans in enumerate(par['answers']):
        choice = SubElement(sub, 'choice')
        if i in par['correct_answers']:
            choice.attrib['correct'] = 'true'
        else:
            choice.attrib['correct'] = 'false'
        choice.text = ans

    if 'explanation' in par:
        add_solution(xml, par['explanation'])

    return xml
Example #27
0
def convert_MoocMultipleChoiceAssessment_to_xml(par):
    """ Convert multiple choice question into xml. """
    xml = Element('problem')

    for key in ['display_name', 'max_attempts']:
        xml.attrib[key] = str(par[key])

    p = SubElement(xml, 'p')
    p.text = par['question']

    p = SubElement(xml, 'p')
    p.text = 'Please select correct answer'

    sub = SubElement(xml, 'multiplechoiceresponse')
    sub = SubElement(sub, 'choicegroup')
    sub.attrib['label'] = "Please select correct answer"
    sub.attrib['type'] = "MultipleChoice"

    for i, ans in enumerate(par['answers']):
        choice = SubElement(sub, 'choice')
        if i == par['correct_answer']:
            choice.attrib['correct'] = 'true'
        else:
            choice.attrib['correct'] = 'false'
        choice.text = ans

    if 'explanation' in par:
        add_solution(xml, par['explanation'])

    return xml
Example #28
0
def story_feed(request, story):
    story = Story.objects.get(slug=story)
    rss = Element('rss')
    rss.set("version","2.0")

    channel = SubElement(rss,'channel')

    title = SubElement(channel,'title')
    title.text = story.title

    link = SubElement(channel,'link')
    link.text = request.build_absolute_uri(reverse("story"))

    desc = SubElement(channel,'description')
    desc.text = story.description

    chapters = story.chapters.all()

    for index in chapters:
        item = SubElement(channel,'item')

        title_c = SubElement(item,'title')
        title_c.text = index.title
        
        link = SubElement(item,'link')
        link.text = request.build_absolute_uri(index.get_absolute_url())

    return HttpResponse(tostring(rss, encoding='UTF-8'))
Example #29
0
def convert_MoocVideo_to_xml(par):
    """ Convert video_cell with MoocVideo into xml. """
    xml = Element('video')
    for key in par:
        xml.attrib[key] = str(par[key])

    return xml
Example #30
0
  def execute(self, mappings, source):
    """Writes the given language code/name mappings to Android XML resource files.

    source = string indicating source of the data, for example, 'cldr'
    mappings = list of dictionaries containing mappings"""

    # In order to be able to to localize a particular, limited set of words across multiple
    # languages, here we define a list of language codes to support for every resource file
    # generated. Where localized language names are missing, a place holder is printed. If
    # ['*'] is specified, then all available language code/name pairs are generated.
    COVERAGE_LIST = ['*']
    
    # Get language names in English as a dict for inclusion in XML comments
    english_pairs = {}
    for entry in mappings:
      for k, v in entry.iteritems():
        if k == 'en':
          english_pairs = v
          break
    
    for entry in mappings:
      for k, v in entry.iteritems():
        dir = os.path.join(os.path.dirname(__file__), self.get_directory(source) +
                           "../" + source + "-android/values-" + k)
        if not os.path.exists(dir):
          os.makedirs(dir)
        with open(dir + "/arrays.xml", "w") as f:
          top = Element('resources')
          if k in english_pairs.keys():
            top_comment = ElementTree.Comment(' ' + english_pairs[k].decode('utf-8') + ' (' + k + ') ')
          else:
            top_comment = ElementTree.Comment(' ' + k + ' ')
          top.append(top_comment)
          child = SubElement(top, 'string-array')          
          child.attrib['name'] = 'languages_all'
          
          if '*' not in COVERAGE_LIST:
            # Iterate through only those codes in COVERAGE_LIST
            for lang_code in COVERAGE_LIST:
              if lang_code in english_pairs.keys():
                comment = ElementTree.Comment(' ' + lang_code + ' - ' + english_pairs[lang_code].decode('utf-8') + ' ')
              else:
                comment = ElementTree.Comment(' ' + lang_code + ' ')
              child.append(comment)
              entry = SubElement(child, 'item')
              if lang_code in v.keys():
                entry.text = v[lang_code].decode('utf-8')
              else:
                entry.text = "UNDEFINED"
          else:
            # Iterate through all available language codes
            for lang_code, lang_name in sorted(v.iteritems()):
              if lang_code in english_pairs.keys():
                comment = ElementTree.Comment(' ' + lang_code + ' - ' + english_pairs[lang_code].decode('utf-8') + ' ')
              else:
                comment = ElementTree.Comment(' ' + lang_code + ' ')
              child.append(comment)
              entry = SubElement(child, 'item')
              entry.text = lang_name.decode('utf-8')
          f.write(self.prettify(top))
Example #31
0
def AddButtonAction():
    global NameLabel, RenderText, window, FoodLabel, PriceLabel
    RenderText.configure(state='normal')
    RenderText.delete(0.0, END)

    Name = str(NameLabel.get())
    Food = str(FoodLabel.get())
    Price = str(PriceLabel.get())

    switch = 0
    for location in Data1.findall("list"):
        if  Name in location.findtext("serviceAreaName"):
            RenderText.insert(INSERT, "삐빅! 중복입니다.")
            switch = 1

    if switch == 0:
        New = Element("list")
        NewName = Element("serviceAreaName")
        NewName.text = Name
        New.append(NewName)
        NewFood = Element("batchMenu")
        NewFood.text = Food
        New.append(NewFood)
        NewPrice = Element("salePrice")
        NewPrice.text = Price
        New.append(NewPrice)
        RenderText.insert(INSERT, Name)
        RenderText.insert(INSERT, "휴게소 추가 완료.")
        Data1.append(New)

    RenderText.configure(state = 'disabled')

    NameLabel.delete(0,END)
    FoodLabel.delete(0,END)
    PriceLabel.delete(0,END)

    doc.write("Data1.xml", encoding="utf-8", xml_declaration=True)
    def toXML(self, input_commstruct, analysis, limit_value, parameter_dic):

        # Retrieve the data from the analyzed statistics
        classified_families = analysis[0]
        motif_classification = analysis[1]
        file_pathes = analysis[2]

        # Create the root element with its attributes
        classification_element = Element(
            FinalOutputProcessor.CLASSIFICATION_TAG)
        classification_element.attrib[
            FinalOutputProcessor.
            PIPELINE_NAME_ATT] = self.component.pipelineName
        classification_element.attrib[
            FinalOutputProcessor.
            REFERENCE_SPECIES_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.REFERENCE_SPECIES]
        classification_element.attrib[
            FinalOutputProcessor.
            ALIGNED_SPECIES_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.ALIGNED_SPECIES]
        classification_element.attrib[
            FinalOutputProcessor.
            REFERENCE_MOTIF_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.REFERENCE_MOTIF]

        classification_element.attrib[
            FinalOutputProcessor.
            BEDSEQUENCES_NUMBER_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.BEDSEQUENCES_NUMBER]
        classification_element.attrib[
            FinalOutputProcessor.
            BEDSEQUENCES_MIN_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.BEDSEQUENCES_MIN_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            BEDSEQUENCES_MAX_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.BEDSEQUENCES_MAX_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            BEDSEQUENCES_MEAN_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.BEDSEQUENCES_MEAN_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            BEDSEQUENCES_TOTAL_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.BEDSEQUENCES_TOTAL_SIZE]

        classification_element.attrib[
            FinalOutputProcessor.
            MSA_NUMBER_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.MSA_NUMBER]
        classification_element.attrib[
            FinalOutputProcessor.
            MSA_MIN_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.MSA_MIN_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            MSA_MAX_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.MSA_MAX_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            MSA_MEAN_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.MSA_MEAN_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            MSA_TOTAL_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.MSA_TOTAL_SIZE]

        classification_element.attrib[
            FinalOutputProcessor.
            CONSERVED_BLOCKS_NUMBER_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.CONSERVED_BLOCKS_NUMBER]
        classification_element.attrib[
            FinalOutputProcessor.
            CONSERVED_BLOCKS_MIN_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.CONSERVED_BLOCKS_MIN_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            CONSERVED_BLOCKS_MAX_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.CONSERVED_BLOCKS_MAX_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            CONSERVED_BLOCKS_MEAN_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.CONSERVED_BLOCKS_MEAN_SIZE]
        classification_element.attrib[
            FinalOutputProcessor.
            CONSERVED_BLOCKS_TOTAL_SIZE_ATT] = input_commstruct.paramStatistics[
                BedSeqAlignmentStatsCommStruct.CONSERVED_BLOCKS_TOTAL_SIZE]

        classification_element.attrib[
            FinalOutputProcessor.BED_SEQUENCES_SIZE_PATH_ATT] = file_pathes[
                FinalOutputProcessor.BED_SEQUENCES_SIZE_PATH_ATT]
        classification_element.attrib[
            FinalOutputProcessor.
            BED_SEQUENCES_SIZE_GRAPH_PATH_ATT] = file_pathes[
                FinalOutputProcessor.BED_SEQUENCES_SIZE_GRAPH_PATH_ATT]

        classification_element.attrib[
            FinalOutputProcessor.ZIP_FILE] = os.path.join(
                os.path.join(self.outPath, "zip"),
                self.component.pipelineName + ".zip")

        # Add all other parameters values
        for param_name in parameter_dic.keys():
            if not param_name in classification_element.attrib.keys():
                classification_element.attrib[param_name] = parameter_dic[
                    param_name]

        # Insert the path to the BED sequences sizes histogram and graph
        self.addFilePathAttribute(
            classification_element,
            FinalOutputProcessor.BED_SEQUENCES_SIZE_PATH_ATT, file_pathes)
        self.addFilePathAttribute(
            classification_element,
            FinalOutputProcessor.BED_SEQUENCES_SIZE_GRAPH_PATH_ATT,
            file_pathes)

        # Insert the path to the Conserved Regions sizes histogram and graph if any
        self.addFilePathAttribute(
            classification_element,
            FinalOutputProcessor.CONSERVED_BLOCKS_SIZE_PATH_ATT, file_pathes)
        self.addFilePathAttribute(
            classification_element,
            FinalOutputProcessor.CONSERVED_BLOCKS_SIZE_GRAPH_PATH_ATT,
            file_pathes)

        # Insert the path to the MSA sizes histogram and graph if any
        self.addFilePathAttribute(classification_element,
                                  FinalOutputProcessor.MSA_SIZE_PATH_ATT,
                                  file_pathes)
        self.addFilePathAttribute(classification_element,
                                  FinalOutputProcessor.MSA_SIZE_GRAPH_PATH_ATT,
                                  file_pathes)

        # Insert the path to the BED output file if any
        self.addFilePathAttribute(classification_element,
                                  FinalOutputProcessor.BED_OUTPUT_ATT,
                                  file_pathes)
        self.addFilePathAttribute(classification_element,
                                  FinalOutputProcessor.BIGBED_OUTPUT_ATT,
                                  file_pathes)

        # Create a root son element for each family
        for family_rank in sorted(classified_families):
            # fill the family element attributes
            family_element = Element(FinalOutputProcessor.FAMILY_TAG)
            classification_element.append(family_element)

            family = classified_families[family_rank]
            family_element.attrib[
                FinalOutputProcessor.FAMILY_NAME_ATT] = family

            # create a family son element for each motif in a family
            for motif_rank in sorted(motif_classification[family].keys()):

                motif_name = motif_classification[family][motif_rank]
                motif_stats = input_commstruct.motifStatistics[motif_name]

                # If the motif has its hypergeometric p-value above the limit, it is ignored
                #if not motif_stats.hasAttribute( MotifStatistics.MOTIF_HYP_PVALUE) or motif_stats.getAttributeAsfloat( MotifStatistics.MOTIF_HYP_PVALUE) > limit_value:
                #    continue
                # If the motif has its hypergeometric e-value above the limit, it is ignored
                if not motif_stats.hasAttribute(
                        MotifStatistics.MOTIF_HYP_EVALUE
                ) or motif_stats.getAttributeAsfloat(
                        MotifStatistics.MOTIF_HYP_EVALUE) > limit_value:
                    continue

                # Create the motif XML element
                motif_element = Element(FinalOutputProcessor.MOTIF_TAG)
                family_element.append(motif_element)

                # fill the motif element attributes
                motif_element.attrib[
                    FinalOutputProcessor.MOTIF_NAME_ATT] = motif_name
                motif_element.attrib[
                    FinalOutputProcessor.MOTIF_FAMILY_ATT] = family
                motif_element.attrib[
                    FinalOutputProcessor.MOTIF_ID_ATT] = motif_stats.motifID
                motif_element.attrib[FinalOutputProcessor.
                                     MOTIF_CLASS_ATT] = motif_stats.motifClass
                motif_element.attrib[FinalOutputProcessor.
                                     MOTIF_TYPE_ATT] = motif_stats.motifType

                motif_element.attrib[
                    FinalOutputProcessor.
                    MOTIF_RANK_ATT] = motif_stats.getAttribute(
                        MotifStatistics.MOTIF_RANK)

                # fill the motif hit score attribute
                motif_element.attrib[
                    FinalOutputProcessor.
                    MOTIF_HIT_SCORE_ATT] = motif_stats.getAttribute(
                        MotifStatistics.MOTIF_HIT_SCORE)

                # fill the motifhypergeometric score and p-value attribute
                if motif_stats.hasAttribute(
                        MotifStatistics.MOTIF_HYP_HIT_SCORE):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIF_HYP_HIT_SCORE_ATT] = motif_stats.getAttribute(
                            MotifStatistics.MOTIF_HYP_HIT_SCORE)
                if motif_stats.hasAttribute(MotifStatistics.MOTIF_HYP_PVALUE):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIF_HYP_PVALUE_ATT] = motif_stats.getAttribute(
                            MotifStatistics.MOTIF_HYP_PVALUE)
                if motif_stats.hasAttribute(MotifStatistics.MOTIF_HYP_EVALUE):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIF_HYP_EVALUE_ATT] = motif_stats.getAttribute(
                            MotifStatistics.MOTIF_HYP_EVALUE)

                # fill the motif chi2 and chi2 p-value attributes
                if motif_stats.hasAttribute(MotifStatistics.MOTIF_CHI2):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIF_CHI2_ATT] = motif_stats.getAttribute(
                            MotifStatistics.MOTIF_CHI2)
                if motif_stats.hasAttribute(MotifStatistics.MOTIF_CHI2_PVALUE):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIF_CHI2_PVALUE_ATT] = motif_stats.getAttribute(
                            MotifStatistics.MOTIF_CHI2_PVALUE)

                # fill the motif contingency values
                if motif_stats.hasAttribute(
                        MotifStatistics.CONTIGENCY_MOTIF_COOCCURENCE):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIFCONTIGENCY_MOTIF_COOCCURENCE] = motif_stats.getAttribute(
                            MotifStatistics.CONTIGENCY_MOTIF_COOCCURENCE)
                if motif_stats.hasAttribute(
                        MotifStatistics.CONTIGENCY_REFERENCE_MOTIF_BEDSEQ):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIFCONTIGENCY_REFERENCE_MOTIF_BEDSEQ] = motif_stats.getAttribute(
                            MotifStatistics.CONTIGENCY_REFERENCE_MOTIF_BEDSEQ)
                if motif_stats.hasAttribute(
                        MotifStatistics.CONTINGENCY_TOTAL_BEDSEQ):
                    motif_element.attrib[
                        FinalOutputProcessor.
                        MOTIFCONTINGENCY_TOTAL_BEDSEQ] = motif_stats.getAttribute(
                            MotifStatistics.CONTINGENCY_TOTAL_BEDSEQ)

                # fill the ratio overlap attribute
                motif_element.attrib[
                    FinalOutputProcessor.MOTIF_RATIO_HOMOLOCATION] = str(
                        int(
                            motif_stats.getAttributeAsfloat(
                                MotifStatistics.MOTIF_RATIO_HOMOLOCATION) *
                            1000.0) / float(10)) + "%"

                # Fill the motif logo and matrix attributes
                motif_element.attrib[
                    FinalOutputProcessor.MOTIF_LOGO_ATT] = os.path.join(
                        FinalOutputProcessor.LOGOS_DIR_NAME,
                        motif_name + "_m1.png")
                motif_element.attrib[
                    FinalOutputProcessor.MOTIF_MATRIX_ATT] = os.path.join(
                        FinalOutputProcessor.LOGOS_DIR_NAME,
                        motif_name + ".tf")

                # fill the motif element graphs
                self.addMotifFilePathAttribute(
                    motif_element,
                    FinalOutputProcessor.MOTIF_DISTANCE_HISTOGRAM_ATT,
                    motif_name, file_pathes)
                self.addMotifFilePathAttribute(
                    motif_element,
                    FinalOutputProcessor.MOTIF_DISTANCE_HISTOGRAM_GRAPH_ATT,
                    motif_name, file_pathes)
                self.addMotifFilePathAttribute(
                    motif_element, FinalOutputProcessor.
                    MOTIF_DISTANCE_HISTOGRAM_GRAPH_PDF_ATT, motif_name,
                    file_pathes)

                self.addMotifFilePathAttribute(
                    motif_element,
                    FinalOutputProcessor.MOTIF_PEAK_SCORE_HISTOGRAM_ATT,
                    motif_name, file_pathes)
                self.addMotifFilePathAttribute(
                    motif_element,
                    FinalOutputProcessor.MOTIF_PEAK_SCORE_HISTOGRAM_GRAPH_ATT,
                    motif_name, file_pathes)

                self.addMotifFilePathAttribute(
                    motif_element,
                    FinalOutputProcessor.MOTIF_COLOCATION_HISTOGRAM_ATT,
                    motif_name, file_pathes)
                self.addMotifFilePathAttribute(
                    motif_element,
                    FinalOutputProcessor.MOTIF_COLOCATION_HISTOGRAM_GRAPH_ATT,
                    motif_name, file_pathes)
                self.addMotifFilePathAttribute(
                    motif_element, FinalOutputProcessor.
                    MOTIF_COLOCATION_HISTOGRAM_GRAPH_PDF_ATT, motif_name,
                    file_pathes)

        return classification_element
Example #33
0
#!/usr/bin/env python
from pprint import pprint
from execo import TaktukRemote
from execo.time_utils import sleep
from execo_g5k import get_host_site, get_host_cluster, get_kavlan_host_name, \
    get_g5k_sites
from vm5k import list_vm, get_oargrid_job_vm5k_resources
from vm5k.plots import topology_plot
from xml.etree.ElementTree import Element, SubElement, dump


state = Element('vm5k')

resources = get_oargrid_job_vm5k_resources(49509)
sites = sorted([site for site in resources.keys() if site != 'global'])
kavlan = resources['global']['kavlan']
hosts = []
for site in sites:
    hosts += map(lambda host: get_kavlan_host_name(host,
                    kavlan), resources[site]['hosts'])


for host in hosts:
    site = get_host_site(host)
    if state.find("./site[@id='" + site+ "']"):
        el_site = state.find("./site[@id='" + site+ "']")
    else:
        el_site = SubElement(state, 'site', attrib={'id': site})
    cluster = get_host_cluster(host)
    if el_site.find("./cluster[@id='" + cluster + "']"):
        el_cluster = el_site.find("./cluster[@id='" + cluster+ "']")
Example #34
0
from xml.etree import ElementTree as et
import parsetag
from xml.dom import minidom
import codecs
import os

ATTRIBUTE_DEFINITION_STRING = '\'\'\'Attribute Definitions:'
CHANGE_LOG_STRING = 'Changelog'
SYNTAX_STRING = '\'\'\'Syntax'
ROOT_TAG = '\'\'\''
HED_NODE_NAME = 'HED'
HED_VERSION_STRING = 'HED version:'
START_STRING = '!# start hed'
UNIT_CLASS_STRING = '\'\'\'Unit classes'
END_STRING = '!# end hed'
hed_node = Element('HED')


# Prints an element tree
def prettify(elem):
    rough_string = et.tostring(elem, encoding='utf-8', method='xml')
    reparsed = minidom.parseString(rough_string)
    prettified_string = reparsed.toprettyxml(indent="   ", encoding='utf-8')
    return prettified_string[:prettified_string.rfind('\n')]


# Removes the last line from a string
def remove_last_line_from_string(s):
    return s[:s.rfind('\n')]

Example #35
0
 def devices_xml(self):
     devices = Element("devices")
     SubElement(devices, "emulator").text = self.emulator
     devices.append(self.disk_xml)
     return devices
Example #36
0
    def _show_data(self, show_obj):
        """
        Creates an elementTree XML structure for a MediaBrowser-style series.xml
        returns the resulting data object.

        show_obj: a TVShow instance to create the NFO for
        """

        indexer_lang = show_obj.lang
        lINDEXER_API_PARMS = sickrage.INDEXER_API(
            show_obj.indexer).api_params.copy()

        lINDEXER_API_PARMS[b'actors'] = True

        if indexer_lang and not indexer_lang == sickrage.INDEXER_DEFAULT_LANGUAGE:
            lINDEXER_API_PARMS[b'language'] = indexer_lang

        if show_obj.dvdorder != 0:
            lINDEXER_API_PARMS[b'dvdorder'] = True

        t = sickrage.INDEXER_API(
            show_obj.indexer).indexer(**lINDEXER_API_PARMS)

        rootNode = Element("details")
        tv_node = SubElement(rootNode, "movie")
        tv_node.attrib[b"isExtra"] = "false"
        tv_node.attrib[b"isSet"] = "false"
        tv_node.attrib[b"isTV"] = "true"

        try:
            myShow = t[int(show_obj.indexerid)]
        except indexer_shownotfound:
            sickrage.LOGGER.error("Unable to find show with id " +
                                  str(show_obj.indexerid) +
                                  " on tvdb, skipping it")
            raise

        except indexer_error:
            sickrage.LOGGER.error(
                "TVDB is down, can't use its data to make the NFO")
            raise

        # check for title and id
        if not (getattr(myShow, 'seriesname', None)
                and getattr(myShow, 'id', None)):
            sickrage.LOGGER.info("Incomplete info for show with id " +
                                 str(show_obj.indexerid) + " on " +
                                 sickrage.INDEXER_API(show_obj.indexer).name +
                                 ", skipping it")
            return False

        SeriesName = SubElement(tv_node, "title")
        SeriesName.text = myShow[b'seriesname']

        if getattr(myShow, "genre", None):
            Genres = SubElement(tv_node, "genres")
            for genre in myShow[b'genre'].split('|'):
                if genre and genre.strip():
                    cur_genre = SubElement(Genres, "Genre")
                    cur_genre.text = genre.strip()

        if getattr(myShow, 'firstaired', None):
            FirstAired = SubElement(tv_node, "premiered")
            FirstAired.text = myShow[b'firstaired']

        if getattr(myShow, "firstaired", None):
            try:
                year_text = str(
                    datetime.datetime.strptime(myShow[b"firstaired"],
                                               dateFormat).year)
                if year_text:
                    year = SubElement(tv_node, "year")
                    year.text = year_text
            except Exception:
                pass

        if getattr(myShow, 'overview', None):
            plot = SubElement(tv_node, "plot")
            plot.text = myShow[b"overview"]

        if getattr(myShow, 'rating', None):
            try:
                rating = int(float(myShow[b'rating']) * 10)
            except ValueError:
                rating = 0

            if rating:
                Rating = SubElement(tv_node, "rating")
                Rating.text = str(rating)

        if getattr(myShow, 'status', None):
            Status = SubElement(tv_node, "status")
            Status.text = myShow[b'status']

        if getattr(myShow, "contentrating", None):
            mpaa = SubElement(tv_node, "mpaa")
            mpaa.text = myShow[b"contentrating"]

        if getattr(myShow, 'imdb_id', None):
            imdb_id = SubElement(tv_node, "id")
            imdb_id.attrib[b"moviedb"] = "imdb"
            imdb_id.text = myShow[b'imdb_id']

        if getattr(myShow, 'id', None):
            indexerid = SubElement(tv_node, "indexerid")
            indexerid.text = myShow[b'id']

        if getattr(myShow, 'runtime', None):
            Runtime = SubElement(tv_node, "runtime")
            Runtime.text = myShow[b'runtime']

        if getattr(myShow, '_actors', None):
            cast = SubElement(tv_node, "cast")
            for actor in myShow[b'_actors']:
                if 'name' in actor and actor[b'name'].strip():
                    cur_actor = SubElement(cast, "actor")
                    cur_actor.text = actor[b'name'].strip()

        indentXML(rootNode)

        data = ElementTree(rootNode)

        return data
Example #37
0
    def _ep_data(self, ep_obj):
        """
        Creates an elementTree XML structure for a MediaBrowser style episode.xml
        and returns the resulting data object.

        show_obj: a TVShow instance to create the NFO for
        """

        eps_to_write = [ep_obj] + ep_obj.relatedEps

        indexer_lang = ep_obj.show.lang

        try:
            # There's gotta be a better way of doing this but we don't wanna
            # change the language value elsewhere
            lINDEXER_API_PARMS = sickrage.INDEXER_API(
                ep_obj.show.indexer).api_params.copy()

            if indexer_lang and not indexer_lang == sickrage.INDEXER_DEFAULT_LANGUAGE:
                lINDEXER_API_PARMS[b'language'] = indexer_lang

            if ep_obj.show.dvdorder != 0:
                lINDEXER_API_PARMS[b'dvdorder'] = True

            t = sickrage.INDEXER_API(
                ep_obj.show.indexer).indexer(**lINDEXER_API_PARMS)
            myShow = t[ep_obj.show.indexerid]
        except indexer_shownotfound as e:
            raise ShowNotFoundException(e.message)
        except indexer_error as e:
            sickrage.LOGGER.error(
                "Unable to connect to TVDB while creating meta files - skipping - {}"
                .format(e))
            return False

        rootNode = Element("details")
        movie = SubElement(rootNode, "movie")

        movie.attrib[b"isExtra"] = "false"
        movie.attrib[b"isSet"] = "false"
        movie.attrib[b"isTV"] = "true"

        # write an MediaBrowser XML containing info for all matching episodes
        for curEpToWrite in eps_to_write:

            try:
                myEp = myShow[curEpToWrite.season][curEpToWrite.episode]
            except (indexer_episodenotfound, indexer_seasonnotfound):
                sickrage.LOGGER.info(
                    "Unable to find episode %dx%d on %s... has it been removed? Should I delete from db?"
                    % (curEpToWrite.season, curEpToWrite.episode,
                       sickrage.INDEXER_API(ep_obj.show.indexer).name))
                return None

            if curEpToWrite == ep_obj:
                # root (or single) episode

                # default to today's date for specials if firstaired is not set
                if curEpToWrite.season == 0 and not getattr(
                        myEp, 'firstaired', None):
                    myEp[b'firstaired'] = str(datetime.date.fromordinal(1))

                if not (getattr(myEp, 'episodename', None)
                        and getattr(myEp, 'firstaired', None)):
                    return None

                episode = movie

                if curEpToWrite.name:
                    EpisodeName = SubElement(episode, "title")
                    EpisodeName.text = curEpToWrite.name

                SeasonNumber = SubElement(episode, "season")
                SeasonNumber.text = str(curEpToWrite.season)

                EpisodeNumber = SubElement(episode, "episode")
                EpisodeNumber.text = str(curEpToWrite.episode)

                if getattr(myShow, "firstaired", None):
                    try:
                        year_text = str(
                            datetime.datetime.strptime(myShow[b"firstaired"],
                                                       dateFormat).year)
                        if year_text:
                            year = SubElement(episode, "year")
                            year.text = year_text
                    except:
                        pass

                if getattr(myShow, "overview", None):
                    plot = SubElement(episode, "plot")
                    plot.text = myShow[b"overview"]

                if curEpToWrite.description:
                    Overview = SubElement(episode, "episodeplot")
                    Overview.text = curEpToWrite.description

                if getattr(myShow, 'contentrating', None):
                    mpaa = SubElement(episode, "mpaa")
                    mpaa.text = myShow[b"contentrating"]

                if not ep_obj.relatedEps and getattr(myEp, "rating", None):
                    try:
                        rating = int((float(myEp[b'rating']) * 10))
                    except ValueError:
                        rating = 0

                    if rating:
                        Rating = SubElement(episode, "rating")
                        Rating.text = str(rating)

                if getattr(myEp, 'director', None):
                    director = SubElement(episode, "director")
                    director.text = myEp[b'director']

                if getattr(myEp, 'writer', None):
                    writer = SubElement(episode, "credits")
                    writer.text = myEp[b'writer']

                if getattr(myShow, '_actors', None) or getattr(
                        myEp, 'gueststars', None):
                    cast = SubElement(episode, "cast")
                    if getattr(myEp, 'gueststars', None) and isinstance(
                            myEp[b'gueststars'], basestring):
                        for actor in (x.strip()
                                      for x in myEp[b'gueststars'].split('|')
                                      if x.strip()):
                            cur_actor = SubElement(cast, "actor")
                            cur_actor.text = actor

                    if getattr(myShow, '_actors', None):
                        for actor in myShow[b'_actors']:
                            if 'name' in actor and actor[b'name'].strip():
                                cur_actor = SubElement(cast, "actor")
                                cur_actor.text = actor[b'name'].strip()

            else:
                # append data from (if any) related episodes

                if curEpToWrite.name:
                    if not EpisodeName.text:
                        EpisodeName.text = curEpToWrite.name
                    else:
                        EpisodeName.text = EpisodeName.text + ", " + curEpToWrite.name

                if curEpToWrite.description:
                    if not Overview.text:
                        Overview.text = curEpToWrite.description
                    else:
                        Overview.text = Overview.text + "\r" + curEpToWrite.description

        indentXML(rootNode)
        data = ElementTree(rootNode)

        return data
def csvToXml(scsv, fxml):
    reader = csv.reader(scsv)
    headers = reader.next()
    headers = map(lambda h: h.replace(' ', ''), headers)

    root = Element('Data')
    for row in reader:
        eRow = Element('Row')
        root.append(eRow)
        for tag, text in zip(headers, row):
            e = Element(tag)
            e.text = text
            eRow.append(e)
    pretty(root)
    et = ElementTree(root)
    et.write(fxml)
Example #39
0
class OwlBuild():
    def __init__(self):
        self.typesCount = self.propsCount = self.namedCount = 0
        self.createDom()
        self.loadGraph()

    def getContent(self):
        #return ET.tostring(self.dom)
        return self.prettify(self.dom).decode()

    def prettify(self,elem):
        # log.info("doc: %s" % ET.tostring(elem))
        doc = minidom.parseString(ET.tostring(elem))
        return doc.toprettyxml(encoding='UTF-8')


    def createDom(self):
        self.dom = Element('rdf:RDF')
        for (k,v) in NAMESPACES.items():
            self.dom.set(k,v)
        
        self.dom.append(Comment("\n\tGenerated from Schema.org version: %s released: %s\n\t" % (getVersion(),getVersionDate(getVersion()))))
        self.ont = SubElement(self.dom,"owl:Ontology")
        self.ont.set("rdf:about",VOCABURI)
        info = SubElement(self.ont,"owl:versionInfo")
        info.set("rdf:datatype","http://www.w3.org/2001/XMLSchema#string")
        info.text = getVersion()
        x = SubElement(self.ont,"rdfs:label")
        x.text = "Schema.org Vocabulary"
        x = SubElement(self.ont,"dcterms:modified")
        x.set("rdf:datatype", "http://www.w3.org/2001/XMLSchema#dat")
        x.text = getVersionDate(getVersion())
        self.dom.append(Comment("\n\t/////////////////////\n\t/ Definitions\n\t/////////////////////\n\n\t"))

    def loadGraph(self):
        self.list(SdoTermSource.sourceGraph())

    def list(self, graph):
        types = {}
        props = {}
        exts = []
        self.dom.append(Comment("\n\t/////////////////////\n\t/ Class Definitions\n\t/////////////////////\n\t"))
        
        for (s,p,o) in graph.triples((None,RDF.type,RDFS.Class)):
            if s.startswith("http://schema.org"):
                types.update({s:graph.identifier})

        for t in sorted(types.keys()):
            self.outputType(t,graph)
            
        self.dom.append(Comment("\n\t/////////////////////\n\t/ Property Definitions\n\t/////////////////////\n\t"))
        for (s,p,o) in graph.triples((None,RDF.type,RDF.Property)):
            if s.startswith("http://schema.org"):
                props.update({s:graph.identifier})

        for p in sorted(props.keys()):
            self.outputProp(p,graph)
            
        self.dom.append(Comment("\n\t/////////////////////\n\t/ Named Individuals Definitions\n\t/////////////////////\n\t"))
        self.outputEnums(graph)
        self.outputNamedIndividuals(VOCABURI + "True",graph)    
        self.outputNamedIndividuals(VOCABURI + "False",graph)    

    def outputType(self, uri, graph):
        self.typesCount += 1
        
        typ = SubElement(self.dom,"owl:Class")
        typ.set("rdf:about",uri)
        ext = None
        for (p,o) in graph.predicate_objects(uri):
            if p == RDFS.label:
                l = SubElement(typ,"rdfs:label")
                l.set("xml:lang","en")
                l.text = o
            elif p == RDFS.comment:
                c = SubElement(typ,"rdfs:comment")
                c.set("xml:lang","en")
                c.text = Markdown.parse(o)
            elif p == RDFS.subClassOf:
                s = SubElement(typ,"rdfs:subClassOf")
                s.set("rdf:resource",o)
            elif p == URIRef(VOCABURI + "isPartOf"): #Defined in an extension
                ext = str(o)
            elif p == RDF.type and o == URIRef(VOCABURI + "DataType"): #A datatype
                s = SubElement(typ,"rdfs:subClassOf")
                s.set("rdf:resource",VOCABURI + "DataType")
        
        typ.append(self.addDefined(uri,ext))
                
    def outputProp(self,uri, graph):
        self.propsCount += 1
        children = []
        domains = {}
        ranges = []
        datatypeonly = True
        ext = None        
        for (p,o) in graph.predicate_objects(uri):
            if p == RDFS.label:
                l = Element("rdfs:label")
                l.set("xml:lang","en")
                l.text = o
                children.append(l)
            elif p == RDFS.comment:
                c = Element("rdfs:comment")
                c.set("xml:lang","en")
                c.text = Markdown.parse(o)
                children.append(c)
            elif p == RDFS.subPropertyOf:
                sub = Element("rdfs:subPropertyOf")
                subval = str(o)
                if subval == "rdf:type":  #Fixes a special case with schema:additionalType
                    subval = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
                    
                sub.set("rdf:resource",subval)
                children.append(sub)
            elif p == INVERSEOF:
                sub = Element("owl:inverseOf")
                sub.set("rdf:resource",o)
                children.append(sub)
            elif p == SUPERSEDEDBY:
                sub = Element("schema:supersededBy")
                sub.set("rdf:resource",o)
                children.append(sub)
            elif p == DOMAININC:
                domains[o] = True
            elif p == RANGEINC:
                ranges.append(str(o))
                if str(o) not in DATATYPES:
                    datatypeonly = False
            elif p == URIRef(VOCABURI + "isPartOf"):
                ext = str(o)
                
        children.append(self.addDefined(uri,ext))
                
                
        if not datatypeonly:
            for r in DEFAULTRANGES:
                if r not in ranges:
                    ranges.append(r)
                
        if len(domains):
            d = Element("rdfs:domain")
            children.append(d)
            cl = SubElement(d,"owl:Class")
            u = SubElement(cl,"owl:unionOf")
            u.set("rdf:parseType","Collection")
            for target in domains.keys():
                targ = SubElement(u,"owl:Class")
                targ.set("rdf:about",target)

        if len(ranges):
            r = Element("rdfs:range")
            children.append(r)
            cl = SubElement(r,"owl:Class")
            u = SubElement(cl,"owl:unionOf")
            u.set("rdf:parseType","Collection")
            for target in ranges:
                targ = SubElement(u,"owl:Class")
                targ.set("rdf:about",target)
                
                
        if datatypeonly:
            prop = SubElement(self.dom,"owl:DatatypeProperty")            
        else:
            prop = SubElement(self.dom,"owl:ObjectProperty")
        prop.set("rdf:about",uri)
        for sub in children:
            prop.append(sub)
            
    def addDefined(self,uri,ext=None):
        if not ext:
            ext = "http://schema.org"
        ext = ext.replace("http://", "https://")
        defn = Element("rdfs:isDefinedBy")
        path = "%s/%s" % (ext,os.path.basename(uri))
        defn.set("rdf:resource",path)
        return defn
        
                

    def outputEnums(self,graph):
        q = """ prefix schema: <http://schema.org/>
        select Distinct ?enum ?parent where{
    		?parent rdfs:subClassOf schema:Enumeration.
            ?enum rdfs:subClassOf ?parent.
        }
        """
        enums = list(graph.query(q))
        #log.info("Enum Count %s" % len(enums))
        for row in enums:
            self.outputNamedIndividuals(row.enum,graph,parent=row.parent)
        
    def outputNamedIndividuals(self,idividual,graph,parent=None):
        self.namedCount += 1
        
        typ = SubElement(self.dom,"owl:NamedIndividual")
        typ.set("rdf:about",idividual)
        ext = None
        for (p,o) in graph.predicate_objects(URIRef(idividual)):
            if p == RDFS.label:
                l = SubElement(typ,"rdfs:label")
                l.set("xml:lang","en")
                l.text = o
            elif p == RDFS.comment:
                c = SubElement(typ,"rdfs:comment")
                c.set("xml:lang","en")
                c.text = Markdown.parse(o)
            elif p == URIRef(VOCABURI + "isPartOf"):
                ext = str(o)

        typ.append(self.addDefined(idividual,ext))

        if parent:
            s = SubElement(typ,"rdfs:subClassOf")
            s.set("rdf:resource",parent)
Example #40
0
    def Udacity2Voc(self,
                    dataSet_dir="example/udacity/",
                    anno_dir="label/labels.csv",
                    label_dir="results/",
                    label_list=None):
        print(
            color.BOLD + color.RED +
            "------------------------- CSV Parsing Start-------------------------"
            + color.END)

        if label_list is None:
            label_list = self.label_list

        work_dir = getcwd() + "/" + dataSet_dir
        anno_dir = work_dir + anno_dir
        label_dir = work_dir + label_dir

        print("Input file : {}".format(anno_dir))

        f = open(anno_dir, 'r', encoding='utf-8')
        l = csv.reader(f)
        try:
            for line in l:
                print(
                    color.BOLD + color.RED +
                    "------------------------- CSV Parsing -------------------------"
                    + color.END)
                convertList = line[0].split(" ")
                length = len(convertList)

                image_name = convertList[0]
                xmin = convertList[1]
                ymin = convertList[2]
                xmax = convertList[3]
                ymax = convertList[4]
                label = convertList[6].split('"')[1]

                if length is 8:
                    state = convertList[7].split('"')[1]
                    label = label + state

                # Open output result files

                img = Image.open(dataSet_dir + "JPEG/" + image_name)
                img_width = int(img.size[0])
                img_height = int(img.size[1])
                img_depth = 3  #int(img.size[2])

                print("image size (width, height) : {}".format(img.size))
                print()

                print("Output : {}".format(label_dir + image_name[:-3] +
                                           "xml"))
                print()

                print("class name, index : ({})".format(label))

                result_outpath = str(label_dir + image_name[:-3] + "xml")

                if not os.path.isfile(result_outpath):
                    xml_annotation = Element("annotation")

                    xml_folder = Element("folder")
                    xml_folder.text = "udacity"

                    xml_annotation.append(xml_folder)

                    xml_filename = Element("filename")
                    xml_filename.text = str(image_name)
                    xml_annotation.append(xml_filename)

                    xml_path = Element("path")
                    xml_path.text = str(label_dir + image_name)
                    xml_annotation.append(xml_path)

                    xml_source = Element("source")

                    xml_database = Element("database")
                    xml_database.text = "Unknown"
                    xml_source.append(xml_database)
                    xml_annotation.append(xml_source)

                    xml_size = Element("size")
                    xml_width = Element("width")
                    xml_width.text = str(img_width)
                    xml_size.append(xml_width)

                    xml_height = Element("height")
                    xml_height.text = str(img_height)
                    xml_size.append(xml_height)

                    xml_depth = Element("depth")
                    xml_depth.text = str(img_depth)
                    xml_size.append(xml_depth)

                    xml_annotation.append(xml_size)

                    xml_segmented = Element("segmented")
                    xml_segmented.text = "0"

                    xml_annotation.append(xml_segmented)

                    xml_object = Element("object")

                    xml_name = Element("name")
                    xml_name.text = label
                    xml_object.append(xml_name)

                    xml_pose = Element("pose")
                    xml_pose.text = "Unspecified"
                    xml_object.append(xml_pose)

                    xml_truncated = Element("truncated")
                    xml_truncated.text = "0"
                    xml_object.append(xml_truncated)

                    xml_difficult = Element("difficult")
                    xml_difficult.text = "0"
                    xml_object.append(xml_difficult)

                    xml_bndbox = Element("bndbox")
                    xml_xmin = Element("xmin")
                    xml_xmin.text = str(xmin)
                    xml_bndbox.append(xml_xmin)

                    xml_ymin = Element("ymin")
                    xml_ymin.text = str(ymin)
                    xml_bndbox.append(xml_ymin)

                    xml_xmax = Element("xmax")
                    xml_xmax.text = str(xmax)
                    xml_bndbox.append(xml_xmax)

                    xml_ymax = Element("ymax")
                    xml_ymax.text = str(ymax)
                    xml_bndbox.append(xml_ymax)
                    xml_object.append(xml_bndbox)

                    xml_annotation.append(xml_object)

                    self.indent(xml_annotation)
                    dump(xml_annotation)
                    ElementTree(xml_annotation).write(result_outpath)
                else:
                    tree = parse(result_outpath)
                    xml_annotation = tree.getroot()
                    xml_object = Element("object")

                    xml_name = Element("name")
                    xml_name.text = label
                    xml_object.append(xml_name)

                    xml_pose = Element("pose")
                    xml_pose.text = "Unspecified"
                    xml_object.append(xml_pose)

                    xml_truncated = Element("truncated")
                    xml_truncated.text = "0"
                    xml_object.append(xml_truncated)

                    xml_difficult = Element("difficult")
                    xml_difficult.text = "0"
                    xml_object.append(xml_difficult)

                    xml_bndbox = Element("bndbox")
                    xml_xmin = Element("xmin")
                    xml_xmin.text = str(xmin)
                    xml_bndbox.append(xml_xmin)

                    xml_ymin = Element("ymin")
                    xml_ymin.text = str(ymin)
                    xml_bndbox.append(xml_ymin)

                    xml_xmax = Element("xmax")
                    xml_xmax.text = str(xmax)
                    xml_bndbox.append(xml_xmax)

                    xml_ymax = Element("ymax")
                    xml_ymax.text = str(ymax)
                    xml_bndbox.append(xml_ymax)
                    xml_object.append(xml_bndbox)

                    xml_annotation.append(xml_object)
                    self.indent(xml_annotation)
                    dump(xml_annotation)
                    ElementTree(xml_annotation).write(result_outpath)

                print(
                    color.BOLD + color.RED +
                    "------------------------- CSV Parsing -------------------------"
                    + color.END)

            print(
                color.BOLD + color.RED +
                "------------------------- CSV Parsing END -------------------------"
                + color.END)
        except Exception as e:
            print(color.BOLD + color.RED + "ERROR : {}".format(e) + color.END)
Example #41
0
def create_node(tag, attribs, text):
    element = Element(tag, attribs)
    element.text = text
    return element
Example #42
0
class _Widget(object):
    def __init__(self, w_type, name, x_pos, y_pos, width, height):
        self.root = Element('widget', type=w_type, version='2.0.0')
        name_child = SubElement(self.root, 'name')
        name_child.text = name

        shared_functions = _SharedPropertyFunctions(self.root)
        shared_functions.integer_property('x', x_pos)
        shared_functions.integer_property('y', y_pos)
        shared_functions.integer_property('width', width)
        shared_functions.integer_property('height', height)

        self._prop_factory = Property(self.root)

    def visible(self, visible):
        child = SubElement(self.root, 'visible')
        child.text = str(visible)

    def version(self, version):
        self.root.attrib['version'] = version

    #def class_name(self, name):
    #    pass

    #def rule(self, rule):
    #    pass

    #def scripts(self, script):
    #    pass

    def tool_tip(self, tool_tip):
        child = SubElement(self.root, 'tooltip')
        child.text = tool_tip

    def find_element(self, tag):
        elements = self.root.findall(tag)
        # check to make sure there are not more than 1 elements
        # we don't want duplicate tags
        if len(elements) > 1:
            print(
                'Warning, more than one element of the same tag! Returning a list'
            )
            return elements
        elif len(elements) == 0:
            return None
        else:
            return elements[0]

    def remove_element(self, tag):
        element = self.find_element(tag)
        if element is not None:
            self.root.remove(element)

    def get_element_value(self, tag):
        return self.find_element(tag).text

    # From: https://pymotw.com/3/xml.etree.ElementTree/create.html
    def prettify(self, elem):
        """Return a pretty-printed XML string for the Element.
        """
        rough_string = tostring(elem, 'utf-8')
        reparse_xml = minidom.parseString(rough_string)
        return reparse_xml.toprettyxml(indent="  ", newl="\n")

    def __str__(self):
        return self.prettify(self.root)

    def __repr__(self):
        return self.prettify(self.root)
Example #43
0
from xml.etree.ElementTree import Element, dump, SubElement

note = Element("note")
to = Element("tos")  #자식 노드
to.text = "Tove"
note.append(to)

SubElement(note, "from").text = "Jani"
note.attrib["data"] = "20120104"

dump(note)
Example #44
0
    def outputProp(self,uri, graph):
        self.propsCount += 1
        children = []
        domains = {}
        ranges = []
        datatypeonly = True
        ext = None        
        for (p,o) in graph.predicate_objects(uri):
            if p == RDFS.label:
                l = Element("rdfs:label")
                l.set("xml:lang","en")
                l.text = o
                children.append(l)
            elif p == RDFS.comment:
                c = Element("rdfs:comment")
                c.set("xml:lang","en")
                c.text = Markdown.parse(o)
                children.append(c)
            elif p == RDFS.subPropertyOf:
                sub = Element("rdfs:subPropertyOf")
                subval = str(o)
                if subval == "rdf:type":  #Fixes a special case with schema:additionalType
                    subval = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
                    
                sub.set("rdf:resource",subval)
                children.append(sub)
            elif p == INVERSEOF:
                sub = Element("owl:inverseOf")
                sub.set("rdf:resource",o)
                children.append(sub)
            elif p == SUPERSEDEDBY:
                sub = Element("schema:supersededBy")
                sub.set("rdf:resource",o)
                children.append(sub)
            elif p == DOMAININC:
                domains[o] = True
            elif p == RANGEINC:
                ranges.append(str(o))
                if str(o) not in DATATYPES:
                    datatypeonly = False
            elif p == URIRef(VOCABURI + "isPartOf"):
                ext = str(o)
                
        children.append(self.addDefined(uri,ext))
                
                
        if not datatypeonly:
            for r in DEFAULTRANGES:
                if r not in ranges:
                    ranges.append(r)
                
        if len(domains):
            d = Element("rdfs:domain")
            children.append(d)
            cl = SubElement(d,"owl:Class")
            u = SubElement(cl,"owl:unionOf")
            u.set("rdf:parseType","Collection")
            for target in domains.keys():
                targ = SubElement(u,"owl:Class")
                targ.set("rdf:about",target)

        if len(ranges):
            r = Element("rdfs:range")
            children.append(r)
            cl = SubElement(r,"owl:Class")
            u = SubElement(cl,"owl:unionOf")
            u.set("rdf:parseType","Collection")
            for target in ranges:
                targ = SubElement(u,"owl:Class")
                targ.set("rdf:about",target)
                
                
        if datatypeonly:
            prop = SubElement(self.dom,"owl:DatatypeProperty")            
        else:
            prop = SubElement(self.dom,"owl:ObjectProperty")
        prop.set("rdf:about",uri)
        for sub in children:
            prop.append(sub)
Example #45
0
 def get_attr_id(self, title, attr_type, edge_or_node, default, mode):
     # find the id of the attribute or generate a new id
     try:
         return self.attr[edge_or_node][mode][title]
     except KeyError:
         # generate new id
         new_id = str(next(self.attr_id))
         self.attr[edge_or_node][mode][title] = new_id
         attr_kwargs = {"id": new_id, "title": title, "type": attr_type}
         attribute = Element("attribute", **attr_kwargs)
         # add subelement for data default value if present
         default_title = default.get(title)
         if default_title is not None:
             default_element = Element("default")
             default_element.text = str(default_title)
             attribute.append(default_element)
         # new insert it into the XML
         attributes_element = None
         for a in self.graph_element.findall("attributes"):
             # find existing attributes element by class and mode
             a_class = a.get("class")
             a_mode = a.get("mode", "static")
             if a_class == edge_or_node and a_mode == mode:
                 attributes_element = a
         if attributes_element is None:
             # create new attributes element
             attr_kwargs = {"mode": mode, "class": edge_or_node}
             attributes_element = Element("attributes", **attr_kwargs)
             self.graph_element.insert(0, attributes_element)
         attributes_element.append(attribute)
     return new_id
Example #46
0
    def _ep_data(self, ep_obj):
        """
        Creates an elementTree XML structure for a WDTV style episode.xml
        and returns the resulting data object.

        ep_obj: a TVShow instance to create the NFO for
        """

        eps_to_write = [ep_obj] + ep_obj.related_episodes

        indexer_lang = ep_obj.show.lang or sickrage.app.config.indexer_default_language

        lINDEXER_API_PARMS = IndexerApi(ep_obj.show.indexer).api_params.copy()
        lINDEXER_API_PARMS['language'] = indexer_lang

        if ep_obj.show.dvdorder != 0:
            lINDEXER_API_PARMS['dvdorder'] = True

        t = IndexerApi(ep_obj.show.indexer).indexer(**lINDEXER_API_PARMS)
        myShow = t[ep_obj.show.indexer_id]
        if not myShow:
            return False

        rootNode = Element("details")

        # write an WDTV XML containing info for all matching episodes
        for curEpToWrite in eps_to_write:
            try:
                myEp = myShow[curEpToWrite.season][curEpToWrite.episode]
            except (indexer_episodenotfound, indexer_seasonnotfound):
                sickrage.app.log.info(
                    "Unable to find episode %dx%d on %s... has it been removed? Should I delete from db?"
                    % (curEpToWrite.season, curEpToWrite.episode,
                       IndexerApi(ep_obj.show.indexer).name))
                return None

            if ep_obj.season == 0 and not getattr(myEp, 'firstaired', None):
                myEp["firstaired"] = str(datetime.date.min)

            if not (getattr(myEp, 'episodename', None)
                    and getattr(myEp, 'firstaired', None)):
                return None

            if len(eps_to_write) > 1:
                episode = SubElement(rootNode, "details")
            else:
                episode = rootNode

            # TODO: get right EpisodeID
            episodeID = SubElement(episode, "id")
            episodeID.text = str(curEpToWrite.indexer_id)

            title = SubElement(episode, "title")
            title.text = ep_obj.pretty_name()

            if getattr(myShow, 'seriesname', None):
                seriesName = SubElement(episode, "series_name")
                seriesName.text = myShow["seriesname"]

            if curEpToWrite.name:
                episodeName = SubElement(episode, "episode_name")
                episodeName.text = curEpToWrite.name

            seasonNumber = SubElement(episode, "season_number")
            seasonNumber.text = str(curEpToWrite.season)

            episodeNum = SubElement(episode, "episode_number")
            episodeNum.text = str(curEpToWrite.episode)

            firstAired = SubElement(episode, "firstaired")

            if curEpToWrite.airdate > datetime.date.min:
                firstAired.text = str(curEpToWrite.airdate)

            if getattr(myShow, 'firstaired', None):
                try:
                    year_text = str(
                        datetime.datetime.strptime(myShow["firstaired"],
                                                   dateFormat).year)
                    if year_text:
                        year = SubElement(episode, "year")
                        year.text = year_text
                except Exception:
                    pass

            if curEpToWrite.season != 0 and getattr(myShow, 'runtime', None):
                runtime = SubElement(episode, "runtime")
                runtime.text = myShow["runtime"]

            if getattr(myShow, 'genre', None):
                genre = SubElement(episode, "genre")
                genre.text = " / ".join([
                    x.strip() for x in myShow["genre"].split('|') if x.strip()
                ])

            if getattr(myEp, 'director', None):
                director = SubElement(episode, "director")
                director.text = myEp['director']

            for actor in t.actors(int(ep_obj.show.indexer_id)):
                if not ('name' in actor and actor['name'].strip()):
                    continue

                cur_actor = SubElement(episode, "actor")

                cur_actor_name = SubElement(cur_actor, "name")
                cur_actor_name.text = actor['name']

                if 'role' in actor and actor['role'].strip():
                    cur_actor_role = SubElement(cur_actor, "role")
                    cur_actor_role.text = actor['role'].strip()

            if curEpToWrite.description:
                overview = SubElement(episode, "overview")
                overview.text = curEpToWrite.description

        # Make it purdy
        indent_xml(rootNode)
        data = ElementTree(rootNode)
        return data
Example #47
0
    def add_edges(self, G, graph_element):
        def edge_key_data(G):
            # helper function to unify multigraph and graph edge iterator
            if G.is_multigraph():
                for u, v, key, data in G.edges(data=True, keys=True):
                    edge_data = data.copy()
                    edge_data.update(key=key)
                    edge_id = edge_data.pop("id", None)
                    if edge_id is None:
                        edge_id = next(self.edge_id)
                        while str(edge_id) in self.all_edge_ids:
                            edge_id = next(self.edge_id)
                        self.all_edge_ids.add(str(edge_id))
                    yield u, v, edge_id, edge_data
            else:
                for u, v, data in G.edges(data=True):
                    edge_data = data.copy()
                    edge_id = edge_data.pop("id", None)
                    if edge_id is None:
                        edge_id = next(self.edge_id)
                        while str(edge_id) in self.all_edge_ids:
                            edge_id = next(self.edge_id)
                        self.all_edge_ids.add(str(edge_id))
                    yield u, v, edge_id, edge_data

        edges_element = Element("edges")
        for u, v, key, edge_data in edge_key_data(G):
            kw = {"id": str(key)}
            try:
                edge_label = edge_data.pop("label")
                kw["label"] = str(edge_label)
            except KeyError:
                pass
            try:
                edge_weight = edge_data.pop("weight")
                kw["weight"] = str(edge_weight)
            except KeyError:
                pass
            try:
                edge_type = edge_data.pop("type")
                kw["type"] = str(edge_type)
            except KeyError:
                pass
            try:
                start = edge_data.pop("start")
                kw["start"] = str(start)
                self.alter_graph_mode_timeformat(start)
            except KeyError:
                pass
            try:
                end = edge_data.pop("end")
                kw["end"] = str(end)
                self.alter_graph_mode_timeformat(end)
            except KeyError:
                pass
            source_id = str(G.nodes[u].get("id", u))
            target_id = str(G.nodes[v].get("id", v))
            edge_element = Element("edge",
                                   source=source_id,
                                   target=target_id,
                                   **kw)
            default = G.graph.get("edge_default", {})
            if self.VERSION == "1.1":
                edge_data = self.add_slices(edge_element, edge_data)
            else:
                edge_data = self.add_spells(edge_element, edge_data)
            edge_data = self.add_viz(edge_element, edge_data)
            edge_data = self.add_attributes("edge", edge_element, edge_data,
                                            default)
            edges_element.append(edge_element)
        graph_element.append(edges_element)
Example #48
0
  def outputLdml(self, parsed_json):
    # Create a tree
    tag = 'keyboard'
    if 'locale' in parsed_json:
      attrib = {'locale': parsed_json['locale']}
    else:
      attrib = {'locale': parsed_json['id']}

    elem = Element(tag, attrib)
    tree = ElementTree(elem)

    version = Element('version', {'platform': '10', 'number': '1.0'})
    elem.append(version)
    names = Element('names')
    name = Element('name', {'value': parsed_json['title']})
    names.append(name)
    elem.append(names)
    settings = Element('settings', {'fallback': 'omit',
                                    'transformPartial': 'hide'})
    elem.append(settings)

    displayMap = None

    # Get all the key mappings for each level

    # Output each layer
    for layer in parsed_json['mappings']:
      try:
        modifier_value = self.layers_to_modifiers[layer]
      except:
        modifier_value = 'UNKNOWN'
        print('Modifier value unknown: %s', layer)
      modifiers = {'modifiers': modifier_value}
      if modifier_value:
        keymap = Element('keyMap', modifiers)
      else:
        keymap = Element('keyMap')

      elements = parsed_json['mappings'][layer]
      for start_point in elements:
        # Get the key mappings.
        mapping_string = elements[start_point]
        codes = self.mapping_parse.split(mapping_string)
        maps = []

        if start_point == '':
          # The whole list E00 ... A3
          keys = []
          for row in self.maprows:
            self.row_base[row]
            self.row_max[row]
            for col in range(self.row_base[row], self.row_max[row]):
              keys.append('%s%02d' % (row, col))
        else:
          keys=[]
          print('STARTING SOMEWHERE ELSE')

        index = 0

        # If there's an A03 element, add this too!
        # TODO:
        #  For anything with keycaps, e.g., {{S||ᐊᐱᓯ||\u202f}},
        #  add display mapping.
        for code in codes:
          if code and index < len(keys):
            output = code
            # Remove {{ }} if needed
            if code[0] == '{' and len(code) > 1 and code[1]== '{':
              if code[2:5] == "S||":
                parts = code.split('||')
                display = parts[1]

                output = parts[2][:-2]
                if display:
                  if not displayMap:
                    displayMap = Element('displayMap')
                  displayElement = Element('display', {'mapOutput': output,
                                                       'display': display})
                  displayMap.append(displayElement)
              else:
                # Get the contents only
                output = code[2:-2]

            if output:
              map_content = {'iso': keys[index],
                             'to': output}
              map = Element('map', map_content)
              keymap.append(map)
            index += 1
      elem.append(keymap)
    if displayMap:
      elem.append(displayMap)

    # transform items
    if parsed_json['transform']:
      transforms = Element('transforms', {'type': 'simple'})
      keys = parsed_json['transform'].keys()
      for key in keys:
        key_parts = key.split('|')
        for part in key_parts:
          to_item = parsed_json['transform'][key]
          transform = Element('transform',
                        {'from': part, 'to': to_item})
          transforms.append(transform)
      elem.append(transforms)

    xml_output = ET.tostring(elem, encoding='utf-8')

    # Add header info
    doctype = '<!DOCTYPE keyboard SYSTEM "../dtd/ldmlKeyboard.dtd">\n'
    return doctype + xml_output
Example #49
0
    def as_xml(self):
        is_protocol_supported = True if len(
            self.accepted_cipher_list) > 0 else False
        result_xml = Element(self.scan_command.get_cli_argument(),
                             title=self.scan_command.get_title(),
                             isProtocolSupported=str(is_protocol_supported))

        # Output the preferred cipher
        preferred_xml = Element('preferredCipherSuite')
        if self.preferred_cipher:
            preferred_xml.append(
                self._format_accepted_cipher_xml(self.preferred_cipher))
        result_xml.append(preferred_xml)

        # Output all the accepted ciphers if any
        accepted_xml = Element('acceptedCipherSuites')
        if len(self.accepted_cipher_list) > 0:
            for cipher in self.accepted_cipher_list:
                accepted_xml.append(self._format_accepted_cipher_xml(cipher))
        result_xml.append(accepted_xml)

        # Output all the rejected ciphers if any
        rejected_xml = Element('rejectedCipherSuites')
        if len(self.rejected_cipher_list) > 0:
            for cipher in self.rejected_cipher_list:
                cipher_xml = Element('cipherSuite',
                                     attrib={
                                         'name':
                                         cipher.name,
                                         'anonymous':
                                         str(cipher.is_anonymous),
                                         'connectionStatus':
                                         cipher.handshake_error_message
                                     })
                rejected_xml.append(cipher_xml)
        result_xml.append(rejected_xml)

        # Output all the errored ciphers if any
        error_xml = Element('errors')
        if len(self.errored_cipher_list) > 0:
            for cipher in self.errored_cipher_list:
                cipher_xml = Element('cipherSuite',
                                     attrib={
                                         'name': cipher.name,
                                         'anonymous': str(cipher.is_anonymous),
                                         'connectionStatus':
                                         cipher.error_message
                                     })
                error_xml.append(cipher_xml)
        result_xml.append(error_xml)

        return result_xml
Example #50
0
 def add_attributes(self, node_or_edge, xml_obj, data, default):
     # Add attrvalues to node or edge
     attvalues = Element("attvalues")
     if len(data) == 0:
         return data
     mode = "static"
     for k, v in data.items():
         # rename generic multigraph key to avoid any name conflict
         if k == "key":
             k = "networkx_key"
         val_type = type(v)
         if val_type not in self.xml_type:
             raise TypeError(
                 f"attribute value type is not allowed: {val_type}")
         if isinstance(v, list):
             # dynamic data
             for val, start, end in v:
                 val_type = type(val)
                 if start is not None or end is not None:
                     mode = "dynamic"
                     self.alter_graph_mode_timeformat(start)
                     self.alter_graph_mode_timeformat(end)
                     break
             attr_id = self.get_attr_id(str(k), self.xml_type[val_type],
                                        node_or_edge, default, mode)
             for val, start, end in v:
                 e = Element("attvalue")
                 e.attrib["for"] = attr_id
                 e.attrib["value"] = str(val)
                 # Handle nan, inf, -inf differently
                 if val_type == float:
                     if e.attrib["value"] == "inf":
                         e.attrib["value"] = "INF"
                     elif e.attrib["value"] == "nan":
                         e.attrib["value"] = "NaN"
                     elif e.attrib["value"] == "-inf":
                         e.attrib["value"] = "-INF"
                 if start is not None:
                     e.attrib["start"] = str(start)
                 if end is not None:
                     e.attrib["end"] = str(end)
                 attvalues.append(e)
         else:
             # static data
             mode = "static"
             attr_id = self.get_attr_id(str(k), self.xml_type[val_type],
                                        node_or_edge, default, mode)
             e = Element("attvalue")
             e.attrib["for"] = attr_id
             if isinstance(v, bool):
                 e.attrib["value"] = str(v).lower()
             else:
                 e.attrib["value"] = str(v)
                 # Handle float nan, inf, -inf differently
                 if val_type == float:
                     if e.attrib["value"] == "inf":
                         e.attrib["value"] = "INF"
                     elif e.attrib["value"] == "nan":
                         e.attrib["value"] = "NaN"
                     elif e.attrib["value"] == "-inf":
                         e.attrib["value"] = "-INF"
             attvalues.append(e)
     xml_obj.append(attvalues)
     return data
Example #51
0
def do_sample_xml(sub_id):
    sub = Submission().get_record(sub_id)
    dfs = list()
    for d in sub["bundle"]:
        dfs.append(DataFile().get_record(d))
    df = dfs[0]
    # p = Profile().get_record(df["profile_id"])
    sample_set = Element("SAMPLE_SET")
    sample_set.set("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
    sample_set.set("xsi:noNamespaceSchemaLocation",
                   "ftp://ftp.sra.ebi.ac.uk/meta/xsd/sra_1_5/SRA.sample.xsd")

    try:
        smp = get_sample(df)
    except:
        # some submission types do not require samples such as annotation submissions
        if sub["repository"] == "ena-ant":
            return False

    # iterate samples to create xml
    sample = Element("SAMPLE")
    sample_alias = get_sample_ref(df)
    sample.set("alias", sample_alias)
    sample.set(
        "center_name",
        df["description"]["attributes"]["study_type"]["study_center_name"])
    sample_set.append(sample)

    sample_name = Element("SAMPLE_NAME")
    sample_title = Element("TITLE")
    sample_title.text = smp["name"]
    sample.append(sample_title)
    sample.append(sample_name)

    # get Source object for organism
    s = Source().get_record(smp["derivesFrom"][0])
    taxon_id = Element("TAXON_ID")
    # get integer portion of NCBI taxon id
    taxon_id_content = s["organism"]["termAccession"].split('_')[1]
    taxon_id.text = taxon_id_content
    sample_name.append(taxon_id)
    scientific_name = Element("SCIENTIFIC_NAME")
    scientific_name.text = s["organism"]["annotationValue"]
    sample_name.append(scientific_name)
    common_name = Element("COMMON_NAME")
    sample_name.append(common_name)
    sample.append(Element("DESCRIPTION"))

    # do attributes
    attributes = Element("SAMPLE_ATTRIBUTES")
    for c in smp["characteristics"]:
        ch = Element("SAMPLE_ATTRIBUTE")
        tag = Element("TAG")
        tag.text = c["category"]["annotationValue"]
        value = Element("VALUE")
        value.text = c["value"]["annotationValue"]
        unit = Element("UNIT")
        unit.text = c["unit"]["annotationValue"]
        ch.append(tag)
        ch.append(value)
        ch.append(unit)
        attributes.append(ch)
    for c in smp["factorValues"]:
        ch = Element("SAMPLE_ATTRIBUTE")
        tag = Element("TAG")
        tag.text = c["category"]["annotationValue"]
        value = Element("VALUE")
        value.text = c["value"]["annotationValue"]
        unit = Element("UNIT")
        unit.text = c["unit"]["annotationValue"]
        ch.append(tag)
        ch.append(value)
        ch.append(unit)
        attributes.append(ch)

    sample.append(attributes)

    return prettify(sample_set)
Example #52
0
class GEXFWriter(GEXF):
    # class for writing GEXF format files
    # use write_gexf() function
    def __init__(self,
                 graph=None,
                 encoding="utf-8",
                 prettyprint=True,
                 version="1.2draft"):
        self.construct_types()
        self.prettyprint = prettyprint
        self.encoding = encoding
        self.set_version(version)
        self.xml = Element(
            "gexf",
            {
                "xmlns": self.NS_GEXF,
                "xmlns:xsi": self.NS_XSI,
                "xsi:schemaLocation": self.SCHEMALOCATION,
                "version": self.VERSION,
            },
        )

        # Make meta element a non-graph element
        # Also add lastmodifieddate as attribute, not tag
        meta_element = Element("meta")
        subelement_text = f"NetworkX {nx.__version__}"
        SubElement(meta_element, "creator").text = subelement_text
        meta_element.set("lastmodifieddate", time.strftime("%Y-%m-%d"))
        self.xml.append(meta_element)

        register_namespace("viz", self.NS_VIZ)

        # counters for edge and attribute identifiers
        self.edge_id = itertools.count()
        self.attr_id = itertools.count()
        self.all_edge_ids = set()
        # default attributes are stored in dictionaries
        self.attr = {}
        self.attr["node"] = {}
        self.attr["edge"] = {}
        self.attr["node"]["dynamic"] = {}
        self.attr["node"]["static"] = {}
        self.attr["edge"]["dynamic"] = {}
        self.attr["edge"]["static"] = {}

        if graph is not None:
            self.add_graph(graph)

    def __str__(self):
        if self.prettyprint:
            self.indent(self.xml)
        s = tostring(self.xml).decode(self.encoding)
        return s

    def add_graph(self, G):
        # first pass through G collecting edge ids
        for u, v, dd in G.edges(data=True):
            eid = dd.get("id")
            if eid is not None:
                self.all_edge_ids.add(str(eid))
        # set graph attributes
        if G.graph.get("mode") == "dynamic":
            mode = "dynamic"
        else:
            mode = "static"
        # Add a graph element to the XML
        if G.is_directed():
            default = "directed"
        else:
            default = "undirected"
        name = G.graph.get("name", "")
        graph_element = Element("graph",
                                defaultedgetype=default,
                                mode=mode,
                                name=name)
        self.graph_element = graph_element
        self.add_nodes(G, graph_element)
        self.add_edges(G, graph_element)
        self.xml.append(graph_element)

    def add_nodes(self, G, graph_element):
        nodes_element = Element("nodes")
        for node, data in G.nodes(data=True):
            node_data = data.copy()
            node_id = str(node_data.pop("id", node))
            kw = {"id": node_id}
            label = str(node_data.pop("label", node))
            kw["label"] = label
            try:
                pid = node_data.pop("pid")
                kw["pid"] = str(pid)
            except KeyError:
                pass
            try:
                start = node_data.pop("start")
                kw["start"] = str(start)
                self.alter_graph_mode_timeformat(start)
            except KeyError:
                pass
            try:
                end = node_data.pop("end")
                kw["end"] = str(end)
                self.alter_graph_mode_timeformat(end)
            except KeyError:
                pass
            # add node element with attributes
            node_element = Element("node", **kw)
            # add node element and attr subelements
            default = G.graph.get("node_default", {})
            node_data = self.add_parents(node_element, node_data)
            if self.VERSION == "1.1":
                node_data = self.add_slices(node_element, node_data)
            else:
                node_data = self.add_spells(node_element, node_data)
            node_data = self.add_viz(node_element, node_data)
            node_data = self.add_attributes("node", node_element, node_data,
                                            default)
            nodes_element.append(node_element)
        graph_element.append(nodes_element)

    def add_edges(self, G, graph_element):
        def edge_key_data(G):
            # helper function to unify multigraph and graph edge iterator
            if G.is_multigraph():
                for u, v, key, data in G.edges(data=True, keys=True):
                    edge_data = data.copy()
                    edge_data.update(key=key)
                    edge_id = edge_data.pop("id", None)
                    if edge_id is None:
                        edge_id = next(self.edge_id)
                        while str(edge_id) in self.all_edge_ids:
                            edge_id = next(self.edge_id)
                        self.all_edge_ids.add(str(edge_id))
                    yield u, v, edge_id, edge_data
            else:
                for u, v, data in G.edges(data=True):
                    edge_data = data.copy()
                    edge_id = edge_data.pop("id", None)
                    if edge_id is None:
                        edge_id = next(self.edge_id)
                        while str(edge_id) in self.all_edge_ids:
                            edge_id = next(self.edge_id)
                        self.all_edge_ids.add(str(edge_id))
                    yield u, v, edge_id, edge_data

        edges_element = Element("edges")
        for u, v, key, edge_data in edge_key_data(G):
            kw = {"id": str(key)}
            try:
                edge_label = edge_data.pop("label")
                kw["label"] = str(edge_label)
            except KeyError:
                pass
            try:
                edge_weight = edge_data.pop("weight")
                kw["weight"] = str(edge_weight)
            except KeyError:
                pass
            try:
                edge_type = edge_data.pop("type")
                kw["type"] = str(edge_type)
            except KeyError:
                pass
            try:
                start = edge_data.pop("start")
                kw["start"] = str(start)
                self.alter_graph_mode_timeformat(start)
            except KeyError:
                pass
            try:
                end = edge_data.pop("end")
                kw["end"] = str(end)
                self.alter_graph_mode_timeformat(end)
            except KeyError:
                pass
            source_id = str(G.nodes[u].get("id", u))
            target_id = str(G.nodes[v].get("id", v))
            edge_element = Element("edge",
                                   source=source_id,
                                   target=target_id,
                                   **kw)
            default = G.graph.get("edge_default", {})
            if self.VERSION == "1.1":
                edge_data = self.add_slices(edge_element, edge_data)
            else:
                edge_data = self.add_spells(edge_element, edge_data)
            edge_data = self.add_viz(edge_element, edge_data)
            edge_data = self.add_attributes("edge", edge_element, edge_data,
                                            default)
            edges_element.append(edge_element)
        graph_element.append(edges_element)

    def add_attributes(self, node_or_edge, xml_obj, data, default):
        # Add attrvalues to node or edge
        attvalues = Element("attvalues")
        if len(data) == 0:
            return data
        mode = "static"
        for k, v in data.items():
            # rename generic multigraph key to avoid any name conflict
            if k == "key":
                k = "networkx_key"
            val_type = type(v)
            if val_type not in self.xml_type:
                raise TypeError(
                    f"attribute value type is not allowed: {val_type}")
            if isinstance(v, list):
                # dynamic data
                for val, start, end in v:
                    val_type = type(val)
                    if start is not None or end is not None:
                        mode = "dynamic"
                        self.alter_graph_mode_timeformat(start)
                        self.alter_graph_mode_timeformat(end)
                        break
                attr_id = self.get_attr_id(str(k), self.xml_type[val_type],
                                           node_or_edge, default, mode)
                for val, start, end in v:
                    e = Element("attvalue")
                    e.attrib["for"] = attr_id
                    e.attrib["value"] = str(val)
                    # Handle nan, inf, -inf differently
                    if val_type == float:
                        if e.attrib["value"] == "inf":
                            e.attrib["value"] = "INF"
                        elif e.attrib["value"] == "nan":
                            e.attrib["value"] = "NaN"
                        elif e.attrib["value"] == "-inf":
                            e.attrib["value"] = "-INF"
                    if start is not None:
                        e.attrib["start"] = str(start)
                    if end is not None:
                        e.attrib["end"] = str(end)
                    attvalues.append(e)
            else:
                # static data
                mode = "static"
                attr_id = self.get_attr_id(str(k), self.xml_type[val_type],
                                           node_or_edge, default, mode)
                e = Element("attvalue")
                e.attrib["for"] = attr_id
                if isinstance(v, bool):
                    e.attrib["value"] = str(v).lower()
                else:
                    e.attrib["value"] = str(v)
                    # Handle float nan, inf, -inf differently
                    if val_type == float:
                        if e.attrib["value"] == "inf":
                            e.attrib["value"] = "INF"
                        elif e.attrib["value"] == "nan":
                            e.attrib["value"] = "NaN"
                        elif e.attrib["value"] == "-inf":
                            e.attrib["value"] = "-INF"
                attvalues.append(e)
        xml_obj.append(attvalues)
        return data

    def get_attr_id(self, title, attr_type, edge_or_node, default, mode):
        # find the id of the attribute or generate a new id
        try:
            return self.attr[edge_or_node][mode][title]
        except KeyError:
            # generate new id
            new_id = str(next(self.attr_id))
            self.attr[edge_or_node][mode][title] = new_id
            attr_kwargs = {"id": new_id, "title": title, "type": attr_type}
            attribute = Element("attribute", **attr_kwargs)
            # add subelement for data default value if present
            default_title = default.get(title)
            if default_title is not None:
                default_element = Element("default")
                default_element.text = str(default_title)
                attribute.append(default_element)
            # new insert it into the XML
            attributes_element = None
            for a in self.graph_element.findall("attributes"):
                # find existing attributes element by class and mode
                a_class = a.get("class")
                a_mode = a.get("mode", "static")
                if a_class == edge_or_node and a_mode == mode:
                    attributes_element = a
            if attributes_element is None:
                # create new attributes element
                attr_kwargs = {"mode": mode, "class": edge_or_node}
                attributes_element = Element("attributes", **attr_kwargs)
                self.graph_element.insert(0, attributes_element)
            attributes_element.append(attribute)
        return new_id

    def add_viz(self, element, node_data):
        viz = node_data.pop("viz", False)
        if viz:
            color = viz.get("color")
            if color is not None:
                if self.VERSION == "1.1":
                    e = Element(
                        f"{{{self.NS_VIZ}}}color",
                        r=str(color.get("r")),
                        g=str(color.get("g")),
                        b=str(color.get("b")),
                    )
                else:
                    e = Element(
                        f"{{{self.NS_VIZ}}}color",
                        r=str(color.get("r")),
                        g=str(color.get("g")),
                        b=str(color.get("b")),
                        a=str(color.get("a")),
                    )
                element.append(e)

            size = viz.get("size")
            if size is not None:
                e = Element(f"{{{self.NS_VIZ}}}size", value=str(size))
                element.append(e)

            thickness = viz.get("thickness")
            if thickness is not None:
                e = Element(f"{{{self.NS_VIZ}}}thickness",
                            value=str(thickness))
                element.append(e)

            shape = viz.get("shape")
            if shape is not None:
                if shape.startswith("http"):
                    e = Element(f"{{{self.NS_VIZ}}}shape",
                                value="image",
                                uri=str(shape))
                else:
                    e = Element(f"{{{self.NS_VIZ}}}shape", value=str(shape))
                element.append(e)

            position = viz.get("position")
            if position is not None:
                e = Element(
                    f"{{{self.NS_VIZ}}}position",
                    x=str(position.get("x")),
                    y=str(position.get("y")),
                    z=str(position.get("z")),
                )
                element.append(e)
        return node_data

    def add_parents(self, node_element, node_data):
        parents = node_data.pop("parents", False)
        if parents:
            parents_element = Element("parents")
            for p in parents:
                e = Element("parent")
                e.attrib["for"] = str(p)
                parents_element.append(e)
            node_element.append(parents_element)
        return node_data

    def add_slices(self, node_or_edge_element, node_or_edge_data):
        slices = node_or_edge_data.pop("slices", False)
        if slices:
            slices_element = Element("slices")
            for start, end in slices:
                e = Element("slice", start=str(start), end=str(end))
                slices_element.append(e)
            node_or_edge_element.append(slices_element)
        return node_or_edge_data

    def add_spells(self, node_or_edge_element, node_or_edge_data):
        spells = node_or_edge_data.pop("spells", False)
        if spells:
            spells_element = Element("spells")
            for start, end in spells:
                e = Element("spell")
                if start is not None:
                    e.attrib["start"] = str(start)
                    self.alter_graph_mode_timeformat(start)
                if end is not None:
                    e.attrib["end"] = str(end)
                    self.alter_graph_mode_timeformat(end)
                spells_element.append(e)
            node_or_edge_element.append(spells_element)
        return node_or_edge_data

    def alter_graph_mode_timeformat(self, start_or_end):
        # If 'start' or 'end' appears, alter Graph mode to dynamic and
        # set timeformat
        if self.graph_element.get("mode") == "static":
            if start_or_end is not None:
                if isinstance(start_or_end, str):
                    timeformat = "date"
                elif isinstance(start_or_end, float):
                    timeformat = "double"
                elif isinstance(start_or_end, int):
                    timeformat = "long"
                else:
                    raise nx.NetworkXError(
                        "timeformat should be of the type int, float or str")
                self.graph_element.set("timeformat", timeformat)
                self.graph_element.set("mode", "dynamic")

    def write(self, fh):
        # Serialize graph G in GEXF to the open fh
        if self.prettyprint:
            self.indent(self.xml)
        document = ElementTree(self.xml)
        document.write(fh, encoding=self.encoding, xml_declaration=True)

    def indent(self, elem, level=0):
        # in-place prettyprint formatter
        i = "\n" + "  " * level
        if len(elem):
            if not elem.text or not elem.text.strip():
                elem.text = i + "  "
            if not elem.tail or not elem.tail.strip():
                elem.tail = i
            for elem in elem:
                self.indent(elem, level + 1)
            if not elem.tail or not elem.tail.strip():
                elem.tail = i
        else:
            if level and (not elem.tail or not elem.tail.strip()):
                elem.tail = i
Example #53
0
def do_analysis_xml(sub_id):
    sub = Submission().get_record(sub_id)
    dfs = list()
    for d in sub["bundle"]:
        dfs.append(DataFile().get_record(d))
    df = dfs[0]
    p = Profile().get_record(df["profile_id"])
    analysis_set = Element("ANALYSIS_SET")
    analysis = Element("ANALYSIS")
    alias = make_alias(sub)
    analysis.set("alias", alias + "_anaysis")
    center_name = df["description"]["attributes"]["study_type"][
        "study_analysis_center_name"]
    analysis.set("analysis_center", center_name)
    broker_name = df["description"]["attributes"]["study_type"]["study_broker"]
    analysis.set("broker_name", broker_name)
    analysis_date = df["description"]["attributes"]["study_type"][
        "study_analysis_date"]
    # ad = analysis_date.split('/')
    # d = datetime.date(int(ad[2]), int(ad[1]), int(ad[0]))
    # analysis.set("anlalysis_date", d)
    # analysis_set.append(analysis)

    title = Element("TITLE")
    title.text = df["description"]["attributes"]["study_type"]["study_title"]
    analysis.append(title)

    description = Element("DESCRIPTION")
    description.text = df["description"]["attributes"]["study_type"][
        "study_description"]
    analysis.append(description)

    study_ref = Element("STUDY_REF")
    study_ref.set("refname", str(sub["_id"]))
    analysis.append(study_ref)

    # TODO - Sample is not required for annotation submissions....ENA documentation saying it is is not correct. Will remove these stages from the wizard at some point
    s_ref = get_sample_ref(df)
    sample_ref = Element("SAMPLE_REF")
    sample_ref.set("refname", s_ref)
    # analysis.append(sample_ref)

    analysis_type = Element("ANALYSIS_TYPE")
    SubElement(analysis_type, "SEQUENCE_ANNOTATION")
    analysis.append(analysis_type)

    files = Element("FILES")
    file = Element("FILE")
    filename = df["name"]
    file_hash = df["file_hash"]

    fqfn = str(
        sub_id) + '/' + data_utils.get_current_user().username + '/' + filename

    file.set("filename", fqfn)
    file.set("filetype", "tab")
    file.set("checksum_method", "MD5")
    file.set("checksum", file_hash)
    file.set("unencrypted_checksum", file_hash)
    files.append(file)
    analysis.append(files)

    attrs = Element("ANALYSIS_ATTRIBUTES")
    for a in df["description"]["attributes"]["attach_study_samples"][
            "attributes"]:
        attr = Element("ANALYSIS_ATTRIBUTE")
        tag = Element("TAG")
        tag.text = a["name"]
        value = Element("VALUE")
        value.text = a["value"]
        attr.append(tag)
        attr.append(value)
        attrs.append(attr)

    analysis.append(attrs)

    return prettify(analysis)
Example #54
0
def do_study_xml(sub_id):
    # get submission object from mongo
    sub = Submission().get_record(sub_id)
    # get datafile objects
    dfs = list()
    for d in sub["bundle"]:
        dfs.append(DataFile().get_record(d))
    df = dfs[0]
    # get profile object
    p = Profile().get_record(df["profile_id"])

    # Do STUDY_SET
    study_set = Element("STUDY_SET")
    study_set.set("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
    study_set.set("xsi:noNamespaceSchemaLocation",
                  "ftp://ftp.sra.ebi.ac.uk/meta/xsd/sra_1_5/SRA.study.xsd")

    # Do STUDY
    study = Element("STUDY")
    study.set("alias", str(sub["_id"]))
    study.set(
        "center_name", df["description"]["attributes"]["study_type"]
        ["study_analysis_center_name"])
    study_set.append(study)

    # Do DESCRIPTOR
    descriptor = Element("DESCRIPTOR")
    # create element, append to parent and add text
    SubElement(descriptor, "STUDY_TITLE").text = p["title"]
    study_type = Element("STUDY_TYPE")
    es = get_study_type_enumeration(
        df["description"]["attributes"]["study_type"]["study_type"])
    # es = df["description"]["attributes"]["study_type"]["study_type"]
    study_type.set("existing_study_type", es)
    descriptor.append(study_type)
    SubElement(descriptor, "STUDY_ABSTRACT").text = p["description"]
    study.append(descriptor)

    # Do STUDY_ATTRIBUTES
    study_attributes = Element("STUDY_ATTRIBUTES")
    # do attribute for date
    study_attribute = Element("STUDY_ATTRIBUTE")
    SubElement(study_attribute, "TAG").text = "Submission Date"
    SubElement(study_attribute,
               "VALUE").text = datetime.datetime.now().strftime('%Y-%m-%d')
    study_attributes.append(study_attribute)

    # here we can loop to add other STUDY_ATTRIBUTES

    study.append(study_attributes)

    return prettify(study_set)
Example #55
0
def _dump_signal(signal, node_refs, signal_element):
    signal_element.set('name', signal.name)

    offset = _start_bit(signal.start, signal.byte_order)
    signal_element.set('offset', str(offset))

    # Length.
    if signal.length != 1:
        signal_element.set('length', str(signal.length))

    # Byte order.
    if signal.byte_order != 'little_endian':
        signal_element.set('endianess', signal.byte_order[:-7])

    # Comment.
    if signal.comment is not None:
        _dump_notes(signal_element, signal.comment)

    # Receivers.
    if signal.receivers:
        consumer = SubElement(signal_element, 'Consumer')

        for receiver in signal.receivers:
            SubElement(consumer,
                       'NodeRef',
                       id=str(node_refs[receiver]))

    # Value.
    value = Element('Value')

    if signal.minimum is not None:
        value.set('min', str(signal.minimum))

    if signal.maximum is not None:
        value.set('max', str(signal.maximum))

    if signal.scale != 1:
        value.set('slope', str(signal.scale))

    if signal.offset != 0:
        value.set('intercept', str(signal.offset))

    if signal.unit is not None:
        value.set('unit', signal.unit)

    if signal.is_float:
        if signal.length == 32:
            type_name = 'single'
        else:
            type_name = 'double'
    elif signal.is_signed:
        type_name = 'signed'
    else:
        type_name = None

    if type_name is not None:
        value.set('type', type_name)

    if value.attrib:
        signal_element.append(value)

    # Label set.
    if signal.choices:
        label_set = SubElement(signal_element, 'LabelSet')

        for value, name in signal.choices.items():
            SubElement(label_set, 'Label', name=str(name), value=str(value))
Example #56
0
def do_submission_xml(sub_id):
    sub = Submission().get_record(sub_id)
    dfs = list()
    for d in sub["bundle"]:
        dfs.append(DataFile().get_record(d))
    df = dfs[0]

    submission = Element("SUBMISSION")
    # get names of files in bundle and append here
    # do alias
    alias = make_alias(sub)
    submission.set("alias", alias + "_sub")
    submission.set(
        "broker_name",
        df["description"]["attributes"]["study_type"]["study_broker"])
    submission.set(
        "center_name", df["description"]["attributes"]["study_type"]
        ["study_analysis_center_name"])
    submission_date = datetime.datetime.now().isoformat()
    submission.set("submission_date", submission_date)
    submission.set("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
    submission.set(
        "xsi:noNamespaceSchemaLocation",
        "ftp://ftp.sra.ebi.ac.uk/meta/xsd/sra_1_5/SRA.submission.xsd")

    contacts = Element("CONTACTS")
    copo_contact = Element("CONTACT")
    copo_contact.set("inform_on_error", "*****@*****.**")
    copo_contact.set("inform_on_status", "*****@*****.**")
    copo_contact.set("name", "COPO Support")
    contacts.append(copo_contact)

    people = Person(sub["profile_id"]).get_people_for_profile()
    for p in people:
        c = Element("CONTACT")
        c.set("name", p["firstName"] + " " + p["lastName"])
        if [
                x for x in p["roles"]
                if x["annotationValue"] == "SRA Inform On Status"
        ]:
            c.set("inform_on_status", p["email"])
        if [
                x for x in p["roles"]
                if x["annotationValue"] == "SRA Inform On Error"
        ]:
            c.set("inform_on_error", p["email"])
        contacts.append(c)
    submission.append(contacts)

    actions = Element("ACTIONS")
    action = Element("ACTION")
    add = Element("ADD")
    add.set("schema", "analysis")
    add.set("source", "analysis.xml")
    action.append(add)
    actions.append(action)
    submission.append(actions)

    return prettify(submission)
Example #57
0
    def generate_cabin(self, world_ele):
        # materials missing for now
        lift_model_name = f'{self.name}'
        lift_model_ele = SubElement(world_ele, 'model')
        lift_model_ele.set('name', lift_model_name)

        # main cabin link for actuation
        platform_name = 'platform'
        platform = SubElement(lift_model_ele, 'link')
        platform.set('name', platform_name)
        inertial = SubElement(platform, 'inertial')
        mass = SubElement(inertial, 'mass')
        mass.text = f'{self.cabin_mass}'

        # visuals and collisions for floor and walls of cabin
        floor_dims = [self.width, self.depth, self.floor_thickness]
        floor_name = 'floor'
        floor_pose = Element('pose')
        floor_pose.text = f'0 0 {-self.floor_thickness / 2} 0 0 0'
        platform.append(
            visual(floor_name, floor_pose, floor_dims, lift_material()))

        platform.append(collision(floor_name, floor_pose, floor_dims, '0x01'))

        # Wall generation
        # get each pair of end_points on each side, generate a section of wall
        # between the pair of points
        for side, end_points in self.end_points.items():
            assert len(end_points) % 2 == 0
            for i in range(0, len(end_points), 2):
                pair = end_points[i:i + 2]
                name = f'{side}wall{i//2+1}'
                self.generate_wall(side, pair, name, platform)

        # lift cabin actuation joint
        lift_model_ele.append(
            joint('cabin_joint',
                  'prismatic',
                  'world',
                  'platform',
                  joint_axis='z'))

        # cabin doors
        for lift_door in self.doors:
            lift_door.generate_cabin_door(
                lift_model_ele, f'CabinDoor_{self.name}_{lift_door.name}')

        # lift cabin plugin
        plugin_ele = SubElement(lift_model_ele, 'plugin')
        plugin_ele.set('name', 'lift')
        plugin_ele.set('filename', 'liblift.so')

        lift_name_ele = SubElement(plugin_ele, 'lift_name')
        lift_name_ele.text = f'{self.name}'

        for level_name, door_names in self.level_doors.items():
            floor_ele = SubElement(plugin_ele, 'floor')
            floor_ele.set('name', f'{level_name}')
            floor_ele.set('elevation', f'{self.level_elevation[level_name]}')
            for door in self.doors:
                if door.name in door_names:
                    door_pair_ele = SubElement(floor_ele, 'door_pair')
                    door_pair_ele.set('cabin_door',
                                      f'CabinDoor_{self.name}_{door.name}')
                    door_pair_ele.set(
                        'shaft_door',
                        f'ShaftDoor_{self.name}_{level_name}_{door.name}')

        reference_floor_ele = SubElement(plugin_ele, 'reference_floor')
        reference_floor_ele.text = f'{self.reference_floor_name}'
        for param_name, param_value in self.params.items():
            ele = SubElement(plugin_ele, param_name)
            ele.text = f'{param_value}'

        cabin_joint_ele = SubElement(plugin_ele, 'cabin_joint_name')
        cabin_joint_ele.text = 'cabin_joint'

        # pose
        model_pose = SubElement(lift_model_ele, 'pose')
        model_pose.text = f'{self.x} {self.y} 0 0 0 {self.yaw}'
Example #58
0
Titulo = titulo_wrapper.h1

#Sinopsis
sinopsis_w = soup.find('div', class_='summary_text')
sinopsis = sinopsis_w.text

#Temporadas
temporadas_w = soup.find('div', class_='seasons-and-year-nav')
temporadas = temporadas_w.a.text

#Capitulos
capitulos_wrapper = soup.find('div', class_='bp_description')
capitulos = capitulos_wrapper.find('span', class_='bp_sub_heading')

###############################################################################################
root = Element('Serie')
tree = ElementTree(root)

titlo = Element('Titulo')
sinsis = Element('sinopsis')
tempdas = Element('temporadas')
caps = Element('capitulos')

root.append(titlo)
root.append(sinsis)
root.append(tempdas)
root.append(caps)

titlo.text = Titulo.text
sinsis.text = sinopsis
caps.text = capitulos.text
Example #59
0
 def _extensions2gpx(self, parent, extensions):
     ext = Element(ns + "extensions")
     ext = self._dict2gpx(ext, extensions)
     parent.append(ext)
     return parent
Example #60
0
 def handle_item(item: ET.Element) -> Dict[str, Optional[DataItem]]:
     ret = dict(map(handle_field, item.findall('field')))
     if 'key' in item.attrib:
         ret['key'] = item.attrib['key']
     return ret