def find(self, document):
if isinstance(document, basestring):
document = ElementTree.fromstring(document)
elif not ElementTree.iselement(document):
document = ElementTree.parse(document)
point_qname = self._get_qname(self.POINT_CLASS)
lat_qname = self._get_qname(self.LATITUDE_PROPERTY)
long_qname = self._get_qname(self.LONGITUDE_PROPERTY)
alt_qname = self._get_qname(self.ALTITUDE_PROPERTY)
queue = [document]
while queue:
element = queue.pop()
if not self.point_class or element.tag == point_qname:
lat_el = element.find(lat_qname)
long_el = element.find(long_qname)
alt_el = element.find(alt_qname)
if lat_el is not None and long_el is not None:
latitude = lat_el.text
longitude = long_el.text
altitude = alt_el and alt_el.text
try:
point = Point((latitude, longitude, altitude))
except (TypeError, ValueError):
if not self.ignore_invalid:
raise
else:
yield Location(None, point)
queue.extend(reversed(element))
def main(file, **kwargs):
""" Given an input layers file and a directory, print the compiled
XML file to stdout and save any encountered external image files
to the named directory.
"""
mmap = mapnik.Map(1, 1)
# allow [zoom] filters to work
mmap.srs = '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null'
cascadenik.load_map(mmap, file, **kwargs)
(handle, filename) = tempfile.mkstemp(suffix='.xml', prefix='cascadenik-mapnik-')
os.close(handle)
mapnik.save_map(mmap, filename)
if kwargs.get('pretty'):
doc = ElementTree.fromstring(open(filename, 'rb').read())
cascadenik._compile.indent(doc)
f = open(filename, 'wb')
doc.write(f)
f.close()
if kwargs.get('compiled'):
os.rename(filename, kwargs['compiled'])
else:
print open(filename, 'r').read()
os.unlink(filename)
return 0
def parseCldrFile(filename, outputDirectory=None):
tree = ElementTree.parse(filename)
language, territory = getLocale(tree)
data = {}
for cal in tree.findall('dates/calendars/calendar'):
if not cal.attrib.has_key("type"): continue
if cal.attrib["type"] != "gregorian": continue
data.update(extractMonth(cal))
data.update(extractDay(cal))
#data.update(extractQuarter(cal))
data.update(extractAmPm(cal))
data.update(extractDateFormat(cal))
data.update(extractTimeFormat(cal))
data.update(extractDateTimeFormat(cal))
data.update(extractFields(cal))
data.update(extractDelimiter(tree))
data.update(extractNumber(tree))
locale = language
if territory != "":
locale += "_" + territory
code = getJavaScript(data, locale, language, territory)
if outputDirectory != None:
outfile = os.path.join(outputDirectory, locale + ".js");
open(outfile, "w").write(code)
else:
print code
def test_TemplateXMLTreeBuilder_nosub(self):
txtb = xml_utils.TemplateXMLTreeBuilder()
# elementree pukes on identifiers starting with $
txtb.feed(self.RESULTCHECK)
et = txtb.close()
result = ElementTree.tostring(et)
self.assertEqual(result, self.RESULTCHECK)
def apicall(command, paramslist):
url = apiurl + apikey + "/" + command
for param in paramslist:
url = url + "/" + urllib.quote_plus(param)
log( __name__ ," getting url '%s'" % url )
try:
response = urllib.urlopen(url)
except:
okdialog = xbmcgui.Dialog()
ok = okdialog.ok("Error", "Failed to contact Bierdopje site.")
log( __name__ ," failed to get url '%s'" % url )
else:
try:
xml = XMLTree.parse(response)
status = gettextelements(xml, "response/status")
except:
okdialog = xbmcgui.Dialog()
ok = okdialog.ok("Error", "Failed to contact Bierdopje site.")
log( __name__ ," failed to get proper response for url '%s'" % url )
return None
if status == "false":
okdialog = xbmcgui.Dialog()
ok = okdialog.ok("Error", "Failed to contact Bierdopje site.")
log( __name__ ," failed to get proper response (status = false) for url '%s'" % url )
return None
else:
return xml
def import_old_xml_store(self):
import ElementTree as et
filename = os.path.expanduser('~/.gnome2/gedit/gedit-tools.xml')
if not os.path.isfile(filename):
return
print "External tools: importing old tools into the new store..."
xtree = et.parse(filename)
xroot = xtree.getroot()
for xtool in xroot:
for i in self.tree.tools:
if i.name == xtool.get('label'):
tool = i
break
else:
tool = Tool(self.tree)
tool.name = xtool.get('label')
tool.autoset_filename()
self.tree.tools.append(tool)
tool.comment = xtool.get('description')
tool.shortcut = xtool.get('accelerator')
tool.applicability = xtool.get('applicability')
tool.output = xtool.get('output')
tool.input = xtool.get('input')
tool.save_with_script(xtool.text)
def main():
bibupload = ChunkedBibUpload(mode='a', user=SCRIPT_NAME, notimechange=True)
bibindex = ChunkedBibIndex(indexes='reportnumber', user=SCRIPT_NAME)
# open url and parse xml
source = sys.argv[1]
tree = ET.parse(urllib.urlopen(source))
root = tree.getroot()
for item in root.iter('article'):
doi = item.get('doi')
arxiv = item.get('preprint_id')
recID = add_doi(arxiv)
if recID:
recID = recID[0]
record_xml = append_doi(recID, doi)
if record_xml:
messages.append("Now we will run the bibupload and bibindex for " + str(recID) + " record")
messages.append("We will upload the following xml code " + repr(record_xml))
bibupload.add(record_xml)
bibindex.add(recID)
if WRITE_ERRORS:
er = enable_log('errors.txt')
map(er, errors)
er("CLOSE")
if WRITE_LOG:
msg = enable_log('log.txt')
map(msg, messages)
msg("CLOSE")
bibupload.__del__()
bibindex.__del__()
def get_updated_episodes(self, period = "day"):
"""Get a list of episode ids which have been updated within this period."""
url = "%s/updates/updates_%s.xml" % (self.base_key_url, period)
data = urllib.urlopen(url)
tree = ET.parse(data)
episode_nodes = tree.getiterator("Episode")
return [(x.findtext("Series"), x.findtext("id")) for x in episode_nodes]
def fetchInput(self):
"""Parses input file into an ElementTree object, returns the object"""
try:
self.inputtree=ET.parse(self.inputfile)
except IOError, detail:
self.writeLog('parsing '+self.inputfile+'Error parsing input file - '+str(detail),'error')
exit()
def default_loader(href, parse, encoding=None):
file = open(href)
if parse == "xml":
data = ElementTree.parse(file).getroot()
else:
data = file.read()
if encoding:
data = data.decode(encoding)
file.close()
return data
def _autowix_one_file(in_path, product_code, force=False):
out_path = splitext(in_path)[0]
log.info("process `%s' -> `%s'", in_path, out_path)
if exists(out_path) and not force:
raise AutowixError("`%s' exists: use -f|--force to allow overwrite"
% out_path)
wix_ns = "{http://schemas.microsoft.com/wix/2006/wi}"
guid_marker = "$(autowix.guid)"
# Use special PIParser() to preserve PIs and comments.
tree = ET.parse(in_path, PIParser())
root = tree.getroot()
for comp in root.getiterator(wix_ns+"Component"):
marker = comp.get("Guid")
if marker == guid_marker:
id = comp.get("Id")
guid = _guid_from_keys([product_code, id])
log.debug("... component %r guid: %r", id, guid)
comp.set("Guid", guid)
# PIParser wraps with a <document> -- just serialize the
# children.
fout = open(out_path, 'w')
try:
fout.write('<?xml version="1.0" encoding="utf-8"?>\n')
for child in root:
# The newline is feeble attempt at some prettiness of
# the output.
s = ET.tostring(child)
# Make some attempts to make the output XML pretty.
# - We know that ElementTree puts in "ns0" for the WiX
# namespace. We are only using the one ns so can
# remove those.
s = s.replace("<ns0:", "<") \
.replace("</ns0:", "</") \
.replace("xmlns:ns0=", "xmlns=")
# - Sprinkle in some newlines.
fout.write(s + '\n')
finally:
fout.close()
def get_matching_shows(self, show_name):
"""Get a list of shows matching show_name."""
get_args = urllib.urlencode({"seriesname": show_name}, doseq=True)
url = "%s/GetSeries.php?%s" % (self.base_url, get_args)
data = urllib.urlopen(url)
show_list = []
if data:
try:
tree = ET.parse(data)
show_list = [(show.findtext("seriesid"), show.findtext("SeriesName")) for show in tree.getiterator("Series")]
except SyntaxError:
pass
return show_list
def get_episode(self, episode_id):
"""Get the episode object matching this episode_id."""
url = "%s/episodes/%s/" % (self.base_key_url, episode_id)
data = urllib.urlopen(url)
episode = None
try:
tree = ET.parse(data)
episode_node = tree.find("Episode")
episode = TheTVDB.Episode(episode_node, self.mirror_url)
except SyntaxError:
pass
return episode
def get_show(self, show_id):
"""Get the show object matching this show_id."""
url = "%s/series/%s/" % (self.base_key_url, show_id)
data = urllib.urlopen(url)
show = None
try:
tree = ET.parse(data)
show_node = tree.find("Series")
show = TheTVDB.Show(show_node, self.mirror_url)
except SyntaxError:
pass
return show
def writeExportFile(strSQL,strFileName):
dbCon = sqlite.connect(videoDB)
dbCur = dbCon.cursor()
dbCur.execute(strSQL)
xmlObj = ET.Element("watched")
for row in dbCur:
child = ET.SubElement(xmlObj, "file")
child.text = row[0]
episodeFileObj = open(strFileName, 'w')
episodeFileObj.write(ET.tostring(xmlObj))
episodeFileObj.close()
def _ParseData(self, filename):
"""
Parse data from an xml file into python structures with ElementTree
"""
#gfr#import xml.etree.ElementTree as ET
import ElementTree as ET
print filename
tree = ET.parse(filename)
root = tree.getroot()
rowno = 0
print 'Processing %s rows' % len(root)
for node in root:
rowno = rowno + 1
print 'Row-No: ', rowno
dataset = {}
for child in node:
if child.tag == 'Author':
# Authors encode all data in attributes
audict = {}
if 'name' in child.attrib:
audict['name'] = child.attrib['name']
if 'IsDKFZ' in child.attrib:
# audict['IsDKFZ'] = False if child.attrib['IsDKFZ'] == '0' else True
if child.attrib['IsDKFZ'] == '0':
audict['IsDKFZ'] = False
else:
audict['IsDKFZ'] = True
if 'Pos' in child.attrib:
audict['pos'] = child.attrib['Pos']
if not child.tag in dataset:
dataset[child.tag] = []
dataset[child.tag].append(audict)
else:
# treat all fields as repeatable
if not child.tag in dataset:
dataset[child.tag] = []
dataset[child.tag].append(child.text)
self._appendBibliographic(dataset)
return
def get_show_image_choices(self, show_id):
"""Get a list of image urls and types relating to this show."""
url = "%s/series/%s/banners.xml" % (self.base_key_url, show_id)
data = urllib.urlopen(url)
tree = ET.parse(data)
images = []
banner_data = tree.find("Banners")
banner_nodes = tree.getiterator("Banner")
for banner in banner_nodes:
banner_path = banner.findtext("BannerPath")
banner_type = banner.findtext("BannerType")
banner_url = "%s/banners/%s" % (self.mirror_url, banner_path)
images.append((banner_url, banner_type))
return images
def parse(self,InName):
# print "Start parsing [%s]" %(InName)
try:
tree = ET.parse(InName)
except (IOError,xml.parsers.expat.ExpatError):
print "parse [%s] error" %(InName)
return False
# print 'get [%d] doc' %(len(lNode))
lNode = tree.findall('./DOC/mid')
if (len(lNode) > 0):
self.mId = lNode[0].text
self.SetEdge(tree)
self.SetName()
self.SetAlias()
self.SetDesp()
self.SetKey()
self.GetConnectedObject()
self.GetType()
return True
def __init__(self, file_definition):
DConfigGuiWrapper.__init__(self)
self.__file_definition = file_definition
#self.__file_storage = file_storage
self.xml = ElementTree.parse(file_definition)
root = self.xml.getroot()
for section in root.findall("section"):
name = section.attrib.get("name", None)
if not name:
continue
s = self.new_section(str(name))
self.__settings[str(name).lower()] = {}
self.parse_struct(section, s, self.__settings[str(name).lower()])
def _read_xml(self):
"""
Reads in XML file of playlist
@access private
@returns dict
"""
return_dict = {}
src_list = []
file_list = []
tree = et.parse(self._source)
for i in tree.findall('settings/source'):
src_list.append(i.text)
return_dict['sources'] = src_list
for i in tree.findall('playlist/file'):
file_list.append([i.get('label'),i.get('path'),int(i.get('playcount'))])
return_dict['playlist'] = file_list
return return_dict
def get_show_and_episodes(self, show_id):
"""Get the show object and all matching episode objects for this show_id."""
url = "%s/series/%s/all/" % (self.base_key_url, show_id)
data = urllib.urlopen(url)
show_and_episodes = None
try:
tree = ET.parse(data)
show_node = tree.find("Series")
show = TheTVDB.Show(show_node, self.mirror_url)
episodes = []
episode_nodes = tree.getiterator("Episode")
for episode_node in episode_nodes:
episodes.append(TheTVDB.Episode(episode_node, self.mirror_url))
show_and_episodes = (show, episodes)
except SyntaxError:
pass
return show_and_episodes
def parse(source):
return ElementTree.parse(source, TreeBuilder())
#!/Python27/python.exe
import sys, gzip, StringIO, csv, sys, math, os, getopt, subprocess, math, datetime, time, json, socket
import urllib2
import ElementTree
import MySQLdb
import ConfigParser
########## INIT VARS ##########
BPO_file = open("jeves.blueprints.xml")
lookup_json = open("lookup.json")
lookup = json.load(lookup_json)
crash_file = "material_bridge_crash.json"
crash_obj={}
BPOs = ElementTree.parse(BPO_file)
#Config File Globals
conf = ConfigParser.ConfigParser()
conf.read(["bridge.ini", "bridge_local.ini"])
########## GLOBALS ##########
regionlist = None #comma separated list of regions (for EMD history)
systemlist = None #comma separated list of systems (for EC history)
itemlist = None #comma separated list of items (default to full list)
csv_only = int(conf.get("GLOBALS","csv_only")) #output CSV instead of SQL
sql_init_only = int(conf.get("GLOBALS","sql_init_only")) #output CSV CREATE file
########## DB VARS ##########
db_table = conf.get("MATERIALDESTROYED","db_table")
db_name = conf.get("GLOBALS","db_name")
def get_xmlized_schema(self):
database = ET.Element('database')
for k, v in PropelDatabase.fields.iteritems():
if self.db.cache.has_key(k) and self.db.cache[k]:
database.attrib[k] = self.db.cache[k]
elif not PropelDatabase.fields[k]['optional']:
database.attrib[k] = PropelDatabase.fields[k]['default']
database = self.convert_bool_value(database, PropelDatabase)
for t in self.db.tables:
if t.get_export == '1':
table = ET.SubElement(database, 'table')
for k, v in PropelTable.fields.iteritems():
if getattr(t, 'get_' + k) and getattr(t, 'get_' + k) != PropelTable.fields[k]['default']:
table.attrib[k] = getattr(t, 'get_' + k)
elif not PropelTable.fields[k]['optional']:
table.attrib[k] = PropelTable.fields[k]['default']
table = self.convert_bool_value(table, PropelTable)
for c in t.columns:
column = ET.SubElement(table, 'column')
for k, v in PropelColumn.fields.iteritems():
if k != 'table':
if getattr(c, 'get_' + k) and getattr(c, 'get_' + k) != PropelColumn.fields[k]['default']:
if k != 'defaultValue':
column.attrib[k] = str(getattr(c, 'get_' + k))
else:
column.attrib[k] = str(getattr(c, 'get_' + k)).strip("'")
elif c.get_primaryKey and k == 'autoIncrement' and self.widgets['export_add_ai_on_pk'].get_bool_value():
column.attrib[k] = 'True'
elif not PropelColumn.fields[k]['optional']:
column.attrib[k] = PropelColumn.fields[k]['default']
column = self.convert_bool_value(column, PropelColumn)
for fk in t.foreignKeys:
foreign_key = ET.SubElement(table, 'foreign-key')
for k, v in PropelForeignKey.fields.iteritems():
if k != 'table' and k != 'localColumn' and k!= 'foreignColumn':
if k == 'name':
if self.widgets['export_FK_name'].get_bool_value():
foreign_key.attrib[k] = str(getattr(fk, 'get_' + k))
elif getattr(fk, 'get_' + k) and getattr(fk, 'get_' + k) != PropelForeignKey.fields[k]['default']:
foreign_key.attrib[k] = str(getattr(fk, 'get_' + k))
elif not PropelForeignKey.fields[k]['optional']:
foreign_key.attrib[k] = PropelForeignKey.fields[k]['default']
foreign_key = self.convert_bool_value(foreign_key, PropelForeignKey)
for k, col in enumerate(fk.wbObject.referencedColumns):
reference = ET.SubElement(foreign_key, 'reference')
reference.attrib['local'] = str(getattr(fk, 'get_localColumn_' + str(k)))
reference.attrib['foreign'] = str(getattr(fk, 'get_foreignColumn_' + str(k)))
for i in t.indices:
if (i.get_indexType == 'UNIQUE' and self.widgets['export_unique'].get_bool_value()) or (i.get_indexType == 'INDEX' and self.widgets['export_index'].get_bool_value()):
type = i.get_indexType.lower()
indice = ET.SubElement(table, type)
for k, v in PropelIndice.fields.iteritems():
if k != 'columnName' and k != 'table' and k != 'indexType':
if k == 'name':
if (i.get_indexType == 'UNIQUE' and self.widgets['export_unique_name'].get_bool_value()) or (i.get_indexType == 'INDEX' and self.widgets['export_index_name'].get_bool_value()):
indice.attrib[k] = str(getattr(i, 'get_' + k))
elif getattr(i, 'get_' + k):
indice.attrib[k] = str(getattr(i, 'get_' + k))
elif not PropelIndice.fields[k]['optional']:
indice.attrib[k] = PropelIndice.fields[k]['default']
for column_name in i.get_columnsName:
indice_column = ET.SubElement(indice, type + '-column')
indice_column.attrib['name'] = column_name
indice = self.convert_bool_value(indice, PropelIndice)
for k, b in enumerate(t.behaviors):
if self.propelBehaviorsDict.has_key(b.get_name):
behavior = ET.SubElement(table, 'behavior')
behavior.attrib['name'] = b.get_name
for p in self.propelBehaviorsDict[b.get_name]:
if getattr(b, 'get_parameter_' + str(p)) != '':
parameter = ET.SubElement(behavior, 'parameter')
parameter.attrib['name'] = p
parameter.attrib['value'] = getattr(b, 'get_parameter_' + str(p))
for k, es in enumerate(self.db.externalSchemas):
external_schema = ET.SubElement(database, 'external-schema')
for k, v in PropelExternalSchema.fields.iteritems():
if getattr(es, 'get_' + k):
external_schema.attrib[k] = str(getattr(es, 'get_' + k))
elif not PropelExternalSchema.fields[k]['optional']:
external_schema.attrib[k] = PropelExternalSchema.fields[k]['default']
external_schema = self.convert_bool_value(external_schema, PropelExternalSchema)
self.indent(database)
return '<?xml version="1.0" encoding="UTF-8"?>\r\n' + ET.tostring(database)
def copy(elem):
e = ElementTree.Element(elem.tag, elem.attrib)
e.text = elem.text
e.tail = elem.tail
e[:] = elem
return e
def canonicalize_test_xml(self):
et = ElementTree.parse(self.XMLFILE)
et.write(self.XMLFILE, encoding="UTF-8")
f = file(self.XMLFILE)
self.XMLSTR = f.read()
f.close()
def test_TemplateXML(self):
tx = xml_utils.TemplateXML(self.FULLREPLACE, **self.MAPPING)
et = ElementTree.ElementTree(None, tx.name)
check = ElementTree.tostring(et.getroot())
self.assertEqual(check, self.RESULTCHECK)
def parse(source):
return ElementTree.parse(source, TreeBuilder())
def parse(source, encoding=None):
return ElementTree.parse(source, HTMLTreeBuilder(encoding=encoding))
entity = htmlentitydefs.entitydefs.get(name)
if entity and len(entity) == 1:
self.__builder.data(entity)
else:
# FIXME: deal with it
print "UNSUPPORTED ENTITY", name, entity
def handle_data(self, data):
self.__builder.data(data)
##
# An alias for the <b>HTMLTreeBuilder</b> class.
TreeBuilder = HTMLTreeBuilder
##
# Parse an HTML document or document fragment.
#
# @param source A filename or file object containing HTML data.
# @return An ElementTree instance
def parse(source):
return ElementTree.parse(source, TreeBuilder())
if __name__ == "__main__":
import sys
ElementTree.dump(parse(open(sys.argv[1])))
def __init__(self, html=0):
self.__builder = ElementTree.TreeBuilder()
if html:
import htmlentitydefs
self.entitydefs.update(htmlentitydefs.entitydefs)
xmllib.XMLParser.__init__(self)
def close(self):
data = _elementtidy.fixup(string.join(self.__data, ""))
return ElementTree.XML(data)
data = unicode(data, self.encoding, "ignore")
self.__builder.data(data)
##
# (Hook) Handles unknown entity references. The default action
# is to ignore unknown entities.
def unknown_entityref(self, name):
pass # ignore by default; override if necessary
##
# An alias for the <b>HTMLTreeBuilder</b> class.
TreeBuilder = HTMLTreeBuilder
##
# Parse an HTML document or document fragment.
#
# @param source A filename or file object containing HTML data.
# @param encoding Optional character encoding, if known. If omitted,
# the parser looks for META tags inside the document. If no tags
# are found, the parser defaults to ISO-8859-1.
# @return An ElementTree instance
def parse(source, encoding=None):
return ElementTree.parse(source, HTMLTreeBuilder(encoding=encoding))
if __name__ == "__main__":
import sys
ElementTree.dump(parse(open(sys.argv[1])))
import traceback
try:
import ElementTree
doc = u"<doc><hello to=\"world\">foo bar</hello></doc>"
print doc
tree = ElementTree.XML(doc)
print tree
print ElementTree.tostring(tree)
except:
traceback.print_exc()
def parse(source, encoding=None):
return ElementTree.parse(source, HTMLTreeBuilder(encoding=encoding))
def test_MappingTreeBuilder_standalone(self):
txtb = xml_utils.TemplateXMLTreeBuilder(**self.MAPPING)
txtb.feed(self.FULLREPLACE)
et = txtb.close()
result = ElementTree.tostring(et)
self.assertEqual(result, self.RESULTCHECK)
