def XMLApps(category_id):
""" Return all apps from a category in XML format """
apps = session.query(App).filter_by(category_id=category_id).all()
data = xmlify([i.serialize for i in apps], wrap="app", indent=" ")
xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + xmlify(data, wrap="category")
response = make_response(xml)
response.mimetype = 'text/xml'
return response
def XMLCategories():
""" Return categories in XML format """
categories = session.query(Category).all()
data = xmlify([i.serialize for i in categories], wrap="category", indent=" ")
xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + xmlify(data, wrap="categories")
response = make_response(xml)
response.mimetype = 'text/xml'
return response
def myItemsXML(user_id):
"""
Returns the XML for the items added by the user_id requested, only if that is the current user
If the user is not the current user return an empty list is returned.
"""
user = getCurrentUser()
serialItem = []
# prevent non item owner from viewing myItems
if user is None or user_id != user.id:
# return empty
return xmlify(serialItem, wrap='Item', indent=' '), 200, {'Content-Type': 'text/css; charset=utf-8'}
items = db_session.query(Item).filter_by(user_id = user_id).order_by(Item.category_id).all()
for i in items:
serialItem.append(i.serialize)
return xmlify(serialItem, wrap='Item', indent=' '), 200, {'Content-Type': 'text/css; charset=utf-8'}
def get_category_xml(id):
"""Get a category's info given its id using XML format."""
category = Category.query.get_or_404(id)
response = make_response(xmlify(category.to_dict("XML"), wrap="category", indent=" "))
response.headers["Content-Type"] = "text/xml"
return response
def exercises_api():
"""Returns the response, the API data, of all exercises.
Checks header for 'ACCEPT' and if json returns, json else if xml return xml
for all exercise categories.
"""
exercises = db_session.query(Exercise).all()
accept = request.headers.get('ACCEPT')
resp = None
if accept == "application/json":
resp = "["
i = 0
for exercise in exercises:
resp += jsonify(exercise.serialize).get_data()
if i < len(exercises) - 1:
resp += (",")
i += 1
resp += ("]")
resp = Response(resp, mimetype='application/json')
else:
resp = "<exercises>"
for exercise in exercises:
resp += "\n"
resp += xmlify(exercise.serialize, wrap="exercise", indent=" ")
resp += ("\n</exercises>")
resp = Response(resp, mimetype='application/xml')
return resp
def list_to_xml(list_of_dicts):
''' Create XML from python dictionary '''
from dict2xml import dict2xml as xmlify
xml_out = xmlify(list_of_dicts, wrap='pair', indent=' ')
print(xml_out)
return xml_out
def showItemXML(category, item):
category = session.query(Category).filter_by(name=category).first()
# Check if the category exists if user manually enters a url.
if category is None:
return categoryAlert()
item = (
session.query(Item)
.filter_by(
name=item,
category_id=category.id
)
.first()
)
if item is None:
return itemAlert()
# Transform existing JSON endpoint into XML endpoint.
# Convert JSON endpoint to a string,
# then convert the string into a dictionary.
data = ast.literal_eval(
showItemJSON(
category.name,
item.name
)
.get_data(as_text=True)
)
return app.response_class(
xmlify(data, wrap="Catalog", indent=" "),
mimetype="application/xml"
)
def restaurantsJSON():
restaurants = session.query(Restaurant).all()
for restaurant in restaurants:
data = {
"name": restaurant.name
}
return xmlify(data, wrap="restaurants", indent= " ")
def exercises_api():
"""Returns the response, the API data, of all exercises.
Checks header for 'ACCEPT' and if json returns, json else if xml return xml
for all exercise categories.
"""
exercises = db_session.query(Exercise).all()
accept = request.headers.get('ACCEPT')
resp = None
if accept == "application/json":
resp = "["
i = 0
for exercise in exercises:
resp += jsonify(exercise.serialize).get_data()
if i < len(exercises) - 1:
resp += (",")
i += 1
resp += ("]")
resp = Response(resp, mimetype='application/json')
else:
resp = "<exercises>"
for exercise in exercises:
resp += "\n"
resp += xmlify(exercise.serialize, wrap="exercise", indent=" ")
resp += ("\n</exercises>")
resp = Response(resp, mimetype='application/xml')
return resp
def bookCategoryXML(category_id):
"""Returns XML for a specific category with category_id."""
category = session.query(Category).filter_by(id=category_id).one()
books = session.query(Book).filter_by(category_id=category_id).all()
return xmlify(data=[i.serialize for i in books],
wrap="booksInCategory",
indent=" ")
def eventJSON(organizer_id, event_id, api_type):
event = session.query(Event).filter_by(id = event_id).one()
if api_type == 'XML':
return xmlify(data = event.serialize, wrap="all", indent=" ")
elif api_type == 'JSON':
return jsonify(Event = event.serialize)
else:
return jsonify({'error' : 'Please choose a valid api type, either XML or JSON.'})
def organizersAPI(api_type):
organizers = session.query(Organizer).all()
if api_type == 'XML':
return xmlify(data = [o.serialize for o in organizers], wrap="all", indent=" ")
elif api_type == 'JSON':
return jsonify(organizers = [o.serialize for o in organizers])
else:
return jsonify({'error' : 'Please choose a valid api type, either XML or JSON.'})
def categories_list_xml():
categories = session.query(Category).all()
output = ''
for c in categories:
xml = xmlify(c.serialize, wrap="all", indent=" ", newlines=True)
output += xml
output += '</br>'
return output
def get_item_xml(id):
"""Get an item's info given its id using XML format."""
item = Item.query.get_or_404(id)
response = make_response(
xmlify(item.to_dict('XML'), wrap="item", indent=" "))
response.headers["Content-Type"] = "text/xml"
return response
def XMLSingleApp(category_id, app_id):
""" Return details of a single app in XML format """
app = session.query(App).filter_by(id=app_id).one()
data = xmlify(app.serialize, wrap="app", indent=" ")
xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + data
response = make_response(xml)
response.mimetype = 'text/xml'
return response
def get_categories_xml():
"""Get all categories available using XML format."""
categories = Category.query.all()
response = make_response(
xmlify({"category": [category.to_dict("XML") for category in categories]}, wrap="categories", indent=" ")
)
response.headers["Content-Type"] = "text/xml"
return response
def organizerEventsAPI(organizer_id, api_type):
organizer = session.query(Organizer).filter_by(id = organizer_id).one()
events = session.query(Event).filter_by(organizer_id = organizer_id).all()
if api_type == 'XML':
return xmlify(data = [e.serialize for e in events], wrap="all", indent=" ")
elif api_type == 'JSON':
return jsonify(Events = [e.serialize for e in events])
else:
return jsonify({'error' : 'Please choose a valid api type, either XML or JSON.'})
def showCatalogXML():
# Transform existing JSON endpoint into XML endpoint.
# Convert JSON endpoint to string,
# then convert the string into a dictionary.
data = ast.literal_eval(showCatalogJSON().get_data(as_text=True))
return app.response_class(
xmlify(data, wrap="Catalog", indent=" "),
mimetype='application/xml'
)
def category_xml(category_id):
items = session.query(Item).filter_by(
category_id=category_id).all()
output = ''
for i in items:
xml = xmlify(i.serialize, wrap="all", indent=" ", newlines=True)
output += xml
output += '</br>'
return output
def get_category_items_by_name_xml(name):
"""Get all items given its category name using XML format."""
category = Category.query.filter_by(name=name).first_or_404()
response = make_response(xmlify(
{"item": [item.to_dict('XML') for item in category.items]},
wrap="items", indent=" "))
response.headers["Content-Type"] = "text/xml"
return response
def eventJSON(organizer_id, event_id, api_type):
event = session.query(Event).filter_by(id=event_id).one()
if api_type == 'XML':
return xmlify(data=event.serialize, wrap="all", indent=" ")
elif api_type == 'JSON':
return jsonify(Event=event.serialize)
else:
return jsonify(
{'error': 'Please choose a valid api type, either XML or JSON.'})
def get_category_items_xml(id):
"""Get all items given its category id using XML format."""
category = Category.query.get_or_404(id)
response = make_response(xmlify(
{"item": [item.to_dict('XML') for item in category.items]},
wrap="items", indent=" "))
response.headers["Content-Type"] = "text/xml"
return response
def menuItemJSON(restaurant_id, menu_id):
menuItem = session.query(MenuItem).filter_by(id=menu_id).one()
data = {
"name": menuItem.name,
"description" : menuItem.description,
"price" : menuItem.price,
"course" : menuItem.course
}
return xmlify(data, wrap=menuItem.name, indent= " ")
def get_items_xml():
"""Get all items available using XML format."""
items = Item.query.all()
response = make_response(xmlify(
{"item": [item.to_dict('XML') for item in items]},
wrap="items", indent=" "))
response.headers["Content-Type"] = "text/xml"
return response
def categoryItemsXML(category_name):
category = session.query(Category).filter_by(name=category_name).first()
# create dict
list_data = {}
for i in category.catalog_items:
item = i.serialize
# serialise and add item to dict
item = {"Item"+str(item['id']): item}
list_data.update(item)
# return response class with application/xml mimetype
return app.response_class(xmlify(list_data, wrap="all", indent=" "), mimetype='application/xml')
def restaurantMenuJSON(restaurant_id):
restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()
items = session.query(MenuItem).filter_by(restaurant_id=restaurant_id).all()
for item in items:
data = {
"name": item.name,
"description" : item.description,
"price" : item.price,
"course" : item.course
}
return xmlify(data, wrap=restaurant.name, indent= " ")
def organizersAPI(api_type):
organizers = session.query(Organizer).all()
if api_type == 'XML':
return xmlify(data=[o.serialize for o in organizers],
wrap="all",
indent=" ")
elif api_type == 'JSON':
return jsonify(organizers=[o.serialize for o in organizers])
else:
return jsonify(
{'error': 'Please choose a valid api type, either XML or JSON.'})
def categoriesXML():
categories = session.query(Category).all()
# create dict
list_data = {}
for i in categories:
item = i.serialize
# serialise and add item to dict
item = {"Item"+str(item['id']): item}
list_data.update(item)
# return response class with application/xml mimetype
return app.response_class(xmlify(list_data, wrap="all", indent=" "), mimetype='application/xml')
def catalogXML():
category_list = session.query(Category).all()
ser_category_list = [category.serialize for category in category_list]
# for each category, grab the item list, serialize it, and add it
# to the JSON category object
for category in ser_category_list:
item_list = session.query(Item).filter_by(
category_id = category['id']).all()
category['item_list'] = [item.serialize for item in item_list]
return xmlify(ser_category_list, wrap = 'category', indent = ' ')
def get_body(self):
body = {}
for i in self.param_body:
body[i] = self.param_body[i][1]
if self.content_type == 'application/x-www-form-urlencoded':
return body
elif self.content_type == 'application/json':
return jsonify(body)
elif self.content_type == 'application/xml':
return xmlify(body, newlines=False)
else:
raise NotImplementedError('unhandlable content-type')
def organizerEventsAPI(organizer_id, api_type):
organizer = session.query(Organizer).filter_by(id=organizer_id).one()
events = session.query(Event).filter_by(organizer_id=organizer_id).all()
if api_type == 'XML':
return xmlify(data=[e.serialize for e in events],
wrap="all",
indent=" ")
elif api_type == 'JSON':
return jsonify(Events=[e.serialize for e in events])
else:
return jsonify(
{'error': 'Please choose a valid api type, either XML or JSON.'})
def output_xml():
"""
XML API endpoint
:return: A list of all the products in XML format
"""
output = "<products>"
products = session.query(Product).all()
result = [p.serialize for p in products]
output += xmlify(result, wrap="product", indent=" ")
output += "</products>"
return Response(output, mimetype="application/xml")
def categoryXML(category_id):
"""
Returns the XML for the items in the category_id requested.
If the category does not exist, an empty list is returned.
"""
cat = db_session.query(Category).filter(Category.id == category_id).first()
newCat = cat.serialize
items = db_session.query(Item).filter_by(category_id=cat.id).all()
serialItems = []
for i in items:
serialItems.append(i.serialize)
newCat['items'] = serialItems
return xmlify(newCat, wrap='Category', indent=' '), 200, {'Content-Type': 'text/css; charset=utf-8'}
def show_collection():
connect(host='mongodb://*****:*****@ds255539.mlab.com:55539/9321test')
feed = AtomFeed(title='All Available Collections',feed_url=request.url)
for a in Area.objects:
data = json.loads(a.to_json())
data2 = xmlify(data, wrap="all", indent=" ")
url = 'http://127.0.0.1:5000'+ url_for('show_entry', name=a.name)
entry = FeedEntry(title=a.name, url=url, updated=datetime.datetime.utcnow(), author={'name': 'admin'}, \
content_type="application/xml",content= data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
def show_entry(name):
connect(host='mongodb://*****:*****@ds255539.mlab.com:55539/9321test')
feed = AtomFeed(title='Single Collection', feed_url=request.url)
for a in Area.objects:
if a.name.lower().replace(' ', '') == name.lower().replace(' ', ''):
#print(xmlify(a.offenses,wrap="all", indent=" "))
data = json.loads(a.to_json())
data2 = xmlify(data, wrap="all", indent=" ")
entry = FeedEntry(title = a.name, url=request.url, updated=datetime.datetime.utcnow(),author = {'name':'admin'}, \
content_type="application/xml",content = data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200 #ATOM
return jsonify(LGA_name=False), 404
def showMenuXML(rest_id):
"""
List all menu items for a restaurant in XML format.
Args:
rest_id: restaurant id
Returns:
Restaurant menu in XML format.
"""
menuItems = session.query(MenuItem).filter_by(restaurant_id=rest_id).all()
for i in menuItems:
i.price = sub('\$', '', i.price)
ms = {'menu_item': [m.serialize for m in menuItems]}
return Response(xmlify(ms, wrap='MenuItems'), mimetype='text/xml')
def showMenuItemXML(rest_id, menu_id):
"""
List properties of a menu item in XML format.
Args:
rest_id: restaurant id
menu_id: menu id
Returns:
Menu item in XML format.
"""
menuItem = session.query(MenuItem).filter_by(restaurant_id = rest_id, id = menu_id).one()
menuItem.price = sub('\$', '', menuItem.price)
m = { 'menu_item': menuItem.serialize }
return Response(xmlify(m, wrap = 'MenuItem'), mimetype = 'text/xml')
def showMenuXML(rest_id):
"""
List all menu items for a restaurant in XML format.
Args:
rest_id: restaurant id
Returns:
Restaurant menu in XML format.
"""
menuItems = session.query(MenuItem).filter_by(restaurant_id = rest_id).all()
for i in menuItems:
i.price = sub('\$', '', i.price)
ms = { 'menu_item': [m.serialize for m in menuItems] }
return Response(xmlify(ms, wrap = 'MenuItems'), mimetype = 'text/xml')
def showMenuItemXML(rest_id, menu_id):
"""
List properties of a menu item in XML format.
Args:
rest_id: restaurant id
menu_id: menu id
Returns:
Menu item in XML format.
"""
menuItem = session.query(MenuItem).filter_by(restaurant_id=rest_id,
id=menu_id).one()
menuItem.price = sub('\$', '', menuItem.price)
m = {'menu_item': menuItem.serialize}
return Response(xmlify(m, wrap='MenuItem'), mimetype='text/xml')
def handle_invalid_usage(error):
"""Handler for InvalidUsageException."""
# JSON error response
if request.accept_mimetypes.accept_json and not request.accept_mimetypes.accept_html:
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
# XML error response
if "text/xml" in request.accept_mimetypes and not request.accept_mimetypes.accept_html:
response = make_response(xmlify({"error": error.message}, indent=" "))
response.headers["Content-Type"] = "text/xml"
return response
# HTML error response
return render_template("error/error.html", message=error.message), error.status_code
def exercise_api(exercise_id):
"""Returns the response, the API data, based on the exercise id.
Checks header for 'ACCEPT' and if json returns, json else if xml return xml
for a given exercise id.
Args:
exercise_id: the id of the exercise item.
"""
exercise = db_session.query(Exercise).filter_by(id=exercise_id).one()
accept = request.headers.get('ACCEPT')
resp = None
if accept == "application/json":
resp = jsonify(exercise.serialize)
else:
xml = xmlify(exercise.serialize, wrap="exercise", indent=" ")
resp = Response(xml, mimetype='application/xml')
return resp
def bookXML(category_id, book_id):
"""Returns XML for a specific book in category_id with id book_id."""
book = session.query(Book).filter_by(id=book_id).one()
book = [book.serialize]
return xmlify(data=book, wrap="book", indent=" ")
def categoryXML(category_name):
category = session.query(Category).filter_by(name=category_name).one()
items = session.query(Item).filter_by(category_id=category.id).all()
data = [i.serialize for i in items]
return "<xmp>%s</xmp>" % xmlify(data, wrap="all", indent=" ")
def XML():
all_items = catalogDict()
return xmlify(all_items, wrap="catalog", indent=" ")
def showRestaurantsXML():
""" List all restaurants in XML format. """
restaurants = session.query(Restaurant).all()
rs = {'restaurant': [r.serialize for r in restaurants]}
return Response(xmlify(rs, wrap='Restaurants'), mimetype='text/xml')
def randomRestaurantXML():
""" Get a random restaurant in XML format. """
rand_restaurant = getRandomRestaurant()
d = {'restaurant': rand_restaurant.serialize}
return Response(xmlify(d, wrap='RandomRestaurant'), mimetype='text/xml')
import time
from lxml import etree
from dict2xml import dict2xml as xmlify
from nltk.tokenize import RegexpTokenizer
from nltk import tokenize
dirname = './'
input_file = 'xx'
start = time.time()
data = json.loads(open(input_file + '.json').read())
with open(dirname + input_file + '.xml', 'w') as x:
print("<Sentences>", file=x)
for di, d in enumerate(data):
e = xmlify(d, wrap="Sentence", newlines=True) # indent=" "
print(e)
print(e.encode('utf-8'), file=x)
print("</Sentences>", file=x)
parser = etree.XMLParser(remove_blank_text=True)
tree = etree.parse(dirname + input_file + '.xml', parser)
elem_date = tree.findall('.//date')
elem_id = tree.findall('.//id')
xslt = etree.parse('../xslt/nyt_topics.xslt')
transform = etree.XSLT(xslt)
newtree = transform(tree)
def categoriesXML():
"""Returns XML for all categories."""
categories = session.query(Category).all()
data = [r.serialize for r in categories]
return xmlify(data=data, wrap="category", indent=" ")
def catListXML(): # cat can be understand as Category.
cat = session.query(Pets).all()
return xmlify(data=[i.serialize for i in cat], wrap="all", indent=" ")
def petListXML(pet_id):
pets = session.query(Pets).filter_by(id=pet_id).one()
names = session.query(PetSub).filter_by(pet_id=pet_id).all()
return xmlify(data=[i.serialize for i in names], wrap="all", indent=" ")
def petXML(pet_id, p_id):
pet = session.query(PetSub).filter_by(id=p_id).one()
return xmlify(data=[pet.serialize], wrap="all", indent=" ")
def filter_entry():
connect(host='mongodb://*****:*****@ds255539.mlab.com:55539/9321test')
raw_str = str(request.url)
raw_str2 = raw_str.split('+')
if raw_str2[4] == 'lgaName': #query-type-one
name1 = raw_str2[2]
name2 = raw_str2[6]
feed = AtomFeed(title='Query 1 Search Results', feed_url=request.url)
url1 = 'http://127.0.0.1:5000' + url_for('show_entry', name=name1)
url2 = 'http://127.0.0.1:5000' + url_for('show_entry', name=name2)
for a in Area.objects: #Search for name 1
if a.name.lower().replace(' ', '') == name1.lower().replace(' ', ''):
data = json.loads(a.to_json())
data2 = xmlify(data, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url1, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
for a in Area.objects: #Search for name 2
if a.name.lower().replace(' ', '') == name2.lower().replace(' ', ''):
data = json.loads(a.to_json())
data2 = xmlify(data, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url2, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
elif raw_str2[4] == 'year': #query-type-two
name1 = raw_str2[2]
year1 = raw_str2[6]
feed = AtomFeed(title='Query 2 Search Results', feed_url=request.url)
url1 = 'http://127.0.0.1:5000' + url_for('show_entry', name=name1)
for a in Area.objects: #Search for name
if a.name.lower().replace(' ', '') == name1.lower().replace(' ', ''):
if year1 == '2014':
fakedb = defaultdict(list)
for stas in a.offenses:
fakedb[stas.id].append({'offence_group':stas.offence_group, 'offence_type':stas.offence_type, \
'incidents_2014':stas.incidents_2014, 'rate_2014':stas.rate_2014})
j_fakedb = json.dumps(fakedb,indent=4)
data2 = xmlify(j_fakedb, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url1, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
elif year1 == '2015':
fakedb = defaultdict(list)
for stas in a.offenses:
fakedb[stas.id].append({'offence_group': stas.offence_group, 'offence_type': stas.offence_type, \
'incidents_2015': stas.incidents_2015, 'rate_2015': stas.rate_2015})
j_fakedb = json.dumps(fakedb, indent=4)
data2 = xmlify(j_fakedb, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url1, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
elif year1 == '2016':
fakedb = defaultdict(list)
for stas in a.offenses:
fakedb[stas.id].append({'offence_group': stas.offence_group, 'offence_type': stas.offence_type, \
'incidents_2016': stas.incidents_2016, 'rate_2016': stas.rate_2016})
j_fakedb = json.dumps(fakedb, indent=4)
data2 = xmlify(j_fakedb, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url1, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
elif year1 == '2012':
fakedb = defaultdict(list)
for stas in a.offenses:
fakedb[stas.id].append({'offence_group': stas.offence_group, 'offence_type': stas.offence_type, \
'incidents_2012': stas.incidents_2012, 'rate_2012': stas.rate_2012})
j_fakedb = json.dumps(fakedb, indent=4)
data2 = xmlify(j_fakedb, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url1, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
elif year1 == '2013':
fakedb = defaultdict(list)
for stas in a.offenses:
fakedb[stas.id].append({'offence_group': stas.offence_group, 'offence_type': stas.offence_type, \
'incidents_2013': stas.incidents_2013, 'rate_2013': stas.rate_2013})
j_fakedb = json.dumps(fakedb, indent=4)
data2 = xmlify(j_fakedb, wrap="all", indent=" ")
entry = FeedEntry(title=a.name, url=url1, updated=datetime.datetime.utcnow(),
author={'name': 'admin'}, \
content_type="application/xml", content=data2)
feed.add(entry)
response = make_response(feed.to_string())
response.mimetype = "application/atom+xml"
return response, 200
else:
return jsonify(Input_Year=False), 400
return jsonify(Input=False),404
def catalogXML():
res = {'category': baseCatalog()}
catalog = xmlify(res, wrap="Categories", indent=" ")
return returnResponseXML(catalog, 200)
def itemZML(item_id):
item = session.query(Items).filter_by(id=item_id).one()
return xmlify(item.serialize, wrap="item", indent=" ")
def petListItemXML(pet_id, p_id):
info = session.query(PetSub).filter_by(id=p_id).one()
return xmlify(data=[info.serialize], wrap="all", indent=" ")
parser = make_parser()
args = parser.parse_args()
new_generator = ImageFlow(images_per_emit=args.tuples_per_emit,
image_size=args.image_size)
stop = False
while (stop != True):
results = new_generator.emit()
xml = results['xml_item']
images = results['images']
uuid = xml['item_id']
dat = xmlify(xml, wrap="consignment", indent=" ")
path = os.path.join(ROOT_DIR, uuid + '.xml')
xmlfile = open(path, "w")
xmlfile.write(dat)
for i, img in enumerate(images):
name = os.path.join(ROOT_DIR, '{0}_{1}.jpg'.format(uuid, i))
Image.fromarray(img).convert("RGB").save(name,
subsampling=0,
quality=100)
#logger.info(results)
# print(numbers)
# print(info)
return [numbers, info]
for a in range(len(coorlist)):
page = requests.get(
"https://maps.googleapis.com/maps/api/place/nearbysearch/json?location="
+ coorlist[a] +
"&radius=55&keyword=restaurant&key=AIzaSyCs9iFQSqVfgFtPhey4WB-zwHd5hhJPeYs"
) #key1=AIzaSyA4ZJTg8gVk9Dg4O_nI3LDCeXrZwXfaU2c key2=AIzaSyCs9iFQSqVfgFtPhey4WB-zwHd5hhJPeYs
tree = html.fromstring(page.content)
stuff = tree.xpath('//body/p/text()') #stuff id list()
stuff2 = xmlify(stuff) #stuff2 becomes string
stuff3 = json.loads(stuff2) #stuff3 set to be json
if len(stuff3['results']) != 0:
for b in range(len(stuff3['results'])): #gets all the nearby places
days_list = []
name = re.sub(r'&', '&', stuff3['results'][b]['name'])
allRes['name'].append(name)
page2 = requests.get(
"https://maps.googleapis.com/maps/api/place/details/json?key=AIzaSyCs9iFQSqVfgFtPhey4WB-zwHd5hhJPeYs&placeid="
+ stuff3['results'][b]['place_id'])
tree2 = html.fromstring(page2.content)
stu = tree2.xpath('//body/p/text()')
stu2 = xmlify(stu)
stu3 = json.loads(stu2)
allRes['url'].append(stu3['result']['url'])
