def _xmlcorewrite(self,xmltree,root):
#xml prolog: always use.*********************************
#standalone, DOCTYPE, processing instructions: only possible in python >= 2.7 or if encoding is utf-8/ascii
if sys.version >= '2.7.0' or self.ta_info['charset'] in ['us-ascii','utf-8'] or ET.VERSION >= '1.3.0':
if self.ta_info['indented']:
indentstring = '\n'
else:
indentstring = ''
if self.ta_info['standalone']:
standalonestring = 'standalone="%s" '%(self.ta_info['standalone'])
else:
standalonestring = ''
processing_instruction = ET.ProcessingInstruction('xml', 'version="%s" encoding="%s" %s'%(self.ta_info['version'],self.ta_info['charset'], standalonestring))
self._outstream.write(ET.tostring(processing_instruction) + indentstring) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#doctype /DTD **************************************
if self.ta_info['DOCTYPE']:
self._outstream.write('<!DOCTYPE %s>'%(self.ta_info['DOCTYPE']) + indentstring)
#processing instructions (other than prolog) ************
if self.ta_info['processing_instructions']:
for eachpi in self.ta_info['processing_instructions']:
processing_instruction = ET.ProcessingInstruction(eachpi[0], eachpi[1])
self._outstream.write(ET.tostring(processing_instruction) + indentstring) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#indent the xml elements
if self.ta_info['indented']:
self._botsindent(root)
#write tree to file; this is differnt for different python/elementtree versions
if sys.version < '2.7.0' and ET.VERSION < '1.3.0':
xmltree.write(self._outstream,encoding=self.ta_info['charset'])
else:
xmltree.write(self._outstream,encoding=self.ta_info['charset'],xml_declaration=False)
def _xmlcorewrite(self,xmltree,root):
#xml prolog: always use.*********************************
#standalone, DOCTYPE, processing instructions: only possible in python >= 2.7 or if encoding is utf-8/ascii
if sys.version >= '2.7.0' or self.ta_info['charset'] in ['us-ascii','utf-8'] or ET.VERSION >= '1.3.0':
if self.ta_info['indented']:
indentstring = '\n'
else:
indentstring = ''
if self.ta_info['standalone']:
standalonestring = 'standalone="%s" '%(self.ta_info['standalone'])
else:
standalonestring = ''
PI = ET.ProcessingInstruction('xml', 'version="%s" encoding="%s" %s'%(self.ta_info['version'],self.ta_info['charset'], standalonestring))
self._outstream.write(ET.tostring(PI) + indentstring) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#doctype /DTD **************************************
if self.ta_info['DOCTYPE']:
self._outstream.write('<!DOCTYPE %s>'%(self.ta_info['DOCTYPE']) + indentstring)
#processing instructions (other than prolog) ************
if self.ta_info['processing_instructions']:
for pi in self.ta_info['processing_instructions']:
PI = ET.ProcessingInstruction(pi[0], pi[1])
self._outstream.write(ET.tostring(PI) + indentstring) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#indent the xml elements
if self.ta_info['indented']:
self.botsindent(root)
#write tree to file; this is differnt for different python/elementtree versions
if sys.version < '2.7.0' and ET.VERSION < '1.3.0':
xmltree.write(self._outstream,encoding=self.ta_info['charset'])
else:
xmltree.write(self._outstream,encoding=self.ta_info['charset'],xml_declaration=False)
def test_cet():
"""cElementTree"""
_table = cet.Element("table")
for row in table:
tr = cet.SubElement(_table, "tr")
for c in row.values():
cet.SubElement(tr, "td").text = str(c)
cet.tostring(_table)
def test_cet():
"""cElementTree"""
_table = cet.Element("table")
for row in table:
tr = cet.SubElement(_table, "tr")
for c in row.values():
cet.SubElement(tr, "td").text = str(c)
cet.tostring(_table)
def test_cet():
"""cElementTree"""
_table = cet.Element('table')
for row in table:
tr = cet.SubElement(_table, 'tr')
for c in row.values():
cet.SubElement(tr, 'td').text=str(c)
cet.tostring(_table)
def test_cet():
"""cElementTree"""
_table = cet.Element('table')
for row in table:
tr = cet.SubElement(_table, 'tr')
for c in row.values():
cet.SubElement(tr, 'td').text = str(c)
cet.tostring(_table)
def build_header(self, message, queue_name, CMQC, now):
if self.needs_mcd:
self.folders["mcd"] = _mcd
mcd = self._pad_folder(etree.tostring(self.folders["mcd"]))
mcd_len = len(mcd)
else:
mcd_len = 0
self.add_jms(message, queue_name, now)
self.add_usr(message)
jms = self._pad_folder(etree.tostring(self.folders["jms"]))
if "usr" in self.folders:
usr = self._pad_folder(etree.tostring(self.folders["usr"]))
usr_len = len(usr)
else:
usr_len = 0
jms_len = len(jms)
total_header_length = 0
total_header_length += MQRFH2JMS.FIXED_PART_LENGTH
# Each folder has a 4-byte header describing its length,
# hence the "len(self.folders) * 4" below.
variable_part_length = len(
self.folders) * 4 + mcd_len + jms_len + usr_len
total_header_length += variable_part_length
buff = StringIO()
buff.write(CMQC.MQRFH_STRUC_ID)
buff.write(_WMQ_MQRFH_VERSION_2)
buff.write(pack("!l", total_header_length))
buff.write(_WMQ_DEFAULT_ENCODING_WIRE_FORMAT)
buff.write(_WMQ_DEFAULT_CCSID_WIRE_FORMAT)
buff.write(CMQC.MQFMT_STRING)
buff.write(_WMQ_MQRFH_NO_FLAGS_WIRE_FORMAT)
buff.write(_WMQ_DEFAULT_CCSID_WIRE_FORMAT)
if self.needs_mcd:
buff.write(pack("!l", mcd_len))
buff.write(mcd)
buff.write(pack("!l", jms_len))
buff.write(jms)
if "usr" in self.folders:
buff.write(pack("!l", usr_len))
buff.write(usr)
value = buff.getvalue()
buff.close()
return value
def build_header(self, message, queue_name, CMQC, now):
if self.needs_mcd:
self.folders["mcd"] = _mcd
mcd = self._pad_folder(etree.tostring(self.folders["mcd"]))
mcd_len = len(mcd)
else:
mcd_len = 0
self.add_jms(message, queue_name, now)
self.add_usr(message)
jms = self._pad_folder(etree.tostring(self.folders["jms"]))
if "usr" in self.folders:
usr = self._pad_folder(etree.tostring(self.folders["usr"]))
usr_len = len(usr)
else:
usr_len = 0
jms_len = len(jms)
total_header_length = 0
total_header_length += MQRFH2JMS.FIXED_PART_LENGTH
# Each folder has a 4-byte header describing its length,
# hence the "len(self.folders) * 4" below.
variable_part_length = len(self.folders) * 4 + mcd_len + jms_len + usr_len
total_header_length += variable_part_length
buff = StringIO()
buff.write(CMQC.MQRFH_STRUC_ID)
buff.write(_WMQ_MQRFH_VERSION_2)
buff.write(pack("!l", total_header_length))
buff.write(_WMQ_DEFAULT_ENCODING_WIRE_FORMAT)
buff.write(_WMQ_DEFAULT_CCSID_WIRE_FORMAT)
buff.write(CMQC.MQFMT_STRING)
buff.write(_WMQ_MQRFH_NO_FLAGS_WIRE_FORMAT)
buff.write(_WMQ_DEFAULT_CCSID_WIRE_FORMAT)
if self.needs_mcd:
buff.write(pack("!l", mcd_len))
buff.write(mcd)
buff.write(pack("!l", jms_len))
buff.write(jms)
if "usr" in self.folders:
buff.write(pack("!l", usr_len))
buff.write(usr)
value = buff.getvalue()
buff.close()
return value
def _write(self, node):
''' write normal XML messages (no envelope)'''
xmltree = ET.ElementTree(self._node2xml(node))
f = botslib.opendata(self.ta_info['filename'], "wb")
if self.ta_info['indented']:
indentstring = '\n'
else:
indentstring = ''
#xml prolog: always use.*********************************
#syntax parameter controls if stand-alone is used within prolog.
#in ET 1.3.0: if standalone is to be used: should surpress ET-generated prolog - explicit parameter
#in ET 1.2.6: always generates prolog if encoding != utf-8/ascii. SO: can not use stadnalone for encoding !=utf-8,ascii
if ET.VERSION not in ['1.2.6', '1.0.6'] or self.ta_info['charset'] in [
'us-ascii', 'utf-8'
]:
if self.ta_info['standalone']:
standalonestring = 'standalone="%s" ' % (
self.ta_info['standalone'])
else:
standalonestring = ''
PI = ET.ProcessingInstruction(
'xml', 'version="%s" encoding="%s" %s' %
(self.ta_info['version'], self.ta_info['charset'],
standalonestring))
f.write(
ET.tostring(PI) + indentstring
) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#doctype /DTD **************************************
if self.ta_info['DOCTYPE']:
f.write('<!DOCTYPE %s>' % (self.ta_info['DOCTYPE']) + indentstring)
#processing instructions (other than prolog) ************
if self.ta_info['processing_instructions']:
for pi in self.ta_info['processing_instructions']:
PI = ET.ProcessingInstruction(pi[0], pi[1])
f.write(
ET.tostring(PI) + indentstring
) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#indent the xml elements
if self.ta_info['indented']:
root = xmltree.getroot()
self.botsindent(root)
if ET.VERSION <= '1.2.6':
xmltree.write(f, encoding=self.ta_info['charset'])
else:
xmltree.write(f,
encoding=self.ta_info['charset'],
xml_declaration=False)
def goInsert(doc):
results=""
tableIdDesc=""
xmlDocResults=""
if(dbSchemaChecker(doc)==1):
if(debugProg["flag"]==1):
debug_Info= "The XML document is " + ElementTree.tostring(doc)+"\n"
if(debugProg["print"]==1): print debug_Info
writefile(debug_Info,debugProg["file"])
debug_Info=""
tableIdDesc,results,dbtable= finder(doc)
# Specific Errors which are returned to the client
if(tableIdDesc=="-" and results=="-" and dbtable=="-"):
xmlDocResults="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
xmlDocResults=xmlDocResults + "<RELATIONS name=\"ERROR\">\n\t<REL name=\"ERROR_1\">\n\t\t<ATT name=\"error_message\">Column or Type mismatch in XML and Schema file."
xmlDocResults=xmlDocResults + "</ATT>\n\t</REL>\n</RELATIONS>\n"
else:
xmlDocResults = makeXMLReply(tableIdDesc,results,dbtable)
else:
# Specific Errors which are returned to the client
xmlDocResults="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
xmlDocResults=xmlDocResults + "<RELATIONS name=\"ERROR\">\n\t<REL name=\"ERROR_1\">\n\t\t<ATT name=\"error_message\">Datatype mismatch in files."
xmlDocResults=xmlDocResults + "</ATT>\n\t</REL>\n</RELATIONS>\n"
return xmlDocResults
class HtmlDom:
def __init__(self, url):
try:
f = file(url)
data = f.read()
f.close()
except IOError, e:
try:
result = fetch(url, agent=MOZILLA_AGENT)
data = result['data']
except:
raise IOError, 'invalid URL'
# create parser
parser = tidy.TreeBuilder()
parser.feed(data)
xmlText = _etree.tostring(parser.close())
#create the DOM
reader = PyExpat.Reader()
self.dom = reader.fromString(xmlText)
self.nss = {u'html': XHTML_NAMESPACE}
self.context = xml.xpath.Context.Context(self.dom, processorNss=self.nss)
def msg_from_iterable(elems):
"""
create full valid xml message for solr (adding data)
"""
message = ElementTree.Element("add")
map(message.append, map(_to_document, elems))
return ElementTree.tostring(message)
def processor(self, content):
if len(dstations) == 0:
root = ElementTree.XML(content)
stations = root.findall('.//station')
for station in stations:
if station.find('.//country').text == 'NL':
code = station.find('.//code').text
if code not in dstations:
dstations[code] = {'alias': [], 'defaultname': '', 'locationX': '', 'locationY': ''}
if station.find('.//alias').text == 'true':
dstations[code]['alias'].append(station.find('.//name').text)
else:
dstations[code]['defaultname'] = station.find('.//name').text
dstations[code]['locationX'] = station.find('.//lat').text
dstations[code]['locationY'] = station.find('.//long').text
dstations[code]['alias'].append(station.find('.//name').text)
root = ElementTree.Element('stations')
root.attrib['timestamp'] = str(int(time.time()))
for station in dstations.values():
for alias in station['alias']:
sub = ElementTree.SubElement(root, 'station')
sub.attrib['locationX'] = station['locationX']
sub.attrib['locationY'] = station['locationY']
sub.attrib['defaultname'] = station['defaultname']
sub.text = alias
web.header('Content-Type', 'application/xml')
return ElementTree.tostring(root)
def write(self, element):
self._flush()
indent(element, self.indentLevel)
element.tail = element.tail[:-self.indentLevel * 2]
self.out.write(self.indentLevel * " " +
ElementTree.tostring(element, "utf-8"))
self.lastElement = None
def write(self, element):
self._flush()
indent(element, self.indentLevel)
if element.tail != None:
element.tail = element.tail[:-self.indentLevel * 2]
self.out.write(self.indentLevel * " " + ElementTree.tostring(element, "utf-8"))
self.lastElement = None
def dict2xml(d):
''' convert python dictionary to xml.
'''
def makenode(tag, content):
node = ET.Element(tag)
if not content:
pass #empty element
elif isinstance(content, basestring):
node.text = content
elif isinstance(content, list):
node.tag = tag + 's' #change node tag
for element in content:
node.append(makenode(tag, element))
elif isinstance(content, dict):
for key, value in content.items():
node.append(makenode(key, value))
else:
node.text = repr(content)
return node
assert isinstance(d, dict) and len(d) == 1
for key, value in d.items():
node = makenode(key, value)
botslib.indent_xml(node)
return ET.tostring(node)
def update_cix_file(mgr, path):
log.info("convert `%s' to pretty CIX 2.0", path)
cix = open(path, 'r').read()
tree = tree_from_cix(cix) # converts to CIX 2.0
tree = pretty_tree_from_tree(tree)
new_cix = ET.tostring(tree)
_run("p4 edit %s" % path)
open(path, 'w').write(new_cix)
def update_cix_file(mgr, path):
log.info("convert `%s' to pretty CIX 2.0", path)
cix = open(path, 'r').read()
tree = tree_from_cix(cix) # converts to CIX 2.0
tree = pretty_tree_from_tree(tree)
new_cix = ET.tostring(tree)
_run("p4 edit %s" % path)
open(path, 'w').write(new_cix)
def _make_printable(self, tutdir, up_to_root=2):
endpath = tutdir
tutdir = os.path.join(self.srcdirs[0], tutdir)
import cElementTree as elementtree
masterdoc = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<?python import printable ?>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:py="http://purl.org/kid/ns#" py:extends="printable">
<head>
<meta content="text/html; charset=UTF-8" http-equiv="content-type" />
<link rel="stylesheet" type="text/css" href="../../default.css" py:attrs="href=root+'default.css'"/>
<link type="text/css" rel="stylesheet" href="../../sh/SyntaxHighlighter.css" py:attrs="href=root+'sh/SyntaxHighlighter.css'"></link>
<title>TurboGears: 20 Minute Wiki Tutorial</title>
</head>
<body>
"""
docs = os.listdir(tutdir)
docs.sort()
for doc in docs:
if not doc.endswith(".html"):
continue
log.info("combining %s" % doc)
tree = elementtree.parse(os.path.join(tutdir, doc))
body = tree.find("{http://www.w3.org/1999/xhtml}body")
map(body.remove, body.findall("{http://www.w3.org/1999/xhtml}script"))
bodytext = elementtree.tostring(body)
bodytext = bodytext.replace("</html:body>", "")
bodytext = bodytext.replace('<html:body xmlns:html="http://www.w3.org/1999/xhtml">', "")
masterdoc += bodytext
masterdoc += """<script src="../../sh/shCore.js" py:attrs="src=root+'sh/shCore.js'"></script>
<script src="../../sh/shBrushPython.js" py:attrs="src=root+'sh/shBrushPython.js'"></script>
<script src="../../sh/shBrushXml.js" py:attrs="src=root+'sh/shBrushXml.js'"></script>
<script src="../../sh/shBrushJScript.js" py:attrs="src=root+'sh/shBrushJScript.js'"></script>
<script language="javascript">
dp.SyntaxHighlighter.HighlightAll('code');
</script>
</body></html>"""
masterdoc = masterdoc.replace("html:", "")
template = kid.Template(source=masterdoc, root="../" * up_to_root)
template.serializer = self.serializer
destend = os.path.join(self.destdir, endpath)
if not os.path.exists(destend):
os.makedirs(destend)
outfn = os.path.join(destend, "printable.html")
print "combined output: %s" % outfn
outfile = open(outfn, "w")
masterdoc = template.serialize(encoding=self.encoding)
masterdoc = masterdoc.replace("$${", "${")
outfile.write(masterdoc)
outfile.close()
self.currentfiles.add(outfn)
def getSettings():
global debugProg
global db_Settings
global Soap_Server_Settings
if not debugProg:
debugProg={}
debugProg["flag"]=0
debugProg["file"]=""
debugProg["print"]=0
db_Settings={}
Soap_Server_Settings={}
## aXMLfile='XSM-configuration.xml'
aXMLfile=CONF_FILE
doc = ElementTree.parse(aXMLfile).getroot()
# Go through the CONF and SET for the settings
for node in doc.findall('CONF'):
for nodeSet in node.findall('SET'):
if(nodeSet.get('name')=="debugProg" and nodeSet.get('value')=="true" and nodeSet.get('file')!=""):
debugProg["flag"]=1
debugProg["file"]=nodeSet.get('file')
if(nodeSet.get('print_out')=="true"):
debugProg["print"]=1
else:
debugProg["print"]=0
if(nodeSet.get('name')=="debugProg" and nodeSet.get('value')=="false"):
debugProg["flag"]=0
debugProg["file"]=""
debugProg["print"]=0
if(nodeSet.get('name')=="dbip" and nodeSet.get('value')!=""): db_Settings["dbip"]=nodeSet.get('value')
if(nodeSet.get('name')=="dbnm" and nodeSet.get('value')!=""): db_Settings["dbnm"]=nodeSet.get('value')
if(nodeSet.get('name')=="dbuser" and nodeSet.get('value')!=""): db_Settings["dbuser"]=nodeSet.get('value')
if(nodeSet.get('name')=="dbpass" and nodeSet.get('value')!=""): db_Settings["dbpass"]=nodeSet.get('value')
if(nodeSet.get('name')=="dbencod" and nodeSet.get('value')!=""): db_Settings["dbencod"]=nodeSet.get('value')
if(nodeSet.get('name')=="dbunicod" and nodeSet.get('value')!=""): db_Settings["dbunicod"]=nodeSet.get('value')
if(nodeSet.get('name')=="databaseSchema" and nodeSet.get('value')!=""): db_Settings["databaseSchema"]=nodeSet.get('value')
if(nodeSet.get('name')=="Soap_Server_IP" and nodeSet.get('value')!=""): Soap_Server_Settings["Soap_Server_IP"]=nodeSet.get('value')
if(nodeSet.get('name')=="Soap_Server_Port" and nodeSet.get('value')!=""): Soap_Server_Settings["Soap_Server_Port"]=nodeSet.get('value')
if(debugProg["flag"]==1):
debug_Info= "Getting settings from configuration file... [%s]\n" %(aXMLfile)
debug_Info= debug_Info + "The settings document is " + ElementTree.tostring(doc) + "\n"
debug_Info= debug_Info + "Settings accepted -\n\tSoap Server: " + str(Soap_Server_Settings) + "\n\t Database setting: " + str(db_Settings) + " \n\tDebug Flag: " + str(debugProg) + "\n"
if(debugProg["print"]==1): print debug_Info
writefile(debug_Info,debugProg["file"])
debug_Info=""
def _write(self,node):
''' write normal XML messages (no envelope)'''
xmltree = ET.ElementTree(self._node2xml(node))
f = botslib.opendata(self.ta_info['filename'],"wb")
if self.ta_info['indented']:
indentstring = '\n'
else:
indentstring = ''
#xml prolog: always use.*********************************
#syntax parameter controls if stand-alone is used within prolog.
#in ET 1.3.0: if standalone is to be used: should surpress ET-generated prolog - explicit parameter
#in ET 1.2.6: always generates prolog if encoding != utf-8/ascii. SO: can not use stadnalone for encoding !=utf-8,ascii
if ET.VERSION not in ['1.2.6','1.0.6'] or self.ta_info['charset'] in ['us-ascii','utf-8']:
if self.ta_info['standalone']:
standalonestring = 'standalone="%s" '%(self.ta_info['standalone'])
else:
standalonestring = ''
PI = ET.ProcessingInstruction('xml', 'version="%s" encoding="%s" %s'%(self.ta_info['version'],self.ta_info['charset'], standalonestring))
f.write(ET.tostring(PI) + indentstring) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#doctype /DTD **************************************
if self.ta_info['DOCTYPE']:
f.write('<!DOCTYPE %s>'%(self.ta_info['DOCTYPE']) + indentstring)
#processing instructions (other than prolog) ************
if self.ta_info['processing_instructions']:
for pi in self.ta_info['processing_instructions']:
PI = ET.ProcessingInstruction(pi[0], pi[1])
f.write(ET.tostring(PI) + indentstring) #do not use encoding here. gives double xml prolog; possibly because ET.ElementTree.write i used again by write()
#indent the xml elements
if self.ta_info['indented']:
root = xmltree.getroot()
self.botsindent(root)
if ET.VERSION <= '1.2.6':
xmltree.write(f,encoding=self.ta_info['charset'])
else:
xmltree.write(f,encoding=self.ta_info['charset'],xml_declaration=False)
def goJoin(doc):
#global myDoc
myDoc=''
global tableDB
tableDB=''
global resultsIdCounter
global fieldsDB
fieldsDB=''
global rowWhere
rowWhere=''
global tableFKeys
tableFKeys=[]
global tableFieldsG
tableFieldsG=[]
global fkTable
fkTable=[]
resultsIdCounter=0
if(debugProg["flag"]==1):
debug_Info= "The XML document is " + ElementTree.tostring(doc)+"\n"
if(debugProg["print"]==1): print debug_Info
writefile(debug_Info,debugProg["file"])
debug_Info=""
myDoc="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
myDoc=myDoc+"<RELATIONS command=\"JOIN_RESULTS\">\n"
myDoc=myDoc+"<REL name=\'RESULTS_ID\' value=\'" + str(resultsIdCounter) + "\'>\n"
finderJoin(doc,'0','none')
resultsIdCounter+=1
#if (replacedOp!="none"): makeTheSelect(dbTable,rowWhere)
#print " " + rowWhere + " =-=-=- " +fieldsDB + " *** " + str(tableDB) + "^^^^^^^^" + str(tableFKeys) + str(tableFieldsG)
for n in range(len(tableFKeys)):
rowWhere=valueConcat(rowWhere," AND ", tableFKeys[n])
print rowWhere + tableFKeys[n]
myDoc=makeTheJoin(tableDB,fieldsDB,rowWhere,myDoc)
myDoc=myDoc+"</REL>\n"
myDoc=myDoc+"<REL name=\"TOTAL_RESULTS\">" + str(resultsIdCounter)
myDoc=myDoc+"</REL>\n"
myDoc=myDoc+"</RELATIONS>\n"
return myDoc
def _send_update(self, *args, **kwargs):
"""Send an update request to Solr.
Solr commits are made only on deletion.
Takes a single argument: the AMQP message that was received.
"""
try:
log.info("Processing update request")
msg = args[0]
updates = json.loads(msg.body)
solr = SolrConnection(self.solr_uri)
if updates["type"] == "updated":
add = ET.Element("add")
for update in updates["data"]:
doc = ET.SubElement(add, "doc")
for fields in update:
# There should only be one pair
# FIXME: move to a dictionary structure
for k, v in fields.items():
SolrUpdater.xml_field(doc, solr.escapeKey(k), solr.escapeVal(v))
log.debug("Sending update to Solr: " + ET.tostring(add))
solr.doUpdateXML(ET.tostring(add))
elif updates["type"] == "deleted":
for id in updates["data"]:
log.debug("Deleting document with id '%s'" % id)
solr.delete(id)
solr.commit()
elif updates["type"] == "deleted_db":
db_name = updates["data"]
log.info("Deleting indexes for database '%s'" % db_name)
solr.deleteByQuery("_db:%s" % db_name)
solr.commit()
else:
log.warning("Unrecognized update type: '%s'" % updates["type"])
except Exception:
log.exception("Unexpected exception")
def goSelect(doc):
#global myDoc
myDoc=''
if(debugProg["flag"]==1):
debug_Info= "The XML document is " + ElementTree.tostring(doc)+"\n"
if(debugProg["print"]==1): print debug_Info
writefile(debug_Info,debugProg["file"])
debug_Info=""
myDoc="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
myDoc=myDoc+"<RELATIONS command=\"SELECT_RESULTS\">\n"
myDoc = finderSelect(doc,myDoc)
myDoc=myDoc+"</RELATIONS>\n"
return myDoc
def view(self, id, format='html'):
try:
vote = self._get_vote(id, format, check_owner=False)
if format == 'json':
response.content_type = "text/javascript"
return vote.toJSON()
elif format == 'xml':
response.content_type = "text/xml"
xml = vote.toXML()
return etree.tostring(xml, encoding='UTF-8')
c.vote = vote
return render("vote.mako")
except StatusException, se:
return se.message
def __PrettyPrintXml(self, doc, level=0):
"""Return a pretty-printed version of the XML document.
Args:
doc: str XML document.
level: int Level of prettiness, defaults to 0. If -1, remove prettiness.
Returns:
str Pretty-printed version of the XML document.
"""
# Make sure we have a valid doc to work with.
if Utils.IsHtml(doc):
return doc
try:
if self.__xml_parser == PYXML:
dom = minidom.parseString(doc)
pretty_doc = dom.toprettyxml(indent=' ', encoding='UTF-8')
elif self.__xml_parser == ETREE:
tree = etree.fromstring(doc)
self.__Indent(tree)
pretty_doc = etree.tostring(tree, 'UTF-8')
except (ExpatError, SyntaxError):
# If there was a problem with loading XML message into a DOM, return
# original XML message.
return doc
# Adjust prettiness of data values in the XML document.
#
# Before: <operations>
# 0
# </operations>
#
# After: <operations>0</operations>
pattern = re.compile('\n\s+\n')
pretty_doc = pattern.sub('\n', pretty_doc)
groups = re.findall('>(\n\s+(.*?)\n\s+)</', pretty_doc, re.M)
for old, new in groups:
if old and new and (new.find('<') > -1 or new.find('>') > -1):
continue
pretty_doc = pretty_doc.replace(old, new)
if level == -1:
pattern = re.compile('>\s+<')
pretty_doc = pattern.sub('><', pretty_doc)
return pretty_doc.strip('\n')
def __PrettyPrintXml(self, doc, level=0):
"""Return a pretty-printed version of the XML document.
Args:
doc: str XML document.
level: int Level of prettiness, defaults to 0. If -1, remove prettiness.
Returns:
str Pretty-printed version of the XML document.
"""
# Make sure we have a valid doc to work with.
if Utils.IsHtml(doc):
return doc
try:
if self.__xml_parser == PYXML:
dom = minidom.parseString(doc)
pretty_doc = dom.toprettyxml(indent=' ', encoding='UTF-8')
elif self.__xml_parser == ETREE:
tree = etree.fromstring(doc)
self.__Indent(tree)
pretty_doc = etree.tostring(tree, 'UTF-8')
except (ExpatError, SyntaxError):
# If there was a problem with loading XML message into a DOM, return
# original XML message.
return doc
# Adjust prettiness of data values in the XML document.
#
# Before: <operations>
# 0
# </operations>
#
# After: <operations>0</operations>
pattern = re.compile('\n\s+\n')
pretty_doc = pattern.sub('\n', pretty_doc)
groups = re.findall('>(\n\s+(.*?)\n\s+)</', pretty_doc, re.M)
for old, new in groups:
if old and new and (new.find('<') > -1 or new.find('>') > -1):
continue
pretty_doc = pretty_doc.replace(old, new)
if level == -1:
pattern = re.compile('>\s+<')
pretty_doc = pattern.sub('><', pretty_doc)
return pretty_doc.strip('\n')
def fstatus(message, format='html', status='success', http_code=200):
if http_code not in [200, 302] and status == 'success':
status = 'error'
response.status_int = http_code
if format == 'xml' or format == 'atom' or format == 'rss':
xml = etree.Element('status')
etree.SubElement(xml, 'status').text = status
etree.SubElement(xml, 'message').text = message
return etree.tostring(xml, encoding='UTF-8')
elif format == 'json':
return json.dumps({
'status': status,
'message': message
})
else:
c.status = status
c.message = message
return render('status.mako')
def dict2xml(d):
''' convert python dictionary to xml.
'''
def makenode(tag,content):
node = ET.Element(tag)
if not content:
pass #empty element
elif isinstance(content, basestring):
node.text = content
elif isinstance(content, list):
node.tag = tag + 's' #change node tag
for element in content:
node.append(makenode(tag, element))
elif isinstance(content, dict):
for key,value in content.items():
node.append(makenode(key, value))
else:
node.text = repr(content)
return node
assert isinstance(d, dict) and len(d) == 1
for key,value in d.items():
node = makenode(key,value)
botslib.indent_xml(node)
return ET.tostring(node)
def _testOneInputFile(self, fpath, tags=None):
_debug = False # Set to true to dump status info for each test run.
infile = os.path.join(gInputsDir, fpath) # input
outfile = os.path.join(gOutputsDir, fpath+'.cix') # expected output
tmpfile = os.path.join(gTmpDir, fpath+'.cix') # actual output
if not os.path.exists(os.path.dirname(tmpfile)):
os.makedirs(os.path.dirname(tmpfile))
errfile = os.path.join(gOutputsDir, fpath+'.error') # expected error
# An options file is a set of kwargs for the buf.scan()
# method call. One key-value pair per-line like this:
# key=value
# Whitespace is stripped off the value.
optsfile = os.path.join(gInputsDir, fpath+'.options') # input options
if _debug:
print()
print("*"*50, "codeintel '%s'" % fpath)
# Set standard options:
opts = {"mtime": "42"}
# Determine input options to use, if any.
#XXX Not used. Drop it.
if os.path.exists(optsfile):
for line in open(optsfile, 'r').read().splitlines(0):
name, value = line.split('=', 1)
value = value.strip()
try: # allow value to be a type other than string
value = eval(value)
except Exception:
pass
opts[name] = value
if _debug:
print("*"*50, "options")
pprint.pprint(opts)
# Scan the file, capturing stdout and stderr and any possible
# error.
# - To allow testing from different dirs (resulting in changing
# path strings, we normalize the <file path="..."> value and any
# <scope ilk="blob" src="..."> attributes).
oldStdout = sys.stdout
oldStderr = sys.stderr
sys.stdout = StringIO()
sys.stderr = StringIO()
try:
try:
lang = None
if tags and "python3" in tags:
lang = "Python3"
buf = self.mgr.buf_from_path(infile, lang=lang)
buf.scan(**opts)
tree = buf.tree
# Normalize paths.
relnorm_infile = infile[len(dirname(gInputsDir))+1:]
absnorm_infile = infile
relnorm_infile = relnorm_infile.replace('\\', '/')
absnorm_infile = absnorm_infile.replace('\\', '/')
for file_elem in tree:
file_elem.set("path", relnorm_infile)
for blob_elem in file_elem:
if blob_elem.get("ilk") != "blob": continue
norm_src = normpath(blob_elem.get("src"))
norm_src = norm_src.replace('\\', '/')
if norm_src in (relnorm_infile, absnorm_infile):
blob_elem.set("src", relnorm_infile)
tree = pretty_tree_from_tree(tree)
# Due to the dynamic nature of the ciler errors (which often
# includes the source code line numbers), it's difficult to check
# that the errors are identical, so we work around this by just
# taking the first 30 characters of the error.
cile_error = tree[0].get("error")
if cile_error and fpath.endswith(".js"):
tree[0].set("error", len(cile_error) < 30 and cile_error or (cile_error[:30] + "..."))
cix = ET.tostring(tree)
except CodeIntelError as ex:
error = traceback.format_exc()
else:
error = None
if isinstance(cix, six.text_type):
with io.open(tmpfile, mode="wt", encoding="utf-8") as fout:
fout.write(cix)
else:
with open(tmpfile, mode="wb") as fout:
fout.write(cix)
finally:
stdout = sys.stdout.getvalue()
stderr = sys.stderr.getvalue()
sys.stdout = oldStdout
sys.stderr = oldStderr
if _debug:
print("*"*50, "stdout")
print(stdout)
print("*"*50, "stderr")
print(stderr)
print("*"*50, "error")
print(str(error))
print("*" * 50)
generateMissing = False
if not os.path.exists(outfile) and generateMissing:
with io.open(outfile, mode='wt', encoding='utf-8') as fout:
with io.open(tmpfile, mode='rt', encoding='utf-8') as ftmp:
fout.write(ftmp.read())
# Verify that the results are as expected.
if os.path.exists(outfile) and error:
self.fail("scanning '%s' raised an error but success was "
"expected:\n%s" % (_encode_for_stdout(fpath), indent(error)))
elif os.path.exists(outfile):
# Convert the <file path="..."/> to the native directory separator.
def to_native_sep(match):
path = match.group(2).replace("\\", os.sep).replace("/", os.sep)
return match.group(1)+path+match.group(3)
path_pat = re.compile(r'(<file .*?path=")(.*?)(".*?>)', re.S)
# Note that we don't really care about line endings here, so we read
# both files in universal newlines mode (i.e. translate to \n)
# and normalize ' ', ' ' and '''
with io.open(outfile, mode='rt', encoding='utf-8') as fout:
expected = path_pat.sub(to_native_sep, fout.read())
expected = expected.replace('
', ' ').replace('
', ' ').replace(''', '\'')
with io.open(tmpfile, mode='rt', encoding='utf-8') as ftmp:
actual = path_pat.sub(to_native_sep, ftmp.read())
actual = actual.replace('
', ' ').replace('
', ' ').replace(''', '\'')
if expected != actual:
do_fail = True
# Useful temporary thing while XML output format is changing.
#if os.stat("../support/xmldiff.py"):
# rc = os.system('python ../support/xmldiff.py "%s" "%s"' % (outfile, tmpfile))
# if rc == 0:
# do_fail = False
if do_fail:
diff = list(difflib.ndiff(expected.splitlines(1),
actual.splitlines(1)))
diff = _diffContext(diff, 2)
if diff:
error_str = "%r != %r:\n --- %s\n +++ %s\n%s" \
% (outfile, tmpfile, outfile, tmpfile,
''.join(diff))
if gMaxDiffOutput > 0 and gMaxNumLines > 0:
if len(error_str) > gMaxDiffOutput:
error_lines = error_str.split("\n")
if len(error_lines) > gMaxNumLines:
error_lines = error_lines[:gMaxNumLines] + ["..."]
if gMaxLineLength > 0:
error_str = "\n".join([len(x) > gMaxLineLength and x[:gMaxLineLength] or x
for x in error_lines])
else:
error_str = "\n".join(error_lines)
self.fail(_encode_for_stdout(error_str))
elif os.path.exists(errfile):
# There is no reference output file. This means that processing
# this file is expected to fail.
expectedError = open(errfile, 'r').read()
actualError = str(error)
self.failUnlessEqual(actualError.strip(), expectedError.strip())
else:
self.fail("No reference output file or error file for '%s'." % infile)
# Ensure next test file gets a clean codeintel.
toDelete = []
for modname in sys.modules:
if modname == "codeintel" or modname.startswith("codeintel."):
toDelete.append(modname)
for modname in toDelete:
del sys.modules[modname]
def _testOneInputFile(self, fpath, tags=None):
_debug = False # Set to true to dump status info for each test run.
infile = os.path.join(gInputsDir, fpath) # input
outfile = os.path.join(gOutputsDir, fpath + '.cix') # expected output
tmpfile = os.path.join(gTmpDir, fpath + '.cix') # actual output
if not os.path.exists(os.path.dirname(tmpfile)):
os.makedirs(os.path.dirname(tmpfile))
errfile = os.path.join(gOutputsDir, fpath + '.error') # expected error
# An options file is a set of kwargs for the buf.scan()
# method call. One key-value pair per-line like this:
# key=value
# Whitespace is stripped off the value.
optsfile = os.path.join(gInputsDir, fpath + '.options') # input options
if _debug:
print
print "*" * 50, "codeintel '%s'" % fpath
# Set standard options:
opts = {"mtime": "42"}
# Determine input options to use, if any.
# XXX Not used. Drop it.
if os.path.exists(optsfile):
for line in open(optsfile, 'r').read().splitlines(0):
name, value = line.split('=', 1)
value = value.strip()
try: # allow value to be a type other than string
value = eval(value)
except Exception:
pass
opts[name] = value
if _debug:
print "*" * 50, "options"
pprint.pprint(opts)
# Scan the file, capturing stdout and stderr and any possible
# error.
# - To allow testing from different dirs (resulting in changing
# path strings, we normalize the <file path="..."> value and any
# <scope ilk="blob" src="..."> attributes).
oldStdout = sys.stdout
oldStderr = sys.stderr
sys.stdout = StringIO.StringIO()
sys.stderr = StringIO.StringIO()
try:
try:
lang = None
if tags and "python3" in tags:
lang = "Python3"
buf = self.mgr.buf_from_path(infile, lang=lang)
buf.scan(**opts)
tree = buf.tree
# Normalize paths.
relnorm_infile = infile[len(dirname(gInputsDir)) + 1:]
absnorm_infile = infile
relnorm_infile = relnorm_infile.replace('\\', '/')
absnorm_infile = absnorm_infile.replace('\\', '/')
for file_elem in tree:
file_elem.set("path", relnorm_infile)
for blob_elem in file_elem:
if blob_elem.get("ilk") != "blob":
continue
norm_src = normpath(blob_elem.get("src"))
norm_src = norm_src.replace('\\', '/')
if norm_src in (relnorm_infile, absnorm_infile):
blob_elem.set("src", relnorm_infile)
tree = pretty_tree_from_tree(tree)
# Due to the dynamic nature of the ciler errors (which often
# includes the source code line numbers), it's difficult to check
# that the errors are identical, so we work around this by just
# taking the first 30 characters of the error.
cile_error = tree[0].get("error")
if cile_error and fpath.endswith(".js"):
tree[0].set(
"error",
len(cile_error) < 30 and cile_error
or (cile_error[:30] + "..."))
cix = ET.tostring(tree)
except CodeIntelError, ex:
error = traceback.format_exc()
else:
def _testOneInputFile(self, fpath, tags=None):
_debug = False # Set to true to dump status info for each test run.
infile = os.path.join(gInputsDir, fpath) # input
outfile = os.path.join(gOutputsDir, fpath+'.cix') # expected output
tmpfile = os.path.join(gTmpDir, fpath+'.cix') # actual output
if not os.path.exists(os.path.dirname(tmpfile)):
os.makedirs(os.path.dirname(tmpfile))
errfile = os.path.join(gOutputsDir, fpath+'.error') # expected error
# An options file is a set of kwargs for the buf.scan()
# method call. One key-value pair per-line like this:
# key=value
# Whitespace is stripped off the value.
optsfile = os.path.join(gInputsDir, fpath+'.options') # input options
if _debug:
print
print "*"*50, "codeintel '%s'" % fpath
# Set standard options:
opts = {"mtime": "42"}
# Determine input options to use, if any.
# XXX Not used. Drop it.
if os.path.exists(optsfile):
for line in open(optsfile, 'r').read().splitlines(0):
name, value = line.split('=', 1)
value = value.strip()
try: # allow value to be a type other than string
value = eval(value)
except Exception:
pass
opts[name] = value
if _debug:
print "*"*50, "options"
pprint.pprint(opts)
# Scan the file, capturing stdout and stderr and any possible
# error.
# - To allow testing from different dirs (resulting in changing
# path strings, we normalize the <file path="..."> value and any
# <scope ilk="blob" src="..."> attributes).
oldStdout = sys.stdout
oldStderr = sys.stderr
sys.stdout = StringIO.StringIO()
sys.stderr = StringIO.StringIO()
try:
try:
lang = None
if tags and "python3" in tags:
lang = "Python3"
buf = self.mgr.buf_from_path(infile, lang=lang)
buf.scan(**opts)
tree = buf.tree
# Normalize paths.
relnorm_infile = infile[len(dirname(gInputsDir))+1:]
absnorm_infile = infile
relnorm_infile = relnorm_infile.replace('\\', '/')
absnorm_infile = absnorm_infile.replace('\\', '/')
for file_elem in tree:
file_elem.set("path", relnorm_infile)
for blob_elem in file_elem:
if blob_elem.get("ilk") != "blob":
continue
norm_src = normpath(blob_elem.get("src"))
norm_src = norm_src.replace('\\', '/')
if norm_src in (relnorm_infile, absnorm_infile):
blob_elem.set("src", relnorm_infile)
tree = pretty_tree_from_tree(tree)
# Due to the dynamic nature of the ciler errors (which often
# includes the source code line numbers), it's difficult to check
# that the errors are identical, so we work around this by just
# taking the first 30 characters of the error.
cile_error = tree[0].get("error")
if cile_error and fpath.endswith(".js"):
tree[0].set("error", len(
cile_error) < 30 and cile_error or (cile_error[:30] + "..."))
cix = ET.tostring(tree)
except CodeIntelError, ex:
error = traceback.format_exc()
else:
def _testOneInputFile(self, fpath, tags=None):
_debug = False # Set to true to dump status info for each test run.
infile = os.path.join(gInputsDir, fpath) # input
outfile = os.path.join(gOutputsDir, fpath + '.cix') # expected output
tmpfile = os.path.join(gTmpDir, fpath + '.cix') # actual output
if not os.path.exists(os.path.dirname(tmpfile)):
os.makedirs(os.path.dirname(tmpfile))
errfile = os.path.join(gOutputsDir, fpath + '.error') # expected error
# An options file is a set of kwargs for the buf.scan()
# method call. One key-value pair per-line like this:
# key=value
# Whitespace is stripped off the value.
optsfile = os.path.join(gInputsDir, fpath + '.options') # input options
if _debug:
print()
print("*" * 50, "codeintel '%s'" % fpath)
# Set standard options:
opts = {"mtime": "42"}
# Determine input options to use, if any.
#XXX Not used. Drop it.
if os.path.exists(optsfile):
for line in open(optsfile, 'r').read().splitlines(0):
name, value = line.split('=', 1)
value = value.strip()
try: # allow value to be a type other than string
value = eval(value)
except Exception:
pass
opts[name] = value
if _debug:
print("*" * 50, "options")
pprint.pprint(opts)
# Scan the file, capturing stdout and stderr and any possible
# error.
# - To allow testing from different dirs (resulting in changing
# path strings, we normalize the <file path="..."> value and any
# <scope ilk="blob" src="..."> attributes).
oldStdout = sys.stdout
oldStderr = sys.stderr
sys.stdout = StringIO()
sys.stderr = StringIO()
try:
try:
lang = None
if tags and "python3" in tags:
lang = "Python3"
buf = self.mgr.buf_from_path(infile, lang=lang)
buf.scan(**opts)
tree = buf.tree
# Normalize paths.
relnorm_infile = infile[len(dirname(gInputsDir)) + 1:]
absnorm_infile = infile
relnorm_infile = relnorm_infile.replace('\\', '/')
absnorm_infile = absnorm_infile.replace('\\', '/')
for file_elem in tree:
file_elem.set("path", relnorm_infile)
for blob_elem in file_elem:
if blob_elem.get("ilk") != "blob": continue
norm_src = normpath(blob_elem.get("src"))
norm_src = norm_src.replace('\\', '/')
if norm_src in (relnorm_infile, absnorm_infile):
blob_elem.set("src", relnorm_infile)
tree = pretty_tree_from_tree(tree)
# Due to the dynamic nature of the ciler errors (which often
# includes the source code line numbers), it's difficult to check
# that the errors are identical, so we work around this by just
# taking the first 30 characters of the error.
cile_error = tree[0].get("error")
if cile_error and fpath.endswith(".js"):
tree[0].set(
"error",
len(cile_error) < 30 and cile_error
or (cile_error[:30] + "..."))
cix = ET.tostring(tree)
except CodeIntelError as ex:
error = traceback.format_exc()
else:
error = None
if isinstance(cix, six.text_type):
with io.open(tmpfile, mode="wt", encoding="utf-8") as fout:
fout.write(cix)
else:
with open(tmpfile, mode="wb") as fout:
fout.write(cix)
finally:
stdout = sys.stdout.getvalue()
stderr = sys.stderr.getvalue()
sys.stdout = oldStdout
sys.stderr = oldStderr
if _debug:
print("*" * 50, "stdout")
print(stdout)
print("*" * 50, "stderr")
print(stderr)
print("*" * 50, "error")
print(str(error))
print("*" * 50)
generateMissing = False
if not os.path.exists(outfile) and generateMissing:
with io.open(outfile, mode='wt', encoding='utf-8') as fout:
with io.open(tmpfile, mode='rt', encoding='utf-8') as ftmp:
fout.write(ftmp.read())
# Verify that the results are as expected.
if os.path.exists(outfile) and error:
self.fail("scanning '%s' raised an error but success was "
"expected:\n%s" % (_encode_for_stdout(fpath), indent(error)))
elif os.path.exists(outfile):
# Convert the <file path="..."/> to the native directory separator.
def to_native_sep(match):
path = match.group(2).replace("\\", os.sep).replace("/", os.sep)
return match.group(1) + path + match.group(3)
path_pat = re.compile(r'(<file .*?path=")(.*?)(".*?>)', re.S)
# Note that we don't really care about line endings here, so we read
# both files in universal newlines mode (i.e. translate to \n)
# and normalize ' ', ' ' and '''
with io.open(outfile, mode='rt', encoding='utf-8') as fout:
expected = path_pat.sub(to_native_sep, fout.read())
expected = expected.replace('
', ' ').replace(
'
', ' ').replace(''', '\'')
with io.open(tmpfile, mode='rt', encoding='utf-8') as ftmp:
actual = path_pat.sub(to_native_sep, ftmp.read())
actual = actual.replace('
', ' ').replace(
'
', ' ').replace(''', '\'')
if expected != actual:
do_fail = True
# Useful temporary thing while XML output format is changing.
#if os.stat("../support/xmldiff.py"):
# rc = os.system('python ../support/xmldiff.py "%s" "%s"' % (outfile, tmpfile))
# if rc == 0:
# do_fail = False
if do_fail:
diff = list(
difflib.ndiff(expected.splitlines(1),
actual.splitlines(1)))
diff = _diffContext(diff, 2)
if diff:
error_str = "%r != %r:\n --- %s\n +++ %s\n%s" \
% (outfile, tmpfile, outfile, tmpfile,
''.join(diff))
if gMaxDiffOutput > 0 and gMaxNumLines > 0:
if len(error_str) > gMaxDiffOutput:
error_lines = error_str.split("\n")
if len(error_lines) > gMaxNumLines:
error_lines = error_lines[:gMaxNumLines] + [
"..."
]
if gMaxLineLength > 0:
error_str = "\n".join([
len(x) > gMaxLineLength
and x[:gMaxLineLength] or x
for x in error_lines
])
else:
error_str = "\n".join(error_lines)
self.fail(_encode_for_stdout(error_str))
elif os.path.exists(errfile):
# There is no reference output file. This means that processing
# this file is expected to fail.
expectedError = open(errfile, 'r').read()
actualError = str(error)
self.failUnlessEqual(actualError.strip(), expectedError.strip())
else:
self.fail("No reference output file or error file for '%s'." % infile)
# Ensure next test file gets a clean codeintel.
toDelete = []
for modname in sys.modules:
if modname == "codeintel" or modname.startswith("codeintel."):
toDelete.append(modname)
for modname in toDelete:
del sys.modules[modname]
def convert_data_from_dict_to_xml(data):
'''
Convert data fields from dictionary to XML when perform studio submission on Basic Template tab.
The output will be updated to value of Advanced Editor.
1. problem description
2. Image url
3. variables (name, min_value, max_value, type, decimal_places)
4. answer_template_string
:param data -- a dictionary of fields supported for raw editor
:return:
<problem>
<description>Given a = [a] and b = [b]. Calculate the [sum], [difference] of a and b. </description>
<images>
<image_url link="http://example.com/image1">Image 1</image_url>
<image_url link="http://example.com/image2">Image 2</image_url>
</images>
<variables>
<variable name="a" min="1" max="200" type="integer"/>
<variable name="b" min="1.0" max="20.5" type="float" decimal_places="2"/>
</variables>
<answer_templates>
<answer sum = "[a] + [b]" difference = "[a] - [b]">Teacher's answer</answer>
</answer_templates>
</problem>
'''
print("## CALLING FUNCTION convert_data_from_dict_to_xml() ##")
# print("Input data type: {}".format(type(data)))
print("Input data: {}".format(data))
xml_string = ''
# init the root element: problem
problem = ET.Element('problem')
# convert question template
field_question_template = data['question_template']
description = ET.SubElement(problem, 'description')
description.text = field_question_template
# Convert answer template tring to dictionary,
# then build xml string for raw edit fields
field_answer_template = data['answer_template']
# Check for empty input
if not field_answer_template:
raise JsonHandlerError(400, "Answer template must not be empty")
# Handle answer template
# Parse and convert answer template string to dictionary first
answer_template_dict = {}
answer_template_list = field_answer_template.split('\n')
for answer in answer_template_list:
# only process if not empty, ignore empty answer template
if answer:
# answer template must contains '=' character
if (answer.find('=') != -1): # found '=' at lowest index of string
answer_attrib_list = answer.split('=')
# print "answer_attrib_list = "
# print(answer_attrib_list)
answer_attrib_key = answer_attrib_list[0]
answer_attrib_value = answer_attrib_list[1]
# print "answer_attrib_key = "
# print(answer_attrib_key)
# print "answer_attrib_value = "
# print(answer_attrib_value)
# Remove unexpected white spaces
answer_attrib_key = answer_attrib_key.lstrip(
) # all leading whitespaces are removed from the string.
answer_attrib_key = answer_attrib_key.rstrip(
) # all ending whitespaces are removed from the string.
answer_attrib_value = answer_attrib_value.lstrip(
) # all leading whitespaces are removed from the string.
answer_attrib_value = answer_attrib_value.rstrip(
) # all ending whitespaces are removed from the string.
# print "REMOVED SPACES, answer_attrib_key = "
# print(answer_attrib_key)
# print "REMOVED SPACES,answer_attrib_value = "
# print(answer_attrib_value)
# Add answer attribute to dict
answer_template_dict[answer_attrib_key] = answer_attrib_value
else:
raise JsonHandlerError(
400,
"Unsupported answer format. Answer template must contains '=' character: {}"
.format(answer))
# print("Resulted answer_template_dict: {}".format(answer_template_dict))
# Answer template xml elements
answer_templates = ET.SubElement(problem, 'answer_templates')
answer = ET.SubElement(answer_templates, 'answer')
# Add the converted dict data to xml elements
for attrib_key, attrib_value in answer_template_dict.iteritems():
answer.set(attrib_key, attrib_value)
answer.text = "Teacher's answer"
# Convert numeric variables
field_variables = data['variables']
# xml elements
variables_elem = ET.SubElement(problem, 'variables')
for var_name, attributes in field_variables.iteritems():
var_name = ET.SubElement(variables_elem, 'variable')
for attribute, value in attributes.iteritems():
# Set attribute
var_name.set(attribute, value)
# Convert string variables dictionary to xml string
field_string_variables = data['string_variables']
# xml elements
string_variables_elem = string_variables_dict_to_xml_element(
field_string_variables)
# Adds the element subelement to the end of this elements internal list of subelements.
problem.append(string_variables_elem)
# convert image
field_image_url = data['image_url']
# xml elements
images = ET.SubElement(problem, 'images')
image_url = ET.SubElement(images, 'image_url')
# Set attribute
image_url.set('link', field_image_url)
# print "before indent, Problem elem dum = ", ET.dump(problem)
indented_problem = indent(problem)
# print "after indent ,Problem elem dum = ", ET.dump(indented_problem)
xml_string = ET.tostring(indented_problem)
# print "Output xml string = ", xml_string
print("## End FUNCTION convert_data_from_dict_to_xml() ##")
return xml_string
def test_string_variables_dict_to_xml_element(string_variables_dict):
elem = string_variables_dict_to_xml_element(string_variables_dict)
xml_string = ET.tostring(indent(elem))
print xml_string
def processor(self, content):
# XSLT was invented for these kind of transformations
# TODO: RitNummer
dtreinen = []
root = ElementTree.XML(content)
treinen = root.findall('.//VertrekkendeTrein')
for trein in treinen:
result = {}
result['vertrektijd'] = trein.find('.//VertrekTijd').text
spoor = trein.find('.//VertrekSpoor')
result['spoor'] = spoor.text
result['spoorwijziging'] = spoor.attrib['wijziging']
result['station'] = trein.find('.//EindBestemming')
vehicle = trein.find('.//TreinSoort')
if vehicle is not None:
result['type'] = vehicle.text
vertraging = trein.find('.//VertrekVertragingTekst')
if vertraging:
result['vertraging'] = vertraging.text
ritnummer = trein.find('.//RitNummer')
if ritnummer:
result['ritnummer'] = ritnummer.text
dtreinen.append(result)
root = ElementTree.Element('liveboard')
root.attrib['version'] = "1.0"
root.attrib['timestamp'] = str(int(time.time()))
self.renderStation(root, self.station)
departures = ElementTree.SubElement(root, 'departures')
departures.attrib['number'] = str(len(dtreinen))
for trein in dtreinen:
departure = ElementTree.SubElement(departures, 'departure')
if 'vertraging' in trein:
departure.attrib['delay'] = trein['vertraging']
self.renderStation(departure, self.station)
if 'type' in trein:
sub = ElementTree.SubElement(departure, 'vehicle')
sub.text = 'NL.NS.'+trein['type']
if 'vertrektijd' in trein:
sub = ElementTree.SubElement(departure, 'time')
sub.attrib['formatted'] = trein['vertrektijd']
sub.text = str(int(time.mktime(iso8601.parse_date(trein['vertrektijd']).timetuple())))
if 'spoor' in trein:
sub = ElementTree.SubElement(departure, 'platform')
sub.text = trein['spoor']
if 'spoorwijziging' in trein:
sub.attrib['change'] = trein['spoorwijziging']
return ElementTree.tostring(root)
def write(self, element):
self._flush()
indent(element, self.indentLevel)
self.out.write(ElementTree.tostring(element, "utf-8"))
self.lastElement = None
def wordpress(xml, instance, author):
"""Imports from an wordpress export xml file directly into everything.
Uses cElementTree (http://effbot.org/zone/celementtree.htm) for XML access."""
xml = ET.parse(StringIO(xml["content"]))
root = xml.getroot().find("channel")
for i in root.findall("item"):
slug = i.findtext("{http://wordpress.org/export/1.0/}post_name")
# Check if this Entry already exists
try:
e = Entry.objects.get(slug=slug)
except:
# Create a new everything entry!
tags = []
try:
for cat in i.findall("category"):
tags.append(cat.text)
tagstring = string.join(tags, ", ")
except:
tagstring = ""
if i.findtext("{http://wordpress.org/export/1.0/}status") == "publish":
status = "public"
else:
status = "draft"
date = dateutil.parser.parse(i.findtext("{http://wordpress.org/export/1.0/}post_date"))
content = i.findtext("{http://purl.org/rss/1.0/modules/content/}encoded")
e = Entry(
title=i.findtext("title"),
content=content,
tags=tagstring,
slug=slug,
status=status,
app=instance,
author_id=int(author),
)
e.save()
e.created = date
e.save()
# print "Imported Entry " + e.title
# Import the comments, too!
for c in i.findall("{http://wordpress.org/export/1.0/}comment"):
ref = "%s.entry.%s" % (instance, e.id)
content = c.find("{http://wordpress.org/export/1.0/}comment_content")
content = ET.tostring(content)
thecontent = content.replace(
'<ns0:comment_content xmlns:ns0="http://wordpress.org/export/1.0/">', ""
).replace("</ns0:comment_content>", "")
themail = c.findtext("{http://wordpress.org/export/1.0/}comment_author_email")
# Check if this Comment does already exists
try:
v = Comment.objects.get(ref=ref, content=thecontent, mail=themail)
except:
if str(c.findtext("{http://wordpress.org/export/1.0/}comment_approved")) == str(1):
status = "ok"
else:
status = "unsure"
v = Comment(
name=c.findtext("{http://wordpress.org/export/1.0/}comment_author"),
mail=themail,
url=c.findtext("{http://wordpress.org/export/1.0/}comment_author_url"),
ip=c.findtext("{http://wordpress.org/export/1.0/}comment_author_IP"),
content=thecontent,
date=dateutil.parser.parse(c.findtext("{http://wordpress.org/export/1.0/}comment_date")),
status=status,
ref=ref,
)
v.save()
def write(self, element):
self._flush()
indent(element, self.indentLevel)
self.out.write(ElementTree.tostring(element, "utf-8"))
self.lastElement = None