def get_xml_write2(classname, box, savepath): with open('template.xml', 'r') as fid: xml_str = fid.read() # xml_dict = xmldict.xml_to_dict(xml_str)['annotation']['object'] xml_dict = xmldict.xml_to_dict(xml_str) del xml_dict['annotation']['object'] objects = [] for i in box: object = {} object['name'] = classname object['truncated'] = 0 object['difficult'] = 0 object['pose'] = 'Unspecified' bndbox = { 'xmin': str(i[0]), 'ymin': str(i[1]), 'xmax': str(i[2]), 'ymax': str(i[3]) } object['bndbox'] = bndbox objects.append(object) # [x, y, x + w, y + h] xml_dict['annotation']['object'] = objects dict_xml = xmldict.dict_to_xml(xml_dict) dom = parseString(dict_xml).toprettyxml() with open(savepath, 'w') as f: f.write(dom) f.close()
def get_xml_write(list_class, list_b, imagePath, savepath): with open('template.xml', 'r') as fid: xml_str = fid.read() # xml_dict = xmldict.xml_to_dict(xml_str)['annotation']['object'] xml_dict = xmldict.xml_to_dict(xml_str) del xml_dict['annotation']['object'] objects = [] for i, v in enumerate(list_b): object = {} object['name'] = list_class[i] object['truncated'] = 0 object['difficult'] = 0 object['pose'] = 'Unspecified' bndbox = { 'xmin': str(v[0]), 'ymin': str(v[1]), 'xmax': str(v[2]), 'ymax': str(v[3]) } object['bndbox'] = bndbox objects.append(object) xml_dict['annotation']['object'] = objects dict_xml = xmldict.dict_to_xml(xml_dict) dom = parseString(dict_xml).toprettyxml() # print(xml_dict['annotation']['folder']) with open(savepath + '\\' + imagePath.replace('jpg', 'xml'), 'w') as f: f.write(dom) f.close()
def get_model_edit_str(self, form_model_fields, submission_values, project_name, form_code): # todo instead of using form_model fields, use xform to find the fields answer_dict, edit_model_dict = {'form_code': form_code}, {} formatted_field_values = convert_date_values(form_model_fields, self._format_field_answers_for(form_model_fields, submission_values)) answer_dict.update(formatted_field_values) edit_model_dict.update({project_name: answer_dict}) return xmldict.dict_to_xml(edit_model_dict)
def get_xml_write1(classname, box, imagePath, savepath): with open('template.xml', 'r') as fid: xml_str = fid.read() # xml_dict = xmldict.xml_to_dict(xml_str)['annotation']['object'] xml_dict = xmldict.xml_to_dict(xml_str) del xml_dict['annotation']['object'] object = {} object['name'] = classname object['truncated'] = 0 object['difficult'] = 0 object['pose'] = 'Unspecified' bndbox = { 'xmin': str(box[0]), 'ymin': str(box[1]), 'xmax': str(box[0] + box[2]), 'ymax': str(box[1] + box[3]) } object['bndbox'] = bndbox # [x, y, x + w, y + h] xml_dict['annotation']['object'] = object dict_xml = xmldict.dict_to_xml(xml_dict) dom = parseString(dict_xml).toprettyxml() with open(savepath + '\\' + imagePath.replace('jpg', 'xml'), 'w') as f: f.write(dom) f.close()
def test_dict_to_xml_attributes(self): dict_xml = {'messages': { 'message': [{'@foo': 'bar1', 'baz': 'baz1', '#text': 'message1'}, {'@foo': 'bar2', 'baz': 'baz2', '#text': 'message2'}], 'flag': True }} expected = '<messages><message foo="bar1"><baz>baz1</baz>message1</message><message foo="bar2"><baz>baz2</baz>message2</message><flag>true</flag></messages>' self.assertEqual(expected, dict_to_xml(dict_xml))
def _dict_to_xml(dict_to_convert): """ Convert Python dict to XML :param dict_to_convert: Python dict to be converted (dict) :return: XML (string) """ __logger__.debug("Converting to XML the Python dict: " + str(dict_to_convert)) return xmldict.dict_to_xml(dict_to_convert)
def _dict_to_xml(dict_to_convert): """ Convert Python dict to XML :param dict_to_convert: Python dict to be converted (dict) :return: XML (string) """ logger.debug("Converting to XML the Python dict: " + str(dict_to_convert)) return xmldict.dict_to_xml(dict_to_convert)
def test_dict_to_xml_simple(self): dict_xml = { 'transaction': { 'amount': '100.00', 'currency_code': 'USD' } } expected = '<transaction><amount>100.00</amount><currency_code>USD</currency_code></transaction>' self.assertEqual(expected, dict_to_xml(dict_xml))
def test_dict_to_xml_lists(self): dict_xml = { 'messages': { 'message': ['message1', 'message2'], 'flag': True } } expected = '<messages><message>message1</message><message>message2</message><flag>true</flag></messages>' self.assertEqual(expected, dict_to_xml(dict_xml))
def _dict_to_xml(dict_to_convert): """ Converts Python dict to XML :param dict_to_convert: Python dict to be converted (dict) :return: XML (string) """ logger.debug("Converting Python dict to XML") return xmldict.dict_to_xml(dict_to_convert)
def dict_to_return_format(self,response,return_format,response_dict): if return_format =='table' : ''' Will return in table format''' to_do = "Call the table output formatter" global response_table response_table = '\n' response_table = response_table +'\t'.join(response_dict)+"\n" def get_table(value_to_convert): ''' This will parse the dictionary recusrsively and print as table format''' table_data = "" if type(value_to_convert) == dict : table_data = table_data +'\t'.join(value_to_convert)+"\n" for temp_val in value_to_convert.values() : table_data = table_data + get_table(temp_val) else : table_data = table_data + str(value_to_convert) +"\t" return table_data for value in response_dict.values() : response_table = response_table + get_table(value) #response_table = response_table + '\t'.join(response_dict.values()) return response_table elif return_format =='config': ''' Will return in config format''' to_do = 'Call dict to config coverter' response_string = str(response_dict) print response_string response_config = re.sub(",", "\n\t", response_string) response_config = re.sub("u\'", "\'", response_config) response_config = re.sub("{", "", response_config) response_config = re.sub("}", "\n", response_config) response_config = re.sub(":", " =", response_config) return "[response]\n\t "+response_config elif return_format == 'xml': ''' Will return in xml format''' from core import dicttoobject response_xml = xmldict.dict_to_xml(response_dict) response_xml = re.sub(">\s*<", ">\n<", response_xml) return "\n"+response_xml elif return_format == 'json': ''' Will return in json format''' to_do = 'Call dict to xml coverter' import json response_json = json.dumps(response_dict) return response_json
def to_string(self, data): serialize_data_dict = {} for k, v in data.viewitems(): if isinstance(v, (list, tuple, set)): v = {self.ITEM_TAG: v} elif isinstance(v, str): v = v.decode('utf-8') serialize_data_dict[k] = v return xmldict.dict_to_xml({ 'root': serialize_data_dict })
def test_dict_to_xml_attributes(self): dict_xml = { "messages": { "message": [ {"@foo": "bar1", "baz": "baz1", "#text": "message1"}, {"@foo": "bar2", "baz": "baz2", "#text": "message2"}, ], "flag": True, } } expected = '<messages><message foo="bar1"><baz>baz1</baz>message1</message><message foo="bar2"><baz>baz2</baz>message2</message><flag>true</flag></messages>' self.assertEqual(expected, dict_to_xml(dict_xml))
def test_dict_to_xml(self): dict_xml = {'transaction': {'amount': '100.00', 'currency_code': 'USD'}} expected = '<transaction><amount>100.00</amount><currency_code>USD</currency_code></transaction>' self.assertEqual(expected, dict_to_xml(dict_xml)) dict_xml = {'xml': {'foo': 'bar','baz': ['baz1', 'baz2'], 'flag': True}} expected = '<xml><flag>true</flag><foo>bar</foo><baz>baz1</baz><baz>baz2</baz></xml>' self.assertEqual(expected, dict_to_xml(dict_xml)) dict_xml = {'xml': {'foo': 'bar', 'baz': [ {'baz1': 'baz2'}, {'baz1':'baz2', '@baz':'baz'}, {'baz3': {'@baz3':'baz3', '#text':'bazbaz'}} ], '@qux': 'qux', 'doo': {'@doo1': 'doo1', '#text': 'doodoo'} } } expected = '<xml qux="qux"><foo>bar</foo><baz><baz1>baz2</baz1></baz><baz baz="baz"><baz1>baz2</baz1></baz><baz><baz3 baz3="baz3">bazbaz</baz3></baz><doo doo1="doo1">doodoo</doo></xml>' self.assertEqual(expected, dict_to_xml(dict_xml))
def test_xml_to_dict_and_reverse(self): test = '''<messages> <message id="1"> a b ... </message> <message id="2"> c d ... </message> </messages>''' expected = { 'messages': { 'message': [ { '@id': '1', '#value': 'a\nb\n...', '#text': '\na\nb\n...\n', }, { '@id': '2', '#value': 'c\nd\n...', '#text': '\nc\nd\n...\n', }, ] } } self.assertEqual(expected, xml_to_dict(test, strict=True)) # once converted to dict, go back to xml (do not care about extra blanks) def _remove_blanks(content): from lxml import etree parser = etree.XMLParser(remove_blank_text=True) elem = etree.XML(content, parser=parser) return etree.tostring(elem) self.assertEqual(_remove_blanks(test), dict_to_xml(expected))
def test_xml_to_dict_and_reverse(self): test = '''<messages> <message id="1"> a b ... </message> <message id="2"> c d ... </message> </messages>''' expected = {'messages': {'message': [ {'@id': '1', '#value': 'a\nb\n...', '#text': '\na\nb\n...\n', }, {'@id': '2', '#value': 'c\nd\n...', '#text': '\nc\nd\n...\n', }, ] } } self.assertEqual(expected, xml_to_dict(test, strict=True)) # once converted to dict, go back to xml (do not care about extra blanks) def _remove_blanks(content): from lxml import etree parser = etree.XMLParser(remove_blank_text=True) elem = etree.XML(content, parser=parser) return etree.tostring(elem) self.assertEqual(_remove_blanks(test), dict_to_xml(expected))
def test_dict_to_xml_simple(self): dict_xml = {'transaction': {'amount': '100.00', 'currency_code': 'USD'}} expected = '<transaction><amount>100.00</amount><currency_code>USD</currency_code></transaction>' self.assertEqual(expected, dict_to_xml(dict_xml))
def test_dict_to_xml_lists(self): dict_xml = {"messages": {"message": ["message1", "message2"], "flag": True}} expected = "<messages><message>message1</message><message>message2</message><flag>true</flag></messages>" self.assertEqual(expected, dict_to_xml(dict_xml))
def get_xml(self): result = {'id': self._id} result.update(self.getDict()) return dict_to_xml(result)
def dict_to_xml(dict): return xmldict.dict_to_xml(dict)
def dic_to_xml(dic): return xmldict.dict_to_xml(dic)
def dict_to_xml(dict_to_convert): return xmldict.dict_to_xml(dict_to_convert)
def convert(self): return xmldict.dict_to_xml(open(self.filename))
def convert_dict_xml(dictionary): elem = dict_to_xml(dictionary) assert len(elem) == 1 return ET.tostring(elem[0])
def test_dict_to_xml_empty(self): dict_xml = {'messages': {'message': None}} expected = '<messages><message>null</message></messages>' self.assertEqual(expected, dict_to_xml(dict_xml))
def format(self, value): obj = IOpenCollaborationServiceXML(value)() return '<?xml version="1.0"?>' + xmldict.dict_to_xml(obj)
def create_report(bulletin_reports, file_name): from xmldict import dict_to_xml xml = dict_to_xml({file_name: bulletin_reports}) f_ptr = open(__base_path + file_name + ".xml", "w") f_ptr.write(xml) f_ptr.close()
def test_dict_to_xml_lists(self): dict_xml = {'messages': {'message': ['message1', 'message2'], 'flag': True}} expected = '<messages><message>message1</message><message>message2</message><flag>true</flag></messages>' self.assertEqual(expected, dict_to_xml(dict_xml))
def test_dict_to_xml_empty(self): dict_xml = {"messages": {"message": None}} expected = "<messages><message>null</message></messages>" self.assertEqual(expected, dict_to_xml(dict_xml))
def get_xml(self): result = {'id' : self._id} result.update(self.getDict()) return dict_to_xml(result)
def test_dict_to_xml_simple(self): dict_xml = {"transaction": {"amount": "100.00", "currency_code": "USD"}} expected = "<transaction><amount>100.00</amount><currency_code>USD</currency_code></transaction>" self.assertEqual(expected, dict_to_xml(dict_xml))