def testIterable(self):
expected = u'<data><data-item>бар</data-item><data-item>foo</data-item><data-item>123</data-item></data>'
self.assertEqual(expected, xmlify.dumps((u'бар', b'foo', 123)))
self.assertEqual(expected, xmlify.dumps([u'бар', b'foo', 123]))
self.assertEqual(expected,
xmlify.dumps(v for v in (u'бар', b'foo', 123)))
actual = etree.fromstring(
xmlify.dumps({u'бар', b'foo', 123}).encode('utf-8'))
self.assertTrue(
all(n.text in (u'бар', 'foo', '123')
for n in actual.iterfind('data')))
def show(self, category_id, request, format=None):
"""Returns the category in a given format.
Args:
category_id - category of the items
item_id - the item id
request - http request
format - The desired format of the returned data,
one of 'JSON', 'XML', or None. None returns
the html for a web page.
"""
try:
category = self.db_session.query(Category) \
.filter_by(id=category_id).one()
if format == 'JSON':
return jsonify(Category=category.serialize)
elif format == 'XML':
return xmlify.dumps(category.serialize, 'category')
elif format == None:
return render_template('category.html',
category=category,
categories=self.getCategories(),
items=self.getItems(category.id))
else:
abort(501)
except:
abort(404)
def showAll(self, request, format=None):
"""Returns all the categories in a given format.
Args:
request - http request
format - The desired format of the returned data,
one of 'JSON', 'XML', or None. None returns
the html for a web page.
"""
try:
categories = self.getCategories()
if format == 'JSON':
return jsonify(
Categories=[c.serialize for c in categories])
elif format == 'XML':
return string.replace(
xmlify.dumps([c.serialize for c in categories],
'categories'), 'categories-item', 'category')
elif not format:
items = self.getAllItems()
return render_template('category_all.html',
categories=categories, category=None,
items=items, item=None)
else:
abort(501)
except:
abort(404)
def testMapping(self):
d = {
u'бар': b'foo',
b'foo': u'бар',
123: 234.345,
234.345: 123,
False: None,
None: False,
datetime.date(2008, 8, 8): decimal.Decimal('2.2'),
decimal.Decimal('2.2'): datetime.date(2008, 8, 8)
}
actual = etree.fromstring(xmlify.dumps(d).encode('utf-8'))
self.assertEqual('foo', actual.find('xd0b1d0b0d180').text)
self.assertEqual(u'бар', actual.find('foo').text)
self.assertEqual('234.345', actual.find('n123').text)
self.assertEqual('123', actual.find('n234.345').text)
self.assertEqual('None', actual.find('False').text)
self.assertEqual('False', actual.find('None').text)
self.assertEqual('2.2', actual.find('n2008-08-08').text)
self.assertEqual('2008-08-08', actual.find('n2.2').text)
self.assertEqual('<data><x>21</x></data>', xmlify.dumps({'': 21}))
self.assertEqual('<data><__>22</__></data>', xmlify.dumps({'!#': 22}))
def show(self, category_id, item_id, request, format=None):
"""Returns an item from the category in a given format.
NOTE: the category_id should be the same as the
Item.category_id. This relationship is loosely enforced,
but if they're out of sync you probably have a database
problem, so consider this a canary in your coal mine.
Args:
category_id - category of the items
item_id - the item id
request - http request
format - The desired format of the returned data,
one of 'JSON', 'XML', or None. None returns
the html for a web page.
"""
try:
item = self.db_session.query(Item) \
.filter_by(category_id=category_id, id=item_id) \
.one()
if format == 'JSON':
return jsonify(Item=item.serialize)
elif format == 'XML':
return xmlify.dumps(item.serialize, 'item')
elif not format:
category = self.db_session.query(Category) \
.filter_by(id=category_id) \
.one()
categories = self.getCategories()
items = self.getItems(category_id)
user = self.db_session.query(User) \
.filter_by(id=category.user_id) \
.one()
return render_template('item.html',
category=category,
categories=categories,
item=item,
items=items,
user=user)
else:
abort(501)
except:
abort(404)
def showAll(self, category_id, request, format=None):
"""Returns all the items from the a category in a given format.
Args:
category_id - category of the items
request - http request
format - The desired format of the returned data,
one of 'JSON', 'XML', or None. None returns
the html for a web page.
"""
try:
items = self.getItems(category_id)
if format == 'JSON':
return jsonify(Items=[i.serialize for i in items])
elif format == 'XML':
return string.replace(
xmlify.dumps([i.serialize for i in items],
'items'),
'items-item',
'item')
elif not format:
category = self.db_session \
.query(Category) \
.filter_by(id=category_id) \
.one()
categories = self.getCategories()
user = self.db_session.query(User) \
.filter_by(id=category.user_id) \
.one()
return render_template('item_all.html',
category=category,
categories=categories,
items=items,
item=None,
user=user)
else:
abort(501)
except:
abort(404)
def testNested(self):
data = {
'request': {
'url': 'http://planetpython.org/rss20.xml',
'method': 'GET',
'headers': {
'host': 'planetpython.org',
'user-agent':
'Mozilla/5.0 (X11; Linux x86_64; rv:27.0) Gecko/20100101 Firefox/27.0',
'accept':
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'accept-language': 'en,en-gb;q=0.7,ru;q=0.3',
'accept-encoding': 'gzip, deflate',
'referer': 'http://planetpython.org/',
'connection': 'keep-alive'
}
},
'response': {
'status':
'200',
'headers': {
'server': 'nginx',
'date': 'Mon, 01 Jun 2015 18:42:30 GMT',
'content-type': 'text/xml',
'content-length': '123690',
'last-modified': 'Mon, 01 Jun 2015 16:48:44 GMT',
'connection': 'keep-alive',
'etag': '"556c8cec-1e32a"',
'accept-ranges': 'bytes'
},
'body':
'''<?xml version="1.0"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
<title>Planet Python</title>
<link>http://planetpython.org/</link>
<language>en</language>
<description>Planet Python - http://planetpython.org/</description>
<item>
<title>PyPy Development: PyPy 2.6.0 release</title>
<guid>http://feedproxy.google.com/~r/PyPyStatusBlog/~3/LP9tp3TPXOY/pypy-260-release.html</guid>
<link>http://feedproxy.google.com/~r/PyPyStatusBlog/~3/LP9tp3TPXOY/pypy-260-release.html</link>
<description><div dir="ltr">
<div class="document">
<div class="section" id="pypy-2-6-0-cameo-charm">
<h2>PyPy 2.6.0 - Cameo Charm</h2>
</description>
<pubDate>Mon, 01 Jun 2015 16:41:36 +0000</pubDate>
</item>
</channel>
</rss>
'''
}
}
actual = etree.fromstring(xmlify.dumps(data).encode('utf-8'))
def match(path, obj):
if isinstance(obj, dict):
for k, v in obj.items():
match(path + [k], v)
elif path:
self.assertEqual(obj, actual.find('/'.join(path)).text)
match([], data)
def testXmlUnfriendly(self):
d = {b'\x00\x80\x01': b'\xde\xad\xbe\xef'}
self.assertEqual('<data><x008001>xdeadbeef</x008001></data>',
xmlify.dumps(d))
def testScalar(self):
self.assertEqual('<data />', xmlify.dumps({}))
self.assertEqual('<data>123</data>', xmlify.dumps(123))
self.assertEqual('<data>123.123</data>', xmlify.dumps(123.123))
self.assertEqual('<data>foo</data>', xmlify.dumps('foo'))
self.assertEqual('<data>foo></data>', xmlify.dumps('foo>'))
self.assertEqual('<data><foo>&</foo></data>',
xmlify.dumps('<foo>&</foo>'))
self.assertEqual('<data>foo</data>', xmlify.dumps(b'foo'))
self.assertEqual('<data>foo></data>', xmlify.dumps(b'foo>'))
self.assertEqual('<data><foo>&</foo></data>',
xmlify.dumps(b'<foo>&</foo>'))
self.assertEqual(u'<data>бар</data>', xmlify.dumps(u'бар'))
self.assertEqual(u'<data>бар<</data>', xmlify.dumps(u'бар<'))
self.assertEqual(u'<data>бар<&baz;></data>',
xmlify.dumps(u'бар<&baz;>'))
self.assertEqual('<data>True</data>', xmlify.dumps(True))
self.assertEqual('<data>None</data>', xmlify.dumps(None))
self.assertEqual('<data>123.123</data>',
xmlify.dumps(decimal.Decimal('123.123')))
self.assertEqual(
'<data>2012-11-10 09:08:07</data>',
xmlify.dumps(datetime.datetime(2012, 11, 10, 9, 8, 7)))
def mapper_final_dos(self):
yield "key", xmlify.dumps(self.listaDef, root="key")
import xmlify
rooms_path = input('Enter your path to rooms.json: ')
rooms_path += "/rooms.json"
students_path = input('Enter your path to students.json: ')
students_path += "/students.json"
students_in_rooms_path = input(
'Enter your path to save student_in_rooms file: ')
doc_type = input('Enter the type of file: ')
students_in_rooms_path += ("/students_in_rooms." + doc_type)
with open(rooms_path, "r") as rooms_json:
rooms = json.load(rooms_json)
with open(students_path, "r") as students_json:
students = json.load(students_json)
for room in rooms:
room['students'] = []
for student in students:
room_id = student['room']
rooms[room_id]['students'].append(student['name'])
if doc_type == ("json"):
with open(students_in_rooms_path, 'w') as f:
json.dump(rooms, f, indent=4)
else:
with open(students_in_rooms_path, "w") as f:
f.write(xmlify.dumps(rooms))
