Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Add non-fold style list #42

Open
wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Add non-fold style list #42

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
7844ece
add fold list style support
jeffkit Jul 28, 2015
f3f78d5
PEP8
jeffkit Jul 28, 2015
67f1545
fix not none condition
jeffkit Jul 29, 2015
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
156 changes: 106 additions & 50 deletions dicttoxml.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,8 @@
# coding: utf-8

"""
Converts a native Python dictionary into an XML string. Supports numbers, strings, lists, dictionaries and arbitrary nesting.
Converts a native Python dictionary into an XML string. Supports numbers,
strings, lists, dictionaries and arbitrary nesting.
"""

from __future__ import unicode_literals
Expand All @@ -14,7 +15,6 @@
import collections
import numbers
import logging
import sys
from xml.dom.minidom import parseString


Expand All @@ -32,42 +32,50 @@
except:
long = int


def set_debug(debug=True, filename='dicttoxml.log'):
if debug:
import datetime
print('Debug mode is on. Events are logged at: %s' % (filename))
logging.basicConfig(filename=filename, level=logging.INFO)
LOG.info('\nLogging session starts: %s' % (str(datetime.datetime.today())))
LOG.info('\nLogging session starts: %s' % (
str(datetime.datetime.today())))
else:
logging.basicConfig(level=logging.WARNING)
print('Debug mode is off.')

ids = [] # initialize list of unique ids
ids = [] # initialize list of unique ids


def unicode_me(something):
"""Converts strings with non-ASCII characters to unicode for LOG. Python 3 doesn't have a `unicode()` function, so `unicode()` is an alias for `str()`, but `str()` doesn't take a second argument, hence this kludge."""
"""Converts strings with non-ASCII characters to unicode for LOG.
Python 3 doesn't have a `unicode()` function, so `unicode()` is an
alias for `str()`, but `str()` doesn't take a second argument,
hence this kludge."""
try:
return unicode(something, 'utf-8')
except:
return unicode(something)


def make_id(element, start=100000, end=999999):
"""Returns a random integer"""
return '%s_%s' % (element, randint(start, end))


def get_unique_id(element):
"""Returns a unique id for a given element"""
this_id = make_id(element)
dup = True
while dup == True:
while dup:
if this_id not in ids:
dup = False
ids.append(this_id)
else:
this_id = make_id(element)
return ids[-1]


def get_xml_type(val):
"""Returns the data type for the xml type attribute"""
if type(val).__name__ in ('str', 'unicode'):
Expand All @@ -88,34 +96,40 @@ def get_xml_type(val):
return 'list'
return type(val).__name__


def xml_escape(s):
if type(s) in (str, unicode):
s = unicode_me(s) # avoid UnicodeDecodeError
s = unicode_me(s) # avoid UnicodeDecodeError
s = s.replace('&', '&')
s = s.replace('"', '"')
s = s.replace('\'', ''')
s = s.replace('<', '&lt;')
s = s.replace('>', '&gt;')
return s


def make_attrstring(attr):
"""Returns an attribute string in the form key="val" """
attrstring = ' '.join(['%s="%s"' % (k, v) for k, v in attr.items()])
return '%s%s' % (' ' if attrstring != '' else '', attrstring)


def key_is_valid_xml(key):
"""Checks that a key is a valid XML name"""
LOG.info('Inside key_is_valid_xml(). Testing "%s"' % (unicode_me(key)))
test_xml = '<?xml version="1.0" encoding="UTF-8" ?><%s>foo</%s>' % (key, key)
test_xml = '<?xml version="1.0" encoding="UTF-8" ?><%s>foo</%s>' % (
key, key)
try:
parseString(test_xml)
return True
except Exception: #minidom does not implement exceptions well
except Exception: # minidom does not implement exceptions well
return False


def make_valid_xml_name(key, attr):
"""Tests an XML name and fixes it if invalid"""
LOG.info('Inside make_valid_xml_name(). Testing key "%s" with attr "%s"' % (unicode_me(key), unicode_me(attr)))
LOG.info('Inside make_valid_xml_name(). Testing key "%s" with attr "%s"' %
(unicode_me(key), unicode_me(attr)))
# pass through if key is already valid
if key_is_valid_xml(key):
return key, attr
Expand All @@ -130,39 +144,47 @@ def make_valid_xml_name(key, attr):
key = 'key'
return key, attr

def convert(obj, ids, attr_type, parent='root'):
"""Routes the elements of an object to the right function to convert them based on their data type"""
LOG.info('Inside convert(). obj type is: "%s", obj="%s"' % (type(obj).__name__, unicode_me(obj)))

def convert(obj, ids, attr_type, parent='root', fold_list=True):
"""Routes the elements of an object to the right function to convert
them based on their data type"""
LOG.info('Inside convert(). obj type is: "%s", obj="%s"' %
(type(obj).__name__, unicode_me(obj)))
if isinstance(obj, numbers.Number) or type(obj) in (str, unicode):
return convert_kv('item', obj, attr_type)
if hasattr(obj, 'isoformat'):
return convert_kv('item', obj.isoformat(), attr_type)
if type(obj) == bool:
return convert_bool('item', obj, attr_type)
if obj == None:
if obj is None:
return convert_none('item', '', attr_type)
if isinstance(obj, dict):
return convert_dict(obj, ids, parent, attr_type)
return convert_dict(obj, ids, parent, attr_type, fold_list)
if isinstance(obj, collections.Iterable):
return convert_list(obj, ids, parent, attr_type)
raise TypeError('Unsupported data type: %s (%s)' % (obj, type(obj).__name__))
return convert_list(obj, ids, parent, attr_type, fold_list)
raise TypeError('Unsupported data type: %s (%s)' %
(obj, type(obj).__name__))


def convert_dict(obj, ids, parent, attr_type):
def convert_dict(obj, ids, parent, attr_type, fold_list):
"""Converts a dict into an XML string."""
LOG.info('Inside convert_dict(): obj type is: "%s", obj="%s"' % (type(obj).__name__, unicode_me(obj)))
LOG.info('Inside convert_dict(): obj type is: "%s", obj="%s"' %
(type(obj).__name__, unicode_me(obj)))
output = []
addline = output.append
for key, val in obj.items():
LOG.info('Looping inside convert_dict(): key="%s", val="%s", type(val)="%s"' % (unicode_me(key), unicode_me(val), type(val).__name__))
LOG.info(
'Looping inside convert_dict():key="%s",val="%s",type(val)="%s"' %
(unicode_me(key), unicode_me(val), type(val).__name__))

attr = {} if not ids else {'id': '%s' % (get_unique_id(parent)) }
attr = {} if not ids else {'id': '%s' % (get_unique_id(parent))}

key, attr = make_valid_xml_name(key, attr)

if isinstance(val, numbers.Number) or type(val) in (str, unicode):
addline(convert_kv(key, val, attr_type, attr))

elif hasattr(val, 'isoformat'): # datetime
elif hasattr(val, 'isoformat'): # datetime
addline(convert_kv(key, val.isoformat(), attr_type, attr))

elif type(val) == bool:
Expand All @@ -172,57 +194,82 @@ def convert_dict(obj, ids, parent, attr_type):
if attr_type:
attr['type'] = get_xml_type(val)
addline('<%s%s>%s</%s>' % (
key, make_attrstring(attr), convert_dict(val, ids, key, attr_type), key)
key, make_attrstring(attr),
convert_dict(val, ids, key, attr_type, fold_list), key)
)
elif isinstance(val, collections.Iterable):
if attr_type:
attr['type'] = get_xml_type(val)
addline('<%s%s>%s</%s>' % (
key, make_attrstring(attr), convert_list(val, ids, key, attr_type), key)
)
if fold_list:
addline('<%s%s>%s</%s>' % (
key, make_attrstring(attr),
convert_list(val, ids, key, attr_type, fold_list), key)
)
else:
addline(convert_list(val, ids, key, attr_type, fold_list))
elif val is None:
addline(convert_none(key, val, attr_type, attr))
else:
raise TypeError('Unsupported data type: %s (%s)' % (val, type(val).__name__))
raise TypeError('Unsupported data type: %s (%s)' %
(val, type(val).__name__))
return ''.join(output)

def convert_list(items, ids, parent, attr_type):

def convert_list(items, ids, parent, attr_type, fold_list):
"""Converts a list into an XML string."""
LOG.info('Inside convert_list()')
output = []
addline = output.append

item_name = 'item' if fold_list else parent

if ids:
this_id = get_unique_id(parent)

for i, item in enumerate(items):
LOG.info('Looping inside convert_list(): item="%s", type="%s"' % (unicode_me(item), type(item).__name__))
attr = {} if not ids else { 'id': '%s_%s' % (this_id, i+1) }
LOG.info('Looping inside convert_list(): item="%s", type="%s"' %
(unicode_me(item), type(item).__name__))
attr = {} if not ids else {'id': '%s_%s' % (this_id, i+1)}
if isinstance(item, numbers.Number) or type(item) in (str, unicode):
addline(convert_kv('item', item, attr_type, attr))
elif hasattr(item, 'isoformat'): # datetime
addline(convert_kv('item', item.isoformat(), attr_type, attr))
addline(convert_kv(item_name, item, attr_type, attr))
elif hasattr(item, 'isoformat'): # datetime
addline(convert_kv(item_name, item.isoformat(), attr_type, attr))
elif type(item) == bool:
addline(convert_bool('item', item, attr_type, attr))
addline(convert_bool(item_name, item, attr_type, attr))
elif isinstance(item, dict):
if not attr_type:
addline('<item>%s</item>' % (convert_dict(item, ids, parent, attr_type)))
addline('<%s>%s</%s>' %
(item_name,
convert_dict(item, ids, parent, attr_type, fold_list),
item_name))
else:
addline('<item type="dict">%s</item>' % (convert_dict(item, ids, parent, attr_type)))
addline('<%s type="dict">%s</%s>' % (
item_name,
convert_dict(item, ids, parent, attr_type, fold_list),
item_name))
elif isinstance(item, collections.Iterable):
if not attr_type:
addline('<item %s>%s</item>' % (make_attrstring(attr), convert_list(item, ids, 'item', attr_type)))
addline('<%s %s>%s</%s>' % (
item_name, make_attrstring(attr),
convert_list(item, ids, 'item', attr_type, fold_list),
item_name))
else:
addline('<item type="list"%s>%s</item>' % (make_attrstring(attr), convert_list(item, ids, 'item', attr_type)))
addline('<%s type="list"%s>%s</%s>' % (
item_name, make_attrstring(attr),
convert_list(item, ids, 'item', attr_type, fold_list),
item_name))
elif item is None:
addline(convert_none('item', None, attr_type, attr))
addline(convert_none(item_name, None, attr_type, attr))
else:
raise TypeError('Unsupported data type: %s (%s)' % (item, type(item).__name__))
raise TypeError('Unsupported data type: %s (%s)' %
(item, type(item).__name__))
return ''.join(output)


def convert_kv(key, val, attr_type, attr={}):
"""Converts a number or string into an XML element"""
LOG.info('Inside convert_kv(): key="%s", val="%s", type(val) is: "%s"' % (unicode_me(key), unicode_me(val), type(val).__name__))
LOG.info('Inside convert_kv(): key="%s", val="%s", type(val) is: "%s"' %
(unicode_me(key), unicode_me(val), type(val).__name__))

key, attr = make_valid_xml_name(key, attr)

Expand All @@ -233,9 +280,11 @@ def convert_kv(key, val, attr_type, attr={}):
key, attrstring, xml_escape(val), key
)


def convert_bool(key, val, attr_type, attr={}):
"""Converts a boolean into an XML element"""
LOG.info('Inside convert_bool(): key="%s", val="%s", type(val) is: "%s"' % (unicode_me(key), unicode_me(val), type(val).__name__))
LOG.info('Inside convert_bool(): key="%s", val="%s", type(val) is: "%s"' %
(unicode_me(key), unicode_me(val), type(val).__name__))

key, attr = make_valid_xml_name(key, attr)

Expand All @@ -244,6 +293,7 @@ def convert_bool(key, val, attr_type, attr={}):
attrstring = make_attrstring(attr)
return '<%s%s>%s</%s>' % (key, attrstring, unicode(val).lower(), key)


def convert_none(key, val, attr_type, attr={}):
"""Converts a null value into an XML element"""
LOG.info('Inside convert_none(): key="%s"' % (unicode_me(key)))
Expand All @@ -255,18 +305,24 @@ def convert_none(key, val, attr_type, attr={}):
attrstring = make_attrstring(attr)
return '<%s%s></%s>' % (key, attrstring, key)

def dicttoxml(obj, root=True, custom_root='root', ids=False, attr_type=True):

def dicttoxml(obj, root=True, custom_root='root', ids=False, attr_type=True,
fold_list=True):
"""Converts a python object into XML
attr_type is used to specify if data type for each element should be included in the resulting xml.
attr_type is used to specify if data type for each element should be
included in the resulting xml.
By default, it is set to True.
"""
LOG.info('Inside dicttoxml(): type(obj) is: "%s", obj="%s"' % (type(obj).__name__, unicode_me(obj)))
LOG.info('Inside dicttoxml(): type(obj) is: "%s", obj="%s"' %
(type(obj).__name__, unicode_me(obj)))
output = []
addline = output.append
if root == True:
if root:
addline('<?xml version="1.0" encoding="UTF-8" ?>')
addline('<%s>%s</%s>' % (custom_root, convert(obj, ids, attr_type, parent=custom_root), custom_root))
addline('<%s>%s</%s>' % (
custom_root,
convert(obj, ids, attr_type, custom_root, fold_list),
custom_root))
else:
addline(convert(obj, ids, attr_type, parent=''))
addline(convert(obj, ids, attr_type, '', fold_list))
return ''.join(output).encode('utf-8')