Esempio n. 1
0
    def make_joint_xml(self):
        """
        Generate the joint_xml and hold it by self.joint_xml
        """
        joint = Element('joint')
        joint.attrib = {'name': self.name, 'type': self.type}

        origin = SubElement(joint, 'origin')
        origin.attrib = {
            'xyz': ' '.join([str(_) for _ in self.xyz]),
            'rpy': '0 0 0'
        }
        parent = SubElement(joint, 'parent')
        parent.attrib = {'link': self.parent}
        child = SubElement(joint, 'child')
        child.attrib = {'link': self.child}
        if self.type == 'revolute' or self.type == 'continuous' or self.type == 'prismatic':
            axis = SubElement(joint, 'axis')
            axis.attrib = {'xyz': ' '.join([str(_) for _ in self.axis])}
        if self.type == 'revolute' or self.type == 'prismatic':
            limit = SubElement(joint, 'limit')
            limit.attrib = {
                'upper': str(self.upper_limit),
                'lower': str(self.lower_limit),
                'effort': '100',
                'velocity': '100'
            }

        self.joint_xml = "\n".join(utils.prettify(joint).split("\n")[1:])
Esempio n. 2
0
    def make_transmission_xml(self):
        """
        Generate the tran_xml and hold it by self.tran_xml
        
        
        Notes
        -----------
        mechanicalTransmission: 1
        type: transmission interface/SimpleTransmission
        hardwareInterface: PositionJointInterface        
        """

        tran = Element('transmission')
        tran.attrib = {'name': self.name + '_tran'}

        joint_type = SubElement(tran, 'type')
        joint_type.text = 'transmission_interface/SimpleTransmission'

        joint = SubElement(tran, 'joint')
        joint.attrib = {'name': self.name}
        hardwareInterface_joint = SubElement(joint, 'hardwareInterface')
        hardwareInterface_joint.text = 'PositionJointInterface'

        actuator = SubElement(tran, 'actuator')
        actuator.attrib = {'name': self.name + '_actr'}
        hardwareInterface_actr = SubElement(actuator, 'hardwareInterface')
        hardwareInterface_actr.text = 'PositionJointInterface'
        mechanicalReduction = SubElement(actuator, 'mechanicalReduction')
        mechanicalReduction.text = '1'

        self.tran_xml = "\n".join(utils.prettify(tran).split("\n")[1:])
Esempio n. 3
0
def gentstxml(tstlists, setid, srclang, trglang):
    mteval = Element('mteval')
    for tstlist in tstlists:
        sysid = tstlist[0]
        set = SubElement(mteval, "tstset")
        set.attrib = {
            "setid": setid,
            "srclang": srclang,
            "trglang": trglang,
            "sysid": sysid
        }
        doc = SubElement(set, "doc")
        doc.attrib = {"docid": "doc1"}

        i = 0
        for sentence in tstlist:
            # 第一位存储具体是哪个引擎
            if i != 0:
                p = SubElement(doc, "p")
                seg = SubElement(p, "seg")
                seg.attrib = {"id": str(i)}
                seg.text = sentence
            i = i + 1
    tree = ElementTree(mteval)
    tree.write(setid + '_tst.xml', encoding='utf-8')
Esempio n. 4
0
    def data2xml(self, datas):
        self.savedata = datas
        fps = Element('fps')
        fps.attrib = {'verdion': '1.2'}
        self.now._setroot(fps)
        item = SubElement(fps, 'item')
        SubElement(item, 'title').text = datas['title']
        time_limit = SubElement(item, 'time_limit')
        time_limit.attrib = {'unit': 's'}
        time_limit.text = '1'
        memory_limit = SubElement(item, 'memory_limit')
        memory_limit.attrib = {'unit': 'mb'}
        memory_limit.text = '64'
        all = datas['src_num']
        print 'all of image :', all
        i = 0
        print datas
        while i != all:
            img = SubElement(item, 'img')
            src = SubElement(img, 'src')
            src.text = datas['src'][i]
            base64 = SubElement(img, 'base64')
            base64.text = datas['base64'][i]
            i = i + 1

        SubElement(item, 'description').text = datas['description']
        SubElement(item, 'input').text = datas['input']
        SubElement(item, 'output').text = datas['output']

        sample_input = SubElement(item, 'sample_input')
        data = CDATA(datas['sample_input'])
        sample_input.append(data)

        sample_output = SubElement(item, 'sample_output')
        data = CDATA(datas['sample_output'])
        sample_output.append(data)

        test_input = SubElement(item, 'test_input')
        data = CDATA(datas['sample_input'])
        test_input.append(data)

        test_output = SubElement(item, 'test_output')
        data = CDATA(datas['sample_output'])
        test_output.append(data)
        # SubElement(item,'test_input').append(CDATA(datas['sample_input']))
        # SubElement(item,'test_output').append(CDATA(datas['sample_output']))
        solution = SubElement(item, 'solution')
        data = CDATA(datas['solution'])
        solution.append(data)
        solution.attrib = {'language': 'C++'}
        SubElement(item, 'hint').text = datas['hint']
        SubElement(
            item,
            'source').text = datas['source'] + '(POJ' + ' ' + datas['ID'] + ')'
        # dump(indent(fps))
        self.save(datas)
Esempio n. 5
0
    def phyloxml(self, **kwargs):
        """
        Returns the root element of UniProt SIFt cluster tree in PhyloXML format.
        """
        root = Element('phyloxml')
        phylogeny = SubElement(root, 'phylogeny')
        phylogeny.set('rooted', 'true')

        # rendering options
        render = SubElement(phylogeny, 'render')
        parameters = SubElement(render, 'parameters')
        circular = SubElement(parameters, 'circular')
        buffer_radius = SubElement(circular, 'bufferRadius')
        buffer_radius.text = kwargs.get(str('buffer_radius'),'0.4')

        # charting options for this tree
        charts = SubElement(render, 'charts')

        # create internal arcs in the tree to display the compound class: drug,
        # endogenous, etc.
        interaction = SubElement(charts, 'interaction')
        interaction.attrib = {'type': 'binary', 'thickness': '10',
                              'isInternal': 'true', 'bufferInner': '0'}

        # binding site property binary arcs
        bindingsite = SubElement(charts, 'bindingsite')
        bindingsite.attrib = {'type': 'binary', 'thickness': '7.5'}

        # ligand efficiency bar charts
        activity = SubElement(charts, 'activity')
        activity.attrib = {'type': 'bar', 'fill':'#000', 'width':'0.4'}

        # styling of elements: charts, arcs, backgrounds
        styles = SubElement(render, 'styles')
        drugtarget = SubElement(styles, 'drugtarget', {'fill': '#75BBE4', 'stroke':'#DDD'})
        enzymecmpd = SubElement(styles, 'enzymecmpd', {'fill': '#DEF1CC', 'stroke':'#DDD'})
        bar_chart = SubElement(styles, 'barChart', {'fill':'#999', 'stroke-width':'0'})

        # chemical component types
        appdrug = SubElement(styles, 'appdrug', {'fill': '#3296CB', 'stroke':'#3296CB'})
        drug = SubElement(styles, 'drug', {'fill': '#75BBE4', 'stroke':'#75BBE4'})
        lead = SubElement(styles, 'lead', {'fill': '#A9D6F0', 'stroke':'#A9D6F0'})
        druglike = SubElement(styles, 'druglike', {'fill': '#CDE9F4', 'stroke':'#CDE9F4'})
        solvent = SubElement(styles, 'solvent', {'fill': '#FFFACD', 'stroke':'#FFFACD'})
        heteropeptide = SubElement(styles, 'heteropeptide', {'fill': '#FBD5A5', 'stroke':'#FBD5A5'})
        nucleotide = SubElement(styles, 'nucleotide', {'fill': '#DEF1CC', 'stroke':'#DEF1CC'})

        # binding site properties
        mutated = SubElement(styles, 'mutated', {'fill': '#E75559', 'stroke':'#DDD'})
        modified = SubElement(styles, 'modified', {'fill': '#F98892', 'stroke':'#DDD'})
        nonstd = SubElement(styles, 'nonstd', {'fill': '#FDCDD7', 'stroke':'#DDD'})

        clade = SubElement(phylogeny, 'clade')
        clade.append(self._clade())

        return root
Esempio n. 6
0
def asset_xml_download(sitename):

    # select assets to generate trends for, based on form
    asset_list = []
    for asset_id in request.form.getlist('asset_id'):
        asset = Asset.query.filter_by(id=asset_id).one()
        asset_list.append(asset)

    # generate xml
    # top level objects
    object_set = Element('ObjectSet')
    object_set.attrib = {
        'ExportMode': 'Standard',
        'Version': '1.8.1.87',
        'Note': 'TypesFirst'
    }
    exported_objects = SubElement(object_set, 'ExportedObjects')
    # folder object for each asset
    for asset in asset_list:
        oi_folder = SubElement(exported_objects, 'OI')
        oi_folder.attrib = {'NAME': asset.name, 'TYPE': 'system.base.Folder'}
        # extended trend object for each point
        for point in asset.points:
            # generate unique identifier as base64encode(siteID.assetID.pointID)
            # unique id is used for matching medusa points to webreports logs
            identifier = 'DONOTMODIFY:' + str(
                b64encode('{}.{}.{}'.format(
                    asset.site.id, asset.id,
                    point.id).encode('ascii')).decode('ascii'))

            # create trend log for each point
            oi_trend = SubElement(oi_folder, 'OI')
            oi_trend.attrib = {
                'NAME': '{} Extended'.format(point.name),
                'TYPE': 'trend.ETLog',
                'DESCR': identifier
            }

            # attribute flag to include in webreports
            pi = SubElement(oi_trend, 'PI')
            pi.attrib = {'Name': 'IncludeInReports', 'Value': '1'}

    # save file
    out = BytesIO()
    tree = ElementTree(object_set)
    # write xml into bytes object
    tree.write(out, encoding='utf-8', xml_declaration=True)
    # reset pointer to start of bytes object
    out.seek(0)

    # prevent browser from caching the download
    response = make_response(
        send_file(out, attachment_filename='Import.xml', as_attachment=True))
    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
    return response
Esempio n. 7
0
def xmlrpc_playlist():
    db = conn.cursor()
    history = []
    requests = []

    db.execute("SELECT * FROM history ORDER BY id DESC")
    rows = db.fetchall()
    for row in rows:
        i_user = row[2]
        history.append(get_song(row[1], i_user=i_user))

    # Get the request list
    db.execute("SELECT * FROM requests ORDER BY id DESC")
    rows = db.fetchall()
    for row in rows:
        i_user = row[2]
        requests.append(get_song(row[0], i_user=i_user))

    # Last song in this history list is what's currently playing
    playing = history.pop()

    # Create the XML
    root = Element('playlist')
    parent = SubElement(root, "nowplaying")
    child = SubElement(parent, "song")
    attribs = {
        'artist': playing['artist'],
        'title': playing['title'],
        'requestby': playing['username']
    }
    child.attrib = attribs

    parent = SubElement(root, "history")
    for song in history:
        child = SubElement(parent, "song")
        attribs = {
            'artist': song['artist'],
            'title': song['title'],
            'requestby': song['username']
        }
        child.attrib = attribs

    parent = SubElement(root, "upcoming")
    for song in requests:
        child = SubElement(parent, "song")
        attribs = {
            'artist': song['artist'],
            'title': song['title'],
            'requestby': song['username']
        }
        child.attrib = attribs

    # FIXME: there literally has to be a better way to do this.
    return parseString(tostring(root)).toprettyxml()
Esempio n. 8
0
	def data2xml(self,datas):
		self.savedata=datas
		fps=Element('fps')
		fps.attrib={'verdion':'1.2'}
		self.now._setroot(fps)
		item=SubElement(fps,'item')
		SubElement(item,'title').text=datas['title']
		time_limit=SubElement(item,'time_limit')
		time_limit.attrib={'unit':'s'}
		time_limit.text='1'
		memory_limit=SubElement(item,'memory_limit')
		memory_limit.attrib={'unit':'mb'}
		memory_limit.text='64'
		all=datas['src_num']
		print 'all of image :',all
		i=0
		print datas
		while i!=all:
			img=SubElement(item,'img')
			src=SubElement(img,'src')
			src.text=datas['src'][i]
			base64=SubElement(img,'base64')
			base64.text=datas['base64'][i]
			i=i+1

		SubElement(item,'description').text=datas['description']
		SubElement(item,'input').text=datas['input']
		SubElement(item,'output').text=datas['output']

		sample_input=SubElement(item,'sample_input')
		data=CDATA(datas['sample_input'])
		sample_input.append(data)

		sample_output=SubElement(item,'sample_output')
		data=CDATA(datas['sample_output'])
		sample_output.append(data)

		test_input=SubElement(item,'test_input')
		data=CDATA(datas['sample_input'])
		test_input.append(data)

		test_output=SubElement(item,'test_output')
		data=CDATA(datas['sample_output'])
		test_output.append(data)
		# SubElement(item,'test_input').append(CDATA(datas['sample_input']))
		# SubElement(item,'test_output').append(CDATA(datas['sample_output']))
		solution=SubElement(item,'solution')
		data=CDATA(datas['solution'])
		solution.append(data)
		solution.attrib={'language':'C++'}
		SubElement(item,'hint').text=datas['hint']
		SubElement(item,'source').text=datas['source']+'(POJ'+' '+datas['ID']+')'
		# dump(indent(fps))
		self.save(datas)
Esempio n. 9
0
def write_gazebo_launch(package_name, robot_name, save_dir):
    """
    write gazebo launch file "save_dir/launch/gazebo.launch"
    
    
    Parameter
    ---------
    robot_name: str
        name of the robot
    save_dir: str
        path of the repository to save
    """

    try:
        os.mkdir(save_dir + '/launch')
    except:
        pass

    launch = Element('launch')
    param = SubElement(launch, 'param')
    param.attrib = {
        'name':
        'robot_description',
        'command':
        '$(find xacro)/xacro $(find {})/urdf/{}.xacro'.format(
            package_name, robot_name)
    }

    node = SubElement(launch, 'node')
    node.attrib = {'name':'spawn_urdf', 'pkg':'gazebo_ros', 'type':'spawn_model',\
                    'args':'-param robot_description -urdf -model {}'.format(robot_name)}

    include_ = SubElement(launch, 'include')
    include_.attrib = {'file': '$(find gazebo_ros)/launch/empty_world.launch'}

    number_of_args = 5
    args = [None for i in range(number_of_args)]
    args_name_value_pairs = [['paused', 'true'], ['use_sim_time', 'true'],
                             ['gui', 'true'], ['headless', 'false'],
                             ['debug', 'false']]

    for i, arg in enumerate(args):
        arg = SubElement(include_, 'arg')
        arg.attrib = {
            'name': args_name_value_pairs[i][0],
            'value': args_name_value_pairs[i][1]
        }

    launch_xml = "\n".join(utils.prettify(launch).split("\n")[1:])

    file_name = save_dir + '/launch/' + 'gazebo.launch'
    with open(file_name, mode='w') as f:
        f.write(launch_xml)
Esempio n. 10
0
    def gen_link_xml(self):
        """
        Generate the link_xml and hold it by self.link_xml
        """

        link = Element('link')
        link.attrib = {'name': self.name}

        #inertial
        inertial = SubElement(link, 'inertial')
        origin_i = SubElement(inertial, 'origin')
        origin_i.attrib = {
            'xyz': ' '.join([str(_) for _ in self.center_of_mass]),
            'rpy': '0 0 0'
        }
        mass = SubElement(inertial, 'mass')
        mass.attrib = {'value': str(self.mass)}
        inertia = SubElement(inertial, 'inertia')
        inertia.attrib = \
            {'ixx':str(self.inertia_tensor[0]), 'iyy':str(self.inertia_tensor[1]),\
            'izz':str(self.inertia_tensor[2]), 'ixy':str(self.inertia_tensor[3]),\
            'iyz':str(self.inertia_tensor[4]), 'ixz':str(self.inertia_tensor[5])}

        # visual
        visual = SubElement(link, 'visual')
        origin_v = SubElement(visual, 'origin')
        origin_v.attrib = {
            'xyz': ' '.join([str(_) for _ in self.xyz]),
            'rpy': '0 0 0'
        }
        geometry_v = SubElement(visual, 'geometry')
        mesh_v = SubElement(geometry_v, 'mesh')
        mesh_v.attrib = {
            'filename': 'package://' + self.repo + self.name + '_m-binary.stl'
        }
        material = SubElement(visual, 'material')
        material.attrib = {'name': 'silver'}
        color = SubElement(material, 'color')
        color.attrib = {'rgba': '1 0 0 1'}

        # collision
        collision = SubElement(link, 'collision')
        origin_c = SubElement(collision, 'origin')
        origin_c.attrib = {
            'xyz': ' '.join([str(_) for _ in self.xyz]),
            'rpy': '0 0 0'
        }
        geometry_c = SubElement(collision, 'geometry')
        mesh_c = SubElement(geometry_c, 'mesh')
        mesh_c.attrib = {
            'filename': 'package://' + self.repo + self.name + '_m-binary.stl'
        }

        # print("\n".join(prettify(link).split("\n")[1:]))
        self.link_xml = "\n".join(prettify(link).split("\n")[1:])
Esempio n. 11
0
def get_columnList(node, SubEltroot):

    ## 指定 一级路径下的 selectlist 防止获取到其他地方
    path = 'selectStatement/atomSelectStatement/selectClause/selectList'

    _selectListElt = node.find(path)
    selectItemElts = _selectListElt.findall('selectItem')

    num = 1
    for selectItemElt in selectItemElts:
        columnList = []

        ## 获取 所有字段 列表
        try:
            expressions = selectItemElt.find('expression').findall(
                './/expression')
        except AttributeError:
            colAsSElt = SubElement(SubEltroot, 'ColAs')
            colAsSElt.attrib = {'col_%s' % num: '*'}
            continue

        if len(expressions) == 0:
            column = selectItemElt.findall('.//expression//identifier')
            columnList = get_columns(column, columnList)
        else:
            for exp in expressions:
                column = exp.findall('.//identifier')
                columnList = get_columns(column, columnList)

        columnList = list(set(columnList))

        ## 获取 字段别名
        try:
            fieldAlias = selectItemElt.find('identifier').text  ## 需要一个排错选项
        except AttributeError:
            fieldAlias = columnList[0].split('.')[-1]

        colAsSElt = SubElement(SubEltroot, 'ColAs')
        colAsSElt.attrib = {'col_%s' % num: fieldAlias}

        for cols in columnList:
            tmpCol = SubElement(colAsSElt, 'Col')
            tmpCol.text = cols

        logicCol = SubElement(colAsSElt, 'logic')
        get_logic(selectItemElt.find('expression'), logicCol)

        num += 1
Esempio n. 12
0
def write_control_launch(robot_name, save_dir, joints_dict):
    """
    write control launch file "save_dir/launch/robot_name_control.launch"
    
    
    Parameter
    ---------
    robot_name: str
        name of the robot
    save_dir: str
        path of the repository to save
    joints_dict: dict
        information of the joints
    """

    try:
        os.mkdir(save_dir + '/launch')
    except:
        pass

    launch = Element('launch')

    controller_name = robot_name + '_controller'
    rosparam = SubElement(launch, 'rosparam')
    rosparam.attrib = {
        'file': '$(find fusion2urdf)/launch/' + controller_name + '.yaml',
        'command': 'load'
    }

    controller_args_str = ' '.join([joint + '_position_controller' for joint in joints_dict]) \
                            + ' joint_state_controller'
    node_controller = SubElement(launch, 'node')
    node_controller.attrib = {'name':'controller_spawner', 'pkg':'controller_manager', 'type':'spawner',\
                    'respawn':'false', 'output':'screen', 'ns':robot_name,\
                    'args':'{}'.format(controller_args_str)}

    node_publisher = SubElement(launch, 'node')
    node_publisher.attrib = {'name':'robot_state_publisher', 'pkg':'robot_state_publisher',\
                    'type':'robot_state_publisher', 'respawn':'false', 'output':'screen'}
    remap = SubElement(node_publisher, 'remap')
    remap.attrib = {'from':'/joint_states',\
                    'to':'/' + robot_name + '/joint_states'}

    launch_xml = "\n".join(prettify(launch).split("\n")[1:])

    file_name = save_dir + '/launch/' + robot_name + '_control.launch'
    with open(file_name, mode='w') as f:
        f.write(launch_xml)
Esempio n. 13
0
File: web.py Progetto: dcorbe/fm
def xmlrpc_playlist():
    db = conn.cursor()
    history = [ ]
    requests = [ ]

    db.execute("SELECT * FROM history ORDER BY id DESC")
    rows = db.fetchall()
    for row in rows:
        i_user = row[2]
        history.append(get_song(row[1], i_user=i_user))

    # Get the request list
    db.execute("SELECT * FROM requests ORDER BY id DESC")
    rows = db.fetchall()
    for row in rows:
        i_user = row[2]
        requests.append(get_song(row[0], i_user=i_user))

    # Last song in this history list is what's currently playing
    playing = history.pop()

    # Create the XML
    root = Element('playlist')
    parent = SubElement(root, "nowplaying")
    child = SubElement(parent, "song")
    attribs = {'artist': playing['artist'],
              'title': playing['title'],
              'requestby': playing['username']}
    child.attrib = attribs

    parent = SubElement(root, "history")
    for song in history:
        child = SubElement(parent, "song")
        attribs = {'artist': song['artist'],
                   'title': song['title'],
                   'requestby': song['username']}
        child.attrib = attribs

    parent = SubElement(root, "upcoming")
    for song in requests:
        child = SubElement(parent, "song")
        attribs = {'artist': song['artist'],
                   'title': song['title'],
                   'requestby': song['username']}
        child.attrib = attribs

    # FIXME: there literally has to be a better way to do this.
    return parseString(tostring(root)).toprettyxml()
Esempio n. 14
0
    def post_entry(self, title, content, updated=None, draft=False):
        if updated and isinstance(updated, datetime) is False:
            raise TypeError('Updated is must be datetime type. Passed updated is {}'.format(type(updated)))

        entry = Element('entry')
        entry.attrib = {'xmlns': 'http://purl.org/atom/ns#'}
        _title = SubElement(entry, 'title')
        _title.text = title
        _content = SubElement(entry, 'content')
        _content.attrib = {'type': 'text/plain'}
        _content.text = content
        _updated = SubElement(entry, 'updated')
        if updated:
            # default timezone is JST
            utc_offset = re.sub(r'((?:\+|-)\d{2})(\d{2})', r'\1:\2', updated.strftime('%z')) if updated.tzinfo else '+09:00'
            _updated.text = updated.strftime('%Y-%m-%dT%H:%M:%S{utc_offset}'.format(utc_offset=utc_offset))
        else:
            _updated.text = None

        data = minidom.parseString(ET.tostring(entry)).toxml(encoding='utf-8')

        url = self.draft_collection if draft else self.collection_url
        response = requests.post(url=url, data=data, auth=self.auth)

        if response.ok:
            return ET.fromstring(response.text)
        else:
            return {'status_code': response.status_code, 'reason': response.reason}
Esempio n. 15
0
def mergePopulationData(populationFile, regionFile, mergedFile):
    csvReader = csv.reader(open(populationFile), delimiter=',', quotechar='"')
    inhabDict = {}
    for entry in csvReader:
        if csvReader.line_num <= 3:
            continue
        while(len(entry[0]) < 2):
            entry[0] = '0' + entry[0]
        while(len(entry[2]) < 2):
            entry[2] = '0' + entry[2]
        while(len(entry[3]) < 4):
            entry[3] = '0' + entry[3]
        while(len(entry[4]) < 3):
            entry[4] = '0' + entry[4]
        inhabDict["".join(entry[:5])] = str(entry[6]).replace(' ', '')

    root = ET.ElementTree(file=regionFile).getroot()
    for parents in root.findall("./*"):
        for elem in parents.findall("param[7]"):
            RSValue = str(elem.attrib)[11:23]
            inhabitants = SubElement(parents, 'param')
            if RSValue in inhabDict:
                inhabitants.clear()
                inhabitants.attrib = {
                    'key': "INHABITANTS", 'value': inhabDict[RSValue]}
    outstr = minidom.parseString(ET.tostring(root)).toprettyxml(indent="    ")
    with open(mergedFile, 'w') as out:
        out.write(outstr.encode('utf-8'))
Esempio n. 16
0
def mergePopulationData(populationFile, regionFile, mergedFile):
    csvReader = csv.reader(open(populationFile), delimiter=',', quotechar='"')
    inhabDict = {}
    for entry in csvReader:
        if csvReader.line_num <= 3:
            continue
        while (len(entry[0]) < 2):
            entry[0] = '0' + entry[0]
        while (len(entry[2]) < 2):
            entry[2] = '0' + entry[2]
        while (len(entry[3]) < 4):
            entry[3] = '0' + entry[3]
        while (len(entry[4]) < 3):
            entry[4] = '0' + entry[4]
        inhabDict["".join(entry[:5])] = str(entry[6]).replace(' ', '')

    root = ET.ElementTree(file=regionFile).getroot()
    for parents in root.findall("./*"):
        for elem in parents.findall("param[7]"):
            RSValue = str(elem.attrib)[11:23]
            inhabitants = SubElement(parents, 'param')
            if RSValue in inhabDict:
                inhabitants.clear()
                inhabitants.attrib = {
                    'key': "INHABITANTS",
                    'value': inhabDict[RSValue]
                }
    outstr = minidom.parseString(ET.tostring(root)).toprettyxml(indent="    ")
    with open(mergedFile, 'w') as out:
        out.write(outstr.encode('utf-8'))
Esempio n. 17
0
 def recurse_tree(xmliter, element=None):
     sub = None
     for tag, attrs in xmliter:
         if isinstance(attrs, list):
             for attr in attrs:
                 recurse_tree(((tag, attr), ), element)
         elif element is not None:
             sub = SubElement(element, tag)
         else:
             sub = Element(tag)
         if isinstance(attrs, (str, int, bool, float)):
             sub.text = six.text_type(attrs)
             continue
         if isinstance(attrs, dict):
             sub.attrib = {
                 attr: six.text_type(val)
                 for attr, val in attrs.items()
                 if not isinstance(val, (dict, list))
             }
         for tag, val in [
                 item for item in normalize_iter(attrs)
                 if isinstance(item[1], (dict, list))
         ]:
             recurse_tree(((tag, val), ), sub)
     return sub
Esempio n. 18
0
def gensrcxml(senlist, setid, srclang):
    mteval = Element('mteval')
    set = SubElement(mteval, "srcset")
    set.attrib = {"setid": setid, "srclang": srclang}
    doc = SubElement(set, "doc")
    doc.attrib = {"docid": "doc1"}

    i = 1
    for sentence in senlist:
        p = SubElement(doc, "p")
        seg = SubElement(p, "seg")
        seg.attrib = {"id": str(i)}
        seg.text = sentence
        i += 1
    tree = ElementTree(mteval)
    tree.write(setid + '_src.xml', encoding='utf-8')
Esempio n. 19
0
 def toxml(self, parent):
     file = SubElement(parent, 'file')
     file.attrib = {'original': self.original, 'source-language': self.source_language, 'datatype': self.data_type,
                    'target-language': self.target_language}
     self.header.toxml(file)
     self.body.toxml(file)
     return file
Esempio n. 20
0
    def make_link_xml(self):
        """
        Generate the link_xml and hold it by self.link_xml
        """

        link = Element('link')
        link.attrib = {'name': self.name}

        #inertial
        inertial = SubElement(link, 'inertial')
        origin_i = SubElement(inertial, 'origin')
        origin_i.attrib = {
            'xyz': ' '.join([str(_) for _ in self.center_of_mass]),
            'rpy': '0 0 0'
        }
        mass = SubElement(inertial, 'mass')
        mass.attrib = {'value': str(self.mass)}
        inertia = SubElement(inertial, 'inertia')
        inertia.attrib = \
            {'ixx':str(self.inertia_tensor[0]), 'iyy':str(self.inertia_tensor[1]),\
            'izz':str(self.inertia_tensor[2]), 'ixy':str(self.inertia_tensor[3]),\
            'iyz':str(self.inertia_tensor[4]), 'ixz':str(self.inertia_tensor[5])}

        # visual
        visual = SubElement(link, 'visual')
        origin_v = SubElement(visual, 'origin')
        origin_v.attrib = {
            'xyz': ' '.join([str(_) for _ in self.xyz]),
            'rpy': '0 0 0'
        }
        geometry_v = SubElement(visual, 'geometry')
        mesh_v = SubElement(geometry_v, 'mesh')
        mesh_v.attrib = {
            'filename':
            'file://' + "$(find " + self.repo + ")" + self.name + '.stl',
            'scale': '0.001 0.001 0.001'
        }
        material = SubElement(visual, 'material')
        material.attrib = {'name': self.material}

        # collision
        collision = SubElement(link, 'collision')
        origin_c = SubElement(collision, 'origin')
        origin_c.attrib = {
            'xyz': ' '.join([str(_) for _ in self.xyz]),
            'rpy': '0 0 0'
        }
        geometry_c = SubElement(collision, 'geometry')
        mesh_c = SubElement(geometry_c, 'mesh')
        mesh_v.attrib = {
            'filename':
            'file://' + "$(find " + self.repo + ")" + self.name + '.stl',
            'scale': '0.001 0.001 0.001'
        }

        # print("\n".join(utils.prettify(link).split("\n")[1:]))
        self.link_xml = "\n".join(utils.prettify(link).split("\n")[1:])
Esempio n. 21
0
 def gen_joint_xml(self):
     """generate the xml strings of joints
     """
     joint = Element('joint')
     joint.attrib = {'name':self.name, 'type':self.type}
     
     origin = SubElement(joint, 'origin')
     origin.attrib = {'xyz':' '.join([str(_) for _ in self.xyz]), 'rpy':'0 0 0'}
     parent = SubElement(joint, 'parent')
     parent.attrib = {'link':self.parent}
     child = SubElement(joint, 'child')
     child.attrib = {'link':self.child}
     axis = SubElement(joint, 'axis')
     axis.attrib = {'xyz':' '.join([str(_) for _ in self.axis])}
     
     # print("\n".join(prettify(joint).split("\n")[1:]))
     self.xml = "\n".join(prettify(joint).split("\n")[1:])
Esempio n. 22
0
    def toxml(self, parent):
        unit = SubElement(parent, 'trans-unit')
        unit.attrib = {'id': self.trans_unit_id}
        map(lambda source: source.toxml(unit), self.sources)
        map(lambda target: target.toxml(unit), self.targets)
        map(lambda note: note.toxml(unit), self.notes)

        return unit
Esempio n. 23
0
def write_control_launch(package_name, robot_name, save_dir, joints_dict):
    """
    write control launch file "save_dir/launch/controller.launch"
    
    
    Parameter
    ---------
    robot_name: str
        name of the robot
    save_dir: str
        path of the repository to save
    joints_dict: dict
        information of the joints
    """
    
    try: os.mkdir(save_dir + '/launch')
    except: pass     
    
    #launch = Element('launch')

    controller_name = robot_name + '_controller'
    #rosparam = SubElement(launch, 'rosparam')
    #rosparam.attrib = {'file':'$(find {})/launch/controller.yaml'.format(package_name),
    #                   'command':'load'}
                       
    controller_args_str = ""
    for j in joints_dict:
        joint_type = joints_dict[j]['type']
        if joint_type != 'fixed':
            controller_args_str += j + '_position_controller '
    controller_args_str += 'joint_state_controller '

    node_controller = Element('node')
    node_controller.attrib = {'name':'controller_spawner', 'pkg':'controller_manager', 'type':'spawner',\
                    'respawn':'false', 'output':'screen', 'ns':robot_name,\
                    'args':'{}'.format(controller_args_str)}
    
    node_publisher = Element('node')
    node_publisher.attrib = {'name':'robot_state_publisher', 'pkg':'robot_state_publisher',\
                    'type':'robot_state_publisher', 'respawn':'false', 'output':'screen'}
    remap = SubElement(node_publisher, 'remap')
    remap.attrib = {'from':'/joint_states',\
                    'to':'/' + robot_name + '/joint_states'}
    
    #launch_xml  = "\n".join(utils.prettify(launch).split("\n")[1:])   
    launch_xml  = "\n".join(utils.prettify(node_controller).split("\n")[1:])   
    launch_xml += "\n".join(utils.prettify(node_publisher).split("\n")[1:])   

    file_name = save_dir + '/launch/controller.launch'    
    with open(file_name, mode='w') as f:
        f.write('<launch>\n')
        f.write('\n')
        #for some reason ROS is very picky about the attribute ordering, so we'll bitbang this element
        f.write('<rosparam file="$(find {})/launch/controller.yaml" command="load"/>'.format(package_name))
        f.write('\n')
        f.write(launch_xml)
        f.write('\n')
        f.write('</launch>')
Esempio n. 24
0
    def make_link_xml(self):
        """
        Generate the link_xml and hold it by self.link_xml
        """
        
        link = Element('link')
        link.attrib = {'name': "$(arg tf_prefix)" + self.name}
        
        #inertial
        inertial = SubElement(link, 'inertial')
        origin_i = SubElement(inertial, 'origin')
        origin_i.attrib = {'xyz':' '.join([str(_) for _ in self.center_of_mass]), 'rpy':'0 0 0'}       
        mass = SubElement(inertial, 'mass')
        mass.attrib = {'value':str(self.mass)}
        inertia = SubElement(inertial, 'inertia')
        inertia.attrib = \
            {'ixx':str(self.inertia_tensor[0]), 'iyy':str(self.inertia_tensor[1]),\
            'izz':str(self.inertia_tensor[2]), 'ixy':str(self.inertia_tensor[3]),\
            'iyz':str(self.inertia_tensor[4]), 'ixz':str(self.inertia_tensor[5])}        
        
        # visual
        for body in self.bodies:
            visual = SubElement(link, 'visual')
            origin_v = SubElement(visual, 'origin')
            origin_v.attrib = {'xyz':' '.join([str(_) for _ in self.xyz]), 'rpy':'0 0 0'}
            geometry_v = SubElement(visual, 'geometry')
            mesh_v = SubElement(geometry_v, 'mesh')
            mesh_v.attrib = {'filename':'package://' + self.repo + self.name + "_" + self.design_name + "_" + body["name"] + "_" + self.name + '.stl','scale':'0.001 0.001 0.001'}
            material = SubElement(visual, 'material')
            material.attrib = {'name': body["material"]}
            color = SubElement(material, 'color') # rviz is not reading the materials properly in melodic so specify color here
            appearance = self.materials[body["material"]]
            color.attrib = {'rgba': "{} {} {} {}".format(appearance[1]/255, appearance[2]/255, appearance[3]/255, appearance[4]/255)}
        
        # collision
        collision = SubElement(link, 'collision')
        origin_c = SubElement(collision, 'origin')
        origin_c.attrib = {'xyz':' '.join([str(_) for _ in self.xyz]), 'rpy':'0 0 0'}
        geometry_c = SubElement(collision, 'geometry')
        mesh_c = SubElement(geometry_c, 'mesh')
        mesh_c.attrib = {'filename':'package://' + self.repo + self.name + '.stl','scale':'0.001 0.001 0.001'}

        # print("\n".join(utils.prettify(link).split("\n")[1:]))
        self.link_xml = "\n".join(utils.prettify(link).split("\n")[1:])
Esempio n. 25
0
def write_gazebo_xacro(joints_dict, links_xyz_dict, inertial_dict,
                       package_name, robot_name, save_dir):
    try:
        os.mkdir(save_dir + '/urdf')
    except:
        pass

    file_name = save_dir + '/urdf/' + robot_name + '.gazebo'  # the name of urdf file
    repo = robot_name + '/meshes/'  # the repository of binary stl files
    #repo = package_name + '/' + robot_name + '/bin_stl/'  # the repository of binary stl files
    with open(file_name, mode='w') as f:
        f.write('<?xml version="1.0" ?>\n')
        f.write(
            '<robot name="{}" xmlns:xacro="http://www.ros.org/wiki/xacro" >\n'.
            format(robot_name))
        f.write('\n')
        f.write('<xacro:property name="body_color" value="Gazebo/Silver" />\n')
        f.write('\n')

        gazebo = Element('gazebo')
        plugin = SubElement(gazebo, 'plugin')
        plugin.attrib = {
            'name': 'control',
            'filename': 'libgazebo_ros_control.so'
        }
        gazebo_xml = "\n".join(utils.prettify(gazebo).split("\n")[1:])
        f.write(gazebo_xml)

        # for base_link
        f.write('<gazebo reference="base_link">\n')
        f.write('  <material>${body_color}</material>\n')
        f.write('  <mu1>0.2</mu1>\n')
        f.write('  <mu2>0.2</mu2>\n')
        f.write('  <selfCollide>true</selfCollide>\n')
        f.write('  <gravity>true</gravity>\n')
        f.write('</gazebo>\n')
        f.write('\n')

        # others
        for joint in joints_dict:
            name = joints_dict[joint]['child']
            f.write('<gazebo reference="{}">\n'.format(name))
            f.write('  <material>${body_color}</material>\n')
            f.write('  <mu1>0.2</mu1>\n')
            f.write('  <mu2>0.2</mu2>\n')
            f.write('  <selfCollide>true</selfCollide>\n')
            f.write('</gazebo>\n')
            f.write('\n')

        f.write('</robot>\n')
Esempio n. 26
0
def write_display_launch(package_name, robot_name, save_dir):
    """
    write display launch file "save_dir/launch/display.launch"


    Parameter
    ---------
    robot_name: str
    name of the robot
    save_dir: str
    path of the repository to save
    """   
    try: os.mkdir(save_dir + '/launch')
    except: pass     

    launch = Element('launch')     

    arg1 = SubElement(launch, 'arg')
    arg1.attrib = {'name':'model', 'default':'$(find {})/urdf/{}.xacro'.format(package_name, robot_name)}

    arg2 = SubElement(launch, 'arg')
    arg2.attrib = {'name':'gui', 'default':'true'}

    arg3 = SubElement(launch, 'arg')
    arg3.attrib = {'name':'rvizconfig', 'default':'$(find {})/launch/urdf.rviz'.format(package_name)}

    param1 = SubElement(launch, 'param')
    param1.attrib = {'name':'robot_description', 'command':'$(find xacro)/xacro $(arg model)'}

    param2 = SubElement(launch, 'param')
    param2.attrib = {'name':'use_gui', 'value':'$(arg gui)'}

    node1 = SubElement(launch, 'node')
    node1.attrib = {'name':'joint_state_publisher', 'pkg':'joint_state_publisher', 'type':'joint_state_publisher'}

    node2 = SubElement(launch, 'node')
    node2.attrib = {'name':'robot_state_publisher', 'pkg':'robot_state_publisher', 'type':'robot_state_publisher'}

    node3 = SubElement(launch, 'node')
    node3.attrib = {'name':'rviz', 'pkg':'rviz', 'args':'-d $(arg rvizconfig)', 'type':'rviz', 'required':'true'}

    launch_xml = "\n".join(utils.prettify(launch).split("\n")[1:])        

    file_name = save_dir + '/launch/display.launch'    
    with open(file_name, mode='w') as f:
        f.write(launch_xml)
Esempio n. 27
0
 def createXMLElement(self, parent):
     '''generates an XML element that represents the given Cell'''
     element = SubElement(parent, "Cell")
     element.attrib = {
         "rX": str(self.rect.x),
         "rY": str(self.rect.y),
         "rW": str(self.rect.w),
         "rH": str(self.rect.h),
         "X": str(self.xLoc),
         "Y": str(self.yLoc),
         "isFlagged": str(self.isFlagged),
         "isVisible": str(self.isVisible),
         "isBomb": str(self.isBomb),
         "value": str(self.value)
     }
Esempio n. 28
0
    def edit_entry(self, date, entry_id, title, content, updated=None, draft=False):
        entry = Element('entry')
        entry.attrib = {'xmlns': 'http://purl.org/atom/ns#'}
        _title = SubElement(entry, 'title')
        _title.text = title
        _content = SubElement(entry, 'content')
        _content.attrib = {'type': 'text/plain'}
        _content.text = content
        _updated = SubElement(entry, 'updated')
        _updated.text = updated

        data = minidom.parseString(ET.tostring(entry)).toxml(encoding='utf-8')

        url = self.draft_member.format(entry_id=entry_id) if draft else self.member_url.format(date=date, entry_id=entry_id)
        response = requests.put(url=url, data=data, auth=self.auth)

        if response.ok:
            return ET.fromstring(response.text)
        else:
            return {'status_code': response.status_code, 'reason': response.reason}
Esempio n. 29
0
def visit_node(node_name: str, path: str, parent: Union[Element, None],
               xml_root: Element, saved_root: Element):
    if parent is None:
        node = xml_root
    else:
        node = SubElement(parent, node_name)  # type: Element
    xnode = XNode(node_name, path, parent, xml_root, saved_root)
    # Get and add attributes
    node.attrib = xnode.get_attributes()
    # Get and add text value
    node.text = xnode.get_node_text()
    # Get children
    child_names = xnode.get_child_node_names()
    # Do last
    for child_name, child_path in child_names:
        visit_node(node_name=child_name,
                   path=child_path,
                   parent=node,
                   xml_root=xml_root,
                   saved_root=saved_root)
Esempio n. 30
0
 def submit(self, data):
     top = Element('xml')  # Creating XML document
     ezled = SubElement(top, 'LED_info_Easy')
     ezled.attrib = data
     submit_data = tostring(top)
     # Headers from original android app
     headers = {
         "User-Agent": "Mozilla/4.0 (compatible; MSIE 6.0; Windows 2000)",
         "Content-Type": "multipart/form-data;boundary=*****",
         "Accept":
         "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
         "Accept-Encoding": "gzip"
     }
     r = post(url=self.url,
              params={"Get_Type": 0},
              headers=headers,
              data=submit_data)
     if "Upload OK!" in r.text:
         return True
     else:
         return False
Esempio n. 31
0
def write_gazebo_plugin_and_endtag(file_name):
    """
    Write about gazebo_plugin and the </robot> tag at the end of the urdf
    
    
    Parameters
    ----------
    file_name: str
        urdf full path
    """
    with open(file_name, mode='a') as f:
        # gazebo plugin
        gazebo = Element('gazebo')
        plugin = SubElement(gazebo, 'plugin')
        plugin.attrib = {
            'name': 'control',
            'filename': 'libgazebo_ros_control.so'
        }
        gazebo_xml = "\n".join(prettify(gazebo).split("\n")[1:])
        f.write(gazebo_xml)
        f.write('</robot>\n')
Esempio n. 32
0
def new_agvinfo_xml(agvinfo, path):

    root = Element('agv_info')
    agvsEle = SubElement(root, 'agvs')
    updateTree = xml.etree.ElementTree.ElementTree(root)
    #updateTree=ElementTree(root)

    head = SubElement(agvsEle, 'agv')
    head.attrib = {
        "id": str(agvinfo.vhid),
        "type": str(agvinfo.vhtype),
        'ip': str(agvinfo.inet),
        'mac_addr': str(agvinfo.hwaddr),
        'port': str(agvinfo.mtport),
        'shell_port': str(agvinfo.shport),
        'fts_port': str(agvinfo.ftsport),
        'status': str(agvinfo.status)
    }
    for i in range(len(agvinfo.attrs)):
        head.attrib[agvinfo.attrs[i].name] = str(agvinfo.attrs[i].describe)

    updateTree.write(path)
Esempio n. 33
0
    def _to_xml(self, parent=None, excludes=[]):
        """
        Serialize document to xml
        """
        if parent is not None:
            root = SubElement(parent, self._tagname)
        else:
            root = Element(self._tagname)

        for name, field in sorted(self._fields.items()):
            if name in self.xml_exclude or name in excludes:
                continue
            value = getattr(self, name)
            if value is None:
                # skip not filled fields
                continue

            attribs = dict()
            if isinstance(field, IntField) and name is not 'id':
                attribs['type'] = 'integer'
            if isinstance(field, PyDateTimeField):
                attribs['type'] = 'datetime'
                value = value.strftime('%Y/%m/%d %H:%M:%S %Z')
            if isinstance(field, PyBooleanField):
                attribs['type'] = 'boolean'
                value = str(value).lower()

            if isinstance(field, EmbeddedDocumentField):
                value._to_xml(root)
            else:
                elem = SubElement(root, name)
                elem.text = str(value)
                elem.attrib = attribs
        # allow sub classes to add custom ad-hoc fields
        self._contribute_to_xml(root)
        return tostring(root)
Esempio n. 34
0
    def _to_xml(self, parent=None, excludes=[]):
        """
        Serialize document to xml
        """
        if parent is not None:
            root = SubElement(parent, self._tagname)
        else:
            root = Element(self._tagname)

        for name, field in sorted(self._fields.items()):
            if name in self.xml_exclude or name in excludes:
                continue
            value = getattr(self, name)
            if value is None:
                # skip not filled fields
                continue

            attribs = dict()
            if isinstance(field, IntField) and name is not 'id':
                attribs['type'] = 'integer'
            if isinstance(field, PyDateTimeField):
                attribs['type'] = 'datetime'
                value = value.strftime('%Y/%m/%d %H:%M:%S %Z')
            if isinstance(field, PyBooleanField):
                attribs['type'] = 'boolean'
                value = str(value).lower()

            if isinstance(field, EmbeddedDocumentField):
                value._to_xml(root)
            else:
                elem = SubElement(root, name)
                elem.text = str(value)
                elem.attrib = attribs
        # allow sub classes to add custom ad-hoc fields
        self._contribute_to_xml(root)
        return tostring(root)
Esempio n. 35
0
# import yaml
# from pprint import  pprint as pp
#
# data_set = yaml.safe_load(open('tmp.yaml'))
# pp(data_set)
"""
<directories>
    <directory name='/tmp'>
      <file size="124" mtime="12 Mon Sep 19">file_name</file>
      <dir size="124" mtime="12 Mon Sep 19">dir_name</dir>
    </directory>
</directories>
"""
"http://collabedit.com/vqkeg"
from xml.etree.ElementTree import Element, SubElement, ElementTree

root_tag = Element('directories')
directory_tag = SubElement(root_tag, 'directory')
directory_tag.set('name', '/tmp')
file_tag = SubElement(directory_tag, 'file')
file_tag.text = 'ansible'  # adding text node to the tag
file_tag.attrib = dict(size="124", mtime="12 Mon Sep 19")

ElementTree(root_tag).write('tmp.xml')
Esempio n. 36
0
def writeFile(results=None):
    if results is None:
        return
    print("aegawgwerg ", results)

    root_xml = Element('root')
    sentence_xml = SubElement(root_xml, 'sentence')
    variables_xml = SubElement(root_xml, 'variables')

    variaDic = results.get("variable")
    if variaDic is not None:
        #有重复现象
        for varia in variaDic:
            variable = variaDic[varia]
            key_xml = SubElement(variables_xml, 'key')
            if "indexOfPlace" in variable and "belong" in variable:
                if variable['indexOfPlace'] is not None and variable[
                        'belong'] is not None:
                    key_xml.attrib = {
                        'name': variable['word'],
                        'indexOfPlace': str(variable['indexOfPlace']),
                        'belong': variable['belong']
                    }
                elif variable['indexOfPlace'] is not None:
                    key_xml.attrib = {
                        'name': variable['word'],
                        'indexOfPlace': str(variable['indexOfPlace'])
                    }
                elif variable['belong'] is not None:
                    key_xml.attrib = {
                        'name': variable['word'],
                        'belong': variable['belong']
                    }
                else:
                    key_xml.attrib = {'name': variable['word']}

            elif "indexOfPlace" in variable:
                if variable['indexOfPlace'] is not None:
                    key_xml.attrib = {
                        'name': variable['word'],
                        'indexOfPlace': str(variable['indexOfPlace'])
                    }
                else:
                    key_xml.attrib = {'name': variable['word']}

            elif "belong" in variable:
                if variable['belong'] is not None:
                    key_xml.attrib = {
                        'name': variable['word'],
                        'belong': variable['belong']
                    }
                else:
                    key_xml.attrib = {'name': variable['word']}
            else:
                key_xml.attrib = {'name': variable['word']}
            ref_xml = SubElement(key_xml, 'ref')
            ref_xml.text = variable['ref']
    # preposition_xml = SubElement(root_xml, 'preposition')
    verb_xml = SubElement(root_xml, 'verb')
    conjunction_xml = SubElement(root_xml, "conjunction")
    # getTrans()
    translate_xml = SubElement(root_xml, 'translate')
    translate_xml.text = "#".join(results['formalSentences'])
    # translate_xml.text=transRst.strip('\n')
    # getType()
    # type_xml = SubElement(root_xml, 'type')
    # type_xml.text=typeRst.strip('\n')
    tree = ElementTree(root_xml)
    sentence = results['rawSentence']
    sentence_xml.text = sentence

    # for prep in prepRst:
    #     tempPrep = SubElement(preposition_xml, prep)
    #     SubElement(tempPrep, 'role').text = prepRst[prep]
    verbRst = results.get('verb')
    if verbRst is not None:
        for verb in verbRst:
            verb = verbRst[verb]
            if verb['originVerb'] is None:
                return False
            verb_item = SubElement(verb_xml, verb['originVerb'])
            attrib = {}
            if "indexOfPlace" in verb and "belong" in verb:
                if verb['indexOfPlace'] is not None and verb[
                        'belong'] is not None:
                    attrib = {
                        'indexOfPlace': str(verb['indexOfPlace']),
                        'belong': verb['belong']
                    }
                elif verb['indexOfPlace'] is not None:
                    attrib = {'indexOfPlace': str(verb['indexOfPlace'])}
                elif verb['belong'] is not None:
                    attrib = {'belong': verb['belong']}
            elif "indexOfPlace" in verb:
                if verb['indexOfPlace'] is not None:
                    attrib['indexOfPlace'] = str(verb['indexOfPlace'])
            elif "belong" in verb:
                if verb['belong'] is not None:
                    attrib['belong'] = verb['belong']
            if "isleft" in verb and verb['isleft'] is not None:
                attrib['isleft'] = str(verb['isleft'])
            if "isNegative" in verb and verb['isNegative'] is not None:
                attrib['isNegative'] = str(verb['isNegative'])
            # print(attrib)
            verb_item.attrib = attrib
            # print(verb_item.attrib)
            source_xml = SubElement(verb_item, 'source')
            source_xml.text = 'propbank'
            word_xml = SubElement(verb_item, "wordInSentence")
            word_xml.text = verb['word']
            # num_xml = SubElement(verb_item, 'num')
            # num_xml.text = re.findall(r'.*\.(.*)', verb_num)[0]
            if "roles" in verb and verb['roles']:
                thema_xml = SubElement(verb_item, 'thematicRoles')
                i = 0
                for r in verb['roles']:
                    argn = SubElement(thema_xml, 'arg' + str(i))
                    role = SubElement(argn, 'role')
                    role.text = r[0]
                    content = SubElement(argn, 'content')
                    content.text = r[1]
                    # descr = SubElement(argn, 'descr')
                    # descr.text = dic['descr']
                    i += 1
    conjunctionRst = results.get("conjunction")
    if conjunctionRst is not None:
        for conjunction in conjunctionRst:
            conjunction = conjunctionRst[conjunction]
            conjunction_item = SubElement(conjunction_xml, conjunction['word'])
            if "indexOfPlace" in conjunction and "belong" in conjunction:
                if conjunction['indexOfPlace'] is not None and conjunction[
                        'belong'] is not None:
                    conjunction_item.attrib = {
                        'indexOfPlace': str(conjunction['indexOfPlace']),
                        'belong': conjunction['belong']
                    }
                elif conjunction['indexOfPlace'] is not None:
                    conjunction_item.attrib = {
                        'indexOfPlace': str(conjunction['indexOfPlace'])
                    }
                elif conjunction['belong'] is not None:
                    conjunction_item.attrib = {'belong': conjunction['belong']}
            elif "indexOfPlace" in conjunction:
                if conjunction['indexOfPlace'] is not None:
                    conjunction_item.attrib = {
                        'indexOfPlace': str(conjunction['indexOfPlace'])
                    }
            elif "belong" in conjunction:
                if conjunction['belong'] is not None:
                    conjunction_item.attrib = {'belong': conjunction['belong']}
            role_xml = SubElement(conjunction_item, 'thematic')
            role_xml.text = conjunction['role']['role']

    # translate_xml.text = transRst.strip('\n')
    # type_xml.text = typeRst.strip('\n')

    filename = results['filename']
    # f = open('./result/%s.xml' % filename,'a+')
    tree.write(filename, encoding='utf-8')
    return True
Esempio n. 37
0
 def toxml(self, parent):
     tool = SubElement(parent, 'tool')
     tool.attrib = {'tool-id': self.tool_id, 'tool-name': self.tool_name, 'tool-version': self.tool_version,
                    'build-num': self.build_num}
     return tool
Esempio n. 38
0
 def _contribute_to_xml(self, etree):
     if getattr(self, "no_owner", False):
         elem = SubElement(etree, "no_owner")
         elem.text = str(True).lower()
         elem.attrib = {'type': 'boolean'}
Esempio n. 39
0
def get_vulnerability(filename="", run_time=10):
    tree = ET.parse(filename)
    root = tree.getroot()
    issues = []

    preferences = root.findall(
        "Policy/Preferences/ServerPreferences/preference")
    for preference in preferences:
        result = {}
        for node in preference:
            result[node.tag] = node.text
        if result["name"] == "plugin_set":
            plugin_set = result["value"]
    number_tests = len(plugin_set.split(";"))

    severity_match = {0: "S4", 1: "S3", 2: "S2", 3: "S1", 4: "S0"}
    testsuites = Element("testsuites")
    number_issues = 0
    for elem in root.findall("Report/ReportHost"):
        # need to get host name or IP address
        host = elem.attrib["name"]
        testsuite = SubElement(testsuites, "testsuite")
        for issue in elem.findall("ReportItem"):
            number_issues = number_issues + 1
            testcase = SubElement(testsuite, "testcase")
            attribs = issue.attrib
            failure = SubElement(testcase, "failure")
            description = ""
            synopsis = ""
            plugin_output = ""
            see_also = ""
            solution = ""
            fname = ""
            plugin_type = ""
            plugin_publication_date = ""
            plugin_modification_date = ""
            plugin_name = ""
            fname = ""
            script_version = ""
            risk_factor = ""

            for atom in issue:
                if atom.tag == "description":
                    description = atom.text
                elif atom.tag == "synopsis":
                    synopsis = atom.text
                elif atom.tag == "plugin_output":
                    plugin_output = atom.text
                elif atom.tag == "see_also":
                    see_also = atom.text
                elif atom.tag == "solution":
                    solution = atom.text
                elif atom.tag == "fname":
                    fname = atom.text
                elif atom.tag == "plugin_modification_date":
                    plugin_modification_date = atom.text
                elif atom.tag == "plugin_name":
                    plugin_name = atom.text
                elif atom.tag == "plugin_type":
                    plugin_type = atom.text
                elif atom.tag == "risk_factor":
                    risk_factor = atom.text
                elif atom.tag == "script_version":
                    script_version = atom.text

            testcase_attribs = {}
            sev_level = int(attribs["severity"])
            testcase_attribs["severity"] = severity_match[sev_level]
            testcase_attribs["name"] = attribs["pluginName"]
            testcase_attribs["pluginID"] = attribs["pluginID"]
            testcase_attribs["pluginName"] = attribs["pluginName"]
            testcase_attribs["classname"] = attribs["pluginID"]
            testcase.attrib = testcase_attribs
            failure.text = u"""Host:{}
                            Description:{}
                            Severity:{}
                            Fname:{}
                            Plugin_modification_date:{}
                            Plugin_name:{}
                            Plugin_publication_date:{}
                            Plugin_type:{}
                            Risk_factor:{}
                            Script_version:{}
                            See Also:{}
                            Solution:{}
                            Synopsis:{}
                            Plugin_output:{}
                            """.format(
                                host,
                                description,
                                testcase_attribs["severity"],
                                fname,
                                plugin_modification_date,
                                plugin_name,
                                plugin_publication_date,
                                plugin_type,
                                risk_factor,
                                script_version,
                                see_also,
                                solution,
                                synopsis,
                                plugin_output)
            issues.append(issue)
    testsuites_attribs = {}
    testsuites_attribs["failures"] = str(number_issues)
    testsuites_attribs["errors"] = "0"
    testsuites_attribs["name"] = "name"
    testsuites_attribs["skips"] = "0"
    testsuites_attribs["tests"] = str(number_tests)
    testsuites_attribs["host"] = host
    testsuites_attribs["time"] = str(run_time)
    testsuites.attrib = testsuites_attribs
    return tostring(testsuites)
Esempio n. 40
0
from xml.etree.ElementTree import Element, SubElement, ElementTree

root_tag = Element('directories')
dir_tag = SubElement(root_tag, 'directory')
dir_tag.set('name', r'c:\users\madduv\Desktop')

file_tag = SubElement(dir_tag, 'file')
file_tag.attrib = dict(size='308160', mtime='Sun Dec 11 11:11:11: 2017')
file_tag.text = 'instance.xls'
doc_tree = ElementTree(root_tag)
doc_tree.write('tmp.xml')
Esempio n. 41
0
from xml.etree.ElementTree import Element, SubElement, ElementTree

root_tag = Element('directories')  # root tag
dir_tag = SubElement(root_tag, 'directory')  # child tag
# dir_tag.set('name', '/tmp')  # setting an  attribute
dir_tag.attrib = {'name': '/tmp'}
file_tag = SubElement(dir_tag, 'file')
file_tag.text = 'Eureka Forbes.pdf'  # text node
file_tag.attrib = dict(size="1243", mtime='Sun Dec 11 22:29:41 2016')

ElementTree(root_tag).write('tmp.xml', xml_declaration=True)  # doc object