def load(file, env): cXMLParser = CXMLParser(env) parser = XMLParser(target=cXMLParser) f = open(file, 'r+') read_data = f.read(); f.close() parser.feed(read_data) parser.close() return cXMLParser.env
def __init__(self, xml_encode):
super().__init__()
parser = XMLParser(target=MaxDepth())
pepe = parser.feed(xml_encode)
parser.close()
print(self.resul_property)
self.xml_encode = xml_encode
def HTMLOfENML(text, resources={}):
target = HTMLCreatorTarget(resources)
parser = XMLParser(target=target)
parser.feed(text)
parser.close()
return tostring(target.root, encoding='utf8', method='html')
def HTMLOfENML(text, resources={}):
target = HTMLCreatorTarget(resources)
parser = XMLParser(target=target)
parser.feed(text)
parser.close()
return tostring(target.root, encoding='utf8', method='html')
def mm2otl(*arg, **kwarg):
fname = arg[0][0]
file = codecs.open(fname, 'r', encoding='utf-8')
filelines = file.readlines()
outline = Outline()
parser = XMLParser(target=outline, encoding='utf-8')
parser.feed(filelines[0].encode('utf-8'))
parser.close()
def mm2otl(*arg, **kwarg):
fname = arg[0][0]
file = codecs.open(fname, 'r', encoding='utf-8')
filelines = file.readlines()
outline = Outline()
parser = XMLParser(target=outline, encoding='utf-8')
parser.feed(filelines[0].encode('utf-8'))
parser.close()
def parse_xml_string(data):
"""
This method parses through the xml string and counts the number of
occurence of the xml tag.
Args:
data (str): Stringify data of xml
Returns:
ELEMENT_COUNT (dict): dictionary of values containing counts of elements
"""
class ElementCounter:
"""Class to get count of Element occurance."""
ELEMENT_COUNT = defaultdict(lambda: 0)
def start(self, tag, attrib):
self.ELEMENT_COUNT[tag] += 1
def end(self, tag):
pass
def data(self, data):
pass
def close(self):
pass
result = {'error': True, 'data': {}, 'message': 'Unstructured XML'}
target = ElementCounter()
parser = XMLParser(target=target)
try:
parser.feed(data)
except ParseError as e:
result.update({'error': True, 'message': 'Unstructured data'})
return result
except Exception as e:
result.update({'error': True, 'message': '{}'.format(e)})
return result
try:
parser.close()
except ParseError as e:
result.update({'error': True, 'message': 'Empty XML'})
return result
except Exception as e:
result.update({'error': True, 'message': '{}'.format(e)})
return result
result.update({
'error': False,
'message': 'xml parse successful',
'data': dict(target.ELEMENT_COUNT)
})
return result
def from_xml(xml):
"""
Deserialize from a XML string.
:param: xml string
:rtype: object tree from XML string
"""
handler = XMLHandler()
parser = XMLParser(target=handler)
parser.feed(xml)
parser.close()
return handler.root
def main():
if 1 < len(sys.argv): # .xml file path in $1 argument, else use /dev/stdin
path = sys.argv[1]
text = open(path).read()
else:
text = "\n".join(sys.stdin.readlines())
ntg = sys.argv[2] if 2 < len(sys.argv) else None
parser = XMLParser(target=_Parser_xml(ntg))
text = re.sub('\\sxmlns="[^"]+"', '', text, count=1)
parser.feed(text)
parser.close()
def ProcessCorpus():
print("Gathering Files")
global dataRecorder
for file in glob(r'E:/Documents/UNE/HUMS_301.2/Corpus/Corpus_XML\*.xml'):
tree = etree.parse(file)
root = tree.getroot()
xmlString = etree.tostring(root, encoding="UTF-8", method='xml')
dataRecorder = DataRecorder()
parser = XMLParser(target=dataRecorder)
parser.feed(xmlString)
parser.close()
print('Corpus procssing compelete!')
def get_ebelge_users():
parser = XMLParser(target=EbelgeUsers())
parser.feed(
frappe.read_file(
frappe.get_site_path("private", "files", "KullaniciListesiXml",
"newUserPkList.xml")))
return parser.close()
def getQueryResult(query,detailedLog=True):
parser = XMLParser(target=ProcessCSQueryResult())
queryAnswerXML = urllib.urlopen(query).read()
if detailedLog:
log_CSQuery(queryAnswerXML)
parser.feed(queryAnswerXML)
return parser.close()
def getQueryResult(query, detailedLog=True):
parser = XMLParser(target=ProcessCSQueryResult())
queryAnswerXML = urllib.urlopen(query).read()
if detailedLog:
log_CSQuery(queryAnswerXML)
parser.feed(queryAnswerXML)
return parser.close()
def get_max_depth(exampleXml):
target = MaxDepth()
parser = XMLParser(target=target)
parser.feed(exampleXml)
depth = parser.close()
return depth
def new_parsetree_from_xml(xml):
# For some reason this does not work with cElementTree.XMLBuilder ...
from xml.etree.ElementTree import XMLParser
from zim.formats import ParseTree
builder = XMLParser()
builder.feed(xml)
root = builder.close()
return ParseTree(root)
def runTest(self):
'''Test OldParseTreeBuilder class'''
# - Test \n before and after h / p / pre
# - Test break line into lines
input = '''\
<?xml version='1.0' encoding='utf-8'?>
<zim-tree>
foo<h level="1">bar</h>baz
dus<pre>ja</pre>hmm
<h level="2">foo
</h>bar
dus ja <emphasis>hmm
dus ja
</emphasis>grrr
<strong>foo
bar
</strong>
<strike></strike><emphasis> </emphasis>.
</zim-tree>'''
wanted = '''\
<?xml version='1.0' encoding='utf-8'?>
<zim-tree>
foo
<h level="1">bar</h>
baz
dus
<pre>ja
</pre>hmm
<h level="2">foo</h>
bar
dus ja <emphasis>hmm</emphasis>
<emphasis>dus ja</emphasis>
grrr
<strong>foo</strong>
<strong>bar</strong>
.
</zim-tree>'''
from xml.etree.ElementTree import XMLParser
builder = XMLParser(target=OldParseTreeBuilder())
builder.feed(input)
root = builder.close()
tree = ParseTree(root)
self.assertEqual(tree.tostring(), wanted)
def _parse_xml(self, xml_data): """ Parse the xml into a python dictionary """ parser = XMLParser() tree = parser.feed(xml_data) root = parser.close() data_dict = XmlDictConfig(root) return data_dict
def read(filename):
""" Read an atlas from a XML file.
"""
builder = TreeBuilder(filename)
parser = XMLParser(target=builder)
data = open(filename).read()
parser.feed(data)
return parser.close()
def __init__(self):
f = open(self.config_file)
xml_src = f.read()
f.close()
parser = XMLParser()
parser.feed(xml_src)
self.config_tree = parser.close()
self.parse()
def main(name):
with open(name, "r") as f:
parser = XMLParser()
for line in f:
parser.feed(line)
xml = XMLTree(parser.close(), False)
M.run(xml.get("files"), xml.get("structure"), xml.get("pages"))
def kplist_parse(plist):
"""Parse a kernel-style property list."""
try:
builder = _KPlistBuilder()
parser = XMLParser(target=builder)
parser.feed(plist)
return parser.close()
except Exception as e:
print(e)
return None
def get_tree(xml_string):
"""
Get the xml tree associated to an xml string
:param request:
- string
:return:
"""
parser = XMLParser(target=MyParser())
parser.feed(xml_string)
tree = parser.close()
return tree
def find_depth(chaine):
target = MaxDepth()
parser = XMLParser(target=target)
exampleXml = """<feed xml:lang='en'>
<title>HackerRank</title>
<subtitle lang='en'>Programming challenges</subtitle>
<link rel='alternate' type='text/html' href='http://hackerrank.com/'/>
<updated>2013-12-25T12:00:00</updated>
</feed>"""
parser.feed(chaine)
print(parser.close()-1)
def __init__(self, config_file=None): if config_file: self.config_file = config_file f = open(self.config_file) xml_src = f.read() f.close() parser = XMLParser() parser.feed(xml_src) self.config_tree = parser.close() self.parse()
def load_plist(self, src):
def rat_iter(dict, key):
if key == '_XBPS_ALTERNATIVES_':
return
nonlocal self
rat = self.rat_from_xbps(dict, repo=self)
if rat:
self.index(rat)
parser = XMLParser(target=XbpsPlistParser(iterator=rat_iter))
while True:
data = src.read(16 * 1024)
if not data:
break
parser.feed(data)
parser.close()
def __init__(self, conf):
f = open(conf.uwsgifile)
logging.basicConfig(level=conf.debuglevel)
self.log = logging
xml_src = f.read()
f.close()
parser = XMLParser()
parser.feed(xml_src)
self.config_tree = parser.close()
self.parse()
def __init__(self, config_file=None):
if config_file:
self.config_file = config_file
f = open(self.config_file)
xml_src = f.read()
f.close()
parser = XMLParser()
parser.feed(xml_src)
self.config_tree = parser.close()
self.parse()
def main():
N = input()
lines = []
for n in xrange(N):
line = raw_input()
lines.append(line)
parser = XMLParser(target=MaxDepth())
parser.feed("\n".join(lines))
print (parser.close() - 1)
def _open(self):
header = self.fp.read(4096)
# size in pixels (width, height)
self._size = svg_default_size
try:
# try to find the SVG width and height
target = SvgPainter(None, self._size, None)
parser = XMLParser(target=target)
parser.feed(header)
if target.svgsize:
self._size = (int(target.svgsize[0]), int(target.svgsize[1]))
parser.close()
except:
pass
# mode setting
self.mode = "RGB"
# data descriptor
self.tile = [("SVGXML", (0, 0) + self.size, 0,
(None, self, None, None, svg_default_background))]
def main():
""" main funciton handles getting the command line parameters and starting
the parsing.
"""
# Parse command line arguments
parser = argparse.ArgumentParser(prog='Make Building Relations',
description='Makes OSM building relations ')
parser.add_argument("--version", "-v", action="version",
version="%(prog)s " + __version__)
parser.add_argument("input_osm", metavar="input.osm",
help="Input OSM data in xml format")
parser.add_argument("output_osm", metavar="output.osm",
help="File to which to write the output")
parser.add_argument("bldg_id_tag", metavar="bldg_id_tag",
help="OSM tag key to be used to join together the various building parts"
+ " into a relation")
args = parser.parse_args(sys.argv[1:])
input_osm = args.input_osm
parser = XMLParser(target=MakeBuildingRelations(args.output_osm, args.bldg_id_tag))
with open(input_osm, 'r') as osm_in:
parser.feed(osm_in.read())
parser.close()
def parse(self, source=None, parser=None):
try:
if not parser:
parser = XMLParser(target=TreeBuilder())
while 1:
data = self.mergeScreenConfigs()
if not data:
break
parser.feed(data)
return parser.close()
# self._root = parser.close()
# return self._root
except:
pass
def parse(self, source=None, parser=None):
try:
if not parser:
parser = XMLParser(target=TreeBuilder())
while 1:
data = self.mergeScreenConfigs()
if not data:
break
parser.feed(data)
return parser.close()
# self._root = parser.close()
# return self._root
except:
pass
def parseData(target, data):
parser = XMLParser(target=target)
errormsg = ''
try:
try:
parser.feed(data)
except SyntaxError as err:
errormsg = str(err)
print(err)
except:
traceback.print_exc()
finally:
parser.close()
except ParseError as err:
formatted_e = errormsg
line = int(formatted_e[formatted_e.find("line ") +
5:formatted_e.find(",")])
column = int(formatted_e[formatted_e.find("column ") + 7:])
split_str = data.split("\n")
print("{}\n{}^".format(split_str[line - 1],
len(split_str[line - 1][0:column]) * "-"))
return target.domain, target.nameSpaces
class SvgDecoder(ImageFile.PyDecoder):
"""
Python implementation of a SVG format decoder.
"""
imagesize: Tuple[int, int] = None
def init(self, args):
(image_draw_mode, image, image_draw, image_size, background) = args
image_draw_mode = "RGBA" if image_draw_mode == None else image_draw_mode
if image != None: self.setimage(image)
image_draw = ImageDraw.Draw(
self.im, image_draw_mode) if image_draw == None else image_draw
self.imagesize = (self.im.width,
self.im.height) if image_size == None else image_size
self.target = SvgPainter(image_draw, self.imagesize, background)
self.parser = XMLParser(target=self.target)
def decode(self, buffer):
self.parser.feed(buffer)
return (len(buffer) if not self.target.finished else -1, 0)
def cleanup(self):
self.parser.close()
def parse_reqdata(self, get_data, post_data):
"""
parse query params and POST data into dictionary
"""
print 'debuggery: runing parse_reqdata...'
data_dict = {}
parser = XMLParser()
tree = parser.feed(post_data)
root = parser.close()
data_dict = XmlDictConfig(root)
# merge the query_params data
for k, v in self.parse_getparams(get_data).iteritems():
data_dict[k] = v
print 'debuggery: parsed !'
# return the dictionary data
return data_dict
def parse_reqdata(self, get_data, post_data):
"""
parse query params and POST data into dictionary
"""
print 'debuggery: runing parse_reqdata...'
data_dict = {}
parser = XMLParser()
tree = parser.feed(post_data)
root = parser.close()
data_dict = XmlDictConfig(root)
# merge the query_params data
for k,v in self.parse_getparams(get_data).iteritems():
data_dict[k] = v
print 'debuggery: parsed !'
# return the dictionary data
return data_dict
def parse_reqdata(self, get_data, post_data):
"""
parse query params and POST data into dictionary
"""
print 'debuggery: runing parse_reqdata...'
data_dict = {}
parser = XMLParser()
try:
parser.feed(post_data)
root = parser.close()
execElement = root.find("executions/execution")
if not execElement:
raise BleepParserError(
"Did not find executions/execution element in post data")
data_dict['execution_id'] = execElement.attrib["id"]
data_dict['execution_href'] = execElement.attrib["href"]
data_dict['execution_status'] = execElement.attrib["status"]
data_dict['execution_user'] = execElement.find("user").text
data_dict['execution_date_started'] = execElement.find(
"date-started").text
data_dict['execution_date_ended'] = execElement.find(
"date-ended").text
data_dict['execution_description'] = execElement.find(
"description").text
data_dict['execution_job_name'] = execElement.find("job/name").text
data_dict['execution_job_group'] = execElement.find(
"job/group").text
data_dict['execution_job_project'] = execElement.find(
"job/project").text
data_dict['execution_job_description'] = execElement.find(
"job/description").text
except KeyError as (keyerr):
print "Oops! missing key error: " + str(keyerr)
except AttributeError as (atterr):
print "Oops! missing attribute error" + str(atterr)
except Exception as (parserr):
raise BleepParserError(
"Unexpected error when parsing post data. " + "Cause: " +
str(parserr))
# merge the query_params data
for k, v in self.parse_getparams(get_data).iteritems():
data_dict[k] = v
print 'debuggery: parsed !'
# return the dictionary data
return data_dict
def read_transaction(self):
parser = XMLParser()
line = ""
while not line.startswith('<?'):
line = yield from self.readline()
parser.feed(line)
key, attrs = yield from self.read_instruction(line)
if key == 'cancel':
self.logger.info('Transaction cancelled')
elif key == 'end':
self.logger.info('Transaction complete')
obj = parser.close()
self.logger.debug(pretty_xml_str(obj))
return obj
elif key == 'start':
self.report_error("Start instruction given mid-transaction")
else:
self.report_error("Unrecognised instruction during transaction: key = {}, attrs = {}".format(key, attrs))
def _unimplement_path_by_id(self, id, spec="9606"):
self.pars["cmd"] = "search"
self.pars["q"] = id
content = self.tnf_obj.ask(self.pars)
parser = XMLParser()
parser.feed(content)
elem = parser.close()
# print content
print elem.tag
print elem.attrib
for path in elem:
print "hear " + path.tag + " " + path.attrib.keys()
return
def _unimplement_path_by_id(self,id,spec="9606"): self.pars["cmd"] = "search" self.pars["q"] = id content = self.tnf_obj.ask(self.pars) parser = XMLParser() parser.feed(content) elem = parser.close() # print content print elem.tag print elem.attrib for path in elem: print "hear "+path.tag+" "+path.attrib.keys() return
def read_transaction(self):
parser = XMLParser()
line = ""
while not line.startswith('<?'):
line = yield from self.readline()
parser.feed(line)
key, attrs = yield from self.read_instruction(line)
if key == 'cancel':
self.logger.info('Transaction cancelled')
elif key == 'end':
self.logger.info('Transaction complete')
obj = parser.close()
self.logger.debug(pretty_xml_str(obj))
return obj
elif key == 'start':
self.report_error("Start instruction given mid-transaction")
else:
self.report_error(
"Unrecognised instruction during transaction: key = {}, attrs = {}"
.format(key, attrs))
def __init__(self, filename):
"""Read and parse an xml file exported from SMS Backup and Restore App.
"""
self.filename = filename
self.messages = {}
self.contacts = []
# regex to find and filter surrogate-coded UTF-16 emojis:
# these are not allowed in xml, so must be translated manually
regex = re.compile("&#(\d{5});&#(\d{5});")
# Expects a match of the pattern in `regex`, with two groups.
# returns the two utf-16 (surrogate) codes translated to proper
# unicode codes:
def repl(match):
g = match.groups()
pair = chr(int(g[0])), chr(int(g[1]))
return "".join(pair).encode('utf-16',
'surrogatepass').decode('utf-16')
# the xml parser's target:
target = XML_Target()
# the xml parser:
parser = XMLParser(target=target)
with open(self.filename, "r", encoding="utf-8") as f:
for line in f:
corrected_line = regex.sub(repl, line)
parser.feed(corrected_line)
self.messages = parser.close()
# sort by date. This is neccessary because mms items always come
# after the sms items in the xml:
for key, msglist in self.messages.items():
self.messages[key] = sorted(msglist, key=lambda s: s._date)
self.contacts = sorted(self.messages.keys(),
key=lambda s: s.casefold())
self.contacts.remove('__all__')
def fromScrollBoxToSigPlus(self,repertoireScroll,repertoireSigPlus):
galerieEnCours=None
fichierScrollBox=os.path.join(repertoireScroll,self.fichierScrollBox)
if os.path.exists(repertoireScroll) and os.path.exists(fichierScrollBox):
if not os.path.exists(repertoireSigPlus):
#on crée un répertoire avec les mêmes droits que le répertoire source
os.mkdir(repertoireSigPlus,os.stat(repertoireScroll).st_mode)
#on va parser le fichier en question
handler = ImageParser()
parser = XMLParser(target=handler)
ficToParse = codecs.open(fichierScrollBox, "r", "utf-8")
donneesXML = u'%s' %(ficToParse.read())
parser.feed(donneesXML)
galerieEnCours=parser.close()
ficSigPlus=open(os.path.join(repertoireSigPlus,self.fichierDescrSigPlus),'w')
for image in galerieEnCours.images:
ficSigPlus.write(u'%s|%s|%s\n' %(image.nomFic,image.titre,image.comment))
shutil.copy(os.path.join(repertoireScroll,image.nomFic), repertoireSigPlus)
msImage=time.mktime(image.date.timetuple())
os.utime(os.path.join(repertoireSigPlus,image.nomFic), (msImage, msImage))
ficSigPlus.close()
else:
print u'le fichier %s n\'a pu être trouvé, abandon\n' %(fichierScrollBox)
def parse_reqdata(self, get_data, post_data):
"""
parse query params and POST data into dictionary
"""
print 'debuggery: runing parse_reqdata...'
data_dict = {}
parser = XMLParser()
try:
parser.feed(post_data)
root = parser.close()
execElement = root.find("executions/execution")
if not execElement:
raise BleepParserError("Did not find executions/execution element in post data")
data_dict['execution_id'] = execElement.attrib["id"]
data_dict['execution_href'] = execElement.attrib["href"]
data_dict['execution_status']= execElement.attrib["status"]
data_dict['execution_user'] = execElement.find("user").text
data_dict['execution_date_started']= execElement.find("date-started").text
data_dict['execution_date_ended']= execElement.find("date-ended").text
data_dict['execution_description']= execElement.find("description").text
data_dict['execution_job_name']= execElement.find("job/name").text
data_dict['execution_job_group']= execElement.find("job/group").text
data_dict['execution_job_project']=execElement.find("job/project").text
data_dict['execution_job_description']= execElement.find("job/description").text
except KeyError as (keyerr):
print "Oops! missing key error: " + str(keyerr)
except AttributeError as (atterr):
print "Oops! missing attribute error" + str(atterr)
except Exception as (parserr):
raise BleepParserError("Unexpected error when parsing post data. "
+ "Cause: " + str(parserr))
# merge the query_params data
for k,v in self.parse_getparams(get_data).iteritems():
data_dict[k] = v
print 'debuggery: parsed !'
# return the dictionary data
return data_dict
def get_tournaments(self, **kwargs):
"""
Returns set of tournaments from Challonge
Keywords:
state: One of { all, pending, in_progress, ended }
type: One of { single_elimination, double_elimination, round_robin, swiss }
created_after: YYYY-MM-DD
created_before: YYYY-MM-DD
subdomain: String
"""
if kwargs.has_key('state') and kwargs['state'] not in ['all', 'pending', 'in_progress', 'ended']:
raise Exception("Invalid state parameter")
if kwargs.has_key('type') and kwargs['type'] not in ['single_elimination', 'double_elimination', 'round_robin', 'swiss']:
raise Exception("Invalid type parameter")
response = self._call("tournaments", **kwargs)
print "got", response
target = TournamentConstructor()
parser = XMLParser(target=target)
parser.feed(response)
return parser.close()
def main(sXml):
target = MenuParser()
parser = XMLParser(target=target)
parser.feed(sXml)
return parser.close()
class _Parser:
def __init__(self, stream, *pos, **kw):
self._stream = stream
self._pending = deque()
builder = _QueueBuilder(self._pending)
self._parser = XMLParser(*pos, target=builder, **kw)
self._builders = [TreeBuilder()]
[method, pos, kw] = self._read()
self.element = getattr(self._builders[-1], method)(*pos, **kw)
def _read(self):
while not self._pending:
data = self._stream.read(0x10000)
if data:
self._parser.feed(data)
else:
self._parser.close()
self._parser = None
return self._pending.popleft()
def __iter__(self):
depth = len(self._builders)
while True:
while len(self._builders) > depth:
[method, pos, kw] = self._read()
if method == "data":
continue
assert method == "end"
self._builders.pop()
[method, pos, kw] = self._read()
if method == "data":
continue
if method == "end":
break
self._builders.append(TreeBuilder())
self.element = getattr(self._builders[-1], method)(*pos, **kw)
yield self.element
self._builders.pop()
def build_subtree(self):
builder = self._builders.pop()
depth = 0
while True:
[method, pos, kw] = self._read()
getattr(builder, method)(*pos, **kw)
if method == "start":
depth += 1
if method == "end":
if depth == 0:
break
depth -=1
return builder.close()
def close(self):
while self._builders:
[method, pos, kw] = self._read()
if method == "data":
continue
assert method == "end"
self._builders.pop()
while self._parser:
data = self._stream.read(0x10000)
if data:
self._parser.feed(data)
else:
self._parser.close()
self._parser = None
return self.element
self.depth += 1
self.current_tag = tag
# print the indented heading
if tag == 'node' and self.depth > 1:
#if 'tab' in attrib['TEXT']:
#import pdb; pdb.set_trace()
print (self.depth-2)*self.indent + attrib['TEXT']
def end(self, tag): # Called for each closing tag.
self.depth -= 1
self.current_tag = None
def data(self, data):
if self.current_tag == 'p':
bodyline = data.rstrip('\r\n')
bodyindent = (self.depth-5)*self.indent + ": "
#textlines = textwrap.wrap(bodytext, width=77-len(bodyindent), break_on_hyphens=False)
#for line in textlines:
print bodyindent + bodyline
def close(self): # Called when all data has been parsed.
pass
outline = Outline()
parser = XMLParser(target=outline, encoding='utf-8')
fname = sys.argv[1]
file = codecs.open(fname, 'r', encoding='utf-8')
filelines = file.readlines();
print "filelines", type(filelines[0]), filelines[0]
parser.feed(filelines[0].encode('utf-8'))
parser.close()
class MaxDepth:
def __init__(self):
self.maxDepth = 0
self.depth = 0
def start(self, tag, attrib):
self.depth += 1
if self.depth > self.maxDepth:
self.maxDepth = self.depth
def end(self, tag):
self.depth -= 1
def data(self, data):
pass
def close(self):
return self.maxDepth - 1
target = MaxDepth()
parser = XMLParser(target=target)
n = int(raw_input().strip())
text = ''
for _ in range(n):
line = raw_input().strip()
text += line + '\n'
parser.feed(text)
print parser.close()
import sys
import re
import string
import xml.etree.ElementTree as ET
from operator import add
import math
from xml.etree.ElementTree import XMLParser
if __name__ == "__main__":
con = sys.stdin.read()
parser = XMLParser()
parser.feed(b'<root>')
parser.feed(con)
parser.feed(b'</root>')
root = parser.close()
for subtree in root:
for subtree in subtree:
for element in subtree.iter('title'):
title = element.text
print element.tag, title.encode('ascii', 'ignore')
for element in subtree.iter('id'):
print element.tag, element.text
for element in subtree.iter('text'):
txt = element.text
words = " ".join(re.findall("[a-zA-Z]+", txt)).lower().split()
for word in words:
for i in range(2, len(words) - 1):
if i > 4:
word = words[i - 4] + "," + words[i - 3] + "," + words[i - 2] + "," + words[i - 1] + words[
def parse_twiml(data, *args, **kwargs):
parser = XMLParser(target=TwimlQueue(*args, **kwargs))
parser.feed(data)
parser.close()
def parse_domain_xml(xml):
target = GuestXmlParser()
parser = XMLParser(target=target)
parser.feed(xml)
return parser.close()
class MaxDepthParser(object):
"""Find the maximum depth using a custom parses."""
depth = 0
max_depth = 0
def start(self, tag, attrib):
self.depth += 1
if self.depth > self.max_depth:
self.max_depth = self.depth
def end(self, tag):
self.depth -= 1
def data(self, data):
pass
def close(self):
return self.max_depth
xml_ = ''.join([raw_input() for _ in range(int(raw_input()))])
parser = XMLParser(target=MaxDepthParser())
parser.feed(xml_)
# -1 accounts for initial depth of 1
print parser.close() - 1
import xml.etree.ElementTree as etree
from xml.etree.ElementTree import XMLParser
class MaxDepth:
maxDepth = 0
depth = 0
def start(self, tag, attrib):
self.depth += 1
if self.depth > self.maxDepth:
self.maxDepth = self.depth
def end(self, tag):
self.depth -= 1
def data(self, data):
pass
def close(self):
if self.maxDepth > 0:
return self.maxDepth - 1
else:
return self.maxDepth
S = ""
for _ in range(int(input())):
S += input()
target = MaxDepth()
parser = XMLParser(target=target)
parser.feed(S)
print(parser.close())
elif self.current_tag==['kml','Document','Folder','Placemark','Point','coordinates']:
self.coor.append([float(e)*math.pi/180 for e in txt.split(',')])
elif self.current_tag==['kml','Document','Folder','Placemark','description']:
x=re.search(r'Confirmation: <b>(\d+)</b> people',txt)
if x: self.confirmation.append(int(x.group(1)))
def close(self):
return list(zip(self.confirmation,self.timestamp,self.ids,self.coor,self.names))
parser=XMLParser(target=Parser(),encoding='utf-8')
parser.feed(line)
try:
while True:
parser.feed(raw_input())
except EOFError:
pass
a=sorted(parser.close(),key=lambda e:(-e[0],-e[1],e[2]))
for e0 in query:
radius,coor1=e0
result=[]
num=None
for e1 in a:
confirmation,timestamp,id,coor2,name=e1
if radius>=6378.137*math.acos( (math.sin(coor1[1])*math.sin(coor2[1])+math.cos(coor1[1])*math.cos(coor2[1])*math.cos(coor1[0]-coor2[0])) ):
if num!=None and num>confirmation: break
result.append(name)
num=confirmation
if len(result)==0:
print('None')
else:
print(', '.join(result))
class MaxDepth:
maxDepth = -1
depth = -1
def start(self, tag, attrib):
self.depth += 1
if self.depth > self.maxDepth:
self.maxDepth = self.depth
def end(self, tag):
self.depth -= 1
def data(self, data):
pass
def close(self):
assert self.maxDepth != -1
return self.maxDepth
lines = int(raw_input())
xml = ''
for i in range(lines):
xml += raw_input()
target = MaxDepth()
parser = XMLParser(target=target)
parser.feed(xml)
maxDepth = parser.close()
print maxDepth
from xml.etree.ElementTree import XMLParser
import sys
sys.stdin = open('test.xml')
class GetCosts: # The target object of the parser
cubes = {'red': 0, 'green': 0, 'blue': 0}
depth = 0
def start(self, tag, attrib): # Called for each opening tag.
self.depth += 1
color = attrib['color']
self.cubes[color] += self.depth
def end(self, tag): # Called for each closing tag.
self.depth -= 1
def data(self, data):
pass # We do not need to do anything with data.
def close(self): # Called when all data has been parsed.
return self.cubes
target = GetCosts()
parser = XMLParser(target=target)
parser.feed(input())
cubes = parser.close()
print('{} {} {}'.format(cubes['red'], cubes['green'], cubes['blue']))
