def parse(self, source, **keyword_args):
if type(source) == types.StringType:
if re.match(r'(?m)^\s*<', source) != None:
file = StringIO(source)
else:
file = urllib.urlopen(source)
else:
file = source
if hasattr(self, 'handler'):
self.tmp_handler = self.handler
if keyword_args.has_key('handler'):
self.tmp_handler = keyword_args['handler']
if isPy2:
self.parser = xml.sax.make_parser()
self.parser.setFeature(feature_namespaces, 0)
self.parser.setContentHandler(self)
else:
self.parser = saxexts.make_parser()
self.parser.setDocumentHandler(self)
self.parser.setErrorHandler(self)
self.namespace_stack = [ { '_Default' : None,
'xmlns' : xmlns_ns } ]
self.node_stack = [ ]
self.result = None
if isPy2:
self.parser.parse(file)
else:
self.parser.parseFile(file)
return self.result
def _load(self, file):
p = saxexts.make_parser()
p.setDocumentHandler(self)
p.parseFile(file)
assert len(self.stack) == 1
result = self.stack[0]
# self._clear()
return result
def process(self, uri):
parser = saxexts.make_parser()
parser.setDocumentHandler(self.handler)
try:
f = open(uri)
parser.parseFile(f)
except IOError,e:
raise NaturalXMLException("Could not open file: %s" % uri)
def _load(self, file):
p = saxexts.make_parser()
p.setDocumentHandler(self)
p.parseFile(file)
assert len(self.stack) == 1
result = self.stack[0]
self._clear()
return result
def _readXML(self, inFile):
"Read in XML tree from file object."
p = saxexts.make_parser()
dh = SaxBuilder()
p.setDocumentHandler(dh)
p.parseFile(inFile)
p.close()
return dh.document
def _readXML(self, inFile):
"Read in XML tree from file object."
p = saxexts.make_parser()
dh = SaxBuilder()
p.setDocumentHandler(dh)
p.parseFile(inFile)
p.close()
return dh.document
def make_objects(url,element,list_elems={},ign_elems={},rep_field={}):
dh=DocHandler(element,list_elems,ign_elems,rep_field)
eh=saxutils.ErrorPrinter()
parser=saxexts.make_parser()
parser.setDocumentHandler(dh)
parser.setErrorHandler(eh)
parser.parse(url)
return dh.get_objects()
def make_objects(url, element, list_elems={}, ign_elems={}, rep_field={}):
dh = DocHandler(element, list_elems, ign_elems, rep_field)
eh = saxutils.ErrorPrinter()
parser = saxexts.make_parser()
parser.setDocumentHandler(dh)
parser.setErrorHandler(eh)
parser.parse(url)
return dh.get_objects()
def _load(self, file):
"Read one value from the open file"
p = saxexts.make_parser()
p.setDocumentHandler(self)
p.parseFile(file)
assert len(self.data_stack) == 1
# leave the instance in a steady state
result = self.data_stack[0]
self._clear()
return result
def _load(self, file):
"Read one value from the open file"
p = saxexts.make_parser()
p.setDocumentHandler(self)
p.parseFile(file)
assert len(self.data_stack) == 1
# leave the instance in a steady state
result = self.data_stack[0]
self._clear()
return result
def sysupdate(): '''Updates denu database of installed programs. Variable:installed.''' handler = installedHandler() parser = saxexts.make_parser() parser.setDocumentHandler(handler) prgmDB = open(config['default'] + "prgmDB.xml", 'r') parser.parseFile(prgmDB) prgmDB.close() d_open(config['default'] + "installed.xml", "installed") buildIdChildRelations(['installed']) return "Successful."
def run(self, text):
try:
from xml.sax.saxexts import make_parser
p = make_parser("xml.sax.drivers.drv_sgmlop")
from xml.dom.ext.reader import Sax
start = time.time()
self.lastResult = Sax.FromXml(text, parser=p)
end = time.time()
self.lastTiming = end - start
return 1
except Exception, e:
self.failMsg = str(e)
return 0
def run(self, text):
try:
from xml.sax.saxexts import make_parser
p = make_parser("xml.sax.drivers.drv_sgmlop")
from xml.dom.ext.reader import Sax
start = time.time()
self.lastResult = Sax.FromXml(text, parser=p)
end = time.time()
self.lastTiming = end - start
return 1
except Exception, e:
self.failMsg = str(e)
return 0
def test2(filename='.md/Executions.xml'):
p = saxexts.make_parser()
print "Beginning performance tests"
for psize in [10, 100]:
t1 = time.time()
for i in range(0, psize):
rf = ExecutionFile(filename)
rf.load()
rf.execution.nextRun()
rf.save()
t2 = time.time()
print "files written %d in %d seconds" % (psize, t2-t1)
def __init__(self, filename, fileset=".", **kw):
self.xth = XTreeHandler(IgnoreWhiteSpace='yes',
RemoveWhiteSpace='yes', CreateElementMap='yes')
self.xth.registerElementClass(Execution)
self.xth.registerElementClass(Run)
try:
self.saxp = kw['sax_parser']
except:
self.saxp = saxexts.make_parser()
self.saxp.setDocumentHandler(self.xth)
self.filename = filename
self.fileset = fileset
self.execution = None
self.backup_on_change = kw.get('backups', 1)
def __init__(self, outer_env={}, parser=None):
if parser == None:
self.parser = saxexts.make_parser()
else:
self.parser = parser
self.xth = XTreeHandler(IgnoreWhiteSpace='yes',
RemoveWhiteSpace='yes',
CreateElementMap='yes',
RequireUserClasses='yes')
for x in outer_env.keys():
if type(outer_env[x]) == types.ClassType:
self.xth.registerElementClass(outer_env[x])
self.parser.setDocumentHandler(self.xth)
def parse_fh(fh, cb):
# Create a parser
parser = saxexts.make_parser()
# Create the handler
ch = ParseXML(cb)
# Tell the parser to use our handler
parser.setDocumentHandler(ch)
# Parse the file
parser.parseFile(fh)
# Close the parser
parser.close()
def parse_fh(fh, cb):
# Create a parser
parser = saxexts.make_parser()
# Create the handler
ch = ParseXML(cb)
# Tell the parser to use our handler
parser.setDocumentHandler(ch)
# Parse the file
parser.parseFile(fh)
# Close the parser
parser.close()
def go(outer_env):
if len(sys.argv) < 2:
print "Usage: python saxtree.py <document>"
print
print " <document>: file name of the document to parse"
sys.exit(1)
p = saxexts.make_parser()
xth = XTreeHandler(IgnoreWhiteSpace='yes',
RemoveWhiteSpace='yes',
CreateElementMap='yes')
for x in outer_env.keys():
if type(outer_env[x]) == types.ClassType:
print "registering %s" % x
xth.registerElementClass(outer_env[x])
p.setDocumentHandler(xth)
Ok=None
try:
p.parse(sys.argv[1])
print "Parse complete:"
print " Elements: %d" % xth.elems
print " Attributes: %d" % xth.attrs
print " Proc instrs: %d" % xth.pis
print " elements: %s" % `xth.getElementMap().keys()`
document = xth.getDocument()
print " Document has %d children " % len(document.getChildren())
content = document.getChildren('Content')
prologue = []
prologue.append('<?xml>')
prologue.append('<!-- Outline Tool by George K. Thiruvathukal -->')
print content[0].toXML(prologue=prologue, indent_text=" ")
topics = content[0].getChildren('Topic')
print "%d content objects" % len(content)
print "%d topic objects" % len(topics)
topics = content[0].getChildren(Topic)
print "%d topic objects" % len(topics)
analyzeTopics(topics)
except IOError,e:
print "\nERROR: "+sys.argv[1]+": "+str(e)
def Load(self):
try:
self.document()
self.layer()
parser = saxexts.make_parser()
parser.setDocumentHandler(SVGHandler(self))
try:
self.file.seek(0)
file = self.file
except:
file = streamfilter.StringDecode(self.match.string, self.file)
parser.parseFile(file)
self.end_all()
self.object.load_Completed()
return self.object
except:
warn_tb('INTERNAL')
raise
def Load(self):
try:
self.document()
self.layer()
parser = saxexts.make_parser()
parser.setDocumentHandler(SVGHandler(self))
try:
self.file.seek(0)
file = self.file
except:
file = streamfilter.StringDecode(self.match.string, self.file)
parser.parseFile(file)
self.end_all()
self.object.load_Completed()
return self.object
except:
warn_tb('INTERNAL')
raise
def _unmarshal(self):
self.parse_value_stack = [[]]
self.parse_type_stack = []
self.parse_keep_text = 0
self.parse_base64 = 0
self.parser = saxexts.make_parser()
self.parser.setDocumentHandler(self)
self.parser.setErrorHandler(self)
lines = []
stream = self.stream
line = stream.readline()
while (line != "\f\n") and (line != ""):
lines.append(line)
line = stream.readline()
if len(lines) == 0:
raise EOFError
stream = StringIO(string.join(lines))
self.parser.parseFile(stream)
self.parser.close()
return self.parse_value_stack[0][0]
def _unmarshal(self):
self.parse_value_stack = [[]]
self.parse_type_stack = []
self.parse_keep_text = 0
self.parse_base64 = 0
self.parser = saxexts.make_parser()
self.parser.setDocumentHandler(self)
self.parser.setErrorHandler(self)
lines = []
stream = self.stream
line = stream.readline()
while (line != "\f\n") and (line != ""):
lines.append(line)
line = stream.readline()
if len(lines) == 0:
raise EOFError
stream = StringIO(string.join(lines))
self.parser.parseFile(stream)
self.parser.close()
return self.parse_value_stack[0][0]
def parseAndGenerate(outfileName, subclassFilename, prefix, \
xschemaFileName):
#IPShell(vars(), '*** (parseAndGenerate) starting.')
#parser = saxexts.make_parser('xml.sax.drivers2.drv_libxmlop')
#parser = saxexts.make_parser()
parser = saxexts.make_parser("xml.sax.drivers2.drv_pyexpat")
#print "Parser: %s (%s, %s)" % \
# (parser.get_parser_name(),parser.get_parser_version(),
# parser.get_driver_version())
#print 'dir(parser):', dir(parser)
dh = XschemaHandler()
#parser.setDocumentHandler(dh)
parser.setContentHandler(dh)
#IPShell(vars(), '*** (parseAndGenerate) before parse.')
parser.parse(xschemaFileName)
#IPShell(vars(), '*** (parseAndGenerate) after parse.')
root = dh.getRoot()
root.annotate()
#response = raw_input('Press Enter')
#root.show(sys.stdout, 0)
#print '=' * 50
#print ']]] root: ', root, '[[['
generate(outfileName, subclassFilename, prefix, root)
def _unmarshal(self):
self.parse_value_stack = [ {} ]
self.parse_utype_stack = [ DICT ]
self.parse_type_stack = [ ]
self.parser = saxexts.make_parser()
self.parser.setDocumentHandler(self)
self.parser.setErrorHandler(self)
lines = []
stream = self.stream
# FIXME SAX parsers should support this on streams
line = stream.readline()
while (line != "\f\n") and (line != ""):
lines.append(line)
line = stream.readline()
if len(lines) == 0:
raise EOFError
stream = StringIO(string.join(lines))
self.parser.parseFile(stream)
o = self.parse_value_stack[0]
delattr(self, 'parse_value_stack')
self.parser.close()
return o
def parseAndGenerate(outfileName, subclassFilename, prefix, \
xschemaFileName):
#IPShell(vars(), '*** (parseAndGenerate) starting.')
#parser = saxexts.make_parser('xml.sax.drivers2.drv_libxmlop')
#parser = saxexts.make_parser()
parser = saxexts.make_parser("xml.sax.drivers2.drv_pyexpat")
#print "Parser: %s (%s, %s)" % \
# (parser.get_parser_name(),parser.get_parser_version(),
# parser.get_driver_version())
#print 'dir(parser):', dir(parser)
dh = XschemaHandler()
#parser.setDocumentHandler(dh)
parser.setContentHandler(dh)
#IPShell(vars(), '*** (parseAndGenerate) before parse.')
parser.parse(xschemaFileName)
#IPShell(vars(), '*** (parseAndGenerate) after parse.')
root = dh.getRoot()
root.annotate()
#response = raw_input('Press Enter')
#root.show(sys.stdout, 0)
#print '=' * 50
#print ']]] root: ', root, '[[['
generate(outfileName, subclassFilename, prefix, root)
def _unmarshal(self):
self.parse_value_stack = [{}]
self.parse_utype_stack = [DICT]
self.parse_type_stack = []
self.parser = saxexts.make_parser()
self.parser.setDocumentHandler(self)
self.parser.setErrorHandler(self)
lines = []
stream = self.stream
# FIXME SAX parsers should support this on streams
line = stream.readline()
while (line != "\f\n") and (line != ""):
lines.append(line)
line = stream.readline()
if len(lines) == 0:
raise EOFError
stream = StringIO(string.join(lines))
self.parser.parseFile(stream)
o = self.parse_value_stack[0]
delattr(self, 'parse_value_stack')
self.parser.close()
return o
in_sysID = trail[0]
if len(trail) == 2:
out_sysID = trail[1]
else:
out_sysID = ""
for (arg, val) in args:
if arg == "-d":
driver = "xml.sax.drivers.drv_" + val
elif arg == "-e":
esis = 1
elif arg == "-s":
silent = 1
p = saxexts.make_parser(driver)
p.setErrorHandler(saxutils.ErrorPrinter())
if out_sysID == "":
out = sys.stdout
else:
try:
out = urllib2.urlopen(out_sysID)
except IOError, e:
print out_sysID + ": " + str(e)
if esis:
dh = saxutils.ESISDocHandler(out)
else:
dh = saxutils.Canonizer(out)
from xml.sax import saxlib
import sys, time
if len(sys.argv) < 3:
print "Usage: python <parser> <document>"
print
print " <document>: file name of the document to parse"
print " <parser>: driver package name"
sys.exit(1)
# Load parser and driver
print "\nLoading parser..."
try:
p = saxexts.make_parser("xml.sax.drivers.drv_" + sys.argv[1])
except saxlib.SAXException, e:
print "ERROR: Parser not available"
sys.exit(1)
# Ready, set, go!
sum = 0
print "Starting parse..."
for ix in range(3):
start = time.clock()
OK = 0
pt = 0
try:
p.parse(sys.argv[2])
# $Id: test_pattern.py,v 1.1 1999/04/11 16:09:15 dieter Exp dieter $
"""Test for PyXPath."""
from xml.dom.sax_builder import SaxBuilder
from xml.sax.saxexts import make_parser
from xml.sax.saxutils import ErrorPrinter
from dmutil.xsl.xpath import makeParser, Env
from dmutil.xsl.DomFactory import IdDecl
import dmutil.xsl
##############################################################################
# build a DOM tree
dh= SaxBuilder()
p= make_parser(); p.setDocumentHandler(dh); p.setErrorHandler(ErrorPrinter())
p.parse('%s/test_pattern.xml' % dmutil.xsl.__path__[0]); p.close()
domtree= dh.document
##############################################################################
# create an idmap provider
# this is only necessary when "id" patterns are used
idmapper= IdDecl({'product':'id'})
# apply it to "domtree"
# this gives "domtree" the infrastructure for "id" pattern handling
idmapper(domtree)
d= domtree
##############################################################################
# create Parser and variable environment
p= makeParser(); e=Env(); e.setVariable('x','Hallo')
# child::para
def get_parser(dtdmodules, handlerclass=ObjectParserHandler, callback=_default_parser_callback): from xml.sax import saxexts handler = handlerclass(callback, dtdmodules) parser = saxexts.make_parser() parser.setDocumentHandler(handler) return parser
#
# If this goes well, a directory would be created containing the persistent
# representation of a document
#
from xml.sax import saxexts
from pparser import PElementParser
from os import system
system('rm -rf xyz')
pp = PElementParser('xyz', saxexts.make_parser())
pp.process('test1.xml')
from xml.sax import saxlib
import sys,time
if len(sys.argv)<3:
print "Usage: python <parser> <document>"
print
print " <document>: file name of the document to parse"
print " <parser>: driver package name"
sys.exit(1)
# Load parser and driver
print "\nLoading parser..."
try:
p=saxexts.make_parser("xml.sax.drivers.drv_" + sys.argv[1])
except saxlib.SAXException,e:
print "ERROR: Parser not available"
sys.exit(1)
# Ready, set, go!
sum=0
print "Starting parse..."
for ix in range(3):
start=time.clock()
OK=0
pt=0
try:
p.parse(sys.argv[2])
in_sysID=trail[0]
if len(trail)==2:
out_sysID=trail[1]
else:
out_sysID=""
for (arg,val) in args:
if arg=="-d":
driver="xml.sax.drivers.drv_" + val
elif arg=="-e":
esis=1
elif arg=="-s":
silent=1
p=saxexts.make_parser(driver)
p.setErrorHandler(saxutils.ErrorPrinter())
if out_sysID=="":
out=sys.stdout
else:
try:
out=urllib2.urlopen(out_sysID)
except IOError,e:
print out_sysID+": "+str(e)
if esis:
dh=saxutils.ESISDocHandler(out)
else:
dh=saxutils.Canonizer(out)
## else:
## res = saxlib.EntityResolver.resolveEntity(name,publicId,systemId)
## print "--> res",res,type(res)
## return res
if len(sys.argv)<2:
print "Usage: %s <sheet.sheet>" % sys.argv[0]
print
print " <sheet.sheet>: file name of the sheet to check"
sys.exit(1)
# Load parser and driver
p=saxexts.make_parser()
#p=saxexts.XMLValParserFactory.make_parser()
ch=CounterHandler()
p.setDocumentHandler(ch)
#p.setEntityResolver(BasicEntityResolver())
fnames =sys.argv[1:]
def make_langresult(langdict,colsize):
langres = map(lambda s,colsize=colsize: string.ljust(s,colsize),
map(lambda (cc,count),total=langdict['']:
("%s:%d%%" % (cc,100*count/total)),
filter(lambda (cc,count): cc, langdict.items())))
langres.sort()
return langres
# $Id: test_pattern.py,v 1.1 1999/04/11 16:09:15 dieter Exp dieter $
"""Test for PyXPath."""
from xml.dom.sax_builder import SaxBuilder
from xml.sax.saxexts import make_parser
from xml.sax.saxutils import ErrorPrinter
from dmutil.xsl.xpath import makeParser, Env
from dmutil.xsl.DomFactory import IdDecl
import dmutil.xsl
##############################################################################
# build a DOM tree
dh = SaxBuilder()
p = make_parser()
p.setDocumentHandler(dh)
p.setErrorHandler(ErrorPrinter())
p.parse('%s/test_pattern.xml' % dmutil.xsl.__path__[0])
p.close()
domtree = dh.document
##############################################################################
# create an idmap provider
# this is only necessary when "id" patterns are used
idmapper = IdDecl({'product': 'id'})
# apply it to "domtree"
# this gives "domtree" the infrastructure for "id" pattern handling
idmapper(domtree)
d = domtree
##############################################################################
# create Parser and variable environment
